void ro_gui_cert_release_window(struct ro_sslcert *s)
{
os_error *error;
if (s == NULL)
return;
LOG(("Releasing SSL data: 0x%x", (unsigned) s));
ro_gui_wimp_event_finalise(s->window);
ro_treeview_destroy(s->tv);
error = xwimp_delete_window(s->window);
if (error) {
LOG(("xwimp_delete_window: 0x%x:%s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
}
error = xwimp_delete_window(s->pane);
if (error) {
LOG(("xwimp_delete_window: 0x%x:%s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
}
free(s);
}
static bool save_complete_save_buffer(save_complete_ctx *ctx,
const char *leafname, const char *data, size_t data_len,
lwc_string *mime_type)
{
FILE *fp;
bool error;
char fullpath[PATH_MAX];
strncpy(fullpath, ctx->path, sizeof fullpath);
error = path_add_part(fullpath, sizeof fullpath, leafname);
if (error == false) {
warn_user("NoMemory", NULL);
return false;
}
fp = fopen(fullpath, "wb");
if (fp == NULL) {
LOG(("fopen(): errno = %i", errno));
warn_user("SaveError", strerror(errno));
return false;
}
fwrite(data, sizeof(*data), data_len, fp);
fclose(fp);
if (ctx->set_type != NULL)
ctx->set_type(fullpath, mime_type);
return true;
}
void ro_gui_save_datasave_ack(wimp_message *message)
{
char *path = message->data.data_xfer.file_name;
os_error *error;
if (!ro_gui_save(path)) return;
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_PATH, reset_filename);
/* Close the save window
*/
ro_gui_dialog_close(dialog_saveas);
/* Ack successful save with message_DATA_LOAD */
message->action = message_DATA_LOAD;
message->your_ref = message->my_ref;
error = xwimp_send_message_to_window(wimp_USER_MESSAGE, message,
message->data.data_xfer.w, message->data.data_xfer.i, 0);
if (error) {
LOG(("xwimp_send_message_to_window: 0x%x: %s",
error->errnum, error->errmess));
warn_user("FileError", error->errmess);
}
if (close_menu) {
error = xwimp_create_menu(wimp_CLOSE_MENU, 0, 0);
if (error) {
LOG(("xwimp_create_menu: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
}
}
close_menu = true;
}
void gui_download_window_done(struct gui_download_window *dw)
{
os_error *error;
if (dw->ctx != NULL)
download_context_destroy(dw->ctx);
dw->ctx = NULL;
ro_gui_download_update_status(dw);
error = xosfind_closew(dw->file);
if (error) {
LOG(("xosfind_closew: 0x%x: %s",
error->errnum, error->errmess));
warn_user("SaveError", error->errmess);
}
dw->file = 0;
if (dw->saved) {
error = xosfile_set_type(dw->path,
dw->file_type);
if (error) {
LOG(("xosfile_set_type: 0x%x: %s",
error->errnum, error->errmess));
warn_user("SaveError", error->errmess);
}
if (dw->send_dataload)
ro_gui_download_send_dataload(dw);
schedule(200, ro_gui_download_window_destroy_wrapper, dw);
}
}
static bool save_complete_inventory(save_complete_ctx *ctx)
{
FILE *fp;
bool error;
save_complete_entry *entry;
char fullpath[PATH_MAX];
strncpy(fullpath, ctx->path, sizeof fullpath);
error = path_add_part(fullpath, sizeof fullpath, "Inventory");
if (error == false) {
warn_user("NoMemory", NULL);
return false;
}
fp = fopen(fullpath, "w");
if (fp == NULL) {
LOG(("fopen(): errno = %i", errno));
warn_user("SaveError", strerror(errno));
return false;
}
for (entry = ctx->list; entry != NULL; entry = entry->next) {
fprintf(fp, "%p %s\n", entry->content,
nsurl_access(hlcache_handle_get_url(
entry->content)));
}
fclose(fp);
return true;
}
void ro_gui_popup_menu(wimp_menu *menu, wimp_w w, wimp_i i)
{
wimp_window_state state;
wimp_icon_state icon_state;
os_error *error;
state.w = w;
icon_state.w = w;
icon_state.i = i;
error = xwimp_get_window_state(&state);
if (error) {
LOG(("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
return;
}
error = xwimp_get_icon_state(&icon_state);
if (error) {
LOG(("xwimp_get_icon_state: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
return;
}
ro_gui_menu_create(menu,
state.visible.x0 + icon_state.icon.extent.x1 + 64,
state.visible.y1 + icon_state.icon.extent.y1 -
state.yscroll, w);
current_menu_icon = i;
}
/**
* creates the file menu
* \param group The gtk 'global' accelerator reference
* \param parent The parent menu to attach to or NULL
*/
static struct nsgtk_file_menu *nsgtk_menu_file_submenu(GtkAccelGroup *group)
{
struct nsgtk_file_menu *fmenu;
fmenu = malloc(sizeof(struct nsgtk_file_menu));
if (fmenu == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
fmenu->file_menu = GTK_MENU(gtk_menu_new());
if (fmenu->file_menu == NULL) {
warn_user(messages_get("NoMemory"), 0);
free(fmenu);
return NULL;
}
IMAGE_ITEM(file, newwindow, gtkNewWindow, fmenu, group);
IMAGE_ITEM(file, newtab, gtkNewTab, fmenu, group);
IMAGE_ITEM(file, openfile, gtkOpenFile, fmenu, group);
IMAGE_ITEM(file, closewindow, gtkCloseWindow, fmenu, group);
ADD_SEP(file, fmenu);
IMAGE_ITEM(file, savepage, gtkSavePage, fmenu, group);
IMAGE_ITEM(file, export, gtkExport, fmenu, group);
ADD_SEP(file, fmenu);
IMAGE_ITEM(file, printpreview, gtkPrintPreview, fmenu, group);
IMAGE_ITEM(file, print, gtkPrint, fmenu, group);
ADD_SEP(file, fmenu);
IMAGE_ITEM(file, quit, gtkQuitMenu, fmenu, group);
SET_SUBMENU(export, fmenu);
return fmenu;
}
static struct nsgtk_edit_menu *nsgtk_menu_edit_submenu(GtkAccelGroup *group)
{
struct nsgtk_edit_menu *ret = malloc(sizeof(struct nsgtk_edit_menu));
if (ret == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
ret->edit_menu = GTK_MENU(gtk_menu_new());
if (ret->edit_menu == NULL) {
warn_user(messages_get("NoMemory"), 0);
free(ret);
return NULL;
}
IMAGE_ITEM(edit, cut, gtkCut, ret, group);
IMAGE_ITEM(edit, copy, gtkCopy, ret, group);
IMAGE_ITEM(edit, paste, gtkPaste, ret, group);
IMAGE_ITEM(edit, delete, gtkDelete, ret, group);
ADD_SEP(edit, ret);
IMAGE_ITEM(edit, selectall, gtkSelectAll, ret, group);
ADD_SEP(edit, ret);
IMAGE_ITEM(edit, find, gtkFind, ret, group);
ADD_SEP(edit, ret);
IMAGE_ITEM(edit, preferences, gtkPreferences, ret, group);
return ret;
}
void ro_gui_menu_create(wimp_menu *menu, int x, int y, wimp_w w)
{
os_error *error;
struct menu_definition *definition;
/* translate menu, if necessary (this returns quickly
* if there's nothing to be done) */
definition = ro_gui_menu_find_menu(menu);
if (definition) {
if (!ro_gui_menu_translate(definition)) {
warn_user("NoMemory", 0);
return;
}
}
/* store the menu characteristics */
current_menu = menu;
current_menu_window = w;
current_menu_icon = wimp_ICON_WINDOW;
/* create the menu */
current_menu_open = true;
error = xwimp_create_menu(menu, x - 64, y);
if (error) {
LOG(("xwimp_create_menu: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
ro_gui_menu_closed();
}
}
static struct nsgtk_nav_menu *nsgtk_menu_nav_submenu(GtkAccelGroup *group)
{
struct nsgtk_nav_menu *ret = malloc(sizeof(struct nsgtk_nav_menu));
if (ret == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
ret->nav_menu = GTK_MENU(gtk_menu_new());
if (ret->nav_menu == NULL) {
warn_user(messages_get("NoMemory"), 0);
free(ret);
return NULL;
}
IMAGE_ITEM(nav, back, gtkBack, ret, group);
IMAGE_ITEM(nav, forward, gtkForward, ret, group);
IMAGE_ITEM(nav, home, gtkHome, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, localhistory, gtkLocalHistory, ret, group);
IMAGE_ITEM(nav, globalhistory, gtkGlobalHistory, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, addbookmarks, gtkAddBookMarks, ret, group);
IMAGE_ITEM(nav, showbookmarks, gtkShowBookMarks, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, showcookies, gtkShowCookies, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, openlocation, gtkOpenLocation, ret, group);
return ret;
}
bool save_complete_inventory(const char *path,
struct save_complete_entry *list)
{
char urlpath[256];
FILE *fp;
char *pathstring, *standardpath = (path[0] == '/') ?
(char *)(path + 1) : (char *)path;
struct save_complete_entry *entry;
snprintf(urlpath, sizeof urlpath, "file:///%s/Inventory",
standardpath);
pathstring = url_to_path(urlpath);
if (pathstring == NULL) {
warn_user("NoMemory", 0);
return false;
}
fp = fopen(pathstring, "w");
free(pathstring);
if (!fp) {
LOG(("fopen(): errno = %i", errno));
warn_user("SaveError", strerror(errno));
return false;
}
for (entry = list; entry; entry = entry->next) {
fprintf(fp, "%p %s\n", entry->content,
content_get_url(entry->content));
}
fclose(fp);
return true;
}
struct sslcert_session_data *
sslcert_create_session_data(unsigned long num,
const char *url,
llcache_query_response cb,
void *cbpw)
{
struct sslcert_session_data *data;
data = malloc(sizeof(struct sslcert_session_data));
if (data == NULL) {
warn_user("NoMemory", 0);
return NULL;
}
data->url = strdup(url);
if (data->url == NULL) {
free(data);
warn_user("NoMemory", 0);
return NULL;
}
data->num = num;
data->cb = cb;
data->cbpw = cbpw;
return data;
}
void ro_url_load(const char *url)
{
char *command;
char *colon;
os_error *error;
colon = strchr(url, ':');
if (!colon) {
LOG(("invalid url '%s'", url));
return;
}
command = malloc(40 + (colon - url) + strlen(url));
if (!command) {
warn_user("NoMemory", 0);
return;
}
sprintf(command, "Alias$URLOpen_%.*s", (int) (colon - url), url);
if (!getenv(command)) {
free(command);
return;
}
sprintf(command, "URLOpen_%.*s %s", (int) (colon - url), url, url);
error = xwimp_start_task(command, 0);
if (error) {
LOG(("xwimp_start_task: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
}
free(command);
}
static void nsgtk_options_theme_combo(void) {
/* populate theme combo from themelist file */
GtkBox *box = GTK_BOX(glade_xml_get_widget(gladeFile, "themehbox"));
char buf[50];
combotheme = gtk_combo_box_new_text();
size_t len = SLEN("themelist") + strlen(res_dir_location) + 1;
char themefile[len];
if ((combotheme == NULL) || (box == NULL)) {
warn_user(messages_get("NoMemory"), 0);
return;
}
snprintf(themefile, len, "%sthemelist", res_dir_location);
FILE *fp = fopen((const char *)themefile, "r");
if (fp == NULL) {
LOG(("Failed opening themes file"));
warn_user("FileError", (const char *) themefile);
return;
}
while (fgets(buf, sizeof(buf), fp) != NULL) {
/* Ignore blank lines */
if (buf[0] == '\0')
continue;
/* Remove trailing \n */
buf[strlen(buf) - 1] = '\0';
gtk_combo_box_append_text(GTK_COMBO_BOX(combotheme), buf);
}
fclose(fp);
gtk_combo_box_set_active(GTK_COMBO_BOX(combotheme),
option_current_theme);
gtk_box_pack_start(box, combotheme, FALSE, TRUE, 0);
gtk_widget_show(combotheme);
}
static node_callback_resp hotlist_node_callback(void *user_data,
struct node_msg_data *msg_data)
{
struct node *node = msg_data->node;
const char *text;
char *norm_text;
bool is_folder = tree_node_is_folder(node);
bool cancelled = false;
switch (msg_data->msg) {
case NODE_ELEMENT_EDIT_CANCELLED:
cancelled = true;
/* fall through */
case NODE_ELEMENT_EDIT_FINISHED:
if (creating_node && !cancelled &&
(is_folder == false) &&
(msg_data->flag == TREE_ELEMENT_TITLE)) {
tree_url_node_edit_url(hotlist_tree, node);
} else {
creating_node = false;
}
return NODE_CALLBACK_HANDLED;
case NODE_ELEMENT_EDIT_FINISHING:
if (creating_node && (is_folder == false))
return tree_url_node_callback(hotlist_tree, msg_data);
if (is_folder == true) {
text = msg_data->data.text;
while (isspace(*text))
text++;
norm_text = strdup(text);
if (norm_text == NULL) {
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return NODE_CALLBACK_REJECT;
}
/* don't allow zero length entry text, return false */
if (norm_text[0] == '\0') {
warn_user("NoNameError", 0);
msg_data->data.text = NULL;
return NODE_CALLBACK_CONTINUE;
}
msg_data->data.text = norm_text;
}
break;
case NODE_DELETE_ELEMENT_IMG:
return NODE_CALLBACK_HANDLED;
default:
if (is_folder == false)
return tree_url_node_callback(hotlist_tree, msg_data);
}
return NODE_CALLBACK_NOT_HANDLED;
}
END_HANDLER
BUTTON_CLICKED(buttonaddtheme)
{
char *filename, *directory;
size_t len;
GtkWidget *fc = gtk_file_chooser_dialog_new(
messages_get("gtkAddThemeTitle"),
GTK_WINDOW(wndPreferences),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
len = SLEN("themes") + strlen(res_dir_location) + 1;
char themesfolder[len];
snprintf(themesfolder, len, "%sthemes", res_dir_location);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc),
themesfolder);
gint res = gtk_dialog_run(GTK_DIALOG(fc));
if (res == GTK_RESPONSE_ACCEPT) {
filename = gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(fc));
if (strcmp(filename, themesfolder) != 0) {
directory = strrchr(filename, '/');
*directory = '\0';
if (strcmp(filename, themesfolder) != 0) {
warn_user(messages_get(
"gtkThemeFolderInstructions"),
0);
gtk_widget_destroy(GTK_WIDGET(fc));
if (filename != NULL)
g_free(filename);
return FALSE;
} else {
directory++;
}
} else {
if (filename != NULL)
g_free(filename);
filename = gtk_file_chooser_get_filename(
GTK_FILE_CHOOSER(fc));
if (strcmp(filename, themesfolder) == 0) {
warn_user(messages_get("gtkThemeFolderSub"),
0);
gtk_widget_destroy(GTK_WIDGET(fc));
g_free(filename);
return FALSE;
}
directory = strrchr(filename, '/') + 1;
}
gtk_widget_destroy(GTK_WIDGET(fc));
nsgtk_theme_add(directory);
if (filename != NULL)
g_free(filename);
}
}
bool ro_gui_theme_install_apply(wimp_w w)
{
char theme_save[256];
char *theme_file;
struct theme_descriptor *theme_install;
os_error *error;
char *fix;
const char *source_data;
unsigned long source_size;
assert(theme_install_content);
/* convert spaces to hard spaces */
theme_file = strdup(theme_install_descriptor.name);
if (!theme_file) {
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return false;
}
for (fix = theme_file; *fix != '\0'; fix++)
if (*fix == ' ')
*fix = 160; /* hard space */
/* simply overwrite previous theme versions */
snprintf(theme_save, sizeof theme_save, "%s.%s",
nsoption_charp(theme_save), theme_file);
theme_save[sizeof theme_save - 1] = '\0';
source_data = content_get_source_data(theme_install_content,
&source_size);
error = xosfile_save_stamped(theme_save, 0xffd,
(byte *) source_data,
(byte *) source_data + source_size);
if (error) {
LOG(("xosfile_save_stamped: 0x%x: %s",
error->errnum, error->errmess));
warn_user("ThemeInstallErr", 0);
free(theme_file);
return false;
}
/* apply the new theme */
ro_gui_theme_get_available();
theme_install = ro_gui_theme_find(theme_file);
if (!theme_install || !ro_gui_theme_apply(theme_install)) {
warn_user("ThemeApplyErr", 0);
} else {
nsoption_set_charp(theme, strdup(theme_install->leafname));
}
free(theme_file);
ro_gui_save_options();
return true;
}
static bool save_complete_save_html_document(save_complete_ctx *ctx,
hlcache_handle *c, bool index)
{
bool error;
FILE *fp;
dom_document *doc;
lwc_string *mime_type;
char filename[32];
char fullpath[PATH_MAX];
strncpy(fullpath, ctx->path, sizeof fullpath);
if (index)
snprintf(filename, sizeof filename, "index");
else
snprintf(filename, sizeof filename, "%p", c);
error = path_add_part(fullpath, sizeof fullpath, filename);
if (error == false) {
warn_user("NoMemory", NULL);
return false;
}
fp = fopen(fullpath, "wb");
if (fp == NULL) {
warn_user("NoMemory", NULL);
return false;
}
ctx->base = html_get_base_url(c);
ctx->fp = fp;
ctx->iter_state = STATE_NORMAL;
doc = html_get_document(c);
if (save_complete_libdom_treewalk((dom_node *) doc,
save_complete_node_handler, ctx) == false) {
warn_user("NoMemory", 0);
fclose(fp);
return false;
}
fclose(fp);
mime_type = content_get_mime_type(c);
if (mime_type != NULL) {
if (ctx->set_type != NULL)
ctx->set_type(fullpath, mime_type);
lwc_string_unref(mime_type);
}
return true;
}
void ro_gui_history_open(struct browser_window *bw,
struct history *history, bool at_pointer)
{
int width, height;
os_box box = {0, 0, 0, 0};
wimp_window_state state;
os_error *error;
assert(history);
history_current = history;
history_bw = bw;
history_size(history, &width, &height);
width *= 2;
height *= 2;
/* set extent */
box.x1 = width;
box.y0 = -height;
error = xwimp_set_extent(history_window, &box);
if (error) {
LOG(("xwimp_set_extent: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
return;
}
/* open full size */
state.w = history_window;
error = xwimp_get_window_state(&state);
if (error) {
LOG(("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
return;
}
state.visible.x0 = 0;
state.visible.y0 = 0;
state.visible.x1 = width;
state.visible.y1 = height;
state.next = wimp_HIDDEN;
error = xwimp_open_window(PTR_WIMP_OPEN(&state));
if (error) {
LOG(("xwimp_open_window: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
return;
}
ro_gui_dialog_open_persistent(bw->window->window, history_window,
at_pointer);
}
bool save_as_draw(hlcache_handle *h, const char *path)
{
pencil_code code;
char *drawfile_buffer;
size_t drawfile_size;
os_error *error;
ro_save_draw_diagram = pencil_create();
if (!ro_save_draw_diagram) {
warn_user("NoMemory", 0);
return false;
}
ro_save_draw_width = content_get_width(h);
ro_save_draw_height = content_get_height(h);
plot = ro_save_draw_plotters;
if (!content_redraw(h, 0, -ro_save_draw_height,
ro_save_draw_width, ro_save_draw_height,
INT_MIN, INT_MIN, INT_MAX, INT_MAX,
1,
0xFFFFFF))
{
pencil_free(ro_save_draw_diagram);
return false;
}
/*pencil_dump(ro_save_draw_diagram);*/
code = pencil_save_drawfile(ro_save_draw_diagram, "NetSurf",
&drawfile_buffer, &drawfile_size);
if (code != pencil_OK) {
warn_user("SaveError", 0);
pencil_free(ro_save_draw_diagram);
return false;
}
assert(drawfile_buffer);
error = xosfile_save_stamped(path, osfile_TYPE_DRAW,
(byte *) drawfile_buffer,
(byte *) drawfile_buffer + drawfile_size);
if (error) {
LOG(("xosfile_save_stamped failed: 0x%x: %s",
error->errnum, error->errmess));
warn_user("SaveError", error->errmess);
pencil_free(ro_save_draw_diagram);
return false;
}
pencil_free(ro_save_draw_diagram);
return true;
}
/**
* Save stylesheets imported by a CONTENT_CSS.
*
* \param imports Array of imports
* \param count Number of imports in list
* \param path Path to save to
* \return true on success, false on error and error reported
*/
bool save_imported_sheets(struct nscss_import *imports, uint32_t count,
const char *path, struct save_complete_entry **list)
{
char filename[256];
unsigned int j;
char *source;
int source_len;
bool res;
for (j = 0; j != count; j++) {
hlcache_handle *css = imports[j].c;
const char *css_data;
unsigned long css_size;
struct nscss_import *child_imports;
uint32_t child_import_count;
if (css == NULL)
continue;
if (save_complete_list_check(css, *list))
continue;
if (!save_complete_list_add(css, list)) {
warn_user("NoMemory", 0);
return false;
}
child_imports = nscss_get_imports(css, &child_import_count);
if (!save_imported_sheets(child_imports, child_import_count,
path, list))
return false;
snprintf(filename, sizeof filename, "%p", css);
css_data = content_get_source_data(css, &css_size);
source = rewrite_stylesheet_urls(css_data, css_size,
&source_len, content_get_url(css),
*list);
if (!source) {
warn_user("NoMemory", 0);
return false;
}
res = save_complete_gui_save(path, filename, source_len,
source, CONTENT_CSS);
free(source);
if (res == false)
return false;
}
return true;
}
nserror theme_install_callback(hlcache_handle *handle,
const hlcache_event *event, void *pw)
{
char buffer[256];
int author_indent = 0;
switch (event->type) {
case CONTENT_MSG_DONE:
{
const char *source_data;
unsigned long source_size;
theme_install_content = handle;
source_data = content_get_source_data(handle, &source_size);
if (!theme_install_read(source_data, source_size)) {
warn_user("ThemeInvalid", 0);
theme_install_close(dialog_theme_install);
break;
}
/* remove '© ' from the start of the data */
if (theme_install_descriptor.author[0] == '©')
author_indent++;
while (theme_install_descriptor.author[author_indent] == ' ')
author_indent++;
snprintf(buffer, sizeof buffer, messages_get("ThemeInstall"),
theme_install_descriptor.name,
&theme_install_descriptor.author[author_indent]);
buffer[sizeof buffer - 1] = '\0';
ro_gui_set_icon_string(dialog_theme_install,
ICON_THEME_INSTALL_MESSAGE,
buffer, true);
ro_gui_set_icon_shaded_state(dialog_theme_install,
ICON_THEME_INSTALL_INSTALL, false);
}
break;
case CONTENT_MSG_ERROR:
theme_install_close(dialog_theme_install);
warn_user(event->data.error, 0);
break;
default:
break;
}
return NSERROR_OK;
}
void ro_gui_save_open(int save_type, int x, int y)
{
char icon_buf[20];
const char *icon = icon_buf;
os_error *error;
gui_save_current_type = save_type;
if (save_type == SAVE_THEME) {
if (theme_filename == NULL) {
theme_filename = malloc(6);
if (!theme_filename) {
LOG(("No memory for malloc()"));
warn_user("NoMemory", 0);
return;
}
sprintf(theme_filename, "Theme");
}
gui_save_filetype = 0xffd;
ro_gui_set_window_title(dialog_saveas, messages_get("SaveTitle"));
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_PATH, theme_filename);
reset_filename = theme_filename;
} else {
if (sprite_filename == NULL) {
sprite_filename = malloc(8);
if (!sprite_filename) {
LOG(("No memory for malloc()"));
warn_user("NoMemory", 0);
return;
}
sprintf(sprite_filename, "Sprites");
}
gui_save_filetype = 0xff9;
ro_gui_set_window_title(dialog_saveas, messages_get("ExportTitle"));
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_PATH, sprite_filename);
reset_filename = sprite_filename;
}
/* icon */
sprintf(icon_buf, "file_%.3x", gui_save_filetype);
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_ICON, icon);
/* open sub menu or persistent dialog */
error = xwimp_create_sub_menu((wimp_menu *) dialog_saveas,
x, y);
if (error) {
LOG(("xwimp_create_sub_menu: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
}
}
static bool save_complete_save_stylesheet(save_complete_ctx *ctx,
hlcache_handle *css)
{
const char *css_data;
unsigned long css_size;
char *source;
unsigned long source_len;
struct nscss_import *imports;
uint32_t import_count;
lwc_string *type;
char filename[32];
bool result;
if (save_complete_ctx_has_content(ctx, css))
return true;
if (save_complete_ctx_add_content(ctx, css) == false) {
warn_user("NoMemory", 0);
return false;
}
imports = nscss_get_imports(css, &import_count);
if (save_complete_save_imported_sheets(ctx,
imports, import_count) == false)
return false;
css_data = content_get_source_data(css, &css_size);
source = save_complete_rewrite_stylesheet_urls(ctx, css_data, css_size,
hlcache_handle_get_url(css), &source_len);
if (source == NULL) {
warn_user("NoMemory", 0);
return false;
}
type = content_get_mime_type(css);
if (type == NULL) {
free(source);
return false;
}
snprintf(filename, sizeof filename, "%p", css);
result = save_complete_save_buffer(ctx, filename,
source, source_len, type);
lwc_string_unref(type);
free(source);
return result;
}
void ro_gui_download_drag_end(wimp_dragged *drag)
{
wimp_pointer pointer;
wimp_message message;
struct gui_download_window *dw = download_window_current;
const char *leaf;
os_error *error;
if (dw->saved || dw->error)
return;
error = xwimp_get_pointer_info(&pointer);
if (error) {
LOG(("xwimp_get_pointer_info: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
return;
}
/* ignore drags to the download window itself */
if (pointer.w == dw->window) return;
leaf = strrchr(dw->path, '.');
if (leaf)
leaf++;
else
leaf = dw->path;
ro_gui_convert_save_path(message.data.data_xfer.file_name, 212, leaf);
message.your_ref = 0;
message.action = message_DATA_SAVE;
message.data.data_xfer.w = pointer.w;
message.data.data_xfer.i = pointer.i;
message.data.data_xfer.pos.x = pointer.pos.x;
message.data.data_xfer.pos.y = pointer.pos.y;
message.data.data_xfer.est_size = dw->total_size ? dw->total_size :
dw->received;
message.data.data_xfer.file_type = dw->file_type;
message.size = 44 + ((strlen(message.data.data_xfer.file_name) + 4) &
(~3u));
error = xwimp_send_message_to_window(wimp_USER_MESSAGE, &message,
pointer.w, pointer.i, 0);
if (error) {
LOG(("xwimp_send_message_to_window: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
}
}
/**
* Creates a tree entry for a URL, and links it into the tree
*
* \param parent the node to link to
* \param url the URL (copied)
* \param data the URL data to use
* \param title the custom title to use
* \return the node created, or NULL for failure
*/
struct node *tree_create_URL_node(struct tree *tree, struct node *parent,
const char *url, const char *title,
tree_node_user_callback user_callback, void *callback_data)
{
struct node *node;
struct node_element *element;
char *text_cp, *squashed;
squashed = squash_whitespace(title ? title : url);
text_cp = strdup(squashed);
if (text_cp == NULL) {
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return NULL;
}
free(squashed);
node = tree_create_leaf_node(tree, parent, text_cp, true, false,
false);
if (node == NULL) {
free(text_cp);
return NULL;
}
if (user_callback != NULL)
tree_set_node_user_callback(node, user_callback,
callback_data);
tree_create_node_element(node, NODE_ELEMENT_BITMAP,
TREE_ELEMENT_THUMBNAIL, false);
tree_create_node_element(node, NODE_ELEMENT_TEXT, TREE_ELEMENT_VISITS,
false);
tree_create_node_element(node, NODE_ELEMENT_TEXT,
TREE_ELEMENT_LAST_VISIT, false);
element = tree_create_node_element(node, NODE_ELEMENT_TEXT,
TREE_ELEMENT_URL, true);
if (element != NULL) {
text_cp = strdup(url);
if (text_cp == NULL) {
tree_delete_node(tree, node, false);
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return NULL;
}
tree_update_node_element(tree, element, text_cp, NULL);
}
return node;
}
/**
* Handle closing of query dialog
*/
void ro_gui_query_close(wimp_w w)
{
struct gui_query_window *qw;
os_error *error;
qw = (struct gui_query_window *)ro_gui_wimp_event_get_user_data(w);
ro_gui_dialog_close(w);
error = xwimp_delete_window(qw->window);
if (error) {
LOG(("xwimp_delete_window: 0x%x:%s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
}
ro_gui_wimp_event_finalise(w);
/* remove from linked-list of query windows and release memory */
if (qw->prev)
qw->prev->next = qw->next;
else
gui_query_window_list = qw->next;
if (qw->next)
qw->next->prev = qw->prev;
free(qw);
}
void fetch_rsrc_register(void)
{
lwc_string *scheme;
int err;
err = find_app_resources();
if (err < B_OK) {
warn_user("Resources", strerror(err));
return;
}
if (lwc_intern_string("rsrc", SLEN("rsrc"), &scheme) != lwc_error_ok) {
die("Failed to initialise the fetch module "
"(couldn't intern \"rsrc\").");
}
fetch_add_fetcher(scheme,
fetch_rsrc_initialise,
fetch_rsrc_can_fetch,
fetch_rsrc_setup,
fetch_rsrc_start,
fetch_rsrc_abort,
fetch_rsrc_free,
fetch_rsrc_poll,
fetch_rsrc_finalise);
}
/**
* Generate menubar menus.
*
* Generate the main menu structure and attach it to a menubar widget.
*/
struct nsgtk_bar_submenu *nsgtk_menu_bar_create(GtkMenuShell *menubar, GtkAccelGroup *group)
{
;
struct nsgtk_bar_submenu *nmenu;
nmenu = malloc(sizeof(struct nsgtk_bar_submenu));
if (nmenu == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
nmenu->bar_menu = GTK_MENU_BAR(menubar);
nmenu->file_submenu = nsgtk_menu_file_submenu(group);
ATTACH_PARENT(menubar, gtkFile, nmenu->file_submenu->file, group);
nmenu->edit_submenu = nsgtk_menu_edit_submenu(group);
ATTACH_PARENT(menubar, gtkEdit, nmenu->edit_submenu->edit, group);
nmenu->view_submenu = nsgtk_menu_view_submenu(group);
ATTACH_PARENT(menubar, gtkView, nmenu->view_submenu->view, group);
nmenu->nav_submenu = nsgtk_menu_nav_submenu(group);
ATTACH_PARENT(menubar, gtkNavigate, nmenu->nav_submenu->nav, group);
nmenu->help_submenu = nsgtk_menu_help_submenu(group);
ATTACH_PARENT(menubar, gtkHelp, nmenu->help_submenu->help, group);
return nmenu;
}
/* Login Clicked -> create a new fetch request, specifying uname & pwd
* CURLOPT_USERPWD takes a string "username:password"
*/
bool ro_gui_401login_apply(wimp_w w)
{
struct session_401 *session;
char *auth;
session = (struct session_401 *)ro_gui_wimp_event_get_user_data(w);
assert(session);
auth = malloc(strlen(session->uname) + strlen(session->pwd) + 2);
if (!auth) {
LOG(("calloc failed"));
warn_user("NoMemory", 0);
return false;
}
sprintf(auth, "%s:%s", session->uname, session->pwd);
urldb_set_auth_details(session->url, session->realm, auth);
free(auth);
session->cb(true, session->cbpw);
/* Flag that we sent response by invalidating callback details */
session->cb = NULL;
session->cbpw = NULL;
return true;
}
