/*
- * GQview
+ * Geeqie
* (C) 2005 John Ellis
+ * Copyright (C) 2008 - 2012 The Geeqie Team
*
* Author: John Ellis
*
*/
-#include "gqview.h"
+#include "main.h"
#include "dupe.h"
#include "cache.h"
#include "collect-table.h"
#include "dnd.h"
#include "editors.h"
-#include "filelist.h"
+#include "filedata.h"
#include "image-load.h"
#include "img-view.h"
-#include "info.h"
#include "layout.h"
#include "layout_image.h"
#include "md5-util.h"
#include "menu.h"
+#include "misc.h"
#include "print.h"
#include "thumb.h"
-#include "utilops.h"
-#include "ui_bookmark.h"
#include "ui_fileops.h"
#include "ui_menu.h"
#include "ui_misc.h"
#include "ui_tree_edit.h"
+#include "uri_utils.h"
+#include "utilops.h"
+#include "window.h"
#include <gdk/gdkkeysyms.h> /* for keyboard values */
#include <math.h>
-#define DUPE_DEF_WIDTH 600
+#define DUPE_DEF_WIDTH 800
#define DUPE_DEF_HEIGHT 400
/* column assignment order (simply change them here) */
static void dupe_dnd_init(DupeWindow *dw);
+static void dupe_notify_cb(FileData *fd, NotifyType type, gpointer data);
+
/*
* ------------------------------------------------------------------
* Window updates
*/
-static void dupe_window_update_count(DupeWindow *dw, gint count_only)
+static void dupe_window_update_count(DupeWindow *dw, gboolean count_only)
{
gchar *text;
return (n * ((n + 1) / 2));
}
-static void dupe_window_update_progress(DupeWindow *dw, const gchar *status, gdouble value, gint force)
+static void dupe_window_update_progress(DupeWindow *dw, const gchar *status, gdouble value, gboolean force)
{
const gchar *status_text;
{
new_time = msec_time() - dw->setup_time;
}
-
+
if (!force &&
value != 0.0 &&
dw->setup_count > 0 &&
{
status_text = NULL;
}
- }
+ }
else
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), 0.0);
{
GdkCursor *cursor;
- if (!widget->window) return;
-
+ if (!gtk_widget_get_window(widget)) return;
+
if (icon == -1)
{
cursor = NULL;
}
else
{
- cursor = gdk_cursor_new (icon);
+ cursor = gdk_cursor_new(icon);
}
-
- gdk_window_set_cursor(widget->window, cursor);
-
+
+ gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
+
if (cursor) gdk_cursor_unref(cursor);
}
GtkTreeIter iter;
gboolean color_set = TRUE;
DupeItem *parent = NULL;
- gint valid;
+ gboolean valid;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
valid = gtk_tree_model_get_iter_first(store, &iter);
* ------------------------------------------------------------------
*/
-static DupeItem *dupe_item_new(const gchar *path, gint64 size, time_t date)
+static DupeItem *dupe_item_new(FileData *fd)
{
DupeItem *di;
di = g_new0(DupeItem, 1);
- di->path = g_strdup(path);
- di->name = filename_from_path(di->path);
- di->size = size;
- di->date = date;
-
- di->group = NULL;
+ di->fd = file_data_ref(fd);
di->group_rank = 0.0;
- di->simd = NULL;
- di->checksum = 0;
- di->md5sum = NULL;
- di->width = 0;
- di->height = 0;
-
- di->second = FALSE;
-
return di;
}
static void dupe_item_free(DupeItem *di)
{
- g_free(di->path);
+ file_data_unref(di->fd);
image_sim_free(di->simd);
g_free(di->md5sum);
if (di->pixbuf) g_object_unref(di->pixbuf);
g_list_free(list);
}
+/*
+static DupeItem *dupe_item_find_fd_by_list(FileData *fd, GList *work)
+{
+ while (work)
+ {
+ DupeItem *di = work->data;
+
+ if (di->fd == fd) return di;
+
+ work = work->next;
+ }
+
+ return NULL;
+}
+*/
+
+/*
+static DupeItem *dupe_item_find_fd(DupeWindow *dw, FileData *fd)
+{
+ DupeItem *di;
+
+ di = dupe_item_find_fd_by_list(fd, dw->list);
+ if (!di && dw->second_set) di = dupe_item_find_fd_by_list(fd, dw->second_list);
+
+ return di;
+}
+*/
+
static DupeItem *dupe_item_find_path_by_list(const gchar *path, GList *work)
{
while (work)
{
DupeItem *di = work->data;
- if (strcmp(di->path, path) == 0) return di;
+ if (strcmp(di->fd->path, path) == 0) return di;
work = work->next;
}
if (!di) return;
- path = cache_find_location(CACHE_TYPE_SIM, di->path);
+ path = cache_find_location(CACHE_TYPE_SIM, di->fd->path);
if (!path) return;
- if (filetime(di->path) != filetime(path))
+ if (filetime(di->fd->path) != filetime(path))
{
g_free(path);
return;
if (!di) return;
- base = cache_get_location(CACHE_TYPE_SIM, di->path, FALSE, &mode);
- if (cache_ensure_dir_exists(base, mode))
+ base = cache_get_location(CACHE_TYPE_SIM, di->fd->path, FALSE, &mode);
+ if (recursive_mkdir_if_not_exists(base, mode))
{
CacheData *cd;
cd = cache_sim_data_new();
- cd->path = cache_get_location(CACHE_TYPE_SIM, di->path, TRUE, NULL);
+ cd->path = cache_get_location(CACHE_TYPE_SIM, di->fd->path, TRUE, NULL);
if (di->width != 0) cache_sim_data_set_dimensions(cd, di->width, di->height);
if (di->checksum != 0) cache_sim_data_set_checksum(cd, di->checksum);
if (cache_sim_data_save(cd))
{
- filetime_set(cd->path, filetime(di->path));
+ filetime_set(cd->path, filetime(di->fd->path));
}
cache_sim_data_free(cd);
}
static gint dupe_listview_find_item(GtkListStore *store, DupeItem *item, GtkTreeIter *iter)
{
- gint valid;
+ gboolean valid;
gint row = 0;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), iter);
else
{
rank = 1;
- printf("NULL group in item!\n");
+ log_printf("NULL group in item!\n");
}
}
else
}
text[DUPE_COLUMN_THUMB] = "";
- text[DUPE_COLUMN_NAME] = (gchar *)di->name;
- text[DUPE_COLUMN_SIZE] = text_from_size(di->size);
- text[DUPE_COLUMN_DATE] = (gchar *)text_from_time(di->date);
+ text[DUPE_COLUMN_NAME] = (gchar *)di->fd->name;
+ text[DUPE_COLUMN_SIZE] = text_from_size(di->fd->size);
+ text[DUPE_COLUMN_DATE] = (gchar *)text_from_time(di->fd->date);
if (di->width > 0 && di->height > 0)
{
text[DUPE_COLUMN_DIMENSIONS] = g_strdup_printf("%d x %d", di->width, di->height);
{
text[DUPE_COLUMN_DIMENSIONS] = g_strdup("");
}
- text[DUPE_COLUMN_PATH] = di->path;
+ text[DUPE_COLUMN_PATH] = di->fd->path;
text[DUPE_COLUMN_COLOR] = NULL;
gtk_list_store_insert(store, &iter, row);
}
-static GList *dupe_listview_get_path_list(DupeWindow *dw, GtkWidget *listview)
+static GList *dupe_listview_get_filelist(DupeWindow *dw, GtkWidget *listview)
{
GtkTreeModel *store;
GtkTreeIter iter;
- gint valid;
+ gboolean valid;
GList *list = NULL;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(listview));
{
DupeItem *di;
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
- list = g_list_prepend(list, g_strdup(di->path));
+ list = g_list_prepend(list, file_data_ref(di->fd));
valid = gtk_tree_model_iter_next(store, &iter);
}
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
if (di)
{
- list = g_list_prepend(list, g_strdup(di->path));
+ list = g_list_prepend(list, file_data_ref(di->fd));
}
work = work->next;
}
return g_list_reverse(list);
}
-static gint dupe_listview_item_is_selected(DupeWindow *dw, DupeItem *di, GtkWidget *listview)
+static gboolean dupe_listview_item_is_selected(DupeWindow *dw, DupeItem *di, GtkWidget *listview)
{
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
GList *work;
- gint found = FALSE;
+ gboolean found = FALSE;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
slist = gtk_tree_selection_get_selected_rows(selection, &store);
GtkTreeModel *store;
GtkTreeSelection *selection;
GtkTreeIter iter;
- gint valid;
+ gboolean valid;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
gtk_tree_selection_unselect_all(selection);
dupe_match_unlink_child(b, a);
}
-static void dupe_match_link_clear(DupeItem *parent, gint unlink_children)
+static void dupe_match_link_clear(DupeItem *parent, gboolean unlink_children)
{
GList *work;
-
+
work = parent->group;
while (work)
{
{
GList *work;
- printf("+ %f %s\n", di->group_rank, di->name);
+ log_printf("+ %f %s\n", di->group_rank, di->fd->name);
work = di->group;
while (work)
DupeMatch *dm = work->data;
work = work->next;
- printf(" %f %s\n", dm->rank, dm->di->name);
+ log_printf(" %f %s\n", dm->rank, dm->di->fd->name);
}
- printf("\n");
+ log_printf("\n");
}
static void dupe_match_print_list(GList *list)
GList *work;
gdouble rank;
- if (debug > 1) printf("link found %s to %s [%d]\n", child->name, parent->name, g_list_length(parent->group));
+ DEBUG_2("link found %s to %s [%d]", child->fd->name, parent->fd->name, g_list_length(parent->group));
work = parent->group;
while (work)
list = g_list_remove(list, orphan);
}
}
-
+
rank = dupe_match_link_rank(child, parent);
dupe_match_link_clear(parent, TRUE);
dupe_match_link(child, parent, rank);
}
else
{
- if (debug > 1) printf("unlinking %s and %s\n", child->name, parent->name);
-
+ DEBUG_2("unlinking %s and %s", child->fd->name, parent->fd->name);
+
dupe_match_unlink(child, parent);
}
dupe_match_rank_update(di);
list = g_list_prepend(list, di);
}
-
+
work = work->next;
}
list = dupe_match_rank_sort(dw->list);
- if (debug > 1) dupe_match_print_list(list);
-
- if (debug) printf("Similar items: %d\n", g_list_length(list));
+ if (required_debug_level(2)) dupe_match_print_list(list);
+
+ DEBUG_1("Similar items: %d", g_list_length(list));
list = dupe_match_group_trim(list, dw);
- if (debug) printf("Unique groups: %d\n", g_list_length(list));
+ DEBUG_1("Unique groups: %d", g_list_length(list));
dupe_match_sort_groups(list);
- if (debug) dupe_match_print_list(list);
+ if (required_debug_level(2)) dupe_match_print_list(list);
list = dupe_match_rank_sort(list);
* ------------------------------------------------------------------
*/
-static gint dupe_match(DupeItem *a, DupeItem *b, DupeMatchType mask, gdouble *rank, gint fast)
+static gboolean dupe_match(DupeItem *a, DupeItem *b, DupeMatchType mask, gdouble *rank, gint fast)
{
*rank = 0.0;
- if (a == b) return FALSE;
+ if (a->fd->path == b->fd->path) return FALSE;
if (mask & DUPE_MATCH_PATH)
{
- if (strcmp(a->path, b->path) != 0) return FALSE;
+ if (utf8_compare(a->fd->path, b->fd->path, TRUE) != 0) return FALSE;
}
if (mask & DUPE_MATCH_NAME)
{
- if (strcmp(a->name, b->name) != 0) return FALSE;
+ if (strcmp(a->fd->collate_key_name, b->fd->collate_key_name) != 0) return FALSE;
+ }
+ if (mask & DUPE_MATCH_NAME_CI)
+ {
+ if (strcmp(a->fd->collate_key_name_nocase, b->fd->collate_key_name_nocase) != 0) return FALSE;
}
if (mask & DUPE_MATCH_SIZE)
{
- if (a->size != b->size) return FALSE;
+ if (a->fd->size != b->fd->size) return FALSE;
}
if (mask & DUPE_MATCH_DATE)
{
- if (a->date != b->date) return FALSE;
+ if (a->fd->date != b->fd->date) return FALSE;
}
if (mask & DUPE_MATCH_SUM)
{
- if (!a->md5sum) a->md5sum = md5_text_from_file_utf8(a->path, "");
- if (!b->md5sum) b->md5sum = md5_text_from_file_utf8(b->path, "");
+ if (!a->md5sum) a->md5sum = md5_text_from_file_utf8(a->fd->path, "");
+ if (!b->md5sum) b->md5sum = md5_text_from_file_utf8(b->fd->path, "");
if (a->md5sum[0] == '\0' ||
b->md5sum[0] == '\0' ||
strcmp(a->md5sum, b->md5sum) != 0) return FALSE;
}
if (mask & DUPE_MATCH_DIM)
{
- if (a->width == 0) image_load_dimensions(a->path, &a->width, &a->height);
- if (b->width == 0) image_load_dimensions(b->path, &b->width, &b->height);
+ if (a->width == 0) image_load_dimensions(a->fd, &a->width, &a->height);
+ if (b->width == 0) image_load_dimensions(b->fd, &b->width, &b->height);
if (a->width != b->width || a->height != b->height) return FALSE;
}
if (mask & DUPE_MATCH_SIM_HIGH ||
if (mask & DUPE_MATCH_SIM_HIGH) m = 0.95;
else if (mask & DUPE_MATCH_SIM_MED) m = 0.90;
- else if (mask & DUPE_MATCH_SIM_CUSTOM) m = (gdouble)dupe_custom_threshold / 100.0;
+ else if (mask & DUPE_MATCH_SIM_CUSTOM) m = (gdouble)options->duplicates_similarity_threshold / 100.0;
else m = 0.85;
if (fast)
if (f < m) return FALSE;
- if (debug > 2) printf("similar: %32s %32s = %f\n", a->name, b->name, f);
+ DEBUG_3("similar: %32s %32s = %f", a->fd->name, b->fd->name, f);
}
return TRUE;
di = dw->thumb_item;
if (di->pixbuf) g_object_unref(di->pixbuf);
- di->pixbuf = thumb_loader_get_pixbuf(dw->thumb_loader, TRUE);
+ di->pixbuf = thumb_loader_get_pixbuf(dw->thumb_loader);
dupe_listview_set_thumb(dw, di, NULL);
}
GtkTreeModel *store;
GtkTreeIter iter;
DupeItem *di = NULL;
- gint valid;
+ gboolean valid;
gint row = 0;
gint length = 0;
dw->thumb_item = di;
thumb_loader_free(dw->thumb_loader);
- dw->thumb_loader = thumb_loader_new(thumb_max_width, thumb_max_height);
+ dw->thumb_loader = thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
thumb_loader_set_callbacks(dw->thumb_loader,
dupe_thumb_done_cb,
dw);
/* start it */
- if (!thumb_loader_start(dw->thumb_loader, di->path))
+ if (!thumb_loader_start(dw->thumb_loader, di->fd))
{
/* error, handle it, do next */
- if (debug) printf("error loading thumb for %s\n", di->path);
+ DEBUG_1("error loading thumb for %s", di->fd->path);
dupe_thumb_do(dw);
dupe_thumb_step(dw);
}
static void dupe_check_stop(DupeWindow *dw)
{
- if (dw->idle_id != -1 || dw->img_loader || dw->thumb_loader)
+ if (dw->idle_id || dw->img_loader || dw->thumb_loader)
{
g_source_remove(dw->idle_id);
- dw->idle_id = -1;
+ dw->idle_id = 0;
dupe_window_update_progress(dw, NULL, 0.0, FALSE);
widget_set_cursor(dw->listview, -1);
}
di->width = gdk_pixbuf_get_width(pixbuf);
di->height = gdk_pixbuf_get_height(pixbuf);
}
- if (enable_thumb_caching)
+ if (options->thumbnails.enable_caching)
{
dupe_item_write_cache(di);
}
return NULL;
}
-static gint dupe_check_cb(gpointer data)
+static gboolean dupe_check_cb(gpointer data)
{
DupeWindow *dw = data;
- if (dw->idle_id == -1) return FALSE;
+ if (!dw->idle_id) return FALSE;
if (!dw->setup_done)
{
dupe_window_update_progress(dw, _("Reading checksums..."),
dw->setup_count == 0 ? 0.0 : (gdouble)(dw->setup_n - 1) / dw->setup_count, FALSE);
- if (enable_thumb_caching)
+ if (options->thumbnails.enable_caching)
{
dupe_item_read_cache(di);
if (di->md5sum) return TRUE;
}
- di->md5sum = md5_text_from_file_utf8(di->path, "");
- if (enable_thumb_caching)
+ di->md5sum = md5_text_from_file_utf8(di->fd->path, "");
+ if (options->thumbnails.enable_caching)
{
dupe_item_write_cache(di);
}
dupe_window_update_progress(dw, _("Reading dimensions..."),
dw->setup_count == 0 ? 0.0 : (gdouble)(dw->setup_n - 1) / dw->setup_count, FALSE);
- if (enable_thumb_caching)
+ if (options->thumbnails.enable_caching)
{
dupe_item_read_cache(di);
if (di->width != 0 || di->height != 0) return TRUE;
}
- image_load_dimensions(di->path, &di->width, &di->height);
- if (enable_thumb_caching)
+ image_load_dimensions(di->fd, &di->width, &di->height);
+ if (options->thumbnails.enable_caching)
{
dupe_item_write_cache(di);
}
dupe_window_update_progress(dw, _("Reading similarity data..."),
dw->setup_count == 0 ? 0.0 : (gdouble)dw->setup_n / dw->setup_count, FALSE);
- if (enable_thumb_caching)
+ if (options->thumbnails.enable_caching)
{
dupe_item_read_cache(di);
if (cache_sim_data_filled(di->simd))
}
}
- dw->img_loader = image_loader_new(di->path);
+ dw->img_loader = image_loader_new(di->fd);
image_loader_set_buffer_size(dw->img_loader, 8);
- image_loader_set_error_func(dw->img_loader, dupe_loader_done_cb, dw);
+ g_signal_connect(G_OBJECT(dw->img_loader), "error", (GCallback)dupe_loader_done_cb, dw);
+ g_signal_connect(G_OBJECT(dw->img_loader), "done", (GCallback)dupe_loader_done_cb, dw);
- if (!image_loader_start(dw->img_loader, dupe_loader_done_cb, dw))
+ if (!image_loader_start(dw->img_loader))
{
image_sim_free(di->simd);
di->simd = image_sim_new();
dw->img_loader = NULL;
return TRUE;
}
- dw->idle_id = -1;
+ dw->idle_id = 0;
return FALSE;
}
dupe_window_update_progress(dw, _("Sorting..."), 1.0, TRUE);
return TRUE;
}
- dw->idle_id = -1;
+ dw->idle_id = 0;
dupe_window_update_progress(dw, NULL, 0.0, FALSE);
dupe_match_rank(dw);
dupe_window_update_count(dw, TRUE);
widget_set_cursor(dw->listview, GDK_WATCH);
- if (dw->idle_id != -1) return;
+ if (dw->idle_id) return;
dw->idle_id = g_idle_add(dupe_check_cb, dw);
}
{
DupeItem *new_parent;
DupeMatch *dm;
-
+
dm = parent->group->data;
new_parent = dm->di;
dupe_match_reparent(dw, parent, new_parent);
dupe_window_update_count(dw, FALSE);
}
-static gint dupe_item_remove_by_path(DupeWindow *dw, const gchar *path)
+static gboolean dupe_item_remove_by_path(DupeWindow *dw, const gchar *path)
{
DupeItem *di;
}
static void dupe_files_add(DupeWindow *dw, CollectionData *collection, CollectInfo *info,
- const gchar *path, gint recurse)
+ FileData *fd, gboolean recurse)
{
DupeItem *di = NULL;
if (info)
{
- di = dupe_item_new(info->path, info->size, info->date);
+ di = dupe_item_new(info->fd);
}
- else if (path)
+ else if (fd)
{
- if (isfile(path))
+ if (isfile(fd->path))
{
- di = dupe_item_new(path, filesize(path), filetime(path));
+ di = dupe_item_new(fd);
}
- else if (isdir(path) && recurse)
+ else if (isdir(fd->path) && recurse)
{
GList *f, *d;
- if (path_list(path, &f, &d))
+ if (filelist_read(fd, &f, &d))
{
GList *work;
- f = path_list_filter(f, FALSE);
- d = path_list_filter(d, TRUE);
+ f = filelist_filter(f, FALSE);
+ d = filelist_filter(d, TRUE);
work = f;
- while(work)
+ while (work)
{
- dupe_files_add(dw, NULL, NULL, (gchar *)work->data, TRUE);
+ dupe_files_add(dw, NULL, NULL, (FileData *)work->data, TRUE);
work = work->next;
}
- path_list_free(f);
+ filelist_free(f);
work = d;
- while(work)
+ while (work)
{
- dupe_files_add(dw, NULL, NULL, (gchar *)work->data, TRUE);
+ dupe_files_add(dw, NULL, NULL, (FileData *)work->data, TRUE);
work = work->next;
}
- path_list_free(d);
+ filelist_free(d);
}
}
}
CollectInfo *info;
info = collection_get_first(collection);
- while(info)
+ while (info)
{
dupe_files_add(dw, collection, info, NULL, FALSE);
info = collection_next_by_info(collection, info);
dupe_check_start(dw);
}
-void dupe_window_add_files(DupeWindow *dw, GList *list, gint recurse)
+void dupe_window_add_files(DupeWindow *dw, GList *list, gboolean recurse)
{
GList *work;
work = list;
- while(work)
+ while (work)
{
- gchar *path = work->data;
+ FileData *fd = work->data;
work = work->next;
- dupe_files_add(dw, NULL, NULL, path, recurse);
+ dupe_files_add(dw, NULL, NULL, fd, recurse);
}
dupe_check_start(dw);
}
-static gint dupe_item_set_path(DupeWindow *dw, const gchar *source, const gchar *dest)
+static void dupe_item_update(DupeWindow *dw, DupeItem *di)
{
- DupeItem *di;
-
- di = dupe_item_find_path(dw, source);
- if (!di) return FALSE;
-
- if ( (dw->match_mask & DUPE_MATCH_NAME) || (dw->match_mask & DUPE_MATCH_PATH) )
+ if ( (dw->match_mask & DUPE_MATCH_NAME) || (dw->match_mask & DUPE_MATCH_PATH || (dw->match_mask & DUPE_MATCH_NAME_CI)) )
{
/* only effects matches on name or path */
+/*
+ FileData *fd = file_data_ref(di->fd);
gint second;
second = di->second;
dupe_item_remove(dw, di);
dw->second_drop = second;
- dupe_files_add(dw, NULL, NULL, dest, FALSE);
+ dupe_files_add(dw, NULL, NULL, fd, FALSE);
dw->second_drop = FALSE;
+ file_data_unref(fd);
+*/
dupe_check_start(dw);
}
else
GtkListStore *store;
GtkTreeIter iter;
gint row;
-
- g_free(di->path);
- di->path = g_strdup(dest);
- di->name = filename_from_path(di->path);
-
/* update the listview(s) */
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
if (row >= 0)
{
gtk_list_store_set(store, &iter,
- DUPE_COLUMN_NAME, di->name,
- DUPE_COLUMN_PATH, di->path, -1);
+ DUPE_COLUMN_NAME, di->fd->name,
+ DUPE_COLUMN_PATH, di->fd->path, -1);
}
if (dw->second_listview)
row = dupe_listview_find_item(store, di, &iter);
if (row >= 0)
{
- gtk_list_store_set(store, &iter, 1, di->path, -1);
+ gtk_list_store_set(store, &iter, 1, di->fd->path, -1);
}
}
}
- return TRUE;
}
+static void dupe_item_update_fd_in_list(DupeWindow *dw, FileData *fd, GList *work)
+{
+ while (work)
+ {
+ DupeItem *di = work->data;
+
+ if (di->fd == fd)
+ dupe_item_update(dw, di);
+
+ work = work->next;
+ }
+}
+
+static void dupe_item_update_fd(DupeWindow *dw, FileData *fd)
+{
+ dupe_item_update_fd_in_list(dw, fd, dw->list);
+ if (dw->second_set) dupe_item_update_fd_in_list(dw, fd, dw->second_list);
+}
+
+
/*
* ------------------------------------------------------------------
* Misc.
label = gtk_label_new(text);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
-
+
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
{
GenericDialog *gd;
gchar *buf;
-
+
if (!di) return;
- gd = file_util_gen_dlg("Image thumbprint debug info", "GQview", "thumbprint",
+ gd = file_util_gen_dlg("Image thumbprint debug info", "thumbprint",
dw->window, TRUE,
NULL, NULL);
generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
- dupe_display_label(gd->vbox, "name:", di->name);
- buf = text_from_size(di->size);
+ dupe_display_label(gd->vbox, "name:", di->fd->name);
+ buf = text_from_size(di->fd->size);
dupe_display_label(gd->vbox, "size:", buf);
g_free(buf);
- dupe_display_label(gd->vbox, "date:", text_from_time(di->date));
+ dupe_display_label(gd->vbox, "date:", text_from_time(di->fd->date));
buf = g_strdup_printf("%d x %d", di->width, di->height);
dupe_display_label(gd->vbox, "dimensions:", buf);
g_free(buf);
guchar *dp;
gint rs;
gint sp;
-
+
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
rs = gdk_pixbuf_get_rowstride(pixbuf);
d_pix = gdk_pixbuf_get_pixels(pixbuf);
image = gtk_image_new_from_pixbuf(pixbuf);
gtk_box_pack_start(GTK_BOX(gd->vbox), image, FALSE, FALSE, 0);
gtk_widget_show(image);
-
- gdk_pixbuf_unref(pixbuf);
+
+ g_object_unref(pixbuf);
}
-
+
gtk_widget_show(gd->dialog);
}
list = dupe_listview_get_selection(dw, listview);
view_window_new_from_list(list);
- path_list_free(list);
+ filelist_free(list);
}
else
{
- layout_image_set_path(NULL, di->path);
+ layout_set_fd(NULL, di->fd);
}
}
}
dupe_listview_realign_colors(dw);
}
-static void dupe_window_edit_selected(DupeWindow *dw, gint n)
+static void dupe_window_edit_selected(DupeWindow *dw, const gchar *key)
{
- GList *list;
-
- list = dupe_listview_get_selection(dw, dw->listview);
-
- start_editor_from_path_list(n, list);
-
- path_list_free(list);
+ file_util_start_editor_from_filelist(key, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
}
static void dupe_window_collection_from_selection(DupeWindow *dw)
list = dupe_listview_get_selection(dw, dw->listview);
w = collection_window_new(NULL);
- collection_table_add_path_list(w->table, list);
- path_list_free(list);
+ collection_table_add_filelist(w->table, list);
+ filelist_free(list);
}
static void dupe_window_append_file_list(DupeWindow *dw, gint on_second)
list = layout_list(NULL);
dupe_window_add_files(dw, list, FALSE);
- path_list_free(list);
+ filelist_free(list);
}
/*
static void dupe_menu_edit_cb(GtkWidget *widget, gpointer data)
{
DupeWindow *dw;
- gint n;
+ const gchar *key = data;
dw = submenu_item_get_data(widget);
- n = GPOINTER_TO_INT(data);
if (!dw) return;
- dupe_window_edit_selected(dw, n);
-}
-
-static void dupe_menu_info_cb(GtkWidget *widget, gpointer data)
-{
- DupeWindow *dw = data;
-
- info_window_new(NULL, dupe_listview_get_selection(dw, dw->listview));
+ dupe_window_edit_selected(dw, key);
}
static void dupe_menu_collection_cb(GtkWidget *widget, gpointer data)
static void dupe_menu_print_cb(GtkWidget *widget, gpointer data)
{
DupeWindow *dw = data;
- const gchar *path;
+ FileData *fd;
- path = (dw->click_item) ? dw->click_item->path : NULL;
+ fd = (dw->click_item) ? dw->click_item->fd : NULL;
- print_window_new(path,
+ print_window_new(fd,
dupe_listview_get_selection(dw, dw->listview),
- dupe_listview_get_path_list(dw, dw->listview), dw->window);
+ dupe_listview_get_filelist(dw, dw->listview), dw->window);
}
static void dupe_menu_copy_cb(GtkWidget *widget, gpointer data)
file_util_delete(NULL, dupe_listview_get_selection(dw, dw->listview), dw->window);
}
+static void dupe_menu_copy_path_cb(GtkWidget *widget, gpointer data)
+{
+ DupeWindow *dw = data;
+
+ file_util_copy_path_list_to_clipboard(dupe_listview_get_selection(dw, dw->listview));
+}
+
static void dupe_menu_remove_cb(GtkWidget *widget, gpointer data)
{
DupeWindow *dw = data;
dupe_window_close(dw);
}
+static void dupe_menu_popup_destroy_cb(GtkWidget *widget, gpointer data)
+{
+ GList *editmenu_fd_list = data;
+
+ filelist_free(editmenu_fd_list);
+}
+
+static GList *dupe_window_get_fd_list(DupeWindow *dw)
+{
+ GList *list;
+
+ if (gtk_widget_has_focus(dw->second_listview))
+ {
+ list = dupe_listview_get_selection(dw, dw->second_listview);
+ }
+ else
+ {
+ list = dupe_listview_get_selection(dw, dw->listview);
+ }
+
+ return list;
+}
+
static GtkWidget *dupe_menu_popup_main(DupeWindow *dw, DupeItem *di)
{
GtkWidget *menu;
GtkWidget *item;
gint on_row;
+ GList *editmenu_fd_list;
on_row = (di != NULL);
menu = popup_menu_short_lived();
+
menu_item_add_sensitive(menu, _("_View"), on_row,
G_CALLBACK(dupe_menu_view_cb), dw);
menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, on_row,
menu_item_add_sensitive(menu, _("Select group _2 duplicates"), (dw->dupes != NULL),
G_CALLBACK(dupe_menu_select_dupes_set2_cb), dw);
menu_item_add_divider(menu);
- submenu_add_edit(menu, &item, G_CALLBACK(dupe_menu_edit_cb), dw);
+
+ editmenu_fd_list = dupe_window_get_fd_list(dw);
+ g_signal_connect(G_OBJECT(menu), "destroy",
+ G_CALLBACK(dupe_menu_popup_destroy_cb), editmenu_fd_list);
+ submenu_add_edit(menu, &item, G_CALLBACK(dupe_menu_edit_cb), dw, editmenu_fd_list);
if (!on_row) gtk_widget_set_sensitive(item, FALSE);
- menu_item_add_stock_sensitive(menu, _("_Properties"), GTK_STOCK_PROPERTIES, on_row,
- G_CALLBACK(dupe_menu_info_cb), dw);
menu_item_add_stock_sensitive(menu, _("Add to new collection"), GTK_STOCK_INDEX, on_row,
G_CALLBACK(dupe_menu_collection_cb), dw);
menu_item_add_stock_sensitive(menu, _("Print..."), GTK_STOCK_PRINT, on_row,
G_CALLBACK(dupe_menu_rename_cb), dw);
menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, on_row,
G_CALLBACK(dupe_menu_delete_cb), dw);
+ menu_item_add_sensitive(menu, _("_Copy path"), on_row,
+ G_CALLBACK(dupe_menu_copy_path_cb), dw);
menu_item_add_divider(menu);
menu_item_add_stock_sensitive(menu, _("Rem_ove"), GTK_STOCK_REMOVE, on_row,
G_CALLBACK(dupe_menu_remove_cb), dw);
return menu;
}
-static gint dupe_listview_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
+static gboolean dupe_listview_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
DupeWindow *dw = data;
GtkTreeModel *store;
dw->click_item = di;
- if (bevent->button == 3)
+ if (bevent->button == MOUSE_BUTTON_RIGHT)
{
/* right click menu */
GtkWidget *menu;
if (!di) return FALSE;
- if (bevent->button == 1 && bevent->type == GDK_2BUTTON_PRESS)
+ if (bevent->button == MOUSE_BUTTON_LEFT &&
+ bevent->type == GDK_2BUTTON_PRESS)
{
dupe_menu_view(dw, di, widget, FALSE);
}
- if (bevent->button == 2) return TRUE;
+ if (bevent->button == MOUSE_BUTTON_MIDDLE) return TRUE;
- if (bevent->button == 3)
+ if (bevent->button == MOUSE_BUTTON_RIGHT)
{
if (!dupe_listview_item_is_selected(dw, di, widget))
{
return TRUE;
}
- if (bevent->button == 1 && bevent->type == GDK_BUTTON_PRESS &&
+ if (bevent->button == MOUSE_BUTTON_LEFT &&
+ bevent->type == GDK_BUTTON_PRESS &&
!(bevent->state & GDK_SHIFT_MASK ) &&
!(bevent->state & GDK_CONTROL_MASK ) &&
dupe_listview_item_is_selected(dw, di, widget))
return FALSE;
}
-static gint dupe_listview_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
+static gboolean dupe_listview_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
DupeWindow *dw = data;
GtkTreeModel *store;
GtkTreeIter iter;
DupeItem *di = NULL;
- if (bevent->button != 1 && bevent->button != 2) return TRUE;
+ if (bevent->button != MOUSE_BUTTON_LEFT && bevent->button != MOUSE_BUTTON_MIDDLE) return TRUE;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_path_free(tpath);
}
- if (bevent->button == 2)
+ if (bevent->button == MOUSE_BUTTON_MIDDLE)
{
if (di && dw->click_item == di)
{
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
gtk_list_store_append(store, &iter);
- gtk_list_store_set(store, &iter, DUPE_COLUMN_POINTER, di, 1, di->path, -1);
+ gtk_list_store_set(store, &iter, DUPE_COLUMN_POINTER, di, 1, di->fd->path, -1);
dupe_second_update_status(dw);
}
static GtkWidget *dupe_menu_popup_second(DupeWindow *dw, DupeItem *di)
{
GtkWidget *menu;
- gint notempty;
- gint on_row;
-
- on_row = (di != NULL);
- notempty = (dw->second_list != NULL);
+ gboolean notempty = (dw->second_list != NULL);
+ gboolean on_row = (di != NULL);
menu = popup_menu_short_lived();
menu_item_add_sensitive(menu, _("_View"), on_row,
{
DupeWindow *dw = data;
- dw->second_set = GTK_TOGGLE_BUTTON(widget)->active;
+ dw->second_set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (dw->second_set)
{
"text", DUPE_MENU_COLUMN_NAME, NULL);
dupe_menu_add_item(store, _("Name"), DUPE_MATCH_NAME, dw);
+ dupe_menu_add_item(store, _("Name case-insensitive"), DUPE_MATCH_NAME_CI, dw);
dupe_menu_add_item(store, _("Size"), DUPE_MATCH_SIZE, dw);
dupe_menu_add_item(store, _("Date"), DUPE_MATCH_DATE, dw);
dupe_menu_add_item(store, _("Dimensions"), DUPE_MATCH_DIM, dw);
/* this overrides the low default of a GtkCellRenderer from 100 to CELL_HEIGHT_OVERRIDE, something sane for our purposes */
#define CELL_HEIGHT_OVERRIDE 512
-
+
void cell_renderer_height_override(GtkCellRenderer *renderer)
{
GParamSpec *spec;
"cell-background-set", set, NULL);
}
-static void dupe_listview_add_column(DupeWindow *dw, GtkWidget *listview, gint n, const gchar *title, gint image, gint right_justify)
+static void dupe_listview_add_column(DupeWindow *dw, GtkWidget *listview, gint n, const gchar *title, gboolean image, gboolean right_justify)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);
}
-static void dupe_listview_set_height(GtkWidget *listview, gint thumb)
+static void dupe_listview_set_height(GtkWidget *listview, gboolean thumb)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
column = gtk_tree_view_get_column(GTK_TREE_VIEW(listview), DUPE_COLUMN_THUMB - 1);
if (!column) return;
- gtk_tree_view_column_set_fixed_width(column, (thumb) ? thumb_max_width : 4);
-
- list = gtk_tree_view_column_get_cell_renderers(column);
+ gtk_tree_view_column_set_fixed_width(column, (thumb) ? options->thumbnails.max_width : 4);
+
+ list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
if (!list) return;
cell = list->data;
g_list_free(list);
- g_object_set(G_OBJECT(cell), "height", (thumb) ? thumb_max_height : -1, NULL);
+ g_object_set(G_OBJECT(cell), "height", (thumb) ? options->thumbnails.max_height : -1, NULL);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(listview));
}
{
DupeWindow *dw = data;
- dw->show_thumbs = GTK_TOGGLE_BUTTON(widget)->active;
+ dw->show_thumbs = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (dw->show_thumbs)
{
{
GtkTreeModel *store;
GtkTreeIter iter;
- gint valid;
+ gboolean valid;
thumb_loader_free(dw->thumb_loader);
dw->thumb_loader = NULL;
*y = cy;
}
-static gint dupe_window_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
+static gboolean dupe_window_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
DupeWindow *dw = data;
- gint stop_signal = FALSE;
- gint on_second;
+ gboolean stop_signal = FALSE;
+ gboolean on_second;
GtkWidget *listview;
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
DupeItem *di = NULL;
- on_second = GTK_WIDGET_HAS_FOCUS(dw->second_listview);
+ on_second = gtk_widget_has_focus(dw->second_listview);
if (on_second)
{
if (event->state & GDK_CONTROL_MASK)
{
- gint edit_val = -1;
-
if (!on_second)
- switch (event->keyval)
{
- case '1':
- edit_val = 0;
- break;
- case '2':
- edit_val = 1;
- break;
- case '3':
- edit_val = 2;
- break;
- case '4':
- edit_val = 3;
- break;
- case '5':
- edit_val = 4;
- break;
- case '6':
- edit_val = 5;
- break;
- case '7':
- edit_val = 6;
- break;
- case '8':
- edit_val = 7;
- break;
- case '9':
- edit_val = 8;
- break;
- case '0':
- edit_val = 9;
- break;
- case 'C': case 'c':
- stop_signal = TRUE;
- file_util_copy(NULL, dupe_listview_get_selection(dw, listview), NULL, dw->window);
- break;
- case 'M': case 'm':
- file_util_move(NULL, dupe_listview_get_selection(dw, listview), NULL, dw->window);
- stop_signal = TRUE;
- break;
- case 'R': case 'r':
- file_util_rename(NULL, dupe_listview_get_selection(dw, listview), dw->window);
- stop_signal = TRUE;
- break;
- case 'D': case 'd':
- file_util_delete(NULL, dupe_listview_get_selection(dw, listview), dw->window);
- stop_signal = TRUE;
- break;
- case 'P': case 'p':
- info_window_new(NULL, dupe_listview_get_selection(dw, listview));
- stop_signal = TRUE;
- break;
- default:
- break;
- }
-
- switch (event->keyval)
- {
- case 'A': case 'a':
- if (event->state & GDK_SHIFT_MASK)
- {
- gtk_tree_selection_unselect_all(selection);
- }
- else
- {
- gtk_tree_selection_select_all(selection);
- }
- stop_signal = TRUE;
- break;
- case GDK_Delete: case GDK_KP_Delete:
- if (on_second)
- {
- dupe_second_clear(dw);
- dupe_window_recompare(dw);
- }
- else
- {
- dupe_window_clear(dw);
- }
- stop_signal = TRUE;
- break;
- case 'L': case 'l':
- dupe_window_append_file_list(dw, FALSE);
- stop_signal = TRUE;
- break;
- case 'T': case 't':
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_thumbs),
- !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dw->button_thumbs)));
- stop_signal = TRUE;
- break;
- case 'W': case 'w':
- dupe_window_close(dw);
- stop_signal = TRUE;
- break;
- default:
- break;
+ stop_signal = TRUE;
+ switch (event->keyval)
+ {
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '0':
+ break;
+ case 'C': case 'c':
+ file_util_copy(NULL, dupe_listview_get_selection(dw, listview),
+ NULL, dw->window);
+ break;
+ case 'M': case 'm':
+ file_util_move(NULL, dupe_listview_get_selection(dw, listview),
+ NULL, dw->window);
+ break;
+ case 'R': case 'r':
+ file_util_rename(NULL, dupe_listview_get_selection(dw, listview), dw->window);
+ break;
+ case 'D': case 'd':
+ file_util_delete(NULL, dupe_listview_get_selection(dw, listview), dw->window);
+ break;
+ default:
+ stop_signal = FALSE;
+ break;
+ }
}
- if (edit_val >= 0)
+ if (!stop_signal)
{
- dupe_window_edit_selected(dw, edit_val);
stop_signal = TRUE;
+ switch (event->keyval)
+ {
+ case 'A': case 'a':
+ if (event->state & GDK_SHIFT_MASK)
+ {
+ gtk_tree_selection_unselect_all(selection);
+ }
+ else
+ {
+ gtk_tree_selection_select_all(selection);
+ }
+ break;
+ case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
+ if (on_second)
+ {
+ dupe_second_clear(dw);
+ dupe_window_recompare(dw);
+ }
+ else
+ {
+ dupe_window_clear(dw);
+ }
+ break;
+ case 'L': case 'l':
+ dupe_window_append_file_list(dw, FALSE);
+ break;
+ case 'T': case 't':
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_thumbs),
+ !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dw->button_thumbs)));
+ break;
+ case 'W': case 'w':
+ dupe_window_close(dw);
+ break;
+ default:
+ stop_signal = FALSE;
+ break;
+ }
}
}
else
{
+ stop_signal = TRUE;
switch (event->keyval)
{
- case GDK_Return: case GDK_KP_Enter:
+ case GDK_KEY_Return: case GDK_KEY_KP_Enter:
dupe_menu_view(dw, di, listview, FALSE);
- stop_signal = TRUE;
break;
case 'V': case 'v':
- stop_signal = TRUE;
dupe_menu_view(dw, di, listview, TRUE);
break;
- case GDK_Delete: case GDK_KP_Delete:
+ case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
dupe_window_remove_selection(dw, listview);
- stop_signal = TRUE;
break;
case 'C': case 'c':
if (!on_second)
{
dupe_window_collection_from_selection(dw);
- stop_signal = TRUE;
}
break;
case '1':
dupe_listview_select_dupes(dw, TRUE);
- stop_signal = TRUE;
break;
case '2':
dupe_listview_select_dupes(dw, FALSE);
- stop_signal = TRUE;
break;
- case GDK_Menu:
- case GDK_F10:
+ case GDK_KEY_Menu:
+ case GDK_KEY_F10:
if (!on_second)
{
GtkWidget *menu;
}
break;
default:
+ stop_signal = FALSE;
break;
}
}
dupe_list_free(dw->second_list);
+ file_data_unregister_notify_func(dupe_notify_cb, dw);
+
g_free(dw);
}
dw = g_new0(DupeWindow, 1);
- dw->list = NULL;
- dw->dupes = NULL;
dw->match_mask = match_mask;
- dw->show_thumbs = FALSE;
-
- dw->idle_id = -1;
- dw->second_set = FALSE;
+ dw->window = window_new(GTK_WINDOW_TOPLEVEL, "dupe", NULL, NULL, _("Find duplicates"));
- dw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- window_set_icon(dw->window, NULL, NULL);
-
- geometry.min_width = 32;
- geometry.min_height = 32;
+ geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
+ geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.base_width = DUPE_DEF_WIDTH;
geometry.base_height = DUPE_DEF_HEIGHT;
gtk_window_set_geometry_hints(GTK_WINDOW(dw->window), NULL, &geometry,
gtk_window_set_default_size(GTK_WINDOW(dw->window), DUPE_DEF_WIDTH, DUPE_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(dw->window), TRUE);
- gtk_window_set_title(GTK_WINDOW(dw->window), _("Find duplicates - GQview"));
- gtk_window_set_wmclass(GTK_WINDOW(dw->window), "dupe", "GQview");
- gtk_container_set_border_width (GTK_CONTAINER (dw->window), 0);
+ gtk_container_set_border_width(GTK_CONTAINER(dw->window), 0);
- g_signal_connect(G_OBJECT(dw->window), "delete_event",
+ g_signal_connect(G_OBJECT(dw->window), "delete_event",
G_CALLBACK(dupe_window_delete), dw);
g_signal_connect(G_OBJECT(dw->window), "key_press_event",
G_CALLBACK(dupe_window_keypress_cb), dw);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_table_attach_defaults(GTK_TABLE(dw->table), scrolled, 0, 2, 0, 1);
- gtk_widget_show(scrolled);
+ gtk_widget_show(scrolled);
store = gtk_list_store_new(9, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(dw->second_vbox), scrolled, TRUE, TRUE, 0);
- gtk_widget_show(scrolled);
+ gtk_widget_show(scrolled);
store = gtk_list_store_new(2, G_TYPE_POINTER, G_TYPE_STRING);
dw->second_listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
dupe_listview_add_column(dw, dw->second_listview, 1, _("Compare to:"), FALSE, FALSE);
gtk_container_add(GTK_CONTAINER(scrolled), dw->second_listview);
- gtk_widget_show(dw->second_listview);
+ gtk_widget_show(dw->second_listview);
dw->second_status_label = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(dw->second_vbox), dw->second_status_label, FALSE, FALSE, 0);
gtk_widget_show(button);
status_box = gtk_hbox_new(FALSE, 0);
- gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
- gtk_widget_show(status_box);
+ gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
+ gtk_widget_show(status_box);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
dupe_window_list = g_list_append(dupe_window_list, dw);
+ file_data_register_notify_func(dupe_notify_cb, dw, NOTIFY_PRIORITY_MEDIUM);
+
return dw;
}
work = d->list;
while (work)
{
- gchar *path = work->data;
+ FileData *fd = work->data;
work = work->next;
- if (isdir(path))
+ if (isdir(fd->path))
{
- GList *list = NULL;
+ GList *list;
- path_list(path, &list, NULL);
- list = path_list_filter(list, FALSE);
+ filelist_read(fd, &list, NULL);
+ list = filelist_filter(list, FALSE);
if (list)
{
dupe_window_add_files(d->dw, list, FALSE);
- path_list_free(list);
+ filelist_free(list);
}
}
}
static void confirm_dir_list_destroy(GtkWidget *widget, gpointer data)
{
CDupeConfirmD *d = data;
- path_list_free(d->list);
+ filelist_free(d->list);
g_free(d);
}
*/
static GtkTargetEntry dupe_drag_types[] = {
- { "text/uri-list", 0, TARGET_URI_LIST },
- { "text/plain", 0, TARGET_TEXT_PLAIN }
+ { "text/uri-list", 0, TARGET_URI_LIST },
+ { "text/plain", 0, TARGET_TEXT_PLAIN }
};
static gint n_dupe_drag_types = 2;
static GtkTargetEntry dupe_drop_types[] = {
- { "application/x-gqview-collection-member", 0, TARGET_APP_COLLECTION_MEMBER },
- { "text/uri-list", 0, TARGET_URI_LIST }
+ { TARGET_APP_COLLECTION_MEMBER_STRING, 0, TARGET_APP_COLLECTION_MEMBER },
+ { "text/uri-list", 0, TARGET_URI_LIST }
};
static gint n_dupe_drop_types = 2;
guint time, gpointer data)
{
DupeWindow *dw = data;
- gchar *uri_text;
- gint length;
GList *list;
switch (info)
case TARGET_TEXT_PLAIN:
list = dupe_listview_get_selection(dw, widget);
if (!list) return;
- uri_text = uri_text_from_list(list, &length, (info == TARGET_TEXT_PLAIN));
- path_list_free(list);
+ uri_selection_data_set_uris_from_filelist(selection_data, list);
+ filelist_free(list);
break;
default:
- uri_text = NULL;
break;
}
-
- if (uri_text) gtk_selection_data_set(selection_data, selection_data->target,
- 8, uri_text, length);
- g_free(uri_text);
}
static void dupe_dnd_data_get(GtkWidget *widget, GdkDragContext *context,
switch (info)
{
case TARGET_APP_COLLECTION_MEMBER:
- collection_from_dnd_data((gchar *)selection_data->data, &list, NULL);
+ collection_from_dnd_data((gchar *)gtk_selection_data_get_data(selection_data), &list, NULL);
break;
case TARGET_URI_LIST:
- list = uri_list_from_text(selection_data->data, TRUE);
+ list = uri_filelist_from_gtk_selection_data(selection_data);
work = list;
- while(work)
+ while (work)
{
- if (isdir((gchar *)work->data))
+ FileData *fd = work->data;
+ if (isdir(fd->path))
{
GtkWidget *menu;
menu = dupe_confirm_dir_list(dw, list);
if (list)
{
dupe_window_add_files(dw, list, FALSE);
- path_list_free(list);
+ filelist_free(list);
}
}
-static void dupe_dest_set(GtkWidget *widget, gint enable)
+static void dupe_dest_set(GtkWidget *widget, gboolean enable)
{
if (enable)
{
*-------------------------------------------------------------------
*/
-void dupe_maint_removed(const gchar *path)
+static void dupe_notify_cb(FileData *fd, NotifyType type, gpointer data)
{
- GList *work;
-
- work = dupe_window_list;
- while (work)
- {
- DupeWindow *dw = work->data;
- work = work->next;
-
- while (dupe_item_remove_by_path(dw, path));
- }
-}
+ DupeWindow *dw = data;
-void dupe_maint_renamed(const gchar *source, const gchar *dest)
-{
- GList *work;
+ if (!(type & NOTIFY_CHANGE) || !fd->change) return;
- work = dupe_window_list;
- while (work)
+ DEBUG_1("Notify dupe: %s %04x", fd->path, type);
+
+ switch (fd->change->type)
{
- DupeWindow *dw = work->data;
- work = work->next;
-
- while (dupe_item_set_path(dw, source, dest));
+ case FILEDATA_CHANGE_MOVE:
+ case FILEDATA_CHANGE_RENAME:
+ dupe_item_update_fd(dw, fd);
+ break;
+ case FILEDATA_CHANGE_COPY:
+ break;
+ case FILEDATA_CHANGE_DELETE:
+ while (dupe_item_remove_by_path(dw, fd->path));
+ break;
+ case FILEDATA_CHANGE_UNSPECIFIED:
+ case FILEDATA_CHANGE_WRITE_METADATA:
+ break;
}
}
-
+/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */