void fm_folder_view_select_file_paths(FmFolderView* fv, FmPathList* paths) { GList* l; for(l = fm_list_peek_head_link(paths);l; l=l->next) { FmPath* path = FM_PATH(l->data); fm_folder_view_select_file_path(fv, path); } }
/** * fm_file_info_job_new * @files_to_query: (allow-none): list of paths to query informatiom * @flags: modificators of query mode * * Creates a new #FmFileInfoJob which can be used by #FmJob API. * * Returns: (transfer full): a new #FmFileInfoJob object. * * Since: 0.1.0 */ FmFileInfoJob* fm_file_info_job_new(FmPathList* files_to_query, FmFileInfoJobFlags flags) { GList* l; FmFileInfoJob* job = (FmFileInfoJob*)g_object_new(FM_TYPE_FILE_INFO_JOB, NULL); FmFileInfoList* file_infos; job->flags = flags; if(files_to_query) { file_infos = job->file_infos; for(l = fm_path_list_peek_head_link(files_to_query);l;l=l->next) { FmPath* path = FM_PATH(l->data); FmFileInfo* fi = fm_file_info_new(); fm_file_info_set_path(fi, path); fm_file_info_list_push_tail_noref(file_infos, fi); } } return job; }
gboolean fm_deep_count_job_run(FmJob* job) { FmDeepCountJob* dc = (FmDeepCountJob*)job; GList* l; l = fm_list_peek_head_link(dc->paths); for(; !fm_job_is_cancelled(job) && l; l=l->next) { FmPath* path = FM_PATH(l->data); if(fm_path_is_native(path)) /* if it's a native file, use posix APIs */ deep_count_posix( dc, path ); else { GFile* gf = fm_path_to_gfile(path); deep_count_gio( dc, NULL, gf ); g_object_unref(gf); } } return TRUE; }
/** * fm_trash_or_delete_files * @parent: a window to place progress dialog over it * @files: list of files to delete * * Removes files into trash can if that operation is supported. * Otherwise erases them. If that operation takes some time then progress * dialog will be opened. * * Before 0.1.15 this call had different arguments. * * Since: 0.1.0 */ void fm_trash_or_delete_files(GtkWindow* parent, FmPathList* files) { if( !fm_path_list_is_empty(files) ) { gboolean all_in_trash = TRUE; if(fm_config->use_trash) { GList* l = fm_path_list_peek_head_link(files); for(;l;l=l->next) { FmPath* path = FM_PATH(l->data); if(!fm_path_is_trash(path)) all_in_trash = FALSE; } } /* files already in trash:/// should only be deleted and cannot be trashed again. */ if(fm_config->use_trash && !all_in_trash) fm_trash_files(parent, files); else fm_delete_files(parent, files); } }
// FIXME_pcm: error handling static gboolean launch_program (FmArchiver *archiver, GAppLaunchContext *ctx, const char *cmd, FmPathList *files, FmPath *dir) { GDesktopAppInfo *app; char *_cmd = NULL; const char *dir_place_holder; GKeyFile *dummy; char *tmp; if (dir && (dir_place_holder = strstr (cmd, "%d"))) { char *dir_str; int len; if (strstr (cmd, "%U") || strstr (cmd, "%u")) // supports URI dir_str = fm_path_to_uri (dir); else { GFile *gf = fm_path_to_gfile (dir); // FIXME_pcm: convert dir to fuse-based local path if needed. dir_str = g_file_get_path (gf); g_object_unref (gf); } // replace all % with %% so encoded URI can be handled correctly when parsing Exec key. tmp = fm_str_replace (dir_str, "%", "%%"); g_free (dir_str); dir_str = tmp; // quote the path or URI tmp = g_shell_quote (dir_str); g_free (dir_str); dir_str = tmp; len = strlen (cmd) - 2 + strlen (dir_str) + 1; _cmd = g_malloc (len); len = (dir_place_holder - cmd); strncpy (_cmd, cmd, len); strcpy (_cmd + len, dir_str); strcat (_cmd, dir_place_holder + 2); g_free (dir_str); cmd = _cmd; } // create a fake key file to cheat GDesktopAppInfo dummy = g_key_file_new (); g_key_file_set_string (dummy, G_KEY_FILE_DESKTOP_GROUP, "Type", "Application"); g_key_file_set_string (dummy, G_KEY_FILE_DESKTOP_GROUP, "Name", archiver->program); // replace all % with %% so encoded URI can be handled correctly when parsing Exec key. g_key_file_set_string (dummy, G_KEY_FILE_DESKTOP_GROUP, "Exec", cmd); app = g_desktop_app_info_new_from_keyfile (dummy); g_key_file_free (dummy); g_debug ("cmd = %s", cmd); if (app) { GList *uris = NULL, *l; for (l = fm_list_peek_head_link (files); l; l=l->next) { FmPath *path = FM_PATH (l->data); uris = g_list_prepend (uris, fm_path_to_uri (path)); } fm_app_info_launch_uris ((GAppInfo *) app, uris, ctx, NULL); g_list_foreach (uris, (GFunc)g_free, NULL); g_list_free (uris); } g_free (_cmd); return TRUE; }
static gboolean on_show_dlg (FmProgressDisplay *data) { GtkBuilder *builder = gtk_builder_new (); GtkWidget *to, *to_label; FmPath *dest; const char *title = NULL; GtkTextTagTable *tag_table = gtk_text_tag_table_new (); gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE); gtk_builder_add_from_string (builder, PROGRESS_DLG, -1, NULL); data->dlg = (GtkWidget*) gtk_builder_get_object (builder, "dlg"); g_signal_connect (data->dlg, "response", (GCallback) on_response, data); to_label = (GtkWidget*) gtk_builder_get_object (builder, "to_label"); to = (GtkWidget*) gtk_builder_get_object (builder, "dest"); data->icon = (GtkWidget*) gtk_builder_get_object (builder, "icon"); data->msg = (GtkWidget*) gtk_builder_get_object (builder, "msg"); data->act = (GtkWidget*) gtk_builder_get_object (builder, "action"); data->src = (GtkWidget*) gtk_builder_get_object (builder, "src"); data->dest = (GtkWidget*) gtk_builder_get_object (builder, "dest"); data->current = (GtkWidget*) gtk_builder_get_object (builder, "current"); data->progress = (GtkWidget*) gtk_builder_get_object (builder, "progress"); data->error_pane = (GtkWidget*) gtk_builder_get_object (builder, "error_pane"); data->error_msg = (GtkWidget*) gtk_builder_get_object (builder, "error_msg"); data->remaining_time = (GtkWidget*) gtk_builder_get_object (builder, "remaining_time"); data->bold_tag = gtk_text_tag_new ("bold"); g_object_set (data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_tag_table_add (tag_table, data->bold_tag); data->error_buf = gtk_text_buffer_new (tag_table); g_object_unref (tag_table); gtk_text_view_set_buffer (GTK_TEXT_VIEW (data->error_msg), data->error_buf); g_object_unref (builder); // set the src label if (data->job->srcs) { GList *l = fm_list_peek_head_link (data->job->srcs); int i; char *disp; FmPath *path; GString *str = g_string_sized_new (512); path = FM_PATH (l->data); disp = fm_path_display_basename (path); g_string_assign (str, disp); g_free (disp); for ( i =1, l=l->next; i < 10 && l; l=l->next, ++i) { path = FM_PATH (l->data); g_string_append (str, _(", ")); disp = fm_path_display_basename (path); g_string_append (str, disp); g_free (disp); } if (l) g_string_append (str, "..."); gtk_label_set_text (GTK_LABEL (data->src), str->str); g_string_free (str, TRUE); } // FIXME_pcm: use accessor functions instead switch (data->job->type) { case FM_FILE_OP_MOVE: title = _("Moving files"); break; case FM_FILE_OP_COPY: title = _("Copying files"); break; case FM_FILE_OP_TRASH: title = _("Trashing files"); break; case FM_FILE_OP_DELETE: title = _("Deleting files"); break; case FM_FILE_OP_LINK: title = _("Creating symlinks"); break; case FM_FILE_OP_CHANGE_ATTR: title = _("Changing file attributes"); break; } if (title) { gtk_window_set_title (GTK_WINDOW (data->dlg), title); gtk_label_set_text (GTK_LABEL (data->act), title); } if (dest = fm_file_ops_job_get_dest (data->job)) { char *dest_str = fm_path_display_name (dest, TRUE); gtk_label_set_text (GTK_LABEL (to), dest_str); g_free (dest_str); } else { gtk_widget_destroy (data->dest); gtk_widget_destroy (to_label); } gtk_window_present (GTK_WINDOW (data->dlg)); data->update_timeout = g_timeout_add (500, (GSourceFunc)on_update_dlg, data); data->delay_timeout = 0; return FALSE; }
static gboolean on_show_dlg(gpointer user_data) { FmProgressDisplay* data = (FmProgressDisplay*)user_data; GtkBuilder* builder; GtkLabel* to; GtkWidget *to_label; FmPath* dest; const char* title = NULL; GtkTextTagTable* tag_table; GDK_THREADS_ENTER(); if(g_source_is_destroyed(g_main_current_source())) goto _end; builder = gtk_builder_new(); tag_table = gtk_text_tag_table_new(); gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE); gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/progress.ui", NULL); data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg")); g_object_weak_ref(G_OBJECT(data->dlg), on_progress_dialog_destroy, data); g_signal_connect(data->dlg, "response", G_CALLBACK(on_response), data); /* FIXME: connect to "close" signal */ to_label = (GtkWidget*)gtk_builder_get_object(builder, "to_label"); to = GTK_LABEL(gtk_builder_get_object(builder, "dest")); data->icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon")); data->msg = GTK_LABEL(gtk_builder_get_object(builder, "msg")); data->act = GTK_LABEL(gtk_builder_get_object(builder, "action")); data->src = GTK_LABEL(gtk_builder_get_object(builder, "src")); data->dest = (GtkWidget*)gtk_builder_get_object(builder, "dest"); data->current = GTK_LABEL(gtk_builder_get_object(builder, "current")); data->progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder, "progress")); data->error_pane = (GtkWidget*)gtk_builder_get_object(builder, "error_pane"); data->error_msg = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "error_msg")); data->remaining_time = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time")); data->bold_tag = gtk_text_tag_new("bold"); g_object_set(data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_tag_table_add(tag_table, data->bold_tag); data->error_buf = gtk_text_buffer_new(tag_table); g_object_unref(tag_table); gtk_text_view_set_buffer(data->error_msg, data->error_buf); g_object_unref(builder); /* set the src label */ /* FIXME: direct access to job struct! */ if(data->job->srcs) { GList* l = fm_path_list_peek_head_link(data->job->srcs); int i; char* disp; FmPath* path; GString* str = g_string_sized_new(512); path = FM_PATH(l->data); disp = fm_path_display_basename(path); g_string_assign(str, disp); g_free(disp); for( i =1, l=l->next; i < 10 && l; l=l->next, ++i) { path = FM_PATH(l->data); g_string_append(str, _(", ")); disp = fm_path_display_basename(path); g_string_append(str, disp); g_free(disp); } if(l) g_string_append(str, "..."); gtk_label_set_text(data->src, str->str); g_string_free(str, TRUE); } /* FIXME: use accessor functions instead */ /* FIXME: direct access to job struct! */ switch(data->job->type) { case FM_FILE_OP_MOVE: title = _("Moving files"); break; case FM_FILE_OP_COPY: title = _("Copying files"); break; case FM_FILE_OP_TRASH: title = _("Trashing files"); break; case FM_FILE_OP_DELETE: title = _("Deleting files"); break; case FM_FILE_OP_LINK: title = _("Creating symlinks"); break; case FM_FILE_OP_CHANGE_ATTR: title = _("Changing file attributes"); break; case FM_FILE_OP_UNTRASH: break; case FM_FILE_OP_NONE: ; } if(title) { gtk_window_set_title(GTK_WINDOW(data->dlg), title); gtk_label_set_text(data->act, title); } dest = fm_file_ops_job_get_dest(data->job); if(dest) { char* dest_str = fm_path_display_name(dest, TRUE); gtk_label_set_text(to, dest_str); g_free(dest_str); } else { gtk_widget_destroy(data->dest); gtk_widget_destroy(to_label); } gtk_window_set_transient_for(GTK_WINDOW(data->dlg), data->parent); gtk_window_present(GTK_WINDOW(data->dlg)); data->update_timeout = g_timeout_add(500, on_update_dlg, data); data->delay_timeout = 0; _end: GDK_THREADS_LEAVE(); return FALSE; }
gboolean fm_dnd_dest_drag_data_received(FmDndDest* dd, GdkDragContext *drag_context, gint x, gint y, GtkSelectionData *sel_data, guint info, guint time) { FmList* files = NULL; GtkWidget *dest_widget = dd->widget; if(info == FM_DND_DEST_TARGET_FM_LIST) { if((sel_data->length >= 0) && (sel_data->format==8)) { /* get the pointer */ memcpy(&files, sel_data->data, sel_data->length); if(files) fm_list_ref(files); if(files) { FmFileInfo* fi = FM_FILE_INFO(fm_list_peek_head(files)); /* get the device of the first dragged source file */ if(fm_path_is_native(fi->path)) dd->src_dev = fi->dev; else dd->src_fs_id = fi->fs_id; } } } else if(info == FM_DND_DEST_TARGET_URI_LIST) { if((sel_data->length >= 0) && (sel_data->format==8)) { gchar **uris; uris = gtk_selection_data_get_uris( sel_data ); files = fm_path_list_new_from_uris((const char **)uris); g_free(uris); if(files) { GFileInfo* inf; FmPath* path = FM_PATH(fm_list_peek_head(files)); GFile* gf = fm_path_to_gfile(path); const char* attr = fm_path_is_native(path) ? G_FILE_ATTRIBUTE_UNIX_DEVICE : G_FILE_ATTRIBUTE_ID_FILESYSTEM; inf = g_file_query_info(gf, attr, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL); g_object_unref(gf); if(fm_path_is_native(path)) dd->src_dev = g_file_info_get_attribute_uint32(inf, G_FILE_ATTRIBUTE_UNIX_DEVICE); else dd->src_fs_id = g_intern_string(g_file_info_get_attribute_string(inf, G_FILE_ATTRIBUTE_ID_FILESYSTEM)); g_object_unref(inf); } } } else if(info == FM_DND_DEST_TARGET_XDS) /* X direct save */ { if( sel_data->format == 8 && sel_data->length == 1 && sel_data->data[0] == 'F') { gdk_property_change(GDK_DRAWABLE(drag_context->source_window), xds_target_atom, gdk_atom_intern_static_string("text/plain"), 8, GDK_PROP_MODE_REPLACE, (const guchar *)"", 0); } else if(sel_data->format == 8 && sel_data->length == 1 && sel_data->data[0] == 'S') { /* XDS succeeds */ } gtk_drag_finish(drag_context, TRUE, FALSE, time); return TRUE; } else return FALSE; /* remove previously cached source files. */ if(G_UNLIKELY(dd->src_files)) { fm_list_unref(dd->src_files); dd->src_files = NULL; } dd->src_files = files; dd->waiting_data = FALSE; dd->info_type = info; return TRUE; }
gboolean _fm_file_ops_job_move_run(FmFileOpsJob* job) { GFile *dest_dir; GFileInfo* inf; GList* l; GError* err = NULL; FmJob* fmjob = FM_JOB(job); dev_t dest_dev = 0; gboolean ret = TRUE; FmDeepCountJob* dc; FmPath *parent = NULL; FmFolder *df, *sf = NULL; /* get information of destination folder */ g_return_val_if_fail(job->dest, FALSE); dest_dir = fm_path_to_gfile(job->dest); _retry_query_dest_info: inf = g_file_query_info(dest_dir, G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL"," G_FILE_ATTRIBUTE_UNIX_DEVICE"," G_FILE_ATTRIBUTE_ID_FILESYSTEM"," G_FILE_ATTRIBUTE_UNIX_DEVICE, 0, fm_job_get_cancellable(fmjob), &err); if(inf) { job->dest_fs_id = g_intern_string(g_file_info_get_attribute_string(inf, G_FILE_ATTRIBUTE_ID_FILESYSTEM)); dest_dev = g_file_info_get_attribute_uint32(inf, G_FILE_ATTRIBUTE_UNIX_DEVICE); /* needed by deep count */ g_object_unref(inf); } else { FmJobErrorAction act = fm_job_emit_error(fmjob, err, FM_JOB_ERROR_MODERATE); g_error_free(err); err = NULL; if(act == FM_JOB_RETRY) goto _retry_query_dest_info; else { g_object_unref(dest_dir); return FALSE; } } /* prepare the job, count total work needed with FmDeepCountJob */ dc = fm_deep_count_job_new(job->srcs, FM_DC_JOB_PREPARE_MOVE); fm_deep_count_job_set_dest(dc, dest_dev, job->dest_fs_id); fm_job_run_sync(FM_JOB(dc)); job->total = dc->total_size; if( fm_job_is_cancelled(FM_JOB(dc)) ) { g_object_unref(dest_dir); g_object_unref(dc); return FALSE; } g_object_unref(dc); g_debug("total size to move: %llu, dest_fs: %s", (long long unsigned int)job->total, job->dest_fs_id); fm_file_ops_job_emit_prepared(job); /* suspend updates for destination */ df = fm_folder_find_by_path(job->dest); if (df) fm_folder_block_updates(df); for(l = fm_path_list_peek_head_link(job->srcs); !fm_job_is_cancelled(fmjob) && l; l=l->next) { FmPath* path = FM_PATH(l->data); GFile* src = fm_path_to_gfile(path); GFile* dest; char* tmp_basename; /* do with updates for source */ if (fm_path_get_parent(path) != parent && fm_path_get_parent(path) != NULL) { FmFolder *pf; pf = fm_folder_find_by_path(fm_path_get_parent(path)); if (pf != sf) { if (sf) { fm_folder_unblock_updates(sf); g_object_unref(sf); } if (pf) fm_folder_block_updates(pf); sf = pf; } else if (pf) g_object_unref(pf); } parent = fm_path_get_parent(path); if(g_file_is_native(src) && g_file_is_native(dest_dir)) /* both are native */ tmp_basename = NULL; else if(g_file_is_native(src)) /* move from native to virtual */ tmp_basename = g_filename_to_utf8(fm_path_get_basename(path), -1, NULL, NULL, NULL); /* gvfs escapes it itself */ else /* move from virtual to native/virtual */ tmp_basename = fm_uri_subpath_to_native_subpath(fm_path_get_basename(path), NULL); dest = g_file_get_child(dest_dir, tmp_basename ? tmp_basename : fm_path_get_basename(path)); g_free(tmp_basename); if(!_fm_file_ops_job_move_file(job, src, NULL, dest, path, sf, df)) ret = FALSE; g_object_unref(src); g_object_unref(dest); if(!ret) break; } /* restore updates for destination and source */ if (df) { fm_folder_unblock_updates(df); g_object_unref(df); } if (sf) { fm_folder_unblock_updates(sf); g_object_unref(sf); } g_object_unref(dest_dir); return ret; }
gboolean _fm_file_ops_job_copy_run(FmFileOpsJob* job) { gboolean ret = TRUE; GFile *dest_dir; GList* l; FmJob* fmjob = FM_JOB(job); /* prepare the job, count total work needed with FmDeepCountJob */ FmDeepCountJob* dc = fm_deep_count_job_new(job->srcs, FM_DC_JOB_DEFAULT); FmFolder *df; /* let the deep count job share the same cancellable object. */ fm_job_set_cancellable(FM_JOB(dc), fm_job_get_cancellable(fmjob)); fm_job_run_sync(FM_JOB(dc)); job->total = dc->total_size; if(fm_job_is_cancelled(fmjob)) { g_object_unref(dc); return FALSE; } g_object_unref(dc); g_debug("total size to copy: %llu", (long long unsigned int)job->total); dest_dir = fm_path_to_gfile(job->dest); /* suspend updates for destination */ df = fm_folder_find_by_path(job->dest); if (df) fm_folder_block_updates(df); fm_file_ops_job_emit_prepared(job); for(l = fm_path_list_peek_head_link(job->srcs); !fm_job_is_cancelled(fmjob) && l; l=l->next) { FmPath* path = FM_PATH(l->data); GFile* src = fm_path_to_gfile(path); GFile* dest; char* tmp_basename; if(g_file_is_native(src) && g_file_is_native(dest_dir)) /* both are native */ tmp_basename = NULL; else if(g_file_is_native(src)) /* copy from native to virtual */ tmp_basename = g_filename_to_utf8(fm_path_get_basename(path), -1, NULL, NULL, NULL); /* gvfs escapes it itself */ else /* copy from virtual to native/virtual */ { /* if we drop URI query onto native filesystem, omit query part */ const char *basename = fm_path_get_basename(path); char *sub_name; sub_name = strchr(basename, '?'); if (sub_name) { sub_name = g_strndup(basename, sub_name - basename); basename = strrchr(sub_name, G_DIR_SEPARATOR); if (basename) basename++; else basename = sub_name; } tmp_basename = fm_uri_subpath_to_native_subpath(basename, NULL); g_free(sub_name); } dest = g_file_get_child(dest_dir, tmp_basename ? tmp_basename : fm_path_get_basename(path)); g_free(tmp_basename); if(!_fm_file_ops_job_copy_file(job, src, NULL, dest, NULL, df)) ret = FALSE; g_object_unref(src); g_object_unref(dest); } /* g_debug("finished: %llu, total: %llu", job->finished, job->total); */ fm_file_ops_job_emit_percent(job); /* restore updates for destination */ if (df) { fm_folder_unblock_updates(df); g_object_unref(df); } g_object_unref(dest_dir); return ret; }
static gboolean _on_show_dlg(gpointer user_data) { FmProgressDisplay* data = (FmProgressDisplay*)user_data; GtkBuilder* builder; GtkLabel* to; GtkWidget *to_label; FmPath* dest; const char* title = NULL; GtkTextTagTable* tag_table; builder = gtk_builder_new(); tag_table = gtk_text_tag_table_new(); gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE); gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/progress.ui", NULL); data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg")); g_object_weak_ref(G_OBJECT(data->dlg), on_progress_dialog_destroy, data); g_signal_connect(data->dlg, "response", G_CALLBACK(on_response), data); /* FIXME: connect to "close" signal */ to_label = (GtkWidget*)gtk_builder_get_object(builder, "to_label"); to = GTK_LABEL(gtk_builder_get_object(builder, "dest")); data->icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon")); data->msg = GTK_LABEL(gtk_builder_get_object(builder, "msg")); data->act = GTK_LABEL(gtk_builder_get_object(builder, "action")); data->src = GTK_LABEL(gtk_builder_get_object(builder, "src")); data->dest = (GtkWidget*)gtk_builder_get_object(builder, "dest"); data->current = GTK_LABEL(gtk_builder_get_object(builder, "current")); data->progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder, "progress")); data->error_pane = (GtkWidget*)gtk_builder_get_object(builder, "error_pane"); data->error_msg = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "error_msg")); data->data_transferred = GTK_LABEL(gtk_builder_get_object(builder, "data_transferred")); data->data_transferred_label = GTK_LABEL(gtk_builder_get_object(builder, "data_transferred_label")); data->remaining_time = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time")); data->remaining_time_label = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time_label")); data->cancel = GTK_BUTTON(gtk_builder_get_object(builder, "cancel")); data->suspend = GTK_BUTTON(gtk_dialog_add_button(data->dlg, _("_Pause"), 1)); gtk_button_set_use_stock(data->suspend, FALSE); gtk_button_set_use_underline(data->suspend, TRUE); gtk_button_set_image(data->suspend, gtk_image_new_from_stock(GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order(data->dlg, 1, GTK_RESPONSE_CANCEL, -1); data->bold_tag = gtk_text_tag_new("bold"); g_object_set(data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_tag_table_add(tag_table, data->bold_tag); data->error_buf = gtk_text_buffer_new(tag_table); g_object_unref(tag_table); gtk_text_view_set_buffer(data->error_msg, data->error_buf); gtk_widget_hide(GTK_WIDGET(data->icon)); g_object_unref(builder); /* set the src label */ /* FIXME: direct access to job struct! */ if(data->job->srcs) { GList* l = fm_path_list_peek_head_link(data->job->srcs); int i; char* disp; FmPath* path; GString* str = g_string_sized_new(512); path = FM_PATH(l->data); disp = fm_path_display_basename(path); g_string_assign(str, disp); g_free(disp); for( i =1, l=l->next; i < 10 && l; l=l->next, ++i) { path = FM_PATH(l->data); g_string_append(str, _(", ")); disp = fm_path_display_basename(path); g_string_append(str, disp); g_free(disp); } if(l) g_string_append(str, "..."); gtk_label_set_text(data->src, str->str); gtk_widget_set_tooltip_text(GTK_WIDGET(data->src), str->str); g_string_free(str, TRUE); } /* FIXME: use accessor functions instead */ /* FIXME: direct access to job struct! */ switch(data->job->type) { /* we set title here if text is complex so may be different from the op_text when is translated to other languages */ case FM_FILE_OP_MOVE: /* translators: it is part of "Moving files:" or "Moving xxx.txt" */ data->op_text = _("Moving"); break; case FM_FILE_OP_COPY: /* translators: it is part of "Copying files:" or "Copying xxx.txt" */ data->op_text = _("Copying"); break; case FM_FILE_OP_TRASH: /* translators: it is part of "Trashing files:" or "Trashing xxx.txt" */ data->op_text = _("Trashing"); break; case FM_FILE_OP_DELETE: /* translators: it is part of "Deleting files:" or "Deleting xxx.txt" */ data->op_text = _("Deleting"); break; case FM_FILE_OP_LINK: /* translators: it is part of "Creating link /path/xxx.txt" */ data->op_text = _("Creating link"); /* translators: 'In:' string is followed by destination folder path */ gtk_label_set_markup(GTK_LABEL(to_label), _("<b>In:</b>")); title = _("Creating links to files"); /* NOTE: on creating single symlink or shortcut all operation is done in single I/O therefore it should fit into 0.5s timeout and progress window will never be shown */ break; case FM_FILE_OP_CHANGE_ATTR: /* translators: it is part of "Changing attributes of xxx.txt" */ data->op_text = _("Changing attributes of"); title = _("Changing attributes of files"); /* NOTE: the same about single symlink is appliable here so there is no need to add never used string for translation */ break; case FM_FILE_OP_UNTRASH: /* translators: it is part of "Restoring files:" or "Restoring xxx.txt" */ data->op_text = _("Restoring"); break; case FM_FILE_OP_NONE: ; } data->str = g_string_sized_new(64); if (title) gtk_window_set_title(GTK_WINDOW(data->dlg), title); else { /* note to translators: resulting string is such as "Deleting files" */ g_string_printf(data->str, _("%s files"), data->op_text); gtk_window_set_title(GTK_WINDOW(data->dlg), data->str->str); } gtk_label_set_markup(data->msg, _("<b>File operation is in progress...</b>")); gtk_widget_show(GTK_WIDGET(data->msg)); if (title) /* we already know the exact string */ g_string_printf(data->str, "<b>%s:</b>", title); else if (fm_path_list_get_length(data->job->srcs) == 1) /* note to translators: resulting string is such as "Deleting file" */ g_string_printf(data->str, _("<b>%s file:</b>"), data->op_text); else /* note to translators: resulting string is such as "Deleting files" */ g_string_printf(data->str, _("<b>%s files:</b>"), data->op_text); gtk_label_set_markup(data->act, data->str->str); dest = fm_file_ops_job_get_dest(data->job); if(dest) { char* dest_str = fm_path_display_name(dest, TRUE); gtk_label_set_text(to, dest_str); gtk_widget_set_tooltip_text(GTK_WIDGET(data->dest), dest_str); g_free(dest_str); } else { gtk_widget_destroy(data->dest); gtk_widget_destroy(to_label); } gtk_window_set_transient_for(GTK_WINDOW(data->dlg), data->parent); gtk_window_present(GTK_WINDOW(data->dlg)); data->delay_timeout = 0; return FALSE; }