static gchar *
ft_manager_format_progress_bytes_and_percentage (guint64 current,
guint64 total,
gdouble speed,
int *percentage)
{
char *total_str, *current_str, *retval;
char *speed_str = NULL;
total_str = g_format_size_for_display (total);
current_str = g_format_size_for_display (current);
if (speed > 0)
speed_str = g_format_size_for_display ((goffset) speed);
/* translators: first %s is the currently processed size, second %s is
* the total file size */
retval = speed_str ?
g_strdup_printf (_("%s of %s at %s/s"), current_str, total_str, speed_str) :
g_strdup_printf (_("%s of %s"), current_str, total_str);
g_free (total_str);
g_free (current_str);
g_free (speed_str);
if (percentage != NULL)
{
if (total != 0)
*percentage = current * 100 / total;
else
*percentage = -1;
}
return retval;
}
static void
update_information_widget ()
{
gchar *path = g_downloadable_get_save_path (selected_download);
gchar *size_str = g_format_size_for_display (g_downloadable_get_size (selected_download));
gchar *downloaded_str = g_format_size_for_display (g_downloadable_get_downloaded_size (selected_download));
gchar time_str[128];
time_t time = g_downloadable_get_start_time (selected_download);
struct tm *started_time = localtime (&time);
strftime (time_str, 128, "%a %d %b %R %p", started_time);
gtk_label_set_text (GTK_LABEL (size), size_str);
gtk_label_set_text (GTK_LABEL (location), path);
gtk_label_set_text (GTK_LABEL (downloaded), downloaded_str);
gtk_label_set_text (GTK_LABEL (started), time_str);
gtk_label_set_text (GTK_LABEL (url), g_downloadable_get_url (selected_download));
Category *cat = g_downloadable_get_category (selected_download);
if (cat == NULL)
gtk_label_set_text (GTK_LABEL (category), _("Unknown"));
else
gtk_label_set_text (GTK_LABEL (category), category_get_name (cat));
g_free (path);
g_free (size_str);
g_free (downloaded_str);
}
void gtkhash_hash_file_report_cb(void *data, goffset file_size,
goffset total_read, GTimer *timer)
{
gdk_threads_enter();
struct page_s *page = data;
gtk_progress_bar_set_fraction(page->progressbar,
(double)total_read /
(double)file_size);
double elapsed = g_timer_elapsed(timer, NULL);
if (elapsed <= 1)
goto out;
// Update progressbar text...
unsigned int s = elapsed / total_read * (file_size - total_read);
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION < 30))
char *total_read_str = g_format_size_for_display(total_read);
char *file_size_str = g_format_size_for_display(file_size);
char *speed_str = g_format_size_for_display(total_read / elapsed);
#else
char *total_read_str = g_format_size(total_read);
char *file_size_str = g_format_size(file_size);
char *speed_str = g_format_size(total_read / elapsed);
#endif
char *text;
if (s > 60) {
unsigned int m = s / 60;
if (m == 1)
text = g_strdup_printf(_("%s of %s - 1 minute left (%s/sec)"),
total_read_str, file_size_str, speed_str);
else
text = g_strdup_printf(_("%s of %s - %u minutes left (%s/sec)"),
total_read_str, file_size_str, m, speed_str);
} else {
if (s == 1)
text = g_strdup_printf(_("%s of %s - 1 second left (%s/sec)"),
total_read_str, file_size_str, speed_str);
else
text = g_strdup_printf(_("%s of %s - %u seconds left (%s/sec)"),
total_read_str, file_size_str, s, speed_str);
}
gtk_progress_bar_set_text(page->progressbar, text);
g_free(text);
g_free(speed_str);
g_free(file_size_str);
g_free(total_read_str);
out:
gdk_threads_leave();
}
static void
gth_metadata_provider_file_read (GthMetadataProvider *self,
GthFileData *file_data,
const char *attributes)
{
GFileAttributeMatcher *matcher;
char *value;
GTimeVal *timeval_p;
const char *value_s;
matcher = g_file_attribute_matcher_new (attributes);
value = g_format_size_for_display (g_file_info_get_size (file_data->info));
g_file_info_set_attribute_string (file_data->info, "gth::file::display-size", value);
g_free (value);
timeval_p = gth_file_data_get_modification_time (file_data);
value = _g_time_val_strftime (timeval_p, "%x %X");
g_file_info_set_attribute_string (file_data->info, "gth::file::display-mtime", value);
g_free (value);
value = g_file_get_parse_name (file_data->file);
g_file_info_set_attribute_string (file_data->info, "gth::file::full-name", value);
g_free (value);
value_s = get_static_string (g_file_info_get_content_type (file_data->info));
if (value_s != NULL)
g_file_info_set_attribute_string (file_data->info, "gth::file::content-type", value_s);
g_file_attribute_matcher_unref (matcher);
}
JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GlibMisc_g_1format_1size_1for_1display
(
JNIEnv* env,
jclass cls,
jlong _size
)
{
char* result;
jstring _result;
goffset size;
// convert parameter size
size = (goffset) _size;
// call function
result = g_format_size_for_display(size);
// cleanup parameter size
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// cleanup return value
if (result != NULL) {
g_free(result);
}
// and finally
return _result;
}
char *
mpd_storage_device_tile_get_title (MpdStorageDeviceTile *self)
{
MpdStorageDeviceTilePrivate *priv = GET_PRIVATE (self);
int64_t size = -1;
int64_t available_size = -1;
char *markup = NULL;
if (priv->storage)
{
g_object_get (priv->storage,
"size", &size,
"available-size", &available_size,
NULL);
}
if (size > -1 && available_size > -1)
{
unsigned int percentage = 100 - (double) available_size / size * 100;
char *size_text = g_format_size_for_display (size);
markup = g_strdup_printf (_("<span font-weight='bold'>%s</span> using "
"<span color='%s'>%d%% of %s</span>"),
priv->name,
TEXT_COLOR,
percentage,
size_text);
g_free (size_text);
} else {
markup = g_strdup_printf (_("<span font-weight='bold'>%s</span>"),
priv->name);
}
return markup;
}
static void
update_album_list (DialogData *data)
{
GtkTreeIter iter;
GList *scan;
char *free_space;
g_return_if_fail (data->user != NULL);
free_space = g_format_size_for_display (data->user->quota_limit - data->user->quota_current);
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("free_space_label")), free_space);
g_free (free_space);
gtk_list_store_clear (GTK_LIST_STORE (GET_WIDGET ("album_liststore")));
for (scan = data->albums; scan; scan = scan->next) {
PicasaWebAlbum *album = scan->data;
char *n_photos_remaining;
char *used_bytes;
n_photos_remaining = g_strdup_printf ("%d", album->n_photos_remaining);
used_bytes = g_format_size_for_display (album->used_bytes);
gtk_list_store_append (GTK_LIST_STORE (GET_WIDGET ("album_liststore")), &iter);
gtk_list_store_set (GTK_LIST_STORE (GET_WIDGET ("album_liststore")), &iter,
ALBUM_DATA_COLUMN, album,
ALBUM_ICON_COLUMN, "file-catalog",
ALBUM_NAME_COLUMN, album->title,
ALBUM_REMAINING_IMAGES_COLUMN, n_photos_remaining,
ALBUM_USED_BYTES_COLUMN, used_bytes,
-1);
if (album->access == PICASA_WEB_ACCESS_PRIVATE)
gtk_list_store_set (GTK_LIST_STORE (GET_WIDGET ("album_liststore")), &iter,
ALBUM_EMBLEM_COLUMN, "emblem-readonly",
-1);
g_free (used_bytes);
g_free (n_photos_remaining);
}
gtk_widget_set_sensitive (GET_WIDGET ("upload_button"), FALSE);
}
static void
show_progress (goffset current_num_bytes,
goffset total_num_bytes,
gpointer user_data)
{
GTimeVal tv;
char *size;
g_get_current_time (&tv);
size = g_format_size_for_display (current_num_bytes / MAX (tv.tv_sec - start_time.tv_sec, 1));
g_print ("progress %"G_GINT64_FORMAT"/%"G_GINT64_FORMAT" (%s/s)\n",
current_num_bytes, total_num_bytes, size);
g_free (size);
}
static void
image_scale_confirm_large (ImageScaleDialog *dialog,
gint64 new_memsize,
gint64 max_memsize)
{
GtkWidget *widget = image_scale_confirm_dialog (dialog);
gchar *size;
size = g_format_size_for_display (new_memsize);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (widget)->box,
_("You are trying to create an image "
"with a size of %s."), size);
g_free (size);
size = g_format_size_for_display (max_memsize);
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (widget)->box,
_("Scaling the image to the chosen size will "
"make it use more memory than what is "
"configured as \"Maximum Image Size\" in the "
"Preferences dialog (currently %s)."), size);
g_free (size);
gtk_widget_show (widget);
}
char*
tr_strlsize( char * buf,
guint64 size,
size_t buflen )
{
if( !size )
g_strlcpy( buf, _( "None" ), buflen );
#if GLIB_CHECK_VERSION( 2, 16, 0 )
else
{
char * tmp = g_format_size_for_display( size );
g_strlcpy( buf, tmp, buflen );
g_free( tmp );
}
#else
else if( size < (guint64)KILOBYTE_FACTOR )
static void
mail_attachment_bar_update_status (EMailAttachmentBar *bar)
{
EAttachmentView *view;
EAttachmentStore *store;
GtkActivatable *activatable;
GtkAction *action;
GtkLabel *label;
gint num_attachments;
guint64 total_size;
gchar *display_size;
gchar *markup;
view = E_ATTACHMENT_VIEW (bar);
store = e_attachment_view_get_store (view);
label = GTK_LABEL (bar->priv->status_label);
num_attachments = e_attachment_store_get_num_attachments (store);
total_size = e_attachment_store_get_total_size (store);
display_size = g_format_size_for_display (total_size);
if (total_size > 0)
markup = g_strdup_printf (
"<b>%d</b> %s (%s)", num_attachments, ngettext (
"Attachment", "Attachments", num_attachments),
display_size);
else
markup = g_strdup_printf (
"<b>%d</b> %s", num_attachments, ngettext (
"Attachment", "Attachments", num_attachments));
gtk_label_set_markup (label, markup);
g_free (markup);
activatable = GTK_ACTIVATABLE (bar->priv->save_all_button);
action = gtk_activatable_get_related_action (activatable);
gtk_action_set_visible (action, (num_attachments > 1));
activatable = GTK_ACTIVATABLE (bar->priv->save_one_button);
action = gtk_activatable_get_related_action (activatable);
gtk_action_set_visible (action, (num_attachments == 1));
g_free (display_size);
}
const char*
mu_str_size_s (size_t s)
{
static char buf[32];
#ifdef HAVE_GLIB216
char *tmp;
tmp = g_format_size_for_display ((goffset)s);
strncpy (buf, tmp, sizeof(buf));
buf[sizeof(buf) -1] = '\0'; /* just in case */
g_free (tmp);
#else
if (s >= 1000 * 1000)
g_snprintf(buf, sizeof(buf), "%.1f MB",
(double)s/(1000*1000));
else
g_snprintf(buf, sizeof(buf), "%.1f kB", (double)s/(1000));
#endif /*HAVE_GLIB216*/
return buf;
}
static void
update (MpdDiskTile *self)
{
MpdDiskTilePrivate *priv = GET_PRIVATE (self);
char *markup;
char *size_text;
uint64_t size;
uint64_t available_size;
unsigned int percentage;
g_object_get (priv->storage,
"size", &size,
"available-size", &available_size,
NULL);
percentage = 100 - (double) available_size / size * 100;
/* We don't want to display 0% used, we still have *something* installed */
if (percentage == 0)
percentage++;
size_text = g_format_size_for_display (size);
markup = g_strdup_printf (_("You are using %d%% of %s"),
percentage,
size_text);
clutter_text_set_markup (CLUTTER_TEXT (mx_label_get_clutter_text (
MX_LABEL (priv->label))), markup);
g_free (markup);
g_free (size_text);
/* The progress bar does not look good if the percentage < 3%. We cheat
* and always display a minimum of 3% */
mx_progress_bar_set_progress (MX_PROGRESS_BAR (priv->meter),
MAX (.03, percentage / 100.));
}
/* Something very similar to g_format_size_for_display() but for rates.
* This should give the same display as in g-s-m */
static char*
format_rate_for_display(guint rate)
{
char* bytes = g_format_size_for_display(rate);
return g_strdup_printf(_("%s/s"), bytes);
}
static gboolean
copy_uri (const gchar *src_uri,
const gchar *dest_uri,
const gchar *copying_format_str,
const gchar *copied_format_str,
GError **error)
{
GnomeVFSHandle *read_handle;
GnomeVFSHandle *write_handle;
GnomeVFSFileInfo *src_info;
GnomeVFSFileSize file_size = 0;
GnomeVFSFileSize bytes_read = 0;
guchar buffer[BUFSIZE];
GnomeVFSResult result;
gchar *memsize;
GTimeVal last_time = { 0, 0 };
gimp_progress_init (_("Connecting to server"));
src_info = gnome_vfs_file_info_new ();
result = gnome_vfs_get_file_info (src_uri, src_info, 0);
/* ignore errors here, they will be noticed below */
if (result == GNOME_VFS_OK &&
(src_info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE))
{
file_size = src_info->size;
}
gnome_vfs_file_info_unref (src_info);
result = gnome_vfs_open (&read_handle, src_uri, GNOME_VFS_OPEN_READ);
if (result != GNOME_VFS_OK)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Could not open '%s' for reading: %s"),
src_uri, gnome_vfs_result_to_string (result));
return FALSE;
}
result = gnome_vfs_create (&write_handle, dest_uri,
GNOME_VFS_OPEN_WRITE, FALSE, 0644);
if (result != GNOME_VFS_OK)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Could not open '%s' for writing: %s"),
dest_uri, gnome_vfs_result_to_string (result));
gnome_vfs_close (read_handle);
return FALSE;
}
memsize = g_format_size_for_display (file_size);
gimp_progress_init_printf (file_size > 0 ?
copying_format_str : copied_format_str,
memsize);
g_free (memsize);
while (TRUE)
{
GnomeVFSFileSize chunk_read;
GnomeVFSFileSize chunk_written;
GTimeVal now;
result = gnome_vfs_read (read_handle, buffer, sizeof (buffer),
&chunk_read);
if (chunk_read == 0)
{
if (result != GNOME_VFS_ERROR_EOF)
{
memsize = g_format_size_for_display (sizeof (buffer));
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Failed to read %s from '%s': %s"),
memsize, src_uri,
gnome_vfs_result_to_string (result));
g_free (memsize);
gnome_vfs_close (read_handle);
gnome_vfs_close (write_handle);
return FALSE;
}
else
{
gimp_progress_update (1.0);
break;
}
}
bytes_read += chunk_read;
/* update the progress only up to 10 times a second */
g_get_current_time (&now);
if (((now.tv_sec - last_time.tv_sec) * 1000 +
(now.tv_usec - last_time.tv_usec) / 1000) > 100)
{
if (file_size > 0)
{
gimp_progress_update ((gdouble) bytes_read / (gdouble) file_size);
}
else
{
memsize = g_format_size_for_display (bytes_read);
gimp_progress_set_text_printf (copied_format_str, memsize);
gimp_progress_pulse ();
g_free (memsize);
}
last_time = now;
}
result = gnome_vfs_write (write_handle, buffer, chunk_read,
&chunk_written);
if (chunk_written < chunk_read)
{
memsize = g_format_size_for_display (chunk_read);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Failed to write %s to '%s': %s"),
memsize, dest_uri,
gnome_vfs_result_to_string (result));
g_free (memsize);
gnome_vfs_close (read_handle);
gnome_vfs_close (write_handle);
return FALSE;
}
}
gnome_vfs_close (read_handle);
gnome_vfs_close (write_handle);
return TRUE;
}
static void
pd_update_general_tab (EomPropertiesDialog *prop_dlg,
EomImage *image)
{
gchar *bytes_str, *dir_str, *uri_str;
gchar *width_str, *height_str;
GFile *file;
GFileInfo *file_info;
const char *mime_str;
char *type_str;
gint width, height;
goffset bytes;
g_object_set (G_OBJECT (prop_dlg->priv->thumbnail_image),
"pixbuf", eom_image_get_thumbnail (image),
NULL);
gtk_label_set_text (GTK_LABEL (prop_dlg->priv->name_label),
eom_image_get_caption (image));
eom_image_get_size (image, &width, &height);
width_str = g_strdup_printf ("%d %s", width,
ngettext ("pixel", "pixels", width));
height_str = g_strdup_printf ("%d %s", height,
ngettext ("pixel", "pixels", height));
gtk_label_set_text (GTK_LABEL (prop_dlg->priv->width_label), width_str);
gtk_label_set_text (GTK_LABEL (prop_dlg->priv->height_label),
height_str);
g_free (height_str);
g_free (width_str);
file = eom_image_get_file (image);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
0, NULL, NULL);
if (file_info == NULL) {
type_str = g_strdup (_("Unknown"));
} else {
mime_str = g_file_info_get_content_type (file_info);
type_str = g_content_type_get_description (mime_str);
g_object_unref (file_info);
}
gtk_label_set_text (GTK_LABEL (prop_dlg->priv->type_label), type_str);
bytes = eom_image_get_bytes (image);
bytes_str = g_format_size_for_display (bytes);
gtk_label_set_text (GTK_LABEL (prop_dlg->priv->bytes_label), bytes_str);
uri_str = eom_image_get_uri_for_display (image);
dir_str = g_path_get_dirname (uri_str);
gtk_label_set_text (GTK_LABEL (prop_dlg->priv->location_label),
dir_str);
g_free (type_str);
g_free (bytes_str);
g_free (dir_str);
g_free (uri_str);
}
void
dlg_export_to_picasaweb (GthBrowser *browser,
GList *file_list)
{
DialogData *data;
GtkTreeSelection *selection;
GList *scan;
int n_total;
goffset total_size;
char *total_size_formatted;
char *text;
data = g_new0 (DialogData, 1);
data->browser = browser;
data->location = gth_file_data_dup (gth_browser_get_location_data (browser));
data->builder = _gtk_builder_new_from_file ("export-to-picasaweb.ui", "picasaweb");
data->dialog = _gtk_builder_get_widget (data->builder, "export_dialog");
data->cancellable = g_cancellable_new ();
{
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
cell_layout = GTK_CELL_LAYOUT (GET_WIDGET ("name_treeviewcolumn"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"icon-name", ALBUM_ICON_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"text", ALBUM_NAME_COLUMN,
NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"icon-name", ALBUM_EMBLEM_COLUMN,
NULL);
}
_gtk_window_resize_to_fit_screen_height (data->dialog, 500);
data->file_list = NULL;
n_total = 0;
total_size = 0;
for (scan = file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
const char *mime_type;
mime_type = gth_file_data_get_mime_type (file_data);
if (g_content_type_equals (mime_type, "image/bmp")
|| g_content_type_equals (mime_type, "image/gif")
|| g_content_type_equals (mime_type, "image/jpeg")
|| g_content_type_equals (mime_type, "image/png"))
{
total_size += g_file_info_get_size (file_data->info);
n_total++;
data->file_list = g_list_prepend (data->file_list, g_object_ref (file_data));
}
}
data->file_list = g_list_reverse (data->file_list);
if (data->file_list == NULL) {
GError *error;
if (data->conn != NULL)
gth_task_dialog (GTH_TASK (data->conn), TRUE);
error = g_error_new_literal (GTH_ERROR, GTH_ERROR_GENERIC, _("No valid file selected."));
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser), _("Could not export the files"), &error);
destroy_dialog (data);
return;
}
total_size_formatted = g_format_size_for_display (total_size);
text = g_strdup_printf (g_dngettext (NULL, "%d file (%s)", "%d files (%s)", n_total), n_total, total_size_formatted);
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("images_info_label")), text);
g_free (text);
g_free (total_size_formatted);
/* Set the widget data */
data->list_view = gth_file_list_new (GTH_FILE_LIST_TYPE_NO_SELECTION, FALSE);
gth_file_list_set_thumb_size (GTH_FILE_LIST (data->list_view), 112);
gth_file_view_set_spacing (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->list_view))), 0);
gth_file_list_enable_thumbs (GTH_FILE_LIST (data->list_view), TRUE);
gth_file_list_set_caption (GTH_FILE_LIST (data->list_view), "none");
gth_file_list_set_sort_func (GTH_FILE_LIST (data->list_view), gth_main_get_sort_type ("file::name")->cmp_func, FALSE);
gtk_widget_show (data->list_view);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("images_box")), data->list_view, TRUE, TRUE, 0);
gth_file_list_set_files (GTH_FILE_LIST (data->list_view), data->file_list);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("album_liststore")), ALBUM_NAME_COLUMN, GTK_SORT_ASCENDING);
gtk_widget_set_sensitive (GET_WIDGET ("upload_button"), FALSE);
/* Set the signals handlers. */
g_signal_connect (data->dialog,
"delete-event",
G_CALLBACK (gtk_widget_hide_on_delete),
NULL);
g_signal_connect (data->dialog,
"response",
G_CALLBACK (export_dialog_response_cb),
data);
g_signal_connect (GET_WIDGET ("add_album_button"),
"clicked",
G_CALLBACK (add_album_button_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("edit_accounts_button"),
"clicked",
G_CALLBACK (edit_accounts_button_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("account_combobox"),
"changed",
G_CALLBACK (account_combobox_changed_cb),
data);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (GET_WIDGET ("albums_treeview")));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection,
"changed",
G_CALLBACK (albums_treeview_selection_changed_cb),
data);
data->accounts = picasa_web_accounts_load_from_file (&data->email);
auto_select_account (data);
}
gboolean
uri_backend_load_image (const gchar *uri,
const gchar *tmpname,
GimpRunMode run_mode,
GError **error)
{
gint pid;
gint p[2];
if (pipe (p) != 0)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"pipe() failed: %s", g_strerror (errno));
return FALSE;
}
/* open a process group, so killing the plug-in will kill wget too */
setpgid (0, 0);
if ((pid = fork()) < 0)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"fork() failed: %s", g_strerror (errno));
return FALSE;
}
else if (pid == 0)
{
gchar timeout_str[16];
close (p[0]);
close (2);
dup (p[1]);
close (p[1]);
/* produce deterministic output */
g_setenv ("LANGUAGE", "C", TRUE);
g_setenv ("LC_ALL", "C", TRUE);
g_setenv ("LANG", "C", TRUE);
g_snprintf (timeout_str, sizeof (timeout_str), "%d", TIMEOUT);
execlp ("wget",
"wget", "-v", "-e", "server-response=off", "--progress=dot", "-T", timeout_str,
uri, "-O", tmpname, NULL);
_exit (127);
}
else
{
FILE *input;
gchar buf[BUFSIZE];
gboolean seen_resolve = FALSE;
gboolean seen_ftp = FALSE;
gboolean connected = FALSE;
gboolean redirect = FALSE;
gboolean file_found = FALSE;
gchar sizestr[37];
gchar *endptr;
guint64 size = 0;
gint i, j;
gchar dot;
guint64 kilobytes = 0;
gboolean finished = FALSE;
gboolean debug = FALSE;
gchar *memsize;
gchar *message;
gchar *timeout_msg;
#define DEBUG(x) if (debug) g_printerr (x)
close (p[1]);
input = fdopen (p[0], "r");
/* hardcoded and not-really-foolproof scanning of wget putput */
wget_begin:
/* Eat any Location lines */
if (redirect && fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
return FALSE;
}
redirect = FALSE;
if (fgets (buf, sizeof (buf), input) == NULL)
{
/* no message here because failing on the first line means
* that wget was not found
*/
return FALSE;
}
DEBUG (buf);
/* The second line is the local copy of the file */
if (fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
return FALSE;
}
/* with an ftp url wget has a "=> `filename.foo" */
else if ( !seen_ftp && strstr (buf, "=> `"))
{
seen_ftp = TRUE;
}
DEBUG (buf);
/* The third line is "Connecting to..." */
timeout_msg = g_strdup_printf (ngettext ("(timeout is %d second)",
"(timeout is %d seconds)",
TIMEOUT), TIMEOUT);
gimp_progress_init_printf ("%s %s",
_("Connecting to server"), timeout_msg);
read_connect:
if (fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
return FALSE;
}
else if (strstr (buf, "connected"))
{
connected = TRUE;
}
/* newer wgets have a "Resolving foo" line, so eat it */
else if (!seen_resolve && strstr (buf, "Resolving"))
{
seen_resolve = TRUE;
goto read_connect;
}
DEBUG (buf);
/* The fourth line is either the network request or an error */
gimp_progress_set_text_printf ("%s %s", _("Opening URI"), timeout_msg);
if (fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
return FALSE;
}
else if (! connected)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("A network error occurred: %s"), buf);
DEBUG (buf);
return FALSE;
}
/* on successful ftp login wget prints a "Logged in" message */
else if ( seen_ftp && !strstr(buf, "Logged in!"))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("A network error occurred: %s"), buf);
DEBUG (buf);
return FALSE;
}
else if (strstr (buf, "302 Found"))
{
DEBUG (buf);
connected = FALSE;
seen_resolve = FALSE;
redirect = TRUE;
goto wget_begin;
}
DEBUG (buf);
/* for an ftp session wget has extra output*/
ftp_session:
if (seen_ftp)
{
if (fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("A network error occurred: %s"), buf);
DEBUG (buf);
return FALSE;
}
/* if there is no size output file does not exist on server */
else if (strstr (buf, "==> SIZE") && strstr (buf, "... done"))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
DEBUG (buf);
return FALSE;
}
/* while no PASV line we eat other messages */
else if (!strstr (buf, "==> PASV"))
{
DEBUG (buf);
goto ftp_session;
}
}
/* The fifth line is either the length of the file or an error */
if (fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
return FALSE;
}
else if (strstr (buf, "Length"))
{
file_found = TRUE;
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("A network error occurred: %s"), buf);
DEBUG (buf);
return FALSE;
}
DEBUG (buf);
if (sscanf (buf, "Length: %37s", sizestr) != 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"Could not parse wget's file length message");
return FALSE;
}
/* strip away commas */
for (i = 0, j = 0; i < sizeof (sizestr); i++, j++)
{
if (sizestr[i] == ',')
i++;
sizestr[j] = sizestr[i];
if (sizestr[j] == '\0')
break;
}
if (*sizestr != '\0')
{
size = g_ascii_strtoull (sizestr, &endptr, 10);
if (*endptr != '\0' || size == G_MAXUINT64)
size = 0;
}
/* on http sessions wget has "Saving to: ..." */
if (!seen_ftp)
{
if (fgets (buf, sizeof (buf), input) == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("wget exited abnormally on URI '%s'"), uri);
return FALSE;
}
}
/* Start the actual download... */
if (size > 0)
{
memsize = g_format_size_for_display (size);
message = g_strdup_printf (_("Downloading %s of image data"),
memsize);
}
else
{
message = g_strdup (_("Downloading unknown amount of image data"));
memsize = NULL;
}
gimp_progress_set_text_printf ("%s %s", message, timeout_msg);
g_free (message);
g_free (memsize);
/* Switch to byte parsing wget's output... */
while (TRUE)
{
dot = fgetc (input);
if (feof (input))
break;
if (debug)
{
fputc (dot, stderr);
fflush (stderr);
}
if (dot == '.') /* one kilobyte */
{
kilobytes++;
if (size > 0)
{
gimp_progress_update ((gdouble) (kilobytes * 1024) /
(gdouble) size);
}
else
{
memsize = g_format_size_for_display (kilobytes * 1024);
gimp_progress_set_text_printf
(_("Downloaded %s of image data"), memsize);
gimp_progress_pulse ();
g_free (memsize);
}
}
else if (dot == ':') /* the time string contains a ':' */
{
fgets (buf, sizeof (buf), input);
DEBUG (buf);
if (! strstr (buf, "error"))
{
finished = TRUE;
gimp_progress_update (1.0);
}
break;
}
}
if (! finished)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"wget exited before finishing downloading URI\n'%s'",
uri);
return FALSE;
}
}
return TRUE;
}
void
checkcopy_worker (CheckcopyWorkerParams * params)
{
GQueue *int_q;
ProgressDialog * progress_dialog;
CheckcopyPlanner *planner;
CheckcopyProcessor *proc;
CheckcopyFileList * list;
gboolean verify_only;
verify_only = g_file_has_uri_scheme (params->dest, "verify");
list = checkcopy_file_list_get_instance ();
g_object_set (G_OBJECT (list), "verify-only", verify_only, NULL);
progress_dialog = params->progress_dialog;
planner = checkcopy_planner_new (progress_dialog);
proc = checkcopy_processor_new (progress_dialog, params->dest, verify_only);
int_q = g_queue_new ();
ext_q = params->queue;
g_async_queue_ref (ext_q);
while (TRUE) {
GFile *file;
/* Collect everything from the external queue to calculate the size.
* Since the files are not processed yet, stick them into the internal queue.
*
* At this point the internal queue is empty, so we can block once for getting the first item
* from the external queue
*/
file = g_async_queue_pop (ext_q);
progress_dialog_thread_set_status (progress_dialog, PROGRESS_DIALOG_STATUS_CALCULATING_SIZE);
do {
g_queue_push_tail (int_q, file);
checkcopy_traverse (file, CHECKCOPY_FILE_HANDLER (planner));
} while ((file = g_async_queue_try_pop (ext_q)) != NULL);
#ifdef DEBUG
{
gchar *size_str;
guint64 total_size = 0;
g_object_get (planner, "total-size", &total_size, NULL);
size_str = g_format_size_for_display (total_size);
DBG ("Total size is now %s", size_str);
g_free (size_str);
}
#endif
progress_dialog_thread_set_status (progress_dialog, PROGRESS_DIALOG_STATUS_COPYING);
g_object_set (G_OBJECT (progress_dialog), "num-files", checkcopy_planner_get_num_files (planner), NULL);
/* Now process the internal queue */
while ((file = g_queue_pop_head (int_q)) != NULL) {
checkcopy_traverse (file, CHECKCOPY_FILE_HANDLER (proc));
g_object_unref (file);
}
checkcopy_file_list_write_checksum (list, params->dest);
checkcopy_file_list_sweep (list);
progress_dialog_thread_set_status (progress_dialog, PROGRESS_DIALOG_STATUS_COMPLETED);
#ifdef DEBUG
progress_dialog_thread_check_stats (progress_dialog);
#endif
DBG ("Waiting for more things to do");
}
/* we won't ever get here but just in case
* we change the loop condition later */
g_async_queue_unref (ext_q);
g_queue_foreach (int_q, (GFunc) g_object_unref, NULL);
g_queue_free (int_q);
g_object_unref (planner);
g_object_unref (proc);
g_object_unref (list);
g_object_unref (params->dest);
g_free (params);
}
/*!
* \brief Check and - if huge - let the user confirm the diagram size before export
*/
gboolean
confirm_export_size (Diagram *dia, GtkWindow *parent, guint flags)
{
GtkWidget *dialog;
int pages = 0;
gint64 bytes = 0;
gchar *size, *msg;
gboolean ret;
pages = ceil((dia->data->extents.right - dia->data->extents.left) / dia->data->paper.width)
* ceil((dia->data->extents.bottom - dia->data->extents.top) / dia->data->paper.height);
/* three guesses: 4 bytes per pixel, 20 pixels per cm; using * dia->data->paper.scaling */
bytes = (gint64)4
* ceil((dia->data->extents.right - dia->data->extents.left) * dia->data->paper.scaling * 20)
* ceil((dia->data->extents.bottom - dia->data->extents.top) * dia->data->paper.scaling * 20);
if ((flags & CONFIRM_PRINT) && (pages < 10)) /* hardcoded limits for the dialog to show */
return TRUE;
else if ((flags & CONFIRM_MEMORY) && (bytes < (G_GINT64_CONSTANT(100)<<16)))
return TRUE; /* smaller than 100MB */
else if ((flags & CONFIRM_PAGES) && (pages < 50))
return TRUE;
/* message and limits depend on the flags give */
#if GLIB_CHECK_VERSION(2,30,0)
size = g_format_size (bytes);
#else
size = g_format_size_for_display (bytes);
#endif
/* See: https://live.gnome.org/TranslationProject/DevGuidelines/Plurals */
if (flags & CONFIRM_PRINT)
msg = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE,
"You are about to print a diagram with %d page.", /* not triggered */
"You are about to print a diagram with %d pages.", pages), pages);
else if ((flags & ~CONFIRM_PAGES) == 0)
msg = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE,
"You are about to export a diagram with %d page.", /* not triggered */
"You are about to export a diagram with %d pages.", pages), pages);
else
msg = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE,
"You are about to export a diagram which may require %s of memory.(%d page).",
"You are about to export a diagram which may require %s of memory.(%d pages).", pages),
size, pages);
dialog = gtk_message_dialog_new (parent, /* diagrams display 'shell' */
GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_OK_CANCEL,
"%s", msg);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("You can adjust the size of the diagram by changing "
"the 'Scaling' in the 'Page Setup' dialog.\n"
"Alternatively use 'Best Fit' "
"to move objects/handles into the intended bounds."));
gtk_window_set_title (GTK_WINDOW (dialog), _("Confirm Diagram Size"));
g_free (size);
g_signal_connect(G_OBJECT (dialog), "response",
G_CALLBACK(confirm_respond), NULL);
ret = (GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (dialog)));
gtk_widget_destroy(dialog);
return ret;
}
static void
rejilla_status_dialog_update (RejillaStatusDialog *self,
RejillaStatus *status)
{
gchar *string;
gchar *size_str;
goffset session_bytes;
gchar *current_action;
RejillaBurnResult res;
RejillaTrackType *type;
RejillaStatusDialogPrivate *priv;
priv = REJILLA_STATUS_DIALOG_PRIVATE (self);
current_action = rejilla_status_get_current_action (status);
if (current_action) {
gchar *string;
string = g_strdup_printf ("<i>%s</i>", current_action);
gtk_label_set_markup (GTK_LABEL (priv->action), string);
g_free (string);
}
else
gtk_label_set_markup (GTK_LABEL (priv->action), "");
g_free (current_action);
if (rejilla_status_get_progress (status) < 0.0)
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->progress));
else
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->progress),
rejilla_status_get_progress (status));
res = rejilla_burn_session_get_size (priv->session,
NULL,
&session_bytes);
if (res != REJILLA_BURN_OK)
return;
type = rejilla_track_type_new ();
rejilla_burn_session_get_input_type (priv->session, type);
if (rejilla_track_type_get_has_stream (type)) {
if (REJILLA_STREAM_FORMAT_HAS_VIDEO (rejilla_track_type_get_stream_format (type))) {
guint64 free_time;
/* This is an embarassing problem: this is an approximation based on the fact that
* 2 hours = 4.3GiB */
free_time = session_bytes * 72000LL / 47LL;
size_str = rejilla_units_get_time_string (free_time,
TRUE,
TRUE);
}
else
size_str = rejilla_units_get_time_string (session_bytes, TRUE, FALSE);
}
/* NOTE: this is perfectly fine as rejilla_track_type_get_medium_type ()
* will return REJILLA_MEDIUM_NONE if this is not a MEDIUM track type */
else if (rejilla_track_type_get_medium_type (type) & REJILLA_MEDIUM_HAS_AUDIO)
size_str = rejilla_units_get_time_string (session_bytes, TRUE, FALSE);
else
size_str = g_format_size_for_display (session_bytes);
rejilla_track_type_free (type);
string = g_strdup_printf (_("Estimated size: %s"), size_str);
g_free (size_str);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (priv->progress), string);
g_free (string);
}
static VALUE
rbglib_m_format_size_for_display(G_GNUC_UNUSED VALUE self, VALUE size)
{
return CSTR2RVAL_FREE(g_format_size_for_display(NUM2ULONG(size)));
}
