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; }
/** * 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 nsgtk_viewsource(GtkWindow *parent, struct browser_window *bw) { nserror ret; struct hlcache_handle *hlcontent; const char *source_data; unsigned long source_size; char *ndata = NULL; size_t ndata_len; char *filename; char *title; hlcontent = browser_window_get_content(bw); if (hlcontent == NULL) { return NSERROR_BAD_PARAMETER; } if (content_get_type(hlcontent) != CONTENT_HTML) { return NSERROR_BAD_CONTENT; } source_data = content_get_source_data(hlcontent, &source_size); ret = nsurl_nice(browser_window_get_url(bw), &filename, false); if (ret != NSERROR_OK) { filename = strdup(messages_get("SaveSource")); if (filename == NULL) { return NSERROR_NOMEM; } } title = malloc(strlen(nsurl_access(browser_window_get_url(bw))) + SLEN("Source of - NetSurf") + 1); if (title == NULL) { free(filename); return NSERROR_NOMEM; } sprintf(title, "Source of %s - NetSurf", nsurl_access(browser_window_get_url(bw))); ret = utf8_from_enc(source_data, content_get_encoding(hlcontent, CONTENT_ENCODING_NORMAL), source_size, &ndata, &ndata_len); if (ret == NSERROR_OK) { ret = nsgtk_viewdata(title, filename, ndata, ndata_len); } free(filename); free(title); return ret; }
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; }
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; }
/* attempt defer and async script execution * * execute scripts using algorithm found in: * http://www.whatwg.org/specs/web-apps/current-work/multipage/scripting-1.html#the-script-element * */ bool html_scripts_exec(html_content *c) { unsigned int i; struct html_script *s; script_handler_t *script_handler; if (c->jscontext == NULL) return false; for (i = 0, s = c->scripts; i != c->scripts_count; i++, s++) { if (s->already_started) { continue; } if ((s->type == HTML_SCRIPT_ASYNC) || (s->type == HTML_SCRIPT_DEFER)) { /* ensure script content is present */ if (s->data.handle == NULL) continue; /* ensure script content fetch status is not an error */ if (content_get_status(s->data.handle) == CONTENT_STATUS_ERROR) continue; /* ensure script handler for content type */ script_handler = select_script_handler( content_get_type(s->data.handle)); if (script_handler == NULL) continue; /* unsupported type */ if (content_get_status(s->data.handle) == CONTENT_STATUS_DONE) { /* external script is now available */ const char *data; unsigned long size; data = content_get_source_data( s->data.handle, &size ); script_handler(c->jscontext, data, size); s->already_started = true; } } } return true; }
bool ami_easy_clipboard_svg(struct hlcache_handle *c) { const char *source_data; ULONG source_size; if(ami_mime_compare(c, "svg") == false) return false; if((source_data = content_get_source_data(c, &source_size)) == NULL) return false; if(!(OpenIFF(iffh,IFFF_WRITE))) { ami_svg_to_dr2d(iffh, source_data, source_size, nsurl_access(hlcache_handle_get_url(c))); CloseIFF(iffh); } return true; }
static bool save_complete_save_html_object(save_complete_ctx *ctx, hlcache_handle *obj) { const char *obj_data; unsigned long obj_size; lwc_string *type; bool result; char filename[32]; if (content_get_type(obj) == CONTENT_NONE) return true; obj_data = content_get_source_data(obj, &obj_size); if (obj_data == NULL) return true; if (save_complete_ctx_has_content(ctx, obj)) return true; if (save_complete_ctx_add_content(ctx, obj) == false) { warn_user("NoMemory", 0); return false; } if (content_get_type(obj) == CONTENT_HTML) { return save_complete_save_html(ctx, obj, false); } snprintf(filename, sizeof filename, "%p", obj); type = content_get_mime_type(obj); if (type == NULL) return false; result = save_complete_save_buffer(ctx, filename, obj_data, obj_size, type); lwc_string_unref(type); return result; }
static nserror theme_install_callback(hlcache_handle *c, const hlcache_event *event, void *pw) { switch (event->type) { case CONTENT_MSG_READY: break; case CONTENT_MSG_DONE: { const char *source_data; unsigned long source_size; source_data = content_get_source_data(c, &source_size); if (!theme_install_read(source_data, source_size)) warn_user("ThemeInvalid", 0); hlcache_handle_release(c); } break; case CONTENT_MSG_ERROR: warn_user(event->data.error, 0); break; case CONTENT_MSG_STATUS: break; case CONTENT_MSG_LOADING: case CONTENT_MSG_REFORMAT: case CONTENT_MSG_REDRAW: default: assert(0); break; } return NSERROR_OK; }
HPDF_Image pdf_extract_image(struct bitmap *bitmap) { HPDF_Image image = NULL; hlcache_handle *content = NULL; /* TODO - get content from bitmap pointer */ if (content) { const char *source_data; unsigned long source_size; /*Not sure if I don't have to check if downloading has been finished. Other way - lock pdf plotting while fetching a website */ source_data = content_get_source_data(content, &source_size); switch(content_get_type(content)){ /*Handle "embeddable" types of images*/ case CONTENT_JPEG: image = HPDF_LoadJpegImageFromMem(pdf_doc, (const HPDF_BYTE *) source_data, source_size); break; /*Disabled until HARU PNG support will be more stable. case CONTENT_PNG: image = HPDF_LoadPngImageFromMem(pdf_doc, (const HPDF_BYTE *)content->source_data, content->total_size); break;*/ default: break; } } if (!image) { HPDF_Image smask; unsigned char *img_buffer, *rgb_buffer, *alpha_buffer; int img_width, img_height, img_rowstride; int i, j; /*Handle pixmaps*/ img_buffer = bitmap_get_buffer(bitmap); img_width = bitmap_get_width(bitmap); img_height = bitmap_get_height(bitmap); img_rowstride = bitmap_get_rowstride(bitmap); rgb_buffer = (unsigned char *)malloc(3 * img_width * img_height); alpha_buffer = (unsigned char *)malloc(img_width * img_height); if (rgb_buffer == NULL || alpha_buffer == NULL) { NSLOG(netsurf, INFO, "Not enough memory to create RGB buffer"); free(rgb_buffer); free(alpha_buffer); return NULL; } for (i = 0; i < img_height; i++) for (j = 0; j < img_width; j++) { rgb_buffer[((i * img_width) + j) * 3] = img_buffer[(i * img_rowstride) + (j * 4)]; rgb_buffer[(((i * img_width) + j) * 3) + 1] = img_buffer[(i * img_rowstride) + (j * 4) + 1]; rgb_buffer[(((i * img_width) + j) * 3) + 2] = img_buffer[(i * img_rowstride) + (j * 4) + 2]; alpha_buffer[(i * img_width)+j] = img_buffer[(i * img_rowstride) + (j * 4) + 3]; } smask = HPDF_LoadRawImageFromMem(pdf_doc, alpha_buffer, img_width, img_height, HPDF_CS_DEVICE_GRAY, 8); image = HPDF_LoadRawImageFromMem(pdf_doc, rgb_buffer, img_width, img_height, HPDF_CS_DEVICE_RGB, 8); if (HPDF_Image_AddSMask(image, smask) != HPDF_OK) image = NULL; free(rgb_buffer); free(alpha_buffer); } return image; }
/** * Callback for syncronous scripts */ static nserror convert_script_sync_cb(hlcache_handle *script, const hlcache_event *event, void *pw) { html_content *parent = pw; unsigned int i; struct html_script *s; script_handler_t *script_handler; dom_hubbub_error err; /* Find script */ for (i = 0, s = parent->scripts; i != parent->scripts_count; i++, s++) { if (s->type == HTML_SCRIPT_SYNC && s->data.handle == script) break; } assert(i != parent->scripts_count); switch (event->type) { case CONTENT_MSG_LOADING: break; case CONTENT_MSG_READY: break; case CONTENT_MSG_DONE: LOG(("script %d done '%s'", i, nsurl_access(hlcache_handle_get_url(script)))); parent->base.active--; LOG(("%d fetches active", parent->base.active)); s->already_started = true; /* attempt to execute script */ script_handler = select_script_handler(content_get_type(s->data.handle)); if (script_handler != NULL) { /* script has a handler */ const char *data; unsigned long size; data = content_get_source_data(s->data.handle, &size ); script_handler(parent->jscontext, data, size); } /* continue parse */ err = dom_hubbub_parser_pause(parent->parser, false); if (err != DOM_HUBBUB_OK) { LOG(("unpause returned 0x%x", err)); } break; case CONTENT_MSG_ERROR: LOG(("script %s failed: %s", nsurl_access(hlcache_handle_get_url(script)), event->data.error)); hlcache_handle_release(script); s->data.handle = NULL; parent->base.active--; LOG(("%d fetches active", parent->base.active)); content_add_error(&parent->base, "?", 0); s->already_started = true; /* continue parse */ err = dom_hubbub_parser_pause(parent->parser, false); if (err != DOM_HUBBUB_OK) { LOG(("unpause returned 0x%x", err)); } break; case CONTENT_MSG_STATUS: break; default: assert(0); } /* if there are no active fetches remaining begin post parse * conversion */ if (html_can_begin_conversion(parent)) { html_begin_conversion(parent); } return NSERROR_OK; }
void nsbeos_gui_view_source(struct hlcache_handle *content) { char *temp_name; bool done = false; BPath path; status_t err; size_t size; const char *source = content_get_source_data(content, &size); if (!content || !source) { warn_user("MiscError", "No document source"); return; } /* try to load local files directly. */ temp_name = url_to_path(nsurl_access(hlcache_handle_get_url(content))); if (temp_name) { path.SetTo(temp_name); BEntry entry; if (entry.SetTo(path.Path()) >= B_OK && entry.Exists() && entry.IsFile()) done = true; } if (!done) { /* We cannot release the requested filename until after it * has finished being used. As we can't easily find out when * this is, we simply don't bother releasing it and simply * allow it to be re-used next time NetSurf is started. The * memory overhead from doing this is under 1 byte per * filename. */ const char *filename = filename_request(); if (!filename) { warn_user("NoMemory", 0); return; } path.SetTo(TEMP_FILENAME_PREFIX); path.Append(filename); BFile file(path.Path(), B_WRITE_ONLY | B_CREATE_FILE); err = file.InitCheck(); if (err < B_OK) { warn_user("IOError", strerror(err)); return; } err = file.Write(source, size); if (err < B_OK) { warn_user("IOError", strerror(err)); return; } lwc_string *mime = content_get_mime_type(content); if (mime) { file.WriteAttr("BEOS:TYPE", B_MIME_STRING_TYPE, 0LL, lwc_string_data(mime), lwc_string_length(mime) + 1); lwc_string_unref(mime); } } entry_ref ref; if (get_ref_for_path(path.Path(), &ref) < B_OK) return; BMessage m(B_REFS_RECEIVED); m.AddRef("refs", &ref); // apps to try const char *editorSigs[] = { "application/x-vnd.beunited.pe", "application/x-vnd.XEmacs", "application/x-vnd.Haiku-StyledEdit", "application/x-vnd.Be-STEE", "application/x-vnd.yT-STEE", NULL }; int i; for (i = 0; editorSigs[i]; i++) { team_id team = -1; { BMessenger msgr(editorSigs[i], team); if (msgr.SendMessage(&m) >= B_OK) break; } err = be_roster->Launch(editorSigs[i], (BMessage *)&m, &team); if (err >= B_OK) break; } }
void ami_file_save(int type, char *fname, struct Window *win, struct hlcache_handle *object, struct hlcache_handle *favicon, struct browser_window *bw) { BPTR lock, fh; const char *source_data; ULONG source_size; struct bitmap *bm; ami_update_pointer(win, GUI_POINTER_WAIT); if(ami_download_check_overwrite(fname, win, 0)) { switch(type) { case AMINS_SAVE_SOURCE: if((source_data = content_get_source_data(object, &source_size))) { BPTR fh; if(fh = FOpen(fname, MODE_NEWFILE,0)) { FWrite(fh, source_data, 1, source_size); FClose(fh); } } break; case AMINS_SAVE_TEXT: save_as_text(object, fname); break; case AMINS_SAVE_COMPLETE: if(lock = CreateDir(fname)) { UnLock(lock); save_complete(object, fname, ami_file_set_type); amiga_icon_superimpose_favicon(fname, favicon, NULL); } break; case AMINS_SAVE_PDF: #ifdef WITH_PDF_EXPORT if(save_as_pdf(object, fname)) amiga_icon_superimpose_favicon(fname, favicon, "pdf"); #endif break; case AMINS_SAVE_IFF: if((bm = content_get_bitmap(object))) { bm->url = (char *)nsurl_access(hlcache_handle_get_url(object)); bm->title = (char *)content_get_title(object); bitmap_save(bm, fname, 0); } #ifdef WITH_NS_SVG else if(ami_mime_compare(object, "svg") == true) { ami_save_svg(object, fname); } #endif break; case AMINS_SAVE_SELECTION: if(source_data = browser_window_get_selection(bw)) { if(fh = FOpen(fname, MODE_NEWFILE,0)) { FWrite(fh, source_data, 1, strlen(source_data)); FClose(fh); } free((void *)source_data); } break; } if(object) SetComment(fname, nsurl_access(hlcache_handle_get_url(object))); } ami_update_pointer(win, GUI_POINTER_DEFAULT); }
bool save_complete_html(hlcache_handle *c, const char *path, bool index, struct save_complete_entry **list) { struct html_stylesheet *sheets; struct content_html_object *objects; const char *base_url; char filename[256]; unsigned int i, count; xmlDocPtr doc; bool res; if (content_get_type(c) != CONTENT_HTML) return false; if (save_complete_list_check(c, *list)) return true; base_url = html_get_base_url(c); /* save stylesheets, ignoring the base and adblocking sheets */ sheets = html_get_stylesheets(c, &count); for (i = STYLESHEET_START; i != count; i++) { hlcache_handle *css; const char *css_data; unsigned long css_size; char *source; int source_len; struct nscss_import *imports; uint32_t import_count; if (sheets[i].type == HTML_STYLESHEET_INTERNAL) { if (save_imported_sheets( sheets[i].data.internal->imports, sheets[i].data.internal->import_count, path, list) == false) return false; continue; } css = sheets[i].data.external; if (!css) continue; if (save_complete_list_check(css, *list)) continue; if (!save_complete_list_add(css, list)) { warn_user("NoMemory", 0); return false; } imports = nscss_get_imports(css, &import_count); if (!save_imported_sheets(imports, 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; } /* save objects */ objects = html_get_objects(c, &count); for (i = 0; i != count; i++) { hlcache_handle *obj = objects[i].content; const char *obj_data; unsigned long obj_size; if (obj == NULL || content_get_type(obj) >= CONTENT_OTHER) continue; obj_data = content_get_source_data(obj, &obj_size); if (obj_data == NULL) continue; if (save_complete_list_check(obj, *list)) continue; if (!save_complete_list_add(obj, list)) { warn_user("NoMemory", 0); return false; } if (content_get_type(obj) == CONTENT_HTML) { if (!save_complete_html(obj, path, false, list)) return false; continue; } snprintf(filename, sizeof filename, "%p", obj); res = save_complete_gui_save(path, filename, obj_size, obj_data, content_get_type(obj)); if(res == false) return false; } /*save_complete_list_dump();*/ /* copy document */ doc = xmlCopyDoc(html_get_document(c), 1); if (doc == NULL) { warn_user("NoMemory", 0); return false; } /* rewrite all urls we know about */ if (!rewrite_document_urls(doc, html_get_base_url(c), *list)) { xmlFreeDoc(doc); warn_user("NoMemory", 0); return false; } /* save the html file out last of all */ if (index) snprintf(filename, sizeof filename, "index"); else snprintf(filename, sizeof filename, "%p", c); errno = 0; if (save_complete_htmlSaveFileFormat(path, filename, doc, 0, 0) == -1) { if (errno) warn_user("SaveError", strerror(errno)); else warn_user("SaveError", "htmlSaveFileFormat failed"); xmlFreeDoc(doc); return false; } xmlFreeDoc(doc); return true; }