/* * Copyright 2004-2007 James Bursa * Copyright 2005 Adrian Lees * * 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 * Save dialog and drag and drop saving implementation for RISC OS. */ #include #include #include #include #include #include #include #include "oslib/dragasprite.h" #include "oslib/osbyte.h" #include "oslib/osfile.h" #include "oslib/osmodule.h" #include "oslib/osspriteop.h" #include "oslib/wimp.h" #include "oslib/wimpspriteop.h" #include "utils/config.h" #include "utils/log.h" #include "utils/messages.h" #include "utils/utf8.h" #include "utils/nsurl.h" #include "netsurf/browser_window.h" #include "netsurf/window.h" #include "netsurf/bitmap.h" #include "netsurf/content.h" #include "netsurf/form.h" #include "desktop/hotlist.h" #include "desktop/global_history.h" #include "desktop/version.h" #include "desktop/save_complete.h" #include "desktop/save_text.h" #include "riscos/bitmap.h" #include "riscos/dialog.h" #include "riscos/gui.h" #include "riscos/window.h" #include "riscos/menus.h" #include "riscos/message.h" #include "riscos/mouse.h" #include "utils/nsoption.h" #include "riscos/query.h" #include "riscos/save.h" #include "riscos/save_draw.h" #include "riscos/save_pdf.h" #include "riscos/textselection.h" #include "riscos/wimp.h" #include "riscos/wimp_event.h" #include "riscos/ucstables.h" #include "riscos/filetype.h" //typedef enum //{ // QueryRsn_Quit, // QueryRsn_Abort, // QueryRsn_Overwrite //} query_reason; /** * \todo much of the state information for a save should probably be * moved into a structure now since we could have multiple saves * outstanding. */ static gui_save_type gui_save_current_type; static struct hlcache_handle *gui_save_content = NULL; static char *gui_save_selection = NULL; static const char *gui_save_url = NULL; static const char *gui_save_title = NULL; static int gui_save_filetype; static query_id gui_save_query; static bool gui_save_send_dataload; static wimp_message gui_save_message; static bool gui_save_close_after = true; static bool dragbox_active = false; /** in-progress Wimp_DragBox/DragASprite op */ static bool using_dragasprite = true; static bool saving_from_dialog = true; static osspriteop_area *saveas_area = NULL; static wimp_w gui_save_sourcew = (wimp_w)-1; #define LEAFNAME_MAX 200 static char save_leafname[LEAFNAME_MAX]; /** Current save directory (updated by and used for dialog-based saving) */ static char *save_dir = NULL; static size_t save_dir_len; typedef enum { LINK_ACORN, LINK_ANT, LINK_TEXT } link_format; /** An entry in gui_save_table. */ struct gui_save_table_entry { int filetype; const char *name; }; /** * Table of filetypes and default filenames. Must be in sync with * gui_save_type (riscos/gui.h). A filetype of 0 indicates the content should * be used. */ static const struct gui_save_table_entry gui_save_table[] = { /* GUI_SAVE_SOURCE, */ { 0, "SaveSource" }, /* GUI_SAVE_DRAW, */ { 0xaff, "SaveDraw" }, /* GUI_SAVE_PDF, */ { 0xadf, "SavePDF" }, /* GUI_SAVE_TEXT, */ { 0xfff, "SaveText" }, /* GUI_SAVE_COMPLETE, */ { 0xfaf, "SaveComplete" }, /* GUI_SAVE_OBJECT_ORIG, */ { 0, "SaveObject" }, /* GUI_SAVE_OBJECT_NATIVE, */ { 0, "SaveObject" }, /* GUI_SAVE_LINK_URI, */ { 0xf91, "SaveLink" }, /* GUI_SAVE_LINK_URL, */ { 0xb28, "SaveLink" }, /* GUI_SAVE_LINK_TEXT, */ { 0xfff, "SaveLink" }, /* GUI_SAVE_HOTLIST_EXPORT_HTML, */ { 0xfaf, "Hotlist" }, /* GUI_SAVE_HISTORY_EXPORT_HTML, */ { 0xfaf, "History" }, /* GUI_SAVE_TEXT_SELECTION, */ { 0xfff, "SaveSelection" }, }; static bool ro_gui_save_content(struct hlcache_handle *h, char *path, bool force_overwrite); /** * Create the saveas dialogue from the given template, and the sprite area * necessary for our thumbnail (full page save) * * \param template_name name of template to be used * \return window handle of created dialogue */ wimp_w ro_gui_saveas_create(const char *template_name) { const int sprite_size = (68 * 68 * 4) + ((68 * 68) / 8); /* 32bpp with mask */ int area_size = sizeof(osspriteop_area) + sizeof(osspriteop_header) + 256 * 8 + sprite_size; void *area = NULL; wimp_window *window; os_error *error; wimp_icon *icons; wimp_w w; window = ro_gui_dialog_load_template(template_name); assert(window); icons = window->icons; error = xosmodule_alloc(area_size, (void **) &area); if (error) { NSLOG(netsurf, INFO, "xosmodule_alloc: 0x%x: %s", error->errnum, error->errmess); xwimp_close_template(); die(error->errmess); } else { saveas_area = area; saveas_area->size = area_size; saveas_area->first = 16; error = xosspriteop_clear_sprites(osspriteop_USER_AREA, saveas_area); if (error) { NSLOG(netsurf, INFO, "xosspriteop_clear_sprites: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("MiscError", error->errmess); xosmodule_free(saveas_area); saveas_area = NULL; } } assert((icons[ICON_SAVE_ICON].flags & (wimp_ICON_TEXT | wimp_ICON_SPRITE | wimp_ICON_INDIRECTED)) == (wimp_ICON_SPRITE | wimp_ICON_INDIRECTED)); icons[ICON_SAVE_ICON].data.indirected_sprite.area = saveas_area; /* create window */ error = xwimp_create_window(window, &w); if (error) { NSLOG(netsurf, INFO, "xwimp_create_window: 0x%x: %s", error->errnum, error->errmess); xwimp_close_template(); die(error->errmess); } /* the window definition is copied by the wimp and may be freed */ free(window); return w; } /** * Clean-up function that releases our sprite area and memory. */ void ro_gui_saveas_quit(void) { if (saveas_area) { os_error *error = xosmodule_free(saveas_area); if (error) { NSLOG(netsurf, INFO, "xosmodule_free: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("MiscError", error->errmess); } saveas_area = NULL; } free(save_dir); save_dir = NULL; } /** * Create a thumbnail sprite for the page being saved. * * \param h content to be converted * \param name sprite name to use * \return true iff successful */ static bool ro_gui_save_create_thumbnail(struct hlcache_handle *h, const char *name) { osspriteop_header *sprite_header; struct bitmap *bitmap; osspriteop_area *area; bitmap = riscos_bitmap_create(34, 34, BITMAP_NEW | BITMAP_OPAQUE | BITMAP_CLEAR_MEMORY); if (!bitmap) { NSLOG(netsurf, INFO, "Thumbnail initialisation failed."); return false; } riscos_bitmap_render(bitmap, h); area = riscos_bitmap_convert_8bpp(bitmap); riscos_bitmap_destroy(bitmap); if (!area) { NSLOG(netsurf, INFO, "Thumbnail conversion failed."); return false; } sprite_header = (osspriteop_header *)(area + 1); strncpy(sprite_header->name, name, 12); /* we can't resize the saveas sprite area because it may move * and we have no elegant way to update the window definition * on all OS versions */ assert(sprite_header->size <= saveas_area->size - saveas_area->first); memcpy((byte*)saveas_area + saveas_area->first, sprite_header, sprite_header->size); saveas_area->sprite_count = 1; saveas_area->used = saveas_area->first + sprite_header->size; free(area); return true; } /** * Suggest a leafname and sprite name for the given content. * * \param h content being saved * \param save_type type of save operation being performed * \param url used to determine leafname * \param leaf_buf buffer to receive suggested leafname. * \param leaf_len size of buffer to receive suggested leafname. * \param icon_buf buffer to receive sprite name. * \param icon_len size of buffer to receive icon name. */ static void ro_gui_save_set_state(struct hlcache_handle *h, gui_save_type save_type, const nsurl *url, char *leaf_buf, size_t leaf_len, char *icon_buf, size_t icon_len) { /* filename */ const char *name = gui_save_table[save_type].name; bool done = false; char *nice = NULL; nserror err; char *local_name; assert(icon_len >= 13); /* parameters that we need to remember */ gui_save_current_type = save_type; gui_save_content = h; /* suggest a filetype based upon the content */ gui_save_filetype = gui_save_table[save_type].filetype; if (!gui_save_filetype && h) { if (save_type == GUI_SAVE_OBJECT_NATIVE) { switch (ro_content_native_type(h)) { case osfile_TYPE_SPRITE: gui_save_filetype = osfile_TYPE_SPRITE; break; case osfile_TYPE_DRAW: gui_save_filetype = osfile_TYPE_DRAW; break; default: break; } } if (!gui_save_filetype) gui_save_filetype = ro_content_filetype(h); } /* leafname */ if ((url != NULL) && (nsurl_nice(url, &nice, nsoption_bool(strip_extensions)) == NSERROR_OK)) { size_t i; for (i = 0; nice[i]; i++) { if (nice[i] == '.') nice[i] = '/'; else if (nice[i] <= ' ' || strchr(":*#$&@^%\\", nice[i])) nice[i] = '_'; } name = nice; } else { name = messages_get(name); } /* filename is utf8 */ if (save_type == GUI_SAVE_COMPLETE && leaf_len > 0) { leaf_buf[0] = '!'; leaf_buf++; leaf_len--; } strncpy(leaf_buf, name, leaf_len); leaf_buf[leaf_len - 1] = 0; err = utf8_to_local_encoding(name, 0, &local_name); if (err != NSERROR_OK) { /* badenc should never happen */ assert(err != NSERROR_BAD_ENCODING); local_name = NULL; } if (local_name != NULL) name = local_name; /* sprite name used for icon and dragging */ if (save_type == GUI_SAVE_COMPLETE) { int index; /* Paint gets confused with uppercase characters and we need to convert spaces to hard spaces */ icon_buf[0] = '!'; for (index = 0; index < 11 && name[index]; ) { char ch = name[index]; if (ch == ' ') icon_buf[++index] = 0xa0; else icon_buf[++index] = tolower(ch); } memset(&icon_buf[index + 1], 0, 11 - index); icon_buf[12] = '\0'; if (ro_gui_save_create_thumbnail(h, icon_buf)) done = true; } if (!done) { osspriteop_header *sprite; os_error *error; sprintf(icon_buf, "file_%.3x", gui_save_filetype); error = ro_gui_wimp_get_sprite(icon_buf, &sprite); if (error && error->errnum == error_SPRITE_OP_DOESNT_EXIST) { /* try the 'unknown' filetype sprite as a fallback */ memcpy(icon_buf, "file_xxx", 9); error = ro_gui_wimp_get_sprite(icon_buf, &sprite); } if (error) { NSLOG(netsurf, INFO, "ro_gui_wimp_get_sprite: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("MiscError", error->errmess); } else { /* the sprite area should always be large enough for * file_xxx sprites */ assert(sprite->size <= saveas_area->size - saveas_area->first); memcpy((byte*)saveas_area + saveas_area->first, sprite, sprite->size); saveas_area->sprite_count = 1; saveas_area->used = saveas_area->first + sprite->size; } } free(local_name); free(nice); } /** * Prepares the save box to reflect gui_save_type and a content, and * opens it. * * \param save_type type of save * \param h content to save * \param s selection to save * \param url url to be saved (link types) * \param title title (if any), when saving links */ void ro_gui_save_prepare(gui_save_type save_type, struct hlcache_handle *h, char *s, const nsurl *url, const char *title) { char name_buf[FILENAME_MAX]; size_t leaf_offset = 0; char icon_buf[20]; assert( (save_type == GUI_SAVE_LINK_URI) || (save_type == GUI_SAVE_LINK_URL) || (save_type == GUI_SAVE_LINK_TEXT) || (save_type == GUI_SAVE_HOTLIST_EXPORT_HTML) || (save_type == GUI_SAVE_HISTORY_EXPORT_HTML) || (save_type == GUI_SAVE_TEXT_SELECTION) || h); if (gui_save_selection == NULL) free(gui_save_selection); gui_save_selection = s; if (url != NULL) { gui_save_url = nsurl_access(url); } else { gui_save_url = NULL; } gui_save_title = title; if (save_dir) { leaf_offset = save_dir_len; memcpy(name_buf, save_dir, leaf_offset); name_buf[leaf_offset++] = '.'; } if (h != NULL) { url = hlcache_handle_get_url(h); } ro_gui_save_set_state(h, save_type, url, name_buf + leaf_offset, FILENAME_MAX - leaf_offset, icon_buf, sizeof(icon_buf)); ro_gui_set_icon_sprite(dialog_saveas, ICON_SAVE_ICON, saveas_area, icon_buf); ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_PATH, name_buf, true); ro_gui_wimp_event_memorise(dialog_saveas); } /** * Handle lack of Message_DataSaveAck for drags, saveas dialogs and clipboard code * * \param message A wimp message. */ static void ro_gui_save_bounced(wimp_message *message) { gui_current_drag_type = GUI_DRAG_NONE; } /** * Handle User_Drag_Box event for a drag from the save dialog or browser window. * * \param *drag The Wimp_DragEnd data block. * \param *data NULL, as function is used as a callback from ro_mouse. */ static void ro_gui_save_drag_end(wimp_dragged *drag, void *data) { const char *name; wimp_pointer pointer; wimp_message message; os_error *error; char *dp, *ep; char *local_name = NULL; if (dragbox_active) ro_gui_drag_box_cancel(); error = xwimp_get_pointer_info(&pointer); if (error) { NSLOG(netsurf, INFO, "xwimp_get_pointer_info: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("WimpError", error->errmess); return; } /* perform hit-test if the destination is the same as the * source window; we want to allow drag-saving from a page * into the input fields within the page, but avoid accidental * replacements of the current page */ if (gui_save_sourcew != (wimp_w)-1 && pointer.w == gui_save_sourcew) { int dx = (drag->final.x1 + drag->final.x0)/2; int dy = (drag->final.y1 + drag->final.y0)/2; struct gui_window *g; bool dest_ok = false; os_coord pos; g = ro_gui_window_lookup(gui_save_sourcew); if (g && ro_gui_window_to_window_pos(g, dx, dy, &pos)) { dest_ok = browser_window_drop_file_at_point(g->bw, pos.x, pos.y, NULL); } if (!dest_ok) return; } if (!saving_from_dialog) { /* saving directly from browser window, choose a * name based upon the URL */ nserror err; err = utf8_to_local_encoding(save_leafname, 0, &local_name); if (err != NSERROR_OK) { /* badenc should never happen */ assert(err != NSERROR_BAD_ENCODING); local_name = NULL; } name = local_name ? local_name : save_leafname; } else { char *dot; /* saving from dialog, grab leafname from icon */ name = ro_gui_get_icon_string(gui_save_sourcew, ICON_SAVE_PATH); dot = strrchr(name, '.'); if (dot) name = dot + 1; } dp = message.data.data_xfer.file_name; ep = dp + sizeof message.data.data_xfer.file_name; if (gui_save_current_type == GUI_SAVE_COMPLETE) { message.data.data_xfer.file_type = 0x2000; if (*name != '!') *dp++ = '!'; } else message.data.data_xfer.file_type = gui_save_filetype; ro_gui_convert_save_path(dp, ep - dp, name); /** \todo we're supposed to set this if drag-n-drop used */ 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 = 1000; message.size = 44 + ((strlen(message.data.data_xfer.file_name) + 4) & (~3u)); ro_message_send_message_to_window(wimp_USER_MESSAGE_RECORDED, &message, pointer.w, pointer.i, ro_gui_save_bounced, NULL); gui_current_drag_type = GUI_DRAG_SAVE; free(local_name); } /** * Starts a drag for the save dialog * * \param pointer mouse position info from Wimp */ void ro_gui_save_start_drag(wimp_pointer *pointer) { if (pointer->buttons & (wimp_DRAG_SELECT | wimp_DRAG_ADJUST)) { const char *sprite = ro_gui_get_icon_string(pointer->w, pointer->i); int x = pointer->pos.x, y = pointer->pos.y; wimp_window_state wstate; wimp_icon_state istate; /* start the drag from the icon's exact location, rather than the pointer */ istate.w = wstate.w = pointer->w; istate.i = pointer->i; if (!xwimp_get_window_state(&wstate) && !xwimp_get_icon_state(&istate)) { x = (istate.icon.extent.x1 + istate.icon.extent.x0)/2 + wstate.visible.x0 - wstate.xscroll; y = (istate.icon.extent.y1 + istate.icon.extent.y0)/2 + wstate.visible.y1 - wstate.yscroll; } ro_mouse_drag_start(ro_gui_save_drag_end, NULL, NULL, NULL); gui_save_sourcew = pointer->w; saving_from_dialog = true; gui_save_close_after = !(pointer->buttons & wimp_DRAG_ADJUST); ro_gui_drag_icon(x, y, sprite); } } /** * Save completed, inform recipient and close our 'save as' dialog. */ static void ro_gui_save_done(void) { os_error *error; if (gui_save_send_dataload) { /* Ack successful save with message_DATA_LOAD */ wimp_message *message = &gui_save_message; message->action = message_DATA_LOAD; message->your_ref = message->my_ref; error = xwimp_send_message(wimp_USER_MESSAGE, message, message->sender); if (error) { NSLOG(netsurf, INFO, "xwimp_send_message: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); } } if (saving_from_dialog) { /* remember the save directory if saving to the Filer */ if (!gui_save_send_dataload || gui_save_message.data.data_xfer.est_size != -1) { char *sp = gui_save_message.data.data_xfer.file_name; char *ep = sp + sizeof(gui_save_message.data.data_xfer.file_name); char *lastdot = NULL; char *p = sp; while (p < ep && *p >= 0x20) { if (*p == '.') { /* don't remember the directory if it's a temporary file */ if (!lastdot && p == sp + 12 && !memcmp(sp, "", 12)) break; lastdot = p; } p++; } if (lastdot) { /* remember the directory */ char *new_dir = realloc(save_dir, (lastdot+1)-sp); if (new_dir) { save_dir_len = lastdot - sp; memcpy(new_dir, sp, save_dir_len); new_dir[save_dir_len] = '\0'; save_dir = new_dir; } } } if (gui_save_close_after) { /* Close the save window */ ro_gui_dialog_close(dialog_saveas); error = xwimp_create_menu(wimp_CLOSE_MENU, 0, 0); if (error) { NSLOG(netsurf, INFO, "xwimp_create_menu: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("MenuError", error->errmess); } } } if (!saving_from_dialog || gui_save_close_after) gui_save_content = 0; } /** * User has opted not to overwrite the existing file. */ static void ro_gui_save_overwrite_cancelled(query_id id, enum query_response res, void *p) { if (!saving_from_dialog) { // ro_gui_save_prepare(gui_save_current_type, gui_save_content); // ro_gui_dialog_open_persistent(g->window, dialog_saveas, true); } } /** * Overwrite of existing file confirmed, proceed with the save. */ static void ro_gui_save_overwrite_confirmed(query_id id, enum query_response res, void *p) { if (ro_gui_save_content(gui_save_content, gui_save_message.data.data_xfer.file_name, true)) { ro_gui_save_done(); } } /** * Save a link file. * * \param url url to be saved * \param title corresponding title, if any * \param format format of link file * \param path pathname for link file * \return true on success, false on failure and reports the error */ static bool ro_gui_save_link(const char *url, const char *title, link_format format, char *path) { FILE *fp = fopen(path, "w"); if (!fp) { ro_warn_user("SaveError", strerror(errno)); return false; } switch (format) { case LINK_ACORN: /* URI */ fprintf(fp, "%s\t%s\n", "URI", "100"); fprintf(fp, "\t# NetSurf %s\n\n", netsurf_version); fprintf(fp, "\t%s\n", url); if (title) fprintf(fp, "\t%s\n", title); else fprintf(fp, "\t*\n"); break; case LINK_ANT: /* URL */ case LINK_TEXT: /* Text */ fprintf(fp, "%s\n", url); break; } fclose(fp); switch (format) { case LINK_ACORN: /* URI */ xosfile_set_type(path, 0xf91); break; case LINK_ANT: /* URL */ xosfile_set_type(path, 0xb28); break; case LINK_TEXT: /* Text */ xosfile_set_type(path, 0xfff); break; } return true; } /** * set RISC OS filetype of file from mimetype * * \param path The path of the file to set filetype on * \param mime_type The mime type to set. */ static void ro_gui_save_set_file_type(const char *path, lwc_string *mime_type) { int rotype = ro_content_filetype_from_mime_type(mime_type); os_error *error; error = xosfile_set_type(path, rotype); if (error != NULL) { NSLOG(netsurf, INFO, "xosfile_set_type: 0x%x: %s", error->errnum, error->errmess); } } /** * Prepare an application directory and save_complete() to it. * * \param h content of type CONTENT_HTML to save * \param path path to save as * \return true on success, false on error and error reported */ static bool ro_gui_save_complete(struct hlcache_handle *h, char *path) { void *spr = ((byte *) saveas_area) + saveas_area->first; osspriteop_header *sprite = (osspriteop_header *) spr; char name[12]; char buf[256]; FILE *fp; os_error *error; size_t len; char *dot; int i; /* Create dir */ error = xosfile_create_dir(path, 0); if (error) { NSLOG(netsurf, INFO, "xosfile_create_dir: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); return false; } /* Save !Run file */ snprintf(buf, sizeof buf, "%s.!Run", path); fp = fopen(buf, "w"); if (!fp) { NSLOG(netsurf, INFO, "fopen(): errno = %i", errno); ro_warn_user("SaveError", strerror(errno)); return false; } fprintf(fp, "IconSprites .!Sprites\n"); fprintf(fp, "Filer_Run .index\n"); fclose(fp); error = xosfile_set_type(buf, 0xfeb); if (error) { NSLOG(netsurf, INFO, "xosfile_set_type: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); return false; } /* create an empty !Runimage so the date gets correctly set */ snprintf(buf, sizeof buf, "%s.!RunImage", path); fp = fopen(buf, "w"); if (!fp) { NSLOG(netsurf, INFO, "Creating !RunImage failed: errno = %i", errno); } else { fclose(fp); } /* Make sure the sprite name matches the directory name, because the user may have renamed the directory since we created the thumbnail sprite */ dot = strrchr(path, '.'); if (dot) dot++; else dot = path; len = strlen(dot); if (len >= 12) len = 12; memcpy(name, sprite->name, 12); /* remember original name */ memcpy(sprite->name, dot, len); memset(sprite->name + len, 0, 12 - len); for (i = 0; i < 12; i++) /* convert to lower case */ if (sprite->name[i] != '\0') sprite->name[i] = tolower(sprite->name[i]); /* Create !Sprites */ snprintf(buf, sizeof buf, "%s.!Sprites", path); error = xosspriteop_save_sprite_file(osspriteop_NAME, saveas_area, buf); if (error) { NSLOG(netsurf, INFO, "xosspriteop_save_sprite_file: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); return false; } /* restore sprite name in case the save fails and we need to try again */ memcpy(sprite->name, name, 12); /* save URL file with original URL */ snprintf(buf, sizeof buf, "%s.URL", path); if (!ro_gui_save_link(nsurl_access(hlcache_handle_get_url(h)), content_get_title(h), LINK_ANT, buf)) return false; return save_complete(h, path, ro_gui_save_set_file_type); } /** * Overwrite confirmation callbacks */ static const query_callback overwrite_funcs = { ro_gui_save_overwrite_confirmed, ro_gui_save_overwrite_cancelled }; /** * Save object in native type */ static bool ro_gui_save_object_native(struct hlcache_handle *h, char *path) { int file_type = ro_content_filetype(h); if (file_type == osfile_TYPE_SPRITE || file_type == osfile_TYPE_DRAW) { /* Native sprite or drawfile */ const uint8_t *source_data; size_t source_size; os_error *error; source_data = content_get_source_data(h, &source_size); error = xosfile_save_stamped(path, file_type, (byte *) source_data, (byte *) source_data + source_size); if (error != NULL) { NSLOG(netsurf, INFO, "xosfile_save_stamped: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); return false; } } else { /* Non-native type: export */ switch (ro_content_native_type(h)) { case osfile_TYPE_SPRITE: { unsigned flags = (os_version == 0xA9) ? BITMAP_SAVE_FULL_ALPHA : 0; riscos_bitmap_save(content_get_bitmap(h), path, flags); } break; case osfile_TYPE_DRAW: /* Must be SVG */ return save_as_draw(h, path); default: return false; } } return true; } /** * Does the actual saving * * \param h handle to content to save (or NULL for other) * \param path path to save to * \param force_overwrite true iff required to overwrite without prompting * \return true on success, * false on (i) error and error reported * or (ii) deferred awaiting user confirmation */ static bool ro_gui_save_content(struct hlcache_handle *h, char *path, bool force_overwrite) { os_error *error; const uint8_t *source_data; size_t source_size; /* does the user want to check for collisions when saving? */ if (!force_overwrite) { fileswitch_object_type obj_type; /* check whether the destination file/dir already exists */ error = xosfile_read_stamped(path, &obj_type, NULL, NULL, NULL, NULL, NULL); if (error) { NSLOG(netsurf, INFO, "xosfile_read_stamped: 0x%x:%s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); return false; } switch (obj_type) { case osfile_NOT_FOUND: break; case osfile_IS_FILE: gui_save_query = query_user("OverwriteFile", NULL, &overwrite_funcs, NULL, messages_get("Replace"), messages_get("DontReplace")); // gui_save_query_rsn = QueryRsn_Overwrite; return false; default: error = xosfile_make_error(path, obj_type); assert(error); ro_warn_user("SaveError", error->errmess); return false; } } switch (gui_save_current_type) { #ifdef WITH_DRAW_EXPORT case GUI_SAVE_DRAW: return save_as_draw(h, path); #endif #ifdef WITH_PDF_EXPORT case GUI_SAVE_PDF: return save_as_pdf(h, path); #endif case GUI_SAVE_TEXT: save_as_text(h, path); xosfile_set_type(path, 0xfff); break; case GUI_SAVE_COMPLETE: assert(h); if (content_get_type(h) == CONTENT_HTML) { if (strcmp(path, "")) return ro_gui_save_complete(h, path); /* we can't send a whole directory to another * application, so just send the HTML source */ gui_save_current_type = GUI_SAVE_SOURCE; } else gui_save_current_type = GUI_SAVE_OBJECT_ORIG; /** \todo do this earlier? */ /* no break */ case GUI_SAVE_SOURCE: case GUI_SAVE_OBJECT_ORIG: source_data = content_get_source_data(h, &source_size); error = xosfile_save_stamped(path, ro_content_filetype(h), (byte *) source_data, (byte *) source_data + source_size); if (error) { NSLOG(netsurf, INFO, "xosfile_save_stamped: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("SaveError", error->errmess); return false; } break; case GUI_SAVE_OBJECT_NATIVE: return ro_gui_save_object_native(h, path); case GUI_SAVE_LINK_URI: return ro_gui_save_link(gui_save_url, gui_save_title, LINK_ACORN, path); case GUI_SAVE_LINK_URL: return ro_gui_save_link(gui_save_url, gui_save_title, LINK_ANT, path); case GUI_SAVE_LINK_TEXT: return ro_gui_save_link(gui_save_url, gui_save_title, LINK_TEXT, path); case GUI_SAVE_HOTLIST_EXPORT_HTML: if (hotlist_export(path, NULL) != NSERROR_OK) return false; error = xosfile_set_type(path, 0xfaf); if (error) NSLOG(netsurf, INFO, "xosfile_set_type: 0x%x: %s", error->errnum, error->errmess); break; case GUI_SAVE_HISTORY_EXPORT_HTML: if (global_history_export(path, NULL) != NSERROR_OK) return false; error = xosfile_set_type(path, 0xfaf); if (error) NSLOG(netsurf, INFO, "xosfile_set_type: 0x%x: %s", error->errnum, error->errmess); break; case GUI_SAVE_TEXT_SELECTION: if (gui_save_selection == NULL) return false; if (!utf8_save_text(gui_save_selection, path)) { free(gui_save_selection); gui_save_selection = NULL; return false; } free(gui_save_selection); gui_save_selection = NULL; xosfile_set_type(path, 0xfff); break; case GUI_SAVE_CLIPBOARD_CONTENTS: return ro_gui_save_clipboard(path); default: NSLOG(netsurf, INFO, "Unexpected content type: %d, path %s", gui_save_current_type, path); return false; } return true; } /** * Handle OK click/keypress in the save dialog. * * \param w window handle of save dialog * \return true on success, false on failure */ bool ro_gui_save_ok(wimp_w w) { const char *name = ro_gui_get_icon_string(w, ICON_SAVE_PATH); wimp_pointer pointer; char path[256]; if (!strrchr(name, '.')) { ro_warn_user("NoPathError", NULL); return false; } ro_gui_convert_save_path(path, sizeof path, name); gui_save_sourcew = w; saving_from_dialog = true; gui_save_send_dataload = false; gui_save_close_after = xwimp_get_pointer_info(&pointer) || !(pointer.buttons & wimp_CLICK_ADJUST); memcpy(&gui_save_message.data.data_xfer.file_name, path, 1 + strlen(path)); if (ro_gui_save_content(gui_save_content, path, !nsoption_bool(confirm_overwrite))) { ro_gui_save_done(); return true; } return false; } /** * Initiates drag saving of an object directly from a browser window * * \param g gui window * \param c content to save * \param save_type type of save */ void gui_drag_save_object(struct gui_window *g, struct hlcache_handle *c, gui_save_type save_type) { wimp_pointer pointer; char icon_buf[20]; os_error *error; /* Close the save window because otherwise we need two contexts */ xwimp_create_menu(wimp_CLOSE_MENU, 0, 0); ro_gui_dialog_close(dialog_saveas); gui_save_sourcew = g->window; saving_from_dialog = false; error = xwimp_get_pointer_info(&pointer); if (error) { NSLOG(netsurf, INFO, "xwimp_get_pointer_info: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("WimpError", error->errmess); return; } ro_gui_save_set_state(c, save_type, hlcache_handle_get_url(c), save_leafname, LEAFNAME_MAX, icon_buf, sizeof(icon_buf)); ro_mouse_drag_start(ro_gui_save_drag_end, NULL, NULL, NULL); ro_gui_drag_icon(pointer.pos.x, pointer.pos.y, icon_buf); } /** * Initiates drag saving of a selection from a browser window * * \param g gui window * \param selection selection object */ void gui_drag_save_selection(struct gui_window *g, const char *selection) { wimp_pointer pointer; char icon_buf[20]; os_error *error; /* Close the save window because otherwise we need two contexts */ xwimp_create_menu(wimp_CLOSE_MENU, 0, 0); ro_gui_dialog_close(dialog_saveas); gui_save_sourcew = g->window; saving_from_dialog = false; error = xwimp_get_pointer_info(&pointer); if (error) { NSLOG(netsurf, INFO, "xwimp_get_pointer_info: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("WimpError", error->errmess); return; } if (gui_save_selection == NULL) free(gui_save_selection); if (selection == NULL) gui_save_selection = strdup(""); else gui_save_selection = strdup(selection); ro_gui_save_set_state(NULL, GUI_SAVE_TEXT_SELECTION, NULL, save_leafname, LEAFNAME_MAX, icon_buf, sizeof(icon_buf)); ro_mouse_drag_start(ro_gui_save_drag_end, NULL, NULL, NULL); ro_gui_drag_icon(pointer.pos.x, pointer.pos.y, icon_buf); } /** * Initiates drag saving of a link/URL file * * \param save_type format in which URL should be saved * \param url url to be saved * \param title title to be included in URI format, if any * \param g gui window to save from * \ */ void ro_gui_drag_save_link(gui_save_type save_type, const nsurl *url, const char *title, struct gui_window *g) { wimp_pointer pointer; char icon_buf[20]; os_error *error; /* Close the save window because otherwise we need two contexts */ xwimp_create_menu(wimp_CLOSE_MENU, 0, 0); ro_gui_dialog_close(dialog_saveas); gui_save_url = nsurl_access(url); gui_save_title = title; gui_save_sourcew = g->window; saving_from_dialog = false; error = xwimp_get_pointer_info(&pointer); if (error) { NSLOG(netsurf, INFO, "xwimp_get_pointer_info: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("WimpError", error->errmess); return; } ro_gui_save_set_state(NULL, save_type, url, save_leafname, LEAFNAME_MAX, icon_buf, sizeof(icon_buf)); ro_mouse_drag_start(ro_gui_save_drag_end, NULL, NULL, NULL); ro_gui_drag_icon(pointer.pos.x, pointer.pos.y, icon_buf); } /** * Start drag of icon under the pointer. * * \param x The x coordinate of the drag start * \param y The y coordinate of the drag start * \param sprite The sprite to use for the drag. */ void ro_gui_drag_icon(int x, int y, const char *sprite) { os_error *error; wimp_drag drag; int r2; drag.initial.x0 = x - 34; drag.initial.y0 = y - 34; drag.initial.x1 = x + 34; drag.initial.y1 = y + 34; if (sprite && (xosbyte2(osbyte_READ_CMOS, 28, 0, &r2) || (r2 & 2))) { osspriteop_area *area = (osspriteop_area*)1; /* first try our local sprite area in case it's a thumbnail sprite */ if (saveas_area) { error = xosspriteop_select_sprite(osspriteop_USER_AREA, saveas_area, (osspriteop_id)sprite, NULL); if (error) { if (error->errnum != error_SPRITE_OP_DOESNT_EXIST) { NSLOG(netsurf, INFO, "xosspriteop_select_sprite: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("MiscError", error->errmess); } } else area = saveas_area; } error = xdragasprite_start(dragasprite_HPOS_CENTRE | dragasprite_VPOS_CENTRE | dragasprite_BOUND_POINTER | dragasprite_DROP_SHADOW, area, sprite, &drag.initial, 0); if (!error) { using_dragasprite = true; dragbox_active = true; return; } NSLOG(netsurf, INFO, "xdragasprite_start: 0x%x: %s", error->errnum, error->errmess); } drag.type = wimp_DRAG_USER_FIXED; drag.bbox.x0 = -0x8000; drag.bbox.y0 = -0x8000; drag.bbox.x1 = 0x7fff; drag.bbox.y1 = 0x7fff; using_dragasprite = false; error = xwimp_drag_box(&drag); if (error) { NSLOG(netsurf, INFO, "xwimp_drag_box: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("DragError", error->errmess); } else { dragbox_active = true; } } /** * Convert a ctrl-char terminated pathname possibly containing spaces * to a NUL-terminated one containing only hard spaces. * * \param dp destination buffer to receive pathname * \param len size of destination buffer * \param p source pathname, ctrl-char terminated */ void ro_gui_convert_save_path(char *dp, size_t len, const char *p) { char *ep = dp + len - 1; /* leave room for NUL */ assert(p <= dp || p > ep); /* in-situ conversion /is/ allowed */ while (dp < ep && *p >= ' ') /* ctrl-char terminated */ { *dp++ = (*p == ' ') ? 160 : *p; p++; } *dp = '\0'; } void ro_gui_drag_box_cancel(void) { if (dragbox_active) { os_error *error; if (using_dragasprite) { error = xdragasprite_stop(); if (error) { NSLOG(netsurf, INFO, "xdragasprite_stop: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("WimpError", error->errmess); } } else { error = xwimp_drag_box(NULL); if (error) { NSLOG(netsurf, INFO, "xwimp_drag_box: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("WimpError", error->errmess); } } dragbox_active = false; } } /** * Send DataSave message on behalf of clipboard code and remember that it's the * clipboard contents we're being asked for when the DataSaveAck reply arrives */ void ro_gui_send_datasave(gui_save_type save_type, wimp_full_message_data_xfer *message, wimp_t to) { /* Close the save window because otherwise we need two contexts */ ro_gui_dialog_close(dialog_saveas); if (ro_message_send_message(wimp_USER_MESSAGE_RECORDED, (wimp_message*)message, to, ro_gui_save_bounced)) { gui_save_current_type = save_type; gui_save_sourcew = (wimp_w)-1; saving_from_dialog = false; gui_current_drag_type = GUI_DRAG_SAVE; } } /** * Handle Message_DataSaveAck for a drag from the save dialog or browser window, * or Clipboard protocol. */ void ro_gui_save_datasave_ack(wimp_message *message) { char *path = message->data.data_xfer.file_name; struct hlcache_handle *h = gui_save_content; bool force_overwrite; switch (gui_save_current_type) { case GUI_SAVE_LINK_URI: case GUI_SAVE_LINK_URL: case GUI_SAVE_LINK_TEXT: case GUI_SAVE_HOTLIST_EXPORT_HTML: case GUI_SAVE_HISTORY_EXPORT_HTML: case GUI_SAVE_TEXT_SELECTION: case GUI_SAVE_CLIPBOARD_CONTENTS: break; default: if (!gui_save_content) { NSLOG(netsurf, INFO, "unexpected DataSaveAck: gui_save_content not set"); return; } break; } if (saving_from_dialog) ro_gui_set_icon_string(gui_save_sourcew, ICON_SAVE_PATH, path, true); gui_save_send_dataload = true; memcpy(&gui_save_message, message, sizeof(gui_save_message)); /* if saving/pasting to another application, don't request user confirmation; a ScrapFile almost certainly exists already */ if (message->data.data_xfer.est_size == -1) force_overwrite = true; else force_overwrite = !nsoption_bool(confirm_overwrite); if (ro_gui_save_content(h, path, force_overwrite)) ro_gui_save_done(); }