FmJob *fm_deep_count_job_new(FmPathList* paths, FmDeepCountJobFlags flags)
{
FmDeepCountJob* job = (FmDeepCountJob*)g_object_new(FM_DEEP_COUNT_JOB_TYPE, NULL);
job->paths = fm_list_ref(paths);
job->flags = flags;
return (FmJob*)job;
}
gboolean fm_clipboard_cut_or_copy_files(GtkWidget* src_widget, FmPathList* files, gboolean _is_cut)
{
GdkDisplay* dpy = src_widget ? gtk_widget_get_display(src_widget) : gdk_display_get_default();
GtkClipboard* clip = gtk_clipboard_get_for_display(dpy, GDK_SELECTION_CLIPBOARD);
gboolean ret = gtk_clipboard_set_with_data(clip, targets, G_N_ELEMENTS(targets),
get_data, clear_data, fm_list_ref(files));
is_cut = _is_cut;
return ret;
}
gboolean fm_dnd_dest_files_dropped(FmDndDest* dd, GdkDragAction action,
int info_type, FmList* files)
{
FmPath* dest;
GtkWidget* parent;
dest = fm_dnd_dest_get_dest_path(dd);
if(!dest)
return FALSE;
g_debug("%d files-dropped!, info_type: %d", fm_list_get_length(files), info_type);
if(fm_list_is_file_info_list(files))
files = fm_path_list_new_from_file_info_list(files);
else
fm_list_ref(files);
parent = gtk_widget_get_toplevel(dd->widget);
switch(action)
{
case GDK_ACTION_MOVE:
if(fm_path_is_trash_root(fm_dnd_dest_get_dest_path(dd)))
fm_trash_files(GTK_WINDOW(parent), files);
else
fm_move_files(GTK_WINDOW(parent), files, fm_dnd_dest_get_dest_path(dd));
break;
case GDK_ACTION_COPY:
fm_copy_files(GTK_WINDOW(parent), files, fm_dnd_dest_get_dest_path(dd));
break;
case GDK_ACTION_LINK:
// fm_link_files(parent, files, fm_dnd_dest_get_dest_path(dd));
break;
case GDK_ACTION_ASK:
g_debug("TODO: GDK_ACTION_ASK");
break;
}
fm_list_unref(files);
return TRUE;
}
void on_dnd_dest_files_dropped(FmDndDest* dd, GdkDragAction action,
int info_type, FmList* files, FmPlacesView* view)
{
FmPath* dest;
GList* l;
dest = fm_dnd_dest_get_dest_path(dd);
g_debug("action= %d, %d files-dropped!, info_type: %d", action, fm_list_get_length(files), info_type);
if(action != GDK_ACTION_LINK)
{
if(fm_list_is_file_info_list(files))
files = fm_path_list_new_from_file_info_list(files);
else
fm_list_ref(files);
}
switch(action)
{
case GDK_ACTION_MOVE:
if(fm_path_is_trash_root(dest))
fm_trash_files(files);
else
fm_move_files(files, dest);
break;
case GDK_ACTION_COPY:
fm_copy_files(files, dest);
break;
case GDK_ACTION_LINK:
{
GtkTreePath* tp = view->dest_row;
if(tp)
{
GtkTreePath* sep = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &sep_it);
int idx = gtk_tree_path_get_indices(tp)[0] - gtk_tree_path_get_indices(sep)[0];
gtk_tree_path_free(sep);
if(view->dest_pos == GTK_TREE_VIEW_DROP_BEFORE)
--idx;
for( l=fm_list_peek_head_link(files); l; l=l->next, ++idx )
{
FmBookmarkItem* item;
if(fm_list_is_file_info_list(files))
{
FmFileInfo* fi = (FmFileInfo*)l->data;
item = fm_bookmarks_insert( bookmarks, fi->path, fi->disp_name, idx);
}
else
{
FmPath* path = (FmPath*)l->data;
char* disp_name = g_filename_display_name(path->name);
item = fm_bookmarks_insert( bookmarks, path, disp_name, idx);
g_free(disp_name);
}
/* we don't need to add item to places view. Later the bookmarks will be reloaded. */
}
}
}
break;
}
fm_list_unref(files);
if(view->dest_row)
{
gtk_tree_path_free(view->dest_row);
view->dest_row = NULL;
}
}
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;
}
/* FIXME: this is a little bit dirty... */
static void on_src_file_info_finished(FmFileInfoJob* job, FmDndDest* dd)
{
dd->src_files = fm_list_ref(job->file_infos);
dd->info_type = FM_DND_DEST_TARGET_FM_LIST;
g_main_loop_quit(dd->mainloop);
}
GtkWidget *fm_file_properties_widget_new (FmFileInfoList *files, gboolean toplevel)
{
GtkBuilder *builder=gtk_builder_new ();
GtkWidget *dlg, *total_size;
FmFilePropData *data;
FmPathList *paths;
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
data = g_slice_new0 (FmFilePropData);
data->files = fm_list_ref (files);
data->single_type = fm_file_info_list_is_same_type (files);
data->single_file = (fm_list_get_length (files) == 1);
data->file_info = fm_list_peek_head (files);
FmMimeType *fi_mime_type = fm_file_info_get_mime_type (data->file_info, FALSE);
if (data->single_type)
data->mime_type = fi_mime_type; // FIXME_pcm: do we need ref counting here?
paths = fm_path_list_new_from_file_info_list (files);
data->dc_job = fm_deep_count_job_new (paths, FM_DC_JOB_DEFAULT);
fm_list_unref (paths);
if (toplevel)
{
gtk_builder_add_from_string (builder, PROPERTIES_DLG, -1, NULL);
GET_WIDGET (dlg);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (data->dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
}
else
{
#if 0
// FIXME_pcm: is this really useful?
const char *names[]= {"notebook", NULL};
gtk_builder_add_objects_from_file (builder, UI_FILE, names, NULL);
data->dlg = (GtkWidget*)gtk_builder_get_object (builder, "notebook");
#endif
}
dlg = data->dlg;
GET_WIDGET (icon);
GET_WIDGET (name);
GET_WIDGET (dir);
GET_WIDGET (target);
GET_WIDGET (target_label);
GET_WIDGET (type);
GET_WIDGET (open_with_label);
GET_WIDGET (open_with);
GET_WIDGET (total_size);
GET_WIDGET (size_on_disk);
GET_WIDGET (mtime);
GET_WIDGET (atime);
GET_WIDGET (owner);
GET_WIDGET (group);
GET_WIDGET (owner_perm);
GET_WIDGET (group_perm);
GET_WIDGET (other_perm);
GET_WIDGET (exec);
g_object_unref (builder);
init_application_list (data);
data->timeout = g_timeout_add (600, (GSourceFunc)on_timeout, data);
g_signal_connect (dlg, "response", G_CALLBACK (on_response), data);
g_signal_connect_swapped (dlg, "destroy", G_CALLBACK (fm_file_prop_data_free), data);
g_signal_connect (data->dc_job, "finished", G_CALLBACK (on_finished), data);
fm_job_run_async (data->dc_job);
update_ui (data);
return dlg;
}
void fm_dnd_src_set_files(FmDndSrc* ds, FmFileInfoList* files)
{
ds->files = fm_list_ref(files);
}
