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;
}
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;
}
bool ro_gui_save_theme(char *path) {
os_error *error;
struct theme_file_header *file_header;
char *workspace;
int workspace_size, output_size, input_left, output_left;
squash_output_status status;
/* Get some memory
*/
unsigned int file_size = sizeof (struct theme_file_header);
file_header = (struct theme_file_header *)calloc(file_size, 1);
if (!file_header) {
LOG(("No memory for calloc()"));
warn_user("NoMemory", 0);
return false;
}
/* Complete the header
*/
file_header->magic_value = 0x4d54534e;
file_header->parser_version = 2;
strcpy(file_header->name, ro_gui_get_icon_string(dialog_main, ICON_MAIN_NAME));
strcpy(file_header->author, ro_gui_get_icon_string(dialog_main, ICON_MAIN_AUTHOR));
file_header->browser_bg = ro_gui_get_icon_background_colour(dialog_main,
ICON_MAIN_BROWSER_COLOUR);
file_header->hotlist_bg = ro_gui_get_icon_background_colour(dialog_main,
ICON_MAIN_HOTLIST_COLOUR);
file_header->status_bg = ro_gui_get_icon_background_colour(dialog_main,
ICON_MAIN_STATUSBG_COLOUR);
file_header->status_fg = ro_gui_get_icon_background_colour(dialog_main,
ICON_MAIN_STATUSFG_COLOUR);
if (ro_gui_get_icon_selected_state(dialog_main, ICON_MAIN_THROBBER_LEFT))
file_header->theme_flags = (1 << 0);
if (ro_gui_get_icon_selected_state(dialog_main, ICON_MAIN_THROBBER_REDRAW))
file_header->theme_flags = (1 << 1);
/* Append the compressed sprites
*/
if (theme_sprites) {
file_header->decompressed_sprite_size = theme_sprites->size;
error = xsquash_compress_return_sizes(theme_sprites->size,
&workspace_size, &output_size);
if (error) {
free(file_header);
LOG(("xsquash_compress_return_sizes: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MiscError", error->errmess);
return false;
}
workspace = realloc(file_header,
file_size + output_size);
if (!workspace) {
free(file_header);
LOG(("No memory for realloc()"));
warn_user("NoMemory", 0);
return false;
}
file_header = (struct theme_file_header *)workspace;
workspace = malloc(workspace_size);
if (!workspace) {
free(file_header);
LOG(("No memory for malloc()"));
warn_user("NoMemory", 0);
return false;
}
error = xsquash_compress((squash_input_status)0,
workspace, (byte *)theme_sprites,
theme_sprites->size,
(byte *)(file_header + 1), output_size,
&status,
0, &input_left, 0, &output_left);
free(workspace);
if (error) {
free(file_header);
LOG(("xsquash_compress: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MiscError", error->errmess);
return false;
}
if ((input_left > 0) || (status != 0)) {
free(file_header);
LOG(("Failed to complete compression with %i bytes left and status %i",
input_left, (int)status));
warn_user("FileError", 0);
return false;
}
file_header->compressed_sprite_size = output_size - output_left;
file_size += output_size - output_left;
}
/* Save the file
*/
error = xosfile_save_stamped(path, (bits)0xffd,
(char *)file_header, ((char *)file_header) + file_size);
free(file_header);
if (error) {
LOG(("xosfile_save_stamped: 0x%x: %s",
error->errnum, error->errmess));
warn_user("FileError", error->errmess);
return false;
}
return false;
}
bool save_as_draw(hlcache_handle *h, const char *path)
{
pencil_code code;
char *drawfile_buffer;
struct rect clip;
struct content_redraw_data data;
size_t drawfile_size;
os_error *error;
struct redraw_context ctx = {
.interactive = false,
.background_images = true,
.plot = &ro_save_draw_plotters
};
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);
clip.x0 = clip.y0 = INT_MIN;
clip.x1 = clip.y1 = INT_MAX;
data.x = 0;
data.y = -ro_save_draw_height;
data.width = ro_save_draw_width;
data.height = ro_save_draw_height;
data.background_colour = 0xFFFFFF;
data.scale = 1;
data.repeat_x = false;
data.repeat_y = false;
if (!content_redraw(h, &data, &clip, &ctx)) {
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;
}
bool ro_save_draw_rectangle(int x0, int y0, int x1, int y1, const plot_style_t *style)
{
pencil_code code;
const int path[] = { draw_MOVE_TO, x0 * 2, -y0 * 2 - 1,
draw_LINE_TO, x1 * 2, -y0 * 2 - 1,
draw_LINE_TO, x1 * 2, -y1 * 2 - 1,
draw_LINE_TO, x0 * 2, -y1 * 2 - 1,
draw_CLOSE_LINE,
draw_END_PATH };
if (style->fill_type != PLOT_OP_TYPE_NONE) {
code = pencil_path(ro_save_draw_diagram,
path,
sizeof path / sizeof path[0],
style->fill_colour << 8,
pencil_TRANSPARENT,
0,
pencil_JOIN_MITRED,
pencil_CAP_BUTT,
pencil_CAP_BUTT,
0,
0,
false,
pencil_SOLID);
if (code != pencil_OK)
return ro_save_draw_error(code);
}
if (style->stroke_type != PLOT_OP_TYPE_NONE) {
code = pencil_path(ro_save_draw_diagram,
path,
sizeof path / sizeof path[0],
pencil_TRANSPARENT,
style->stroke_colour << 8,
style->stroke_width,
pencil_JOIN_MITRED,
pencil_CAP_BUTT,
pencil_CAP_BUTT,
0,
0,
false,
pencil_SOLID);
if (code != pencil_OK)
return ro_save_draw_error(code);
}
return true;
}
