gboolean tilem_animation_save(TilemAnimation *anim,
const char *fname, const char *type,
char **option_keys, char **option_values,
GError **err)
{
FILE *fp;
char *dname;
int errnum;
GdkPixbuf *pb;
gboolean status;
byte palette[768];
int i;
g_return_val_if_fail(TILEM_IS_ANIMATION(anim), FALSE);
g_return_val_if_fail(fname != NULL, FALSE);
g_return_val_if_fail(type != NULL, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
if (strcmp(type, "gif") != 0) {
pb = gdk_pixbuf_animation_get_static_image
(GDK_PIXBUF_ANIMATION(anim));
status = gdk_pixbuf_savev(pb, fname, type,
option_keys, option_values,
err);
return status;
}
fp = g_fopen(fname, "wb");
if (!fp) {
errnum = errno;
dname = g_filename_display_name(fname);
g_set_error(err, G_FILE_ERROR,
g_file_error_from_errno(errnum),
_("Failed to open '%s' for writing: %s"),
dname, g_strerror(errnum));
g_free(dname);
return FALSE;
}
for (i = 0; i < 256; i++) {
palette[3 * i] = anim->palette[i] >> 16;
palette[3 * i + 1] = anim->palette[i] >> 8;
palette[3 * i + 2] = anim->palette[i];
}
tilem_animation_write_gif(anim, palette, 256, fp);
if (fclose(fp)) {
errnum = errno;
dname = g_filename_display_name(fname);
g_set_error(err, G_FILE_ERROR,
g_file_error_from_errno(errnum),
_("Error while closing '%s': %s"),
dname, g_strerror(errnum));
g_free(dname);
return FALSE;
}
return TRUE;
}
static void
save_file(GtkWidget *widget, gpointer user_data)
{
GUI* gptr = (GUI*) user_data;
Window* w = gptr->get_window();
Plane* p = gptr->get_plane();
int width = atoi(gtk_entry_get_text((GtkEntry*)w->width_entry));
int height = atoi(gtk_entry_get_text((GtkEntry*)w->height_entry));
Plane plane(width, height);
plane.up = p->up;
plane.down = p->down;
plane.left = p->left;
plane.right = p->right;
Renderer renderer("", gptr->get_rs()[gptr->get_rs_current()].get_function());
renderer.set_plane(&plane);
renderer.render();
GError *error = NULL;
GdkPixbuf* pixbuf = gdk_pixbuf_new_from_data (
plane.data,
GDK_COLORSPACE_RGB,
FALSE,
8,
plane.width,
plane.height,
plane.width*3,
NULL,
NULL);
gdk_pixbuf_savev (pixbuf, "New.bmp", "bmp", NULL, NULL, &error);
g_object_unref(pixbuf);
}
static gboolean write_image(GObject* image, const char* filename)
{
char *keys[11]; /* enough for known keys + 1 */
char *vals[11];
GdkPixbuf *pix = GDK_PIXBUF(image);
char *known_keys[] = { "tEXt::Thumb::URI", "tEXt::Thumb::MTime",
"tEXt::Thumb::Size", "tEXt::Thumb::Mimetype",
"tEXt::Description", "tEXt::Software",
"tEXt::Thumb::Image::Width", "tEXt::Thumb::Image::Height",
"tEXt::Thumb::Document::Pages", "tEXt::Thumb::Movie::Length" };
guint i, x;
/* unfortunately GdkPixbuf APIs does not contain API to get
list of options that are set, neither there is API to save
the file with all options, so all we can do now is to scan
options for known ones and save them into target file */
for (i = 0, x = 0; i < G_N_ELEMENTS(known_keys); i++)
{
const char *val = gdk_pixbuf_get_option(pix, known_keys[i]);
if (val)
{
keys[x] = known_keys[i];
vals[x] = (char*)val;
x++;
}
}
keys[x] = NULL;
vals[x] = NULL;
return gdk_pixbuf_savev(pix, filename, "png", keys, vals, NULL);
}
// Save current picture as PNG
void saveCurrentPic() {
GdkPixbuf *scaledpb;
GString *pngfilename;
pngfilename = g_string_new(g_key_file_get_string(config,"slowrx","rxdir",NULL));
g_string_append_printf(pngfilename, "/%s_%s.png", CurrentPic.timestr, ModeSpec[CurrentPic.Mode].ShortName);
printf(" Saving to %s\n", pngfilename->str);
scaledpb = gdk_pixbuf_scale_simple (pixbuf_rx, ModeSpec[CurrentPic.Mode].ImgWidth,
ModeSpec[CurrentPic.Mode].ImgHeight * ModeSpec[CurrentPic.Mode].YScale, GDK_INTERP_HYPER);
ensure_dir_exists(g_key_file_get_string(config,"slowrx","rxdir",NULL));
gdk_pixbuf_savev(scaledpb, pngfilename->str, "png", NULL, NULL, NULL);
g_object_unref(scaledpb);
g_string_free(pngfilename, TRUE);
}
gboolean
_gdk_pixbuf_savev (GdkPixbuf *pixbuf,
const char *local_file,
const char *type,
char **keys,
char **values,
GError **error)
{
gboolean result;
g_return_val_if_fail (pixbuf != NULL, FALSE);
g_return_val_if_fail (local_file != NULL, FALSE);
g_return_val_if_fail (type != NULL, FALSE);
g_return_val_if_fail (! uri_has_scheme (local_file), FALSE);
#ifdef HAVE_LIBTIFF
if (strcmp (type, "tiff") == 0)
result = _gdk_pixbuf_save_as_tiff (pixbuf,
local_file,
keys, values,
error);
else
#endif
if (strcmp (type, "jpeg") == 0)
result = _gdk_pixbuf_save_as_jpeg (pixbuf,
local_file,
keys, values,
error);
else
if ((strcmp (type, "x-tga") == 0) || (strcmp (type, "tga") == 0))
result = _gdk_pixbuf_save_as_tga (pixbuf,
local_file,
keys, values,
error);
else
result = gdk_pixbuf_savev (pixbuf, local_file, type,
keys, values,
error);
return result;
}
//getPic saves the current imagebuf to a png file
gboolean getPic(gpointer data) {
numLines = 1;
std::string filename = FILENAME;
std::ostringstream ss;
ss << fileSeed;
filename.append(ss.str());
std::cout << "Saving image as " << filename << std::endl;
filename.append(".");
filename.append(FILETYPE);
gdk_pixbuf_savev(imagebuf, filename.c_str(), FILETYPE, NULL, NULL, NULL);
fileSeed++;
//remove the old seedfile
system("rm seedfile.dat");
//rewrite the seedfile with an incremented count
std::ofstream seedFile;
seedFile.open(SEEDFILE);
seedFile << fileSeed;
seedFile.close();
return FALSE;
}
void write_setting(SettingItem * item, gpointer p)
{
GKeyFile * f = (GKeyFile *) p;
switch(item->type)
{
case ST_BOOL:
g_key_file_set_boolean(f,item->section,item->key,get_bool(item));
break;
case ST_INT:
g_key_file_set_integer(f,item->section,item->key,get_int(item));
break;
case ST_FLOAT:
g_key_file_set_string(f,item->section,item->key,get_float_str(item));
break;
case ST_COLOR:
g_key_file_set_string(f,item->section,item->key,get_color(item));
break;
case ST_FONT:
g_key_file_set_string(f,item->section,item->key,get_font(item));
break;
case ST_META_STRING:
g_key_file_set_string(f,item->section,item->key,get_string(item));
break;
case ST_STRING_COMBO:
g_key_file_set_string(f,item->section,item->key,get_string_combo(item));
break;
case ST_IMG_FILE:
//g_key_file_set_string(f,item->section,item->key,get_img_file(item));
{
gchar * s = g_strdup_printf("%s/.emerald/theme/%s.%s.png",g_get_home_dir(),item->section,item->key);
GdkPixbuf * pbuf = gtk_image_get_pixbuf(item->image);
if (pbuf)
{
gdk_pixbuf_savev(pbuf,s,"png",NULL,NULL,NULL);
}
else
{
g_unlink(s); // to really clear out a clear'd image
}
g_free(s);
}
break;
case ST_ENGINE_COMBO:
{
EngineMetaInfo emi;
const gchar * active_engine = get_engine_combo(item);
if (get_engine_meta_info(active_engine,&emi))
g_key_file_set_string(f,"engine_version",active_engine,emi.version);
g_key_file_set_string(f,item->section,item->key,active_engine);
do_engine(active_engine);
}
break;
case ST_SFILE_INT:
if (f==global_theme_file)
{
g_key_file_set_integer(global_settings_file,item->section,
item->key,get_int(item));
write_setting_file();
}
break;
case ST_SFILE_BOOL:
if (f==global_theme_file)
{
g_key_file_set_boolean(global_settings_file,item->section,
item->key,get_bool(item));
write_setting_file();
}
break;
case ST_SFILE_INT_COMBO:
if (f==global_theme_file)
{
g_key_file_set_integer(global_settings_file,item->section,
item->key,get_sf_int_combo(item));
write_setting_file();
}
break;
default:
break;
//unhandled types
}
}
static gboolean
gimp_thumbnail_save (GimpThumbnail *thumbnail,
GimpThumbSize size,
const gchar *filename,
GdkPixbuf *pixbuf,
const gchar *software,
GError **error)
{
const gchar *keys[12];
gchar *values[12];
gchar *basename;
gchar *dirname;
gchar *tmpname;
gboolean success;
gint i = 0;
keys[i] = TAG_DESCRIPTION;
values[i] = g_strdup_printf ("Thumbnail of %s", thumbnail->image_uri);
i++;
keys[i] = TAG_SOFTWARE;
values[i] = g_strdup (software);
i++;
keys[i] = TAG_THUMB_URI;
values[i] = g_strdup (thumbnail->image_uri);
i++;
keys[i] = TAG_THUMB_MTIME;
values[i] = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_mtime);
i++;
keys[i] = TAG_THUMB_FILESIZE;
values[i] = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_filesize);
i++;
if (thumbnail->image_mimetype)
{
keys[i] = TAG_THUMB_MIMETYPE;
values[i] = g_strdup (thumbnail->image_mimetype);
i++;
}
if (thumbnail->image_width > 0)
{
keys[i] = TAG_THUMB_IMAGE_WIDTH;
values[i] = g_strdup_printf ("%d", thumbnail->image_width);
i++;
}
if (thumbnail->image_height > 0)
{
keys[i] = TAG_THUMB_IMAGE_HEIGHT;
values[i] = g_strdup_printf ("%d", thumbnail->image_height);
i++;
}
if (thumbnail->image_type)
{
keys[i] = TAG_THUMB_GIMP_TYPE;
values[i] = g_strdup (thumbnail->image_type);
i++;
}
if (thumbnail->image_num_layers > 0)
{
keys[i] = TAG_THUMB_GIMP_LAYERS;
values[i] = g_strdup_printf ("%d", thumbnail->image_num_layers);
i++;
}
keys[i] = NULL;
values[i] = NULL;
basename = g_path_get_basename (filename);
dirname = g_path_get_dirname (filename);
tmpname = g_strdup_printf ("%s%cgimp-thumb-%d-%.8s",
dirname, G_DIR_SEPARATOR, getpid (), basename);
g_free (dirname);
g_free (basename);
success = gdk_pixbuf_savev (pixbuf, tmpname, "png",
(gchar **) keys, values,
error);
for (i = 0; keys[i]; i++)
g_free (values[i]);
if (success)
{
#ifdef GIMP_THUMB_DEBUG
g_printerr ("thumbnail saved to temporary file %s\n", tmpname);
#endif
success = (g_rename (tmpname, filename) == 0);
if (! success)
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not create thumbnail for %s: %s"),
thumbnail->image_uri, g_strerror (errno));
}
if (success)
{
#ifdef GIMP_THUMB_DEBUG
g_printerr ("temporary thumbnail file renamed to %s\n", filename);
#endif
success = (g_chmod (filename, 0600) == 0);
if (! success)
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
"Could not set permissions of thumbnail for %s: %s",
thumbnail->image_uri, g_strerror (errno));
g_object_freeze_notify (G_OBJECT (thumbnail));
gimp_thumbnail_update_thumb (thumbnail, size);
if (success &&
thumbnail->thumb_state == GIMP_THUMB_STATE_EXISTS &&
strcmp (filename, thumbnail->thumb_filename) == 0)
{
thumbnail->thumb_state = GIMP_THUMB_STATE_OK;
}
g_object_thaw_notify (G_OBJECT (thumbnail));
}
g_unlink (tmpname);
g_free (tmpname);
return success;
}
