static void
do_finalize (GObject *self)
{
CajaFileConflictDialogDetails *details =
CAJA_FILE_CONFLICT_DIALOG (self)->details;
g_free (details->conflict_name);
if (details->handle != NULL)
{
caja_file_list_cancel_call_when_ready (details->handle);
}
if (details->src_handler_id)
{
g_signal_handler_disconnect (details->source, details->src_handler_id);
caja_file_monitor_remove (details->source, self);
}
if (details->dest_handler_id)
{
g_signal_handler_disconnect (details->destination, details->dest_handler_id);
caja_file_monitor_remove (details->destination, self);
}
caja_file_unref (details->source);
caja_file_unref (details->destination);
caja_file_unref (details->dest_dir);
G_OBJECT_CLASS (caja_file_conflict_dialog_parent_class)->finalize (self);
}
void
caja_file_queue_remove (CajaFileQueue *queue,
CajaFile *file)
{
GList *link;
link = g_hash_table_lookup (queue->item_to_link_map, file);
if (link == NULL)
{
/* It's not on the queue */
return;
}
if (link == queue->tail)
{
/* Need to special-case removing the tail. */
queue->tail = queue->tail->prev;
}
queue->head = g_list_remove_link (queue->head, link);
g_list_free (link);
g_hash_table_remove (queue->item_to_link_map, file);
caja_file_unref (file);
}
char *
caja_compute_title_for_location (GFile *location)
{
CajaFile *file;
char *title;
/* TODO-gio: This doesn't really work all that great if the
info about the file isn't known atm... */
title = NULL;
if (location)
{
file = caja_file_get (location);
title = caja_file_get_description (file);
if (title == NULL)
{
title = caja_file_get_display_name (file);
}
caja_file_unref (file);
}
if (title == NULL)
{
title = g_strdup ("");
}
return title;
}
static void
fm_ditem_page_exec_drag_data_received (GtkWidget *widget, GdkDragContext *context,
int x, int y,
GtkSelectionData *selection_data,
guint info, guint time,
GtkEntry *entry)
{
char **uris;
gboolean exactly_one;
CajaFile *file;
GKeyFile *key_file;
char *uri, *type, *exec;
uris = g_strsplit (gtk_selection_data_get_data (selection_data), "\r\n", 0);
exactly_one = uris[0] != NULL && (uris[1] == NULL || uris[1][0] == '\0');
if (!exactly_one)
{
g_strfreev (uris);
return;
}
file = caja_file_get_by_uri (uris[0]);
g_strfreev (uris);
g_return_if_fail (file != NULL);
uri = caja_file_get_uri (file);
if (caja_file_is_mime_type (file, "application/x-desktop"))
{
key_file = _g_key_file_new_from_uri (uri, G_KEY_FILE_NONE, NULL);
if (key_file != NULL)
{
type = g_key_file_get_string (key_file, MAIN_GROUP, "Type", NULL);
if (type != NULL && strcmp (type, "Application") == 0)
{
exec = g_key_file_get_string (key_file, MAIN_GROUP, "Exec", NULL);
if (exec != NULL)
{
g_free (uri);
uri = exec;
}
}
g_free (type);
g_key_file_free (key_file);
}
}
gtk_entry_set_text (entry,
uri?uri:"");
gtk_widget_grab_focus (GTK_WIDGET (entry));
g_free (uri);
caja_file_unref (file);
}
static void
each_path_get_data_binder (CajaDragEachSelectedItemDataGet data_get,
gpointer context,
gpointer data)
{
DragDataGetInfo *info;
GList *l;
CajaFile *file;
GtkTreeRowReference *row;
GtkTreePath *path;
char *uri;
GdkRectangle cell_area;
GtkTreeViewColumn *column;
info = context;
g_return_if_fail (info->model->details->drag_view);
column = gtk_tree_view_get_column (info->model->details->drag_view, 0);
for (l = info->path_list; l != NULL; l = l->next)
{
row = l->data;
path = gtk_tree_row_reference_get_path (row);
file = fm_list_model_file_for_path (info->model, path);
if (file)
{
gtk_tree_view_get_cell_area
(info->model->details->drag_view,
path,
column,
&cell_area);
uri = caja_file_get_uri (file);
(*data_get) (uri,
0,
cell_area.y - info->model->details->drag_begin_y,
cell_area.width, cell_area.height,
data);
g_free (uri);
caja_file_unref (file);
}
gtk_tree_path_free (path);
}
}
static void
done_with_file (CajaNotesViewer *notes)
{
cancel_pending_save (notes);
if (notes->details->file != NULL)
{
caja_file_monitor_remove (notes->details->file, notes);
g_signal_handlers_disconnect_matched (notes->details->file,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
0, 0, NULL,
G_CALLBACK (load_note_text_from_metadata),
notes);
caja_file_unref (notes->details->file);
}
}
static void
file_entry_free (FileEntry *file_entry)
{
caja_file_unref (file_entry->file);
if (file_entry->reverse_map)
{
g_hash_table_destroy (file_entry->reverse_map);
file_entry->reverse_map = NULL;
}
if (file_entry->subdirectory != NULL)
{
caja_directory_unref (file_entry->subdirectory);
}
if (file_entry->files != NULL)
{
g_sequence_free (file_entry->files);
}
g_free (file_entry);
}
/* This is a one-shot idle callback called from the main loop to call
notify_file_changed() for a thumbnail. It frees the uri afterwards.
We do this in an idle callback as I don't think caja_file_changed() is
thread-safe. */
static gboolean
thumbnail_thread_notify_file_changed (gpointer image_uri)
{
CajaFile *file;
file = caja_file_get_by_uri ((char *) image_uri);
#ifdef DEBUG_THUMBNAILS
g_message ("(Thumbnail Thread) Notifying file changed file:%p uri: %s\n", file, (char*) image_uri);
#endif
if (file != NULL)
{
caja_file_set_is_thumbnailing (file, FALSE);
caja_file_invalidate_attributes (file,
CAJA_FILE_ATTRIBUTE_THUMBNAIL |
CAJA_FILE_ATTRIBUTE_INFO);
caja_file_unref (file);
}
g_free (image_uri);
return FALSE;
}
static void
free_xdg_dir_cache (void)
{
int i;
if (cached_xdg_dirs != NULL)
{
for (i = 0; cached_xdg_dirs[i].type != NULL; i++)
{
if (cached_xdg_dirs[i].file != NULL)
{
caja_file_monitor_remove (cached_xdg_dirs[i].file,
&cached_xdg_dirs[i]);
g_signal_handlers_disconnect_by_func (cached_xdg_dirs[i].file,
G_CALLBACK (xdg_dir_changed),
&cached_xdg_dirs[i]);
caja_file_unref (cached_xdg_dirs[i].file);
}
g_free (cached_xdg_dirs[i].type);
g_free (cached_xdg_dirs[i].path);
}
g_free (cached_xdg_dirs);
}
}
void
caja_launch_application_by_uri (GAppInfo *application,
GList *uris,
GtkWindow *parent_window)
{
char *uri, *uri_scheme;
GList *locations, *l;
GFile *location;
CajaFile *file;
gboolean result;
GError *error;
GdkAppLaunchContext *launch_context;
CajaIconInfo *icon;
int count, total;
g_assert (uris != NULL);
/* count the number of uris with local paths */
count = 0;
total = g_list_length (uris);
locations = NULL;
for (l = uris; l != NULL; l = l->next)
{
uri = l->data;
location = g_file_new_for_uri (uri);
if (g_file_is_native (location))
{
count++;
}
locations = g_list_prepend (locations, location);
}
locations = g_list_reverse (locations);
launch_context = gdk_app_launch_context_new ();
if (parent_window)
gdk_app_launch_context_set_screen (launch_context,
gtk_window_get_screen (parent_window));
file = caja_file_get_by_uri (uris->data);
icon = caja_file_get_icon (file, 48, 0);
caja_file_unref (file);
if (icon)
{
gdk_app_launch_context_set_icon_name (launch_context,
caja_icon_info_get_used_name (icon));
g_object_unref (icon);
}
error = NULL;
if (count == total)
{
/* All files are local, so we can use g_app_info_launch () with
* the file list we constructed before.
*/
result = g_app_info_launch (application,
locations,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
}
else
{
/* Some files are non local, better use g_app_info_launch_uris ().
*/
result = g_app_info_launch_uris (application,
uris,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
}
g_object_unref (launch_context);
if (!result)
{
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_NOT_SUPPORTED)
{
uri_scheme = g_uri_parse_scheme (uris->data);
application_cannot_open_location (application,
file,
uri_scheme,
parent_window);
g_free (uri_scheme);
}
else
{
#ifdef NEW_MIME_COMPLETE
caja_program_chooser_show_invalid_message
(MATE_VFS_MIME_ACTION_TYPE_APPLICATION, file, parent_window);
#else
g_warning ("Cannot open app: %s\n", error->message);
#endif
}
g_error_free (error);
}
else
{
for (l = uris; l != NULL; l = l->next)
{
file = caja_file_get_by_uri (l->data);
caja_recent_add_file (file, application);
caja_file_unref (file);
}
}
g_list_free_full (locations, g_object_unref);
}
static void
fm_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value)
{
FMListModel *model;
FileEntry *file_entry;
CajaFile *file;
char *str;
GdkPixbuf *icon, *rendered_icon;
GIcon *gicon, *emblemed_icon, *emblem_icon;
CajaIconInfo *icon_info;
GEmblem *emblem;
GList *emblem_icons, *l;
int icon_size;
CajaZoomLevel zoom_level;
CajaFile *parent_file;
char *emblems_to_ignore[3];
int i;
CajaFileIconFlags flags;
model = (FMListModel *)tree_model;
g_return_if_fail (model->details->stamp == iter->stamp);
g_return_if_fail (!g_sequence_iter_is_end (iter->user_data));
file_entry = g_sequence_get (iter->user_data);
file = file_entry->file;
switch (column)
{
case FM_LIST_MODEL_FILE_COLUMN:
g_value_init (value, CAJA_TYPE_FILE);
g_value_set_object (value, file);
break;
case FM_LIST_MODEL_SUBDIRECTORY_COLUMN:
g_value_init (value, CAJA_TYPE_DIRECTORY);
g_value_set_object (value, file_entry->subdirectory);
break;
case FM_LIST_MODEL_SMALLEST_ICON_COLUMN:
case FM_LIST_MODEL_SMALLER_ICON_COLUMN:
case FM_LIST_MODEL_SMALL_ICON_COLUMN:
case FM_LIST_MODEL_STANDARD_ICON_COLUMN:
case FM_LIST_MODEL_LARGE_ICON_COLUMN:
case FM_LIST_MODEL_LARGER_ICON_COLUMN:
case FM_LIST_MODEL_LARGEST_ICON_COLUMN:
g_value_init (value, GDK_TYPE_PIXBUF);
if (file != NULL)
{
zoom_level = fm_list_model_get_zoom_level_from_column_id (column);
icon_size = caja_get_icon_size_for_zoom_level (zoom_level);
flags = CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS |
CAJA_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE |
CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM;
if (model->details->drag_view != NULL)
{
GtkTreePath *path_a, *path_b;
gtk_tree_view_get_drag_dest_row (model->details->drag_view,
&path_a,
NULL);
if (path_a != NULL)
{
path_b = gtk_tree_model_get_path (tree_model, iter);
if (gtk_tree_path_compare (path_a, path_b) == 0)
{
flags |= CAJA_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT;
}
gtk_tree_path_free (path_a);
gtk_tree_path_free (path_b);
}
}
gicon = caja_file_get_gicon (file, flags);
/* render emblems with GEmblemedIcon */
parent_file = caja_file_get_parent (file);
i = 0;
emblems_to_ignore[i++] = CAJA_FILE_EMBLEM_NAME_TRASH;
if (parent_file) {
if (!caja_file_can_write (parent_file)) {
emblems_to_ignore[i++] = CAJA_FILE_EMBLEM_NAME_CANT_WRITE;
}
caja_file_unref (parent_file);
}
emblems_to_ignore[i++] = NULL;
emblem = NULL;
emblem_icons = caja_file_get_emblem_icons (file,
emblems_to_ignore);
if (emblem_icons != NULL) {
emblem_icon = emblem_icons->data;
emblem = g_emblem_new (emblem_icon);
emblemed_icon = g_emblemed_icon_new (gicon, emblem);
g_object_unref (emblem);
for (l = emblem_icons->next; l != NULL; l = l->next) {
emblem_icon = l->data;
emblem = g_emblem_new (emblem_icon);
g_emblemed_icon_add_emblem
(G_EMBLEMED_ICON (emblemed_icon), emblem);
g_object_unref (emblem);
}
g_list_free_full (emblem_icons, g_object_unref);
g_object_unref (gicon);
gicon = emblemed_icon;
}
icon_info = caja_icon_info_lookup (gicon, icon_size);
icon = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size);
g_object_unref (icon_info);
g_object_unref (gicon);
if (model->details->highlight_files != NULL &&
g_list_find_custom (model->details->highlight_files,
file, (GCompareFunc) caja_file_compare_location))
{
rendered_icon = eel_gdk_pixbuf_render (icon, 1, 255, 255, 0, 0);
if (rendered_icon != NULL)
{
g_object_unref (icon);
icon = rendered_icon;
}
}
g_value_set_object (value, icon);
g_object_unref (icon);
}
break;
case FM_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN:
g_value_init (value, G_TYPE_BOOLEAN);
g_value_set_boolean (value, file != NULL && caja_file_can_rename (file));
break;
default:
if (column >= FM_LIST_MODEL_NUM_COLUMNS || column < FM_LIST_MODEL_NUM_COLUMNS + model->details->columns->len)
{
CajaColumn *caja_column;
GQuark attribute;
caja_column = model->details->columns->pdata[column - FM_LIST_MODEL_NUM_COLUMNS];
g_value_init (value, G_TYPE_STRING);
g_object_get (caja_column,
"attribute_q", &attribute,
NULL);
if (file != NULL)
{
str = caja_file_get_string_attribute_with_default_q (file,
attribute);
g_value_take_string (value, str);
}
else if (attribute == attribute_name_q)
{
if (file_entry->parent->loaded)
{
g_value_set_string (value, _("(Empty)"));
}
else
{
g_value_set_string (value, _("Loading..."));
}
}
}
else
{
g_assert_not_reached ();
}
}
}
GHashTable *
caja_trashed_files_get_original_directories (GList *files,
GList **unhandled_files)
{
GHashTable *directories;
CajaFile *file, *original_file, *original_dir;
GList *l, *m;
directories = NULL;
if (unhandled_files != NULL)
{
*unhandled_files = NULL;
}
for (l = files; l != NULL; l = l->next)
{
file = CAJA_FILE (l->data);
original_file = caja_file_get_trash_original_file (file);
original_dir = NULL;
if (original_file != NULL)
{
original_dir = caja_file_get_parent (original_file);
}
if (original_dir != NULL)
{
if (directories == NULL)
{
directories = g_hash_table_new_full (g_direct_hash, g_direct_equal,
(GDestroyNotify) caja_file_unref,
(GDestroyNotify) caja_file_list_unref);
}
caja_file_ref (original_dir);
m = g_hash_table_lookup (directories, original_dir);
if (m != NULL)
{
g_hash_table_steal (directories, original_dir);
caja_file_unref (original_dir);
}
m = g_list_append (m, caja_file_ref (file));
g_hash_table_insert (directories, original_dir, m);
}
else if (unhandled_files != NULL)
{
*unhandled_files = g_list_append (*unhandled_files, caja_file_ref (file));
}
if (original_file != NULL)
{
caja_file_unref (original_file);
}
if (original_dir != NULL)
{
caja_file_unref (original_dir);
}
}
return directories;
}
void
caja_launch_application_by_uri (GAppInfo *application,
GList *uris,
GtkWindow *parent_window)
{
char *uri, *uri_scheme;
GList *locations, *l;
GFile *location;
CajaFile *file;
gboolean result;
GError *error;
GdkDisplay *display;
GdkAppLaunchContext *launch_context;
CajaIconInfo *icon;
int count, total;
g_assert (uris != NULL);
/* count the number of uris with local paths */
count = 0;
total = g_list_length (uris);
locations = NULL;
for (l = uris; l != NULL; l = l->next)
{
uri = l->data;
location = g_file_new_for_uri (uri);
if (g_file_is_native (location))
{
count++;
}
locations = g_list_prepend (locations, location);
}
locations = g_list_reverse (locations);
if (parent_window != NULL) {
display = gtk_widget_get_display (GTK_WIDGET (parent_window));
} else {
display = gdk_display_get_default ();
}
launch_context = gdk_display_get_app_launch_context (display);
if (parent_window != NULL) {
gdk_app_launch_context_set_screen (launch_context,
gtk_window_get_screen (parent_window));
}
file = caja_file_get_by_uri (uris->data);
icon = caja_file_get_icon (file, 48, 0);
caja_file_unref (file);
if (icon)
{
gdk_app_launch_context_set_icon_name (launch_context,
caja_icon_info_get_used_name (icon));
g_object_unref (icon);
}
error = NULL;
result = g_desktop_app_info_launch_uris_as_manager (G_DESKTOP_APP_INFO (application),
uris,
G_APP_LAUNCH_CONTEXT (launch_context),
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL,
gather_pid_callback, application,
&error);
g_object_unref (launch_context);
if (!result)
{
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_NOT_SUPPORTED)
{
uri_scheme = g_uri_parse_scheme (uris->data);
application_cannot_open_location (application,
file,
uri_scheme,
parent_window);
g_free (uri_scheme);
}
else
{
#ifdef NEW_MIME_COMPLETE
caja_program_chooser_show_invalid_message
(MATE_VFS_MIME_ACTION_TYPE_APPLICATION, file, parent_window);
#else
g_warning ("Cannot open app: %s\n", error->message);
#endif
}
g_error_free (error);
}
else
{
for (l = uris; l != NULL; l = l->next)
{
file = caja_file_get_by_uri (l->data);
caja_recent_add_file (file, application);
caja_file_unref (file);
}
}
g_list_free_full (locations, g_object_unref);
}