/*
- * GQview
- * (C) 2006 John Ellis
+ * Copyright (C) 2006 John Ellis
+ * Copyright (C) 2008 - 2016 The Geeqie Team
*
* Author: John Ellis
*
- * This software is released under the GNU General Public License (GNU GPL).
- * Please read the included file COPYING for more information.
- * This software comes with no warranty of any kind, use at your own risk!
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include "gqview.h"
+#include "main.h"
#include "cache_maint.h"
#include "cache.h"
-#include "filelist.h"
+#include "cache-loader.h"
+#include "filedata.h"
+#include "layout.h"
#include "thumb.h"
#include "thumb_standard.h"
#include "ui_fileops.h"
#include "ui_spinner.h"
#include "ui_tabcomp.h"
#include "ui_utildlg.h"
+#include "window.h"
typedef struct _CMData CMData;
{
GList *list;
GList *done_list;
- gint idle_id;
+ guint idle_id; /* event source id */
GenericDialog *gd;
GtkWidget *entry;
GtkWidget *spinner;
GtkWidget *button_stop;
GtkWidget *button_close;
- gint clear;
- gint metadata;
+ gboolean clear;
+ gboolean metadata;
+ gboolean remote;
};
#define PURGE_DIALOG_WIDTH 400
*-------------------------------------------------------------------
*/
-static gint extension_truncate(gchar *path, const gchar *ext)
-{
- gint l;
- gint el;
-
- if (!path || !ext) return FALSE;
-
- l = strlen(path);
- el = strlen(ext);
-
- if (l < el || strcmp(path + (l - el), ext) != 0) return FALSE;
-
- path[l - el] = '\0';
-
- return TRUE;
-}
-
static gchar *extension_find_dot(gchar *path)
{
- gchar *ptr;
-
- if (!path || *path == '\0') return NULL;
+ gchar *dot = NULL;
- ptr = path;
- while (*ptr != '\0') ptr++;
+ if (!path) return NULL;
- while (ptr > path && *ptr != '.') ptr--;
-
- if (ptr == path) return NULL;
+ while (*path != '\0')
+ {
+ if (*path == '.') dot = path;
+ path++;
+ }
- return ptr;
+ return dot;
}
-static gint isempty(const gchar *path)
+static gboolean isempty(const gchar *path)
{
DIR *dp;
struct dirent *dir;
static void cache_maintain_home_close(CMData *cm)
{
- if (cm->idle_id != -1) g_source_remove(cm->idle_id);
+ if (cm->idle_id) g_source_remove(cm->idle_id);
if (cm->gd) generic_dialog_close(cm->gd);
- path_list_free(cm->list);
+ filelist_free(cm->list);
g_list_free(cm->done_list);
g_free(cm);
}
static void cache_maintain_home_stop(CMData *cm)
{
- if (cm->idle_id != -1)
+ if (cm->idle_id)
{
g_source_remove(cm->idle_id);
- cm->idle_id = -1;
+ cm->idle_id = 0;
}
- gtk_entry_set_text(GTK_ENTRY(cm->entry), _("done"));
- spinner_set_interval(cm->spinner, -1);
+ if (!cm->remote)
+ {
+ gtk_entry_set_text(GTK_ENTRY(cm->entry), _("done"));
+ spinner_set_interval(cm->spinner, -1);
- gtk_widget_set_sensitive(cm->button_stop, FALSE);
- gtk_widget_set_sensitive(cm->button_close, TRUE);
+ gtk_widget_set_sensitive(cm->button_stop, FALSE);
+ gtk_widget_set_sensitive(cm->button_close, TRUE);
+ }
}
-static gint cache_maintain_home_cb(gpointer data)
+static gboolean cache_maintain_home_cb(gpointer data)
{
CMData *cm = data;
GList *dlist = NULL;
GList *list = NULL;
- gchar *path;
- gint just_done = FALSE;
- gint still_have_a_file = TRUE;
- gint base_length;
+ FileData *fd;
+ gboolean just_done = FALSE;
+ gboolean still_have_a_file = TRUE;
+ gsize base_length;
const gchar *cache_folder;
+ gboolean filter_disable;
if (cm->metadata)
{
- cache_folder = GQVIEW_CACHE_RC_METADATA;
+ cache_folder = get_metadata_cache_dir();
}
else
{
- cache_folder = GQVIEW_CACHE_RC_THUMB;
+ cache_folder = get_thumbnails_cache_dir();
}
- base_length = strlen(homedir()) + strlen("/") + strlen(cache_folder);
+ base_length = strlen(cache_folder);
if (!cm->list)
{
- if (debug) printf("purge chk done.\n");
- cm->idle_id = -1;
+ DEBUG_1("purge chk done.");
+ cm->idle_id = 0;
cache_maintain_home_stop(cm);
return FALSE;
}
- path = cm->list->data;
+ fd = cm->list->data;
- if (debug) printf("purge chk (%d) \"%s\"\n", (cm->clear && !cm->metadata), path);
+ DEBUG_1("purge chk (%d) \"%s\"", (cm->clear && !cm->metadata), fd->path);
- if (g_list_find(cm->done_list, path) == NULL)
+/**
+ * It is necessary to disable the file filter when clearing the cache,
+ * otherwise the .sim (file similarity) files are not deleted.
+ */
+ filter_disable = options->file_filter.disable;
+ options->file_filter.disable = TRUE;
+
+ if (g_list_find(cm->done_list, fd) == NULL)
{
- cm->done_list = g_list_prepend(cm->done_list, path);
+ cm->done_list = g_list_prepend(cm->done_list, fd);
- if (path_list(path, &list, &dlist))
+ if (filelist_read(fd, &list, &dlist))
{
GList *work;
just_done = TRUE;
still_have_a_file = FALSE;
-
+
work = list;
while (work)
{
- gchar *path_buf = work->data;
+ FileData *fd_list = work->data;
+ gchar *path_buf = g_strdup(fd_list->path);
gchar *dot;
-
+
dot = extension_find_dot(path_buf);
-
+
if (dot) *dot = '\0';
if ((!cm->metadata && cm->clear) ||
(strlen(path_buf) > base_length && !isfile(path_buf + base_length)) )
{
if (dot) *dot = '.';
- if (!unlink_file(path_buf)) printf("failed to delete:%s\n", path_buf);
+ if (!unlink_file(path_buf)) log_printf("failed to delete:%s\n", path_buf);
}
else
{
still_have_a_file = TRUE;
}
+ g_free(path_buf);
work = work->next;
}
}
}
- path_list_free(list);
+ options->file_filter.disable = filter_disable;
+
+ filelist_free(list);
cm->list = g_list_concat(dlist, cm->list);
if (cm->list && g_list_find(cm->done_list, cm->list->data) != NULL)
{
/* check if the dir is empty */
-
- if (cm->list->data == path && just_done)
+
+ if (cm->list->data == fd && just_done)
{
- if (!still_have_a_file && !dlist && cm->list->next && !rmdir_utf8(path))
+ if (!still_have_a_file && !dlist && cm->list->next && !rmdir_utf8(fd->path))
{
- printf("Unable to delete dir: %s\n", path);
+ log_printf("Unable to delete dir: %s\n", fd->path);
}
}
else
{
/* must re-check for an empty dir */
- if (isempty(path) && cm->list->next && !rmdir_utf8(path))
+ if (isempty(fd->path) && cm->list->next && !rmdir_utf8(fd->path))
{
- printf("Unable to delete dir: %s\n", path);
+ log_printf("Unable to delete dir: %s\n", fd->path);
}
}
- path = cm->list->data;
- cm->done_list = g_list_remove(cm->done_list, path);
- cm->list = g_list_remove(cm->list, path);
- g_free(path);
+ fd = cm->list->data;
+ cm->done_list = g_list_remove(cm->done_list, fd);
+ cm->list = g_list_remove(cm->list, fd);
+ file_data_unref(fd);
}
- if (cm->list)
+ if (cm->list && !cm->remote)
{
const gchar *buf;
- path = cm->list->data;
- if (strlen(path) > base_length)
+ fd = cm->list->data;
+ if (strlen(fd->path) > base_length)
{
- buf = path + base_length;
+ buf = fd->path + base_length;
}
else
{
{
CMData *cm = data;
- if (!GTK_WIDGET_SENSITIVE(cm->button_close)) return;
+ if (!gtk_widget_get_sensitive(cm->button_close)) return;
cache_maintain_home_close(cm);
}
}
/* sorry for complexity (cm->done_list), but need it to remove empty dirs */
-void cache_maintain_home(gint metadata, gint clear, GtkWidget *parent)
+void cache_maintain_home(gboolean metadata, gboolean clear, GtkWidget *parent)
{
CMData *cm;
- GList *dlist = NULL;
- gchar *base;
+ GList *dlist;
+ FileData *dir_fd;
const gchar *msg;
const gchar *cache_folder;
GtkWidget *hbox;
if (metadata)
{
- cache_folder = GQVIEW_CACHE_RC_METADATA;
+ cache_folder = get_metadata_cache_dir();
}
else
{
- cache_folder = GQVIEW_CACHE_RC_THUMB;
+ cache_folder = get_thumbnails_cache_dir();
}
- base = g_strconcat(homedir(), "/", cache_folder, NULL);
-
- if (!path_list(base, NULL, &dlist))
+ dir_fd = file_data_new_dir(cache_folder);
+ if (!filelist_read(dir_fd, NULL, &dlist))
{
- g_free(base);
+ file_data_unref(dir_fd);
return;
}
- dlist = g_list_append(dlist, base);
+ dlist = g_list_append(dlist, dir_fd);
cm = g_new0(CMData, 1);
cm->list = dlist;
cm->done_list = NULL;
cm->clear = clear;
cm->metadata = metadata;
+ cm->remote = FALSE;
if (metadata)
{
}
cm->gd = generic_dialog_new(_("Maintenance"),
- "GQview", "gqview_maintenance",
+ "main_maintenance",
parent, FALSE,
NULL, cm);
cm->gd->cancel_cb = cache_maintain_home_close_cb;
cm->button_stop = generic_dialog_add_button(cm->gd, GTK_STOCK_STOP, NULL,
cache_maintain_home_stop_cb, FALSE);
- generic_dialog_add_message(cm->gd, NULL, msg, NULL);
+ generic_dialog_add_message(cm->gd, NULL, msg, NULL, FALSE);
gtk_window_set_default_size(GTK_WINDOW(cm->gd->dialog), PURGE_DIALOG_WIDTH, -1);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
cm->entry = gtk_entry_new();
- GTK_WIDGET_UNSET_FLAGS(cm->entry, GTK_CAN_FOCUS);
+ gtk_widget_set_can_focus(cm->entry, FALSE);
gtk_editable_set_editable(GTK_EDITABLE(cm->entry), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), cm->entry, TRUE, TRUE, 0);
gtk_widget_show(cm->entry);
cm->spinner = spinner_new(NULL, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), cm->spinner, FALSE, FALSE, 0);
gtk_widget_show(cm->spinner);
-
+
gtk_widget_show(cm->gd->dialog);
cm->idle_id = g_idle_add(cache_maintain_home_cb, cm);
}
-/* This checks all files in ~/.gqview/thumbnails and
- * removes them if thay have no source counterpart.
- * (this assumes all cache files have an extension of 4 chars including '.')
- */
-gint cache_maintain_home_dir(const gchar *dir, gint recursive, gint clear)
+void cache_maintain_home_remote(gboolean metadata, gboolean clear)
{
- gchar *base;
- gint base_length;
- GList *dlist = NULL;
- GList *flist = NULL;
- gint still_have_a_file = FALSE;
-
- if (debug) printf("maintainance check: %s\n", dir);
-
- base_length = strlen(homedir()) + strlen("/") + strlen(GQVIEW_CACHE_RC_THUMB);
- base = g_strconcat(homedir(), "/", GQVIEW_CACHE_RC_THUMB, dir, NULL);
+ CMData *cm;
+ GList *dlist;
+ FileData *dir_fd;
+ const gchar *cache_folder;
- if (path_list(base, &flist, &dlist))
+ if (metadata)
{
- GList *work;
-
- work = dlist;
- while(work)
- {
- gchar *path = work->data;
- if (recursive && strlen(path) > base_length &&
- !cache_maintain_home_dir(path + base_length, recursive, clear))
- {
- if (debug) printf("Deleting thumb dir: %s\n", path);
- if (!rmdir_utf8(path))
- {
- printf("Unable to delete dir: %s\n", path);
- }
- }
- else
- {
- still_have_a_file = TRUE;
- }
- work = work->next;
- }
-
- work = flist;
- while (work)
- {
- gchar *path = work->data;
- gchar *dot;
-
- dot = extension_find_dot(path);
-
- if (dot) *dot = '\0';
- if (clear ||
- (strlen(path) > base_length && !isfile(path + base_length)) )
- {
- if (dot) *dot = '.';
- if (!unlink_file(path)) printf("failed to delete:%s\n", path);
- }
- else
- {
- still_have_a_file = TRUE;
- }
-
- work = work->next;
- }
+ cache_folder = get_metadata_cache_dir();
}
-
- path_list_free(dlist);
- path_list_free(flist);
- g_free(base);
-
- return still_have_a_file;
-}
-
-/* This checks relative caches in dir/.thumbnails and
- * removes them if they have no source counterpart.
- */
-gint cache_maintain_dir(const gchar *dir, gint recursive, gint clear)
-{
- GList *list = NULL;
- gchar *cachedir;
- gint still_have_a_file = FALSE;
- GList *work;
-
- cachedir = g_strconcat(dir, "/", GQVIEW_CACHE_LOCAL_THUMB, NULL);
-
- path_list(cachedir, &list, NULL);
- work = list;
-
- while (work)
+ else
{
- const gchar *path;
- gchar *source;
-
- path = work->data;
- work = work->next;
-
- source = g_strconcat(dir, "/", filename_from_path(path), NULL);
-
- if (clear ||
- extension_truncate(source, GQVIEW_CACHE_EXT_THUMB) ||
- extension_truncate(source, GQVIEW_CACHE_EXT_SIM))
- {
- if (!clear && isfile(source))
- {
- still_have_a_file = TRUE;
- }
- else
- {
- if (!unlink_file(path))
- {
- if (debug) printf("Failed to remove cache file %s\n", path);
- still_have_a_file = TRUE;
- }
- }
- }
- else
- {
- still_have_a_file = TRUE;
- }
- g_free(source);
+ cache_folder = get_thumbnails_cache_dir();
}
- path_list_free(list);
- g_free(cachedir);
-
- if (recursive)
+ dir_fd = file_data_new_dir(cache_folder);
+ if (!filelist_read(dir_fd, NULL, &dlist))
{
- list = NULL;
+ file_data_unref(dir_fd);
+ return;
+ }
- path_list(dir, NULL, &list);
- work = list;
- while (work)
- {
- const gchar *path = work->data;
- work = work->next;
+ dlist = g_list_append(dlist, dir_fd);
- still_have_a_file |= cache_maintain_dir(path, recursive, clear);
- }
-
- path_list_free(list);
- }
+ cm = g_new0(CMData, 1);
+ cm->list = dlist;
+ cm->done_list = NULL;
+ cm->clear = clear;
+ cm->metadata = metadata;
+ cm->remote = TRUE;
- return still_have_a_file;
+ cm->idle_id = g_idle_add(cache_maintain_home_cb, cm);
}
static void cache_file_move(const gchar *src, const gchar *dest)
if (!move_file(src, dest))
{
- if (debug) printf("Failed to move cache file %s\nto %s\n", src, dest);
+ DEBUG_1("Failed to move cache file \"%s\" to \"%s\"", src, dest);
/* we remove it anyway - it's stale */
unlink_file(src);
}
}
-void cache_maint_moved(FileData *fd)
+static void cache_maint_moved(FileData *fd)
{
gchar *base;
mode_t mode = 0755;
if (!src || !dest) return;
base = cache_get_location(CACHE_TYPE_THUMB, dest, FALSE, &mode);
- if (cache_ensure_dir_exists(base, mode))
+ if (recursive_mkdir_if_not_exists(base, mode))
{
gchar *buf;
gchar *d;
}
else
{
- printf("Failed to create cache dir for move %s\n", base);
+ log_printf("Failed to create cache dir for move %s\n", base);
}
g_free(base);
base = cache_get_location(CACHE_TYPE_METADATA, dest, FALSE, &mode);
- if (cache_ensure_dir_exists(base, mode))
+ if (recursive_mkdir_if_not_exists(base, mode))
{
gchar *buf;
gchar *d;
-
+
buf = cache_find_location(CACHE_TYPE_METADATA, src);
d = cache_get_location(CACHE_TYPE_METADATA, dest, TRUE, NULL);
cache_file_move(buf, d);
}
g_free(base);
- if (enable_thumb_caching && thumbnail_spec_standard) thumb_std_maint_moved(src, dest);
+ if (options->thumbnails.enable_caching && options->thumbnails.spec_standard)
+ thumb_std_maint_moved(src, dest);
}
static void cache_file_remove(const gchar *path)
{
if (path && isfile(path) && !unlink_file(path))
{
- if (debug) printf("Failed to remove cache file %s\n", path);
+ DEBUG_1("Failed to remove cache file %s", path);
}
}
-void cache_maint_removed(FileData *fd)
+static void cache_maint_removed(FileData *fd)
{
gchar *buf;
cache_file_remove(buf);
g_free(buf);
- if (enable_thumb_caching && thumbnail_spec_standard) thumb_std_maint_removed(fd->path);
+ if (options->thumbnails.enable_caching && options->thumbnails.spec_standard)
+ thumb_std_maint_removed(fd->path);
}
-void cache_maint_copied(FileData *fd)
+static void cache_maint_copied(FileData *fd)
{
gchar *dest_base;
gchar *src_cache;
if (!src_cache) return;
dest_base = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, FALSE, &mode);
- if (cache_ensure_dir_exists(dest_base, mode))
+ if (recursive_mkdir_if_not_exists(dest_base, mode))
{
gchar *path;
-
+
path = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, TRUE, NULL);
if (!copy_file(src_cache, path))
{
- if (debug) printf("failed to copy metadata %s to %s\n", src_cache, path);
+ DEBUG_1("failed to copy metadata %s to %s", src_cache, path);
}
g_free(path);
}
g_free(src_cache);
}
+void cache_notify_cb(FileData *fd, NotifyType type, gpointer data)
+{
+ if (!(type & NOTIFY_CHANGE) || !fd->change) return;
+
+ DEBUG_1("Notify cache_maint: %s %04x", fd->path, type);
+ switch (fd->change->type)
+ {
+ case FILEDATA_CHANGE_MOVE:
+ case FILEDATA_CHANGE_RENAME:
+ cache_maint_moved(fd);
+ break;
+ case FILEDATA_CHANGE_COPY:
+ cache_maint_copied(fd);
+ break;
+ case FILEDATA_CHANGE_DELETE:
+ cache_maint_removed(fd);
+ break;
+ case FILEDATA_CHANGE_UNSPECIFIED:
+ case FILEDATA_CHANGE_WRITE_METADATA:
+ break;
+ }
+}
+
+
/*
*-------------------------------------------------------------------
* new cache maintenance utilities
gint count_done;
};
-typedef struct _CleanData CleanData;
-struct _CleanData
+typedef struct _CacheOpsData CacheOpsData;
+struct _CacheOpsData
{
GenericDialog *gd;
ThumbLoaderStd *tl;
+ CacheLoader *cl;
GList *list;
GList *list_dir;
gint days;
- gint clear;
+ gboolean clear;
GtkWidget *button_close;
GtkWidget *button_stop;
GtkWidget *button_start;
GtkWidget *progress;
+ GtkWidget *progress_bar;
GtkWidget *spinner;
GtkWidget *group;
gint count_total;
gint count_done;
- gint local;
- gint recurse;
+ gboolean local;
+ gboolean recurse;
- gint idle_id;
+ gboolean remote;
+
+ guint idle_id; /* event source id */
};
-static void cache_manager_render_reset(CleanData *cd)
+static void cache_manager_render_reset(CacheOpsData *cd)
{
- path_list_free(cd->list);
+ filelist_free(cd->list);
cd->list = NULL;
- path_list_free(cd->list_dir);
+ filelist_free(cd->list_dir);
cd->list_dir = NULL;
thumb_loader_free((ThumbLoader *)cd->tl);
static void cache_manager_render_close_cb(GenericDialog *fd, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
- if (!GTK_WIDGET_SENSITIVE(cd->button_close)) return;
+ if (!gtk_widget_get_sensitive(cd->button_close)) return;
cache_manager_render_reset(cd);
generic_dialog_close(cd->gd);
g_free(cd);
}
-static void cache_manager_render_finish(CleanData *cd)
+static void cache_manager_render_finish(CacheOpsData *cd)
{
cache_manager_render_reset(cd);
+ if (!cd->remote)
+ {
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), _("done"));
+ spinner_set_interval(cd->spinner, -1);
- gtk_entry_set_text(GTK_ENTRY(cd->progress), _("done"));
- spinner_set_interval(cd->spinner, -1);
-
- gtk_widget_set_sensitive(cd->group, TRUE);
- gtk_widget_set_sensitive(cd->button_start, TRUE);
- gtk_widget_set_sensitive(cd->button_stop, FALSE);
- gtk_widget_set_sensitive(cd->button_close, TRUE);
+ gtk_widget_set_sensitive(cd->group, TRUE);
+ gtk_widget_set_sensitive(cd->button_start, TRUE);
+ gtk_widget_set_sensitive(cd->button_stop, FALSE);
+ gtk_widget_set_sensitive(cd->button_close, TRUE);
+ }
}
static void cache_manager_render_stop_cb(GenericDialog *fd, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), _("stopped"));
cache_manager_render_finish(cd);
}
-static void cache_manager_render_folder(CleanData *cd, const gchar *path)
+static void cache_manager_render_folder(CacheOpsData *cd, FileData *dir_fd)
{
GList *list_d = NULL;
GList *list_f = NULL;
if (cd->recurse)
{
- path_list(path, &list_f, &list_d);
+ filelist_read(dir_fd, &list_f, &list_d);
}
else
{
- path_list(path, &list_f, NULL);
+ filelist_read(dir_fd, &list_f, NULL);
}
- list_f = path_list_filter(list_f, FALSE);
- list_d = path_list_filter(list_d, TRUE);
+ list_f = filelist_filter(list_f, FALSE);
+ list_d = filelist_filter(list_d, TRUE);
cd->list = g_list_concat(list_f, cd->list);
cd->list_dir = g_list_concat(list_d, cd->list_dir);
}
-static gint cache_manager_render_file(CleanData *cd);
+static gboolean cache_manager_render_file(CacheOpsData *cd);
static void cache_manager_render_thumb_done_cb(ThumbLoader *tl, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
thumb_loader_free((ThumbLoader *)cd->tl);
cd->tl = NULL;
while (cache_manager_render_file(cd));
}
-static gint cache_manager_render_file(CleanData *cd)
+static gboolean cache_manager_render_file(CacheOpsData *cd)
{
if (cd->list)
{
- gchar *path;
+ FileData *fd;
gint success;
- path = cd->list->data;
- cd->list = g_list_remove(cd->list, path);
+ fd = cd->list->data;
+ cd->list = g_list_remove(cd->list, fd);
- cd->tl = (ThumbLoaderStd *)thumb_loader_new(thumb_max_width, thumb_max_height);
+ cd->tl = (ThumbLoaderStd *)thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
thumb_loader_set_callbacks((ThumbLoader *)cd->tl,
cache_manager_render_thumb_done_cb,
cache_manager_render_thumb_done_cb,
NULL, cd);
thumb_loader_set_cache((ThumbLoader *)cd->tl, TRUE, cd->local, TRUE);
- success = thumb_loader_start((ThumbLoader *)cd->tl, path);
+ success = thumb_loader_start((ThumbLoader *)cd->tl, fd);
if (success)
{
- gtk_entry_set_text(GTK_ENTRY(cd->progress), path);
+ if (!cd->remote)
+ {
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), fd->path);
+ cd->count_done = cd->count_done + 1;
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress_bar), (gdouble)cd->count_done / cd->count_total);
+ }
}
else
{
cd->tl = NULL;
}
- g_free(path);
+ file_data_unref(fd);
return (!success);
}
else if (cd->list_dir)
{
- gchar *path;
+ FileData *fd;
- path = cd->list_dir->data;
- cd->list_dir = g_list_remove(cd->list_dir, path);
+ fd = cd->list_dir->data;
+ cd->list_dir = g_list_remove(cd->list_dir, fd);
- cache_manager_render_folder(cd, path);
+ cache_manager_render_folder(cd, fd);
- g_free(path);
+ file_data_unref(fd);
return TRUE;
}
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), _("done"));
cache_manager_render_finish(cd);
return FALSE;
static void cache_manager_render_start_cb(GenericDialog *fd, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
gchar *path;
+ GList *list_total = NULL;
- if (cd->list || !GTK_WIDGET_SENSITIVE(cd->button_start)) return;
+ if(!cd->remote)
+ {
+ if (cd->list || !gtk_widget_get_sensitive(cd->button_start)) return;
+ }
path = remove_trailing_slash((gtk_entry_get_text(GTK_ENTRY(cd->entry))));
parse_out_relatives(path);
if (!isdir(path))
{
- warning_dialog(_("Invalid folder"),
- _("The specified folder can not be found."),
- GTK_STOCK_DIALOG_WARNING, cd->gd->dialog);
+ if (!cd->remote)
+ {
+ warning_dialog(_("Invalid folder"),
+ _("The specified folder can not be found."),
+ GTK_STOCK_DIALOG_WARNING, cd->gd->dialog);
+ }
+ else
+ {
+ log_printf("The specified folder can not be found: %s\n", path);
+ }
}
else
{
- gtk_widget_set_sensitive(cd->group, FALSE);
- gtk_widget_set_sensitive(cd->button_start, FALSE);
- gtk_widget_set_sensitive(cd->button_stop, TRUE);
- gtk_widget_set_sensitive(cd->button_close, FALSE);
+ FileData *dir_fd;
+ if(!cd->remote)
+ {
+ gtk_widget_set_sensitive(cd->group, FALSE);
+ gtk_widget_set_sensitive(cd->button_start, FALSE);
+ gtk_widget_set_sensitive(cd->button_stop, TRUE);
+ gtk_widget_set_sensitive(cd->button_close, FALSE);
+
+ spinner_set_interval(cd->spinner, SPINNER_SPEED);
+ }
+ dir_fd = file_data_new_dir(path);
+ cache_manager_render_folder(cd, dir_fd);
+ list_total = filelist_recursive(dir_fd);
+ cd->count_total = g_list_length(list_total);
+ file_data_unref(dir_fd);
+ g_list_free(list_total);
+ cd->count_done = 0;
+
+ while (cache_manager_render_file(cd));
+ }
+
+ g_free(path);
+}
- spinner_set_interval(cd->spinner, SPINNER_SPEED);
+static void cache_manager_render_start_render_remote(CacheOpsData *cd, const gchar *user_path)
+{
+ gchar *path;
+
+ path = remove_trailing_slash(user_path);
+ parse_out_relatives(path);
+
+ if (!isdir(path))
+ {
+ log_printf("The specified folder can not be found: %s\n", path);
+ }
+ else
+ {
+ FileData *dir_fd;
- cache_manager_render_folder(cd, path);
+ dir_fd = file_data_new_dir(path);
+ cache_manager_render_folder(cd, dir_fd);
+ file_data_unref(dir_fd);
while (cache_manager_render_file(cd));
}
static void cache_manager_render_dialog(GtkWidget *widget, const gchar *path)
{
- CleanData *cd;
+ CacheOpsData *cd;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
- cd = g_new0(CleanData, 1);
+ cd = g_new0(CacheOpsData, 1);
+ cd->remote = FALSE;
cd->gd = generic_dialog_new(_("Create thumbnails"),
- "GQview", "create_thumbnails",
+ "create_thumbnails",
widget, FALSE,
NULL, cd);
gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
cache_manager_render_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
- generic_dialog_add_message(cd->gd, NULL, _("Create thumbnails"), NULL);
+ generic_dialog_add_message(cd->gd, NULL, _("Create thumbnails"), NULL, FALSE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
- label = tab_completion_new(&cd->entry, path, NULL, NULL);
+ label = tab_completion_new(&cd->entry, path, NULL, NULL, NULL, NULL);
tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
pref_checkbox_new_int(cd->group, _("Include subfolders"), FALSE, &cd->recurse);
button = pref_checkbox_new_int(cd->group, _("Store thumbnails local to source images"), FALSE, &cd->local);
- gtk_widget_set_sensitive(button, thumbnail_spec_standard);
+ gtk_widget_set_sensitive(button, options->thumbnails.spec_standard);
pref_line(cd->gd->vbox, PREF_PAD_SPACE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
cd->progress = gtk_entry_new();
- GTK_WIDGET_UNSET_FLAGS(cd->progress, GTK_CAN_FOCUS);
+ gtk_widget_set_can_focus(cd->progress, FALSE);
gtk_editable_set_editable(GTK_EDITABLE(cd->progress), FALSE);
gtk_entry_set_text(GTK_ENTRY(cd->progress), _("click start to begin"));
gtk_box_pack_start(GTK_BOX(hbox), cd->progress, TRUE, TRUE, 0);
gtk_widget_show(cd->progress);
+ cd->progress_bar = gtk_progress_bar_new();
+ gtk_box_pack_start(GTK_BOX(cd->gd->vbox), cd->progress_bar, TRUE, TRUE, 0);
+ gtk_widget_show(cd->progress_bar);
+
cd->spinner = spinner_new(NULL, -1);
gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
gtk_widget_show(cd->spinner);
gtk_widget_show(cd->gd->dialog);
}
+void cache_manager_render_remote(const gchar *path, gboolean recurse, gboolean local)
+{
+ CacheOpsData *cd;
+ cd = g_new0(CacheOpsData, 1);
+ cd->recurse = recurse;
+ cd->local = local;
+ cd->remote = TRUE;
+ cache_manager_render_start_render_remote(cd, path);
+}
static void cache_manager_standard_clean_close_cb(GenericDialog *gd, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
- if (!GTK_WIDGET_SENSITIVE(cd->button_close)) return;
+ if (!gtk_widget_get_sensitive(cd->button_close)) return;
generic_dialog_close(cd->gd);
thumb_loader_std_thumb_file_validate_cancel(cd->tl);
- path_list_free(cd->list);
+ filelist_free(cd->list);
g_free(cd);
}
-static void cache_manager_standard_clean_done(CleanData *cd)
+static void cache_manager_standard_clean_done(CacheOpsData *cd)
{
- gtk_widget_set_sensitive(cd->button_stop, FALSE);
- gtk_widget_set_sensitive(cd->button_close, TRUE);
-
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress), 1.0);
- gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("done"));
+ if (!cd->remote)
+ {
+ gtk_widget_set_sensitive(cd->button_stop, FALSE);
+ gtk_widget_set_sensitive(cd->button_close, TRUE);
- if (cd->idle_id != -1)
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress), 1.0);
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("done"));
+ }
+ if (cd->idle_id)
{
g_source_remove(cd->idle_id);
- cd->idle_id = -1;
+ cd->idle_id = 0;
}
thumb_loader_std_thumb_file_validate_cancel(cd->tl);
cd->tl = NULL;
- path_list_free(cd->list);
+ filelist_free(cd->list);
cd->list = NULL;
}
static void cache_manager_standard_clean_stop_cb(GenericDialog *gd, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
cache_manager_standard_clean_done(cd);
}
static gint cache_manager_standard_clean_clear_cb(gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
if (cd->list)
{
- gchar *next_path;
+ FileData *next_fd;
- next_path = cd->list->data;
- cd->list = g_list_remove(cd->list, next_path);
+ next_fd = cd->list->data;
+ cd->list = g_list_remove(cd->list, next_fd);
- if (debug) printf("thumb removed: %s\n", next_path);
+ DEBUG_1("thumb removed: %s", next_fd->path);
- unlink_file(next_path);
- g_free(next_path);
+ unlink_file(next_fd->path);
+ file_data_unref(next_fd);
cd->count_done++;
- if (cd->count_total != 0)
+ if (!cd->remote)
{
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
- (gdouble)cd->count_done / cd->count_total);
+ if (cd->count_total != 0)
+ {
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
+ (gdouble)cd->count_done / cd->count_total);
+ }
}
return TRUE;
}
- cd->idle_id = -1;
+ cd->idle_id = 0;
cache_manager_standard_clean_done(cd);
return FALSE;
}
-static void cache_manager_standard_clean_valid_cb(const gchar *path, gint valid, gpointer data)
+static void cache_manager_standard_clean_valid_cb(const gchar *path, gboolean valid, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
if (path)
{
if (!valid)
{
- if (debug) printf("thumb cleaned: %s\n", path);
+ DEBUG_1("thumb cleaned: %s", path);
unlink_file(path);
}
cd->count_done++;
- if (cd->count_total != 0)
+ if (!cd->remote)
{
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
- (gdouble)cd->count_done / cd->count_total);
+ if (cd->count_total != 0)
+ {
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
+ (gdouble)cd->count_done / cd->count_total);
+ }
}
}
cd->tl = NULL;
if (cd->list)
{
- gchar *next_path;
+ FileData *next_fd;
+
+ next_fd = cd->list->data;
+ cd->list = g_list_remove(cd->list, next_fd);
- next_path = cd->list->data;
- cd->list = g_list_remove(cd->list, next_path);
-
- cd->tl = thumb_loader_std_thumb_file_validate(next_path, cd->days,
+ cd->tl = thumb_loader_std_thumb_file_validate(next_fd->path, cd->days,
cache_manager_standard_clean_valid_cb, cd);
- g_free(next_path);
+ file_data_unref(next_fd);
}
else
{
}
}
-static void cache_manager_standard_clean_start_cb(GenericDialog *gd, gpointer data)
+static void cache_manager_standard_clean_start(GenericDialog *gd, gpointer data)
{
- CleanData *cd = data;
+ CacheOpsData *cd = data;
GList *list;
gchar *path;
+ FileData *dir_fd;
- if (cd->list || !GTK_WIDGET_SENSITIVE(cd->button_start)) return;
+ if (!cd->remote)
+ {
+ if (cd->list || !gtk_widget_get_sensitive(cd->button_start)) return;
- gtk_widget_set_sensitive(cd->button_start, FALSE);
- gtk_widget_set_sensitive(cd->button_stop, TRUE);
- gtk_widget_set_sensitive(cd->button_close, FALSE);
+ gtk_widget_set_sensitive(cd->button_start, FALSE);
+ gtk_widget_set_sensitive(cd->button_stop, TRUE);
+ gtk_widget_set_sensitive(cd->button_close, FALSE);
- gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("running..."));
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("running..."));
+ }
- path = g_strconcat(homedir(), "/", THUMB_FOLDER_GLOBAL, "/", THUMB_FOLDER_NORMAL, NULL);
- list = NULL;
- path_list(path, &list, NULL);
+ path = g_build_filename(get_thumbnails_standard_cache_dir(), THUMB_FOLDER_NORMAL, NULL);
+ dir_fd = file_data_new_dir(path);
+ filelist_read(dir_fd, &list, NULL);
cd->list = list;
+ file_data_unref(dir_fd);
g_free(path);
- path = g_strconcat(homedir(), "/", THUMB_FOLDER_GLOBAL, "/", THUMB_FOLDER_LARGE, NULL);
- list = NULL;
- path_list(path, &list, NULL);
+ path = g_build_filename(get_thumbnails_standard_cache_dir(), THUMB_FOLDER_LARGE, NULL);
+ dir_fd = file_data_new_dir(path);
+ filelist_read(dir_fd, &list, NULL);
cd->list = g_list_concat(cd->list, list);
+ file_data_unref(dir_fd);
g_free(path);
- path = g_strconcat(homedir(), "/", THUMB_FOLDER_GLOBAL, "/", THUMB_FOLDER_FAIL, NULL);
- list = NULL;
- path_list(path, &list, NULL);
+ path = g_build_filename(get_thumbnails_standard_cache_dir(), THUMB_FOLDER_FAIL, NULL);
+ dir_fd = file_data_new_dir(path);
+ filelist_read(dir_fd, &list, NULL);
cd->list = g_list_concat(cd->list, list);
+ file_data_unref(dir_fd);
g_free(path);
cd->count_total = g_list_length(cd->list);
}
}
-static void cache_manager_standard_process(GtkWidget *widget, gint clear)
+static void cache_manager_standard_clean_start_cb(GenericDialog *gd, gpointer data)
+{
+ cache_manager_standard_clean_start(gd, data);
+}
+
+static void cache_manager_standard_process(GtkWidget *widget, gboolean clear)
{
- CleanData *cd;
+ CacheOpsData *cd;
const gchar *stock_id;
const gchar *msg;
- cd = g_new0(CleanData, 1);
+ cd = g_new0(CacheOpsData, 1);
cd->clear = clear;
+ cd->remote = FALSE;
if (clear)
{
}
cd->gd = generic_dialog_new(_("Maintenance"),
- "GQview", "standard_maintenance",
+ "standard_maintenance",
widget, FALSE,
NULL, cd);
cd->gd->cancel_cb = cache_manager_standard_clean_close_cb;
cache_manager_standard_clean_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
- generic_dialog_add_message(cd->gd, stock_id, msg, NULL);
+ generic_dialog_add_message(cd->gd, stock_id, msg, NULL, FALSE);
cd->progress = gtk_progress_bar_new();
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("click start to begin"));
+#if GTK_CHECK_VERSION(3,0,0)
+ gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(cd->progress), TRUE);
+#endif
gtk_box_pack_start(GTK_BOX(cd->gd->vbox), cd->progress, FALSE, FALSE, 0);
gtk_widget_show(cd->progress);
cd->days = 30;
cd->tl = NULL;
- cd->idle_id = -1;
+ cd->idle_id = 0;
gtk_widget_show(cd->gd->dialog);
}
+void cache_manager_standard_process_remote(gboolean clear)
+{
+ CacheOpsData *cd;
+
+ cd = g_new0(CacheOpsData, 1);
+ cd->clear = clear;
+ cd->days = 30;
+ cd->tl = NULL;
+ cd->idle_id = 0;
+ cd->remote = TRUE;
+
+ cache_manager_standard_clean_start(NULL, cd);
+}
+
static void cache_manager_standard_clean_cb(GtkWidget *widget, gpointer data)
{
cache_manager_standard_process(widget, FALSE);
}
-static void cache_manager_gqview_clean_cb(GtkWidget *widget, gpointer data)
+static void cache_manager_main_clean_cb(GtkWidget *widget, gpointer data)
{
cache_maintain_home(FALSE, FALSE, widget);
}
/* no op, only so cancel button appears */
}
-static void cache_manager_gqview_clear_ok_cb(GenericDialog *gd, gpointer data)
+static void cache_manager_main_clear_ok_cb(GenericDialog *gd, gpointer data)
{
cache_maintain_home(FALSE, TRUE, NULL);
}
-void cache_manager_gqview_clear_confirm(GtkWidget *parent)
+void cache_manager_main_clear_confirm(GtkWidget *parent)
{
GenericDialog *gd;
gd = generic_dialog_new(_("Clear cache"),
- "GQview", "clear_cache", parent, TRUE,
+ "clear_cache", parent, TRUE,
dummy_cancel_cb, NULL);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Clear cache"),
- _("This will remove all thumbnails that have\nbeen saved to disk, continue?"));
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, cache_manager_gqview_clear_ok_cb, TRUE);
+ _("This will remove all thumbnails and sim. files\nthat have been saved to disk, continue?"), TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, cache_manager_main_clear_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
}
-static void cache_manager_gqview_clear_cb(GtkWidget *widget, gpointer data)
+static void cache_manager_main_clear_cb(GtkWidget *widget, gpointer data)
{
- cache_manager_gqview_clear_confirm(widget);
+ cache_manager_main_clear_confirm(widget);
}
static void cache_manager_render_cb(GtkWidget *widget, gpointer data)
{
- cache_manager_render_dialog(widget, homedir());
+ const gchar *path = layout_get_path(NULL);
+
+ if (!path || !*path) path = homedir();
+ cache_manager_render_dialog(widget, path);
}
static void cache_manager_metadata_clean_cb(GtkWidget *widget, gpointer data)
cache_manager = NULL;
}
+static void cache_manager_help_cb(GenericDialog *gd, gpointer data)
+{
+ help_window_show("GuideReferenceManagement.html");
+}
+
+static GtkWidget *cache_manager_location_label(GtkWidget *group, const gchar *subdir)
+{
+ GtkWidget *label;
+ gchar *buf;
+
+ buf = g_strdup_printf(_("Location: %s"), subdir);
+ label = pref_label_new(group, buf);
+ g_free(buf);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
+
+ return label;
+}
+
+static gboolean cache_manager_sim_file(CacheOpsData *cd);
+
+static void cache_manager_sim_reset(CacheOpsData *cd)
+{
+ filelist_free(cd->list);
+ cd->list = NULL;
+
+ filelist_free(cd->list_dir);
+ cd->list_dir = NULL;
+
+ cache_loader_free((CacheLoader *)cd->cl);
+ cd->cl = NULL;
+}
+
+static void cache_manager_sim_close_cb(GenericDialog *fd, gpointer data)
+{
+ CacheOpsData *cd = data;
+
+ if (!gtk_widget_get_sensitive(cd->button_close)) return;
+
+ cache_manager_sim_reset(cd);
+ generic_dialog_close(cd->gd);
+ g_free(cd);
+}
+
+static void cache_manager_sim_finish(CacheOpsData *cd)
+{
+ cache_manager_sim_reset(cd);
+ if (!cd->remote)
+ {
+ spinner_set_interval(cd->spinner, -1);
+
+ gtk_widget_set_sensitive(cd->group, TRUE);
+ gtk_widget_set_sensitive(cd->button_start, TRUE);
+ gtk_widget_set_sensitive(cd->button_stop, FALSE);
+ gtk_widget_set_sensitive(cd->button_close, TRUE);
+ }
+}
+
+static void cache_manager_sim_stop_cb(GenericDialog *fd, gpointer data)
+{
+ CacheOpsData *cd = data;
+
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), _("stopped"));
+ cache_manager_sim_finish(cd);
+}
+
+static void cache_manager_sim_folder(CacheOpsData *cd, FileData *dir_fd)
+{
+ GList *list_d = NULL;
+ GList *list_f = NULL;
+
+ if (cd->recurse)
+ {
+ filelist_read(dir_fd, &list_f, &list_d);
+ }
+ else
+ {
+ filelist_read(dir_fd, &list_f, NULL);
+ }
+
+ list_f = filelist_filter(list_f, FALSE);
+ list_d = filelist_filter(list_d, TRUE);
+
+ cd->list = g_list_concat(list_f, cd->list);
+ cd->list_dir = g_list_concat(list_d, cd->list_dir);
+}
+
+static void cache_manager_sim_file_done_cb(CacheLoader *cl, gint error, gpointer data)
+{
+ CacheOpsData *cd = data;
+
+ cache_loader_free((CacheLoader *)cd->cl);
+ cd->cl = NULL;
+
+ while (cache_manager_sim_file(cd));
+}
+
+static gboolean cache_manager_sim_file(CacheOpsData *cd)
+{
+ CacheDataType load_mask;
+
+ if (cd->list)
+ {
+ FileData *fd;
+ fd = cd->list->data;
+ cd->list = g_list_remove(cd->list, fd);
+
+ load_mask = CACHE_LOADER_DIMENSIONS | CACHE_LOADER_DATE | CACHE_LOADER_MD5SUM | CACHE_LOADER_SIMILARITY;
+ cd->cl = (CacheLoader *)cache_loader_new(fd, load_mask, (cache_manager_sim_file_done_cb), cd);
+
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), fd->path);
+
+ file_data_unref(fd);
+ cd->count_done = cd->count_done + 1;
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress_bar), (gdouble)cd->count_done / cd->count_total);
+
+ return FALSE;
+ }
+ else if (cd->list_dir)
+ {
+ FileData *fd;
+
+ fd = cd->list_dir->data;
+ cd->list_dir = g_list_remove(cd->list_dir, fd);
+
+ cache_manager_sim_folder((CacheOpsData *)cd, fd);
+ file_data_unref(fd);
+
+ return TRUE;
+ }
+
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), _("done"));
+ cache_manager_sim_finish((CacheOpsData *)cd);
+
+ return FALSE;
+}
+
+static void cache_manager_sim_start_cb(GenericDialog *fd, gpointer data)
+{
+ CacheOpsData *cd = data;
+ gchar *path;
+ GList *list_total = NULL;
+
+ if (!cd->remote)
+ {
+ if (cd->list || !gtk_widget_get_sensitive(cd->button_start)) return;
+ }
+
+ path = remove_trailing_slash((gtk_entry_get_text(GTK_ENTRY(cd->entry))));
+ parse_out_relatives(path);
+
+ if (!isdir(path))
+ {
+ if (!cd->remote)
+ {
+ warning_dialog(_("Invalid folder"),
+ _("The specified folder can not be found."),
+ GTK_STOCK_DIALOG_WARNING, cd->gd->dialog);
+ }
+ else
+ {
+ log_printf("The specified folder can not be found: %s\n", path);
+ }
+ }
+ else
+ {
+ FileData *dir_fd;
+ if(!cd->remote)
+ {
+ gtk_widget_set_sensitive(cd->group, FALSE);
+ gtk_widget_set_sensitive(cd->button_start, FALSE);
+ gtk_widget_set_sensitive(cd->button_stop, TRUE);
+ gtk_widget_set_sensitive(cd->button_close, FALSE);
+
+ spinner_set_interval(cd->spinner, SPINNER_SPEED);
+ }
+ dir_fd = file_data_new_dir(path);
+ cache_manager_sim_folder(cd, dir_fd);
+ list_total = filelist_recursive(dir_fd);
+ cd->count_total = g_list_length(list_total);
+ file_data_unref(dir_fd);
+ g_list_free(list_total);
+ cd->count_done = 0;
+
+ while (cache_manager_sim_file((CacheOpsData *)cd));
+ }
+
+ g_free(path);
+}
+
+static void cache_manager_sim_load_dialog(GtkWidget *widget, const gchar *path)
+{
+ CacheOpsData *cd;
+ GtkWidget *hbox;
+ GtkWidget *label;
+
+ cd = g_new0(CacheOpsData, 1);
+ cd->remote = FALSE;
+ cd->recurse = TRUE;
+
+ cd->gd = generic_dialog_new(_("Create sim. files"), "create_sim_files", widget, FALSE, NULL, cd);
+ gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
+ cd->gd->cancel_cb = cache_manager_sim_close_cb;
+ cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
+ cache_manager_sim_close_cb, FALSE);
+ cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
+ cache_manager_sim_start_cb, FALSE);
+ cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
+ cache_manager_sim_stop_cb, FALSE);
+ gtk_widget_set_sensitive(cd->button_stop, FALSE);
+
+ generic_dialog_add_message(cd->gd, NULL, _("Create sim. files recursively"), NULL, FALSE);
+
+ hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
+ pref_spacer(hbox, PREF_PAD_INDENT);
+ cd->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
+
+ hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
+ pref_label_new(hbox, _("Folder:"));
+
+ label = tab_completion_new(&cd->entry, path, NULL, NULL, NULL, NULL);
+ tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
+ gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
+ gtk_widget_show(label);
+
+ pref_line(cd->gd->vbox, PREF_PAD_SPACE);
+ hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
+
+ cd->progress = gtk_entry_new();
+ gtk_widget_set_can_focus(cd->progress, FALSE);
+ gtk_editable_set_editable(GTK_EDITABLE(cd->progress), FALSE);
+ gtk_entry_set_text(GTK_ENTRY(cd->progress), _("click start to begin"));
+ gtk_box_pack_start(GTK_BOX(hbox), cd->progress, TRUE, TRUE, 0);
+ gtk_widget_show(cd->progress);
+
+ cd->progress_bar = gtk_progress_bar_new();
+ gtk_box_pack_start(GTK_BOX(cd->gd->vbox), cd->progress_bar, TRUE, TRUE, 0);
+ gtk_widget_show(cd->progress_bar);
+
+ cd->spinner = spinner_new(NULL, -1);
+ gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
+ gtk_widget_show(cd->spinner);
+
+ cd->list = NULL;
+
+ gtk_widget_show(cd->gd->dialog);
+}
+
+static void cache_manager_sim_load_cb(GtkWidget *widget, gpointer data)
+{
+ const gchar *path = layout_get_path(NULL);
+
+ if (!path || !*path) path = homedir();
+ cache_manager_sim_load_dialog(widget, path);
+}
+
void cache_manager_show(void)
{
GenericDialog *gd;
GtkWidget *group;
GtkWidget *button;
- GtkWidget *label;
GtkWidget *table;
GtkSizeGroup *sizegroup;
- gchar *buf;
+ gchar *path;
if (cache_manager)
{
cache_manager = g_new0(CacheManager, 1);
- cache_manager->dialog = generic_dialog_new(_("Cache Maintenance - GQview"),
- "GQiew", "cache_manager",
+ cache_manager->dialog = generic_dialog_new(_("Cache Maintenance"),
+ "cache_manager",
NULL, FALSE,
NULL, cache_manager);
gd = cache_manager->dialog;
gd->cancel_cb = cache_manager_close_cb;
generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL,
cache_manager_close_cb, FALSE);
+ generic_dialog_add_button(gd, GTK_STOCK_HELP, NULL,
+ cache_manager_help_cb, FALSE);
- generic_dialog_add_message(gd, NULL, _("Cache and Data Maintenance"), NULL);
+ generic_dialog_add_message(gd, NULL, _("Cache and Data Maintenance"), NULL, FALSE);
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
- group = pref_group_new(gd->vbox, FALSE, _("GQview thumbnail cache"), GTK_ORIENTATION_VERTICAL);
+ group = pref_group_new(gd->vbox, FALSE, _("Geeqie thumbnail and sim. cache"), GTK_ORIENTATION_VERTICAL);
- buf = g_strconcat(_("Location:"), " ", homedir(), "/", GQVIEW_CACHE_RC_THUMB, NULL);
- label = pref_label_new(group, buf);
- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
- g_free(buf);
+ cache_manager_location_label(group, get_thumbnails_cache_dir());
table = pref_table_new(group, 2, 2, FALSE, FALSE);
button = pref_table_button(table, 0, 0, GTK_STOCK_CLEAR, _("Clean up"), FALSE,
- G_CALLBACK(cache_manager_gqview_clean_cb), cache_manager);
+ G_CALLBACK(cache_manager_main_clean_cb), cache_manager);
gtk_size_group_add_widget(sizegroup, button);
- pref_table_label(table, 1, 0, _("Remove orphaned or outdated thumbnails."), 0.0);
+ pref_table_label(table, 1, 0, _("Remove orphaned or outdated thumbnails and sim. files."), 0.0);
button = pref_table_button(table, 0, 1, GTK_STOCK_DELETE, _("Clear cache"), FALSE,
- G_CALLBACK(cache_manager_gqview_clear_cb), cache_manager);
+ G_CALLBACK(cache_manager_main_clear_cb), cache_manager);
gtk_size_group_add_widget(sizegroup, button);
- pref_table_label(table, 1, 1, _("Delete all cached thumbnails."), 0.0);
+ pref_table_label(table, 1, 1, _("Delete all cached data."), 0.0);
group = pref_group_new(gd->vbox, FALSE, _("Shared thumbnail cache"), GTK_ORIENTATION_VERTICAL);
- buf = g_strconcat(_("Location:"), " ", homedir(), "/", THUMB_FOLDER_GLOBAL, NULL);
- label = pref_label_new(group, buf);
- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
- g_free(buf);
+ path = g_build_filename(get_thumbnails_standard_cache_dir(), NULL);
+ cache_manager_location_label(group, path);
+ g_free(path);
table = pref_table_new(group, 2, 2, FALSE, FALSE);
G_CALLBACK(cache_manager_render_cb), cache_manager);
gtk_size_group_add_widget(sizegroup, button);
pref_table_label(table, 1, 1, _("Render thumbnails for a specific folder."), 0.0);
+ gtk_widget_set_sensitive(group, options->thumbnails.enable_caching);
+
+ group = pref_group_new(gd->vbox, FALSE, _("File similarity cache"), GTK_ORIENTATION_VERTICAL);
+
+ table = pref_table_new(group, 3, 2, FALSE, FALSE);
+
+ button = pref_table_button(table, 0, 0, GTK_STOCK_EXECUTE, _("Create"), FALSE,
+ G_CALLBACK(cache_manager_sim_load_cb), cache_manager);
+ gtk_size_group_add_widget(sizegroup, button);
+ pref_table_label(table, 1, 0, _("Create sim. files recursively."), 0.0);
+ gtk_widget_set_sensitive(group, options->thumbnails.enable_caching);
group = pref_group_new(gd->vbox, FALSE, _("Metadata"), GTK_ORIENTATION_VERTICAL);
-
- buf = g_strconcat(_("Location:"), " ", homedir(), "/", GQVIEW_CACHE_RC_METADATA, NULL);
- label = pref_label_new(group, buf);
- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
- g_free(buf);
+
+ cache_manager_location_label(group, get_metadata_cache_dir());
table = pref_table_new(group, 2, 1, FALSE, FALSE);
gtk_widget_show(cache_manager->dialog->dialog);
}
-
+/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */