src/cache_maint.c

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "main.h"
  23 #include "cache_maint.h"
  24
  25 #include "cache.h"
  26 #include "filedata.h"
  27 #include "layout.h"
  28 #include "thumb.h"
  29 #include "thumb_standard.h"
  30 #include "ui_fileops.h"
  31 #include "ui_misc.h"
  32 #include "ui_spinner.h"
  33 #include "ui_tabcomp.h"
  34 #include "ui_utildlg.h"
  35 #include "window.h"
  36
  37
  38 typedef struct _CMData CMData;
  39 struct _CMData
  40 {
  41         GList *list;
  42         GList *done_list;
  43         guint idle_id; /* event source id */
  44         GenericDialog *gd;
  45         GtkWidget *entry;
  46         GtkWidget *spinner;
  47         GtkWidget *button_stop;
  48         GtkWidget *button_close;
  49         gboolean clear;
  50         gboolean metadata;
  51         gboolean remote;
  52 };
  53
  54 #define PURGE_DIALOG_WIDTH 400
  55
  56
  57 /*
  58  *-------------------------------------------------------------------
  59  * cache maintenance
  60  *-------------------------------------------------------------------
  61  */
  62
  63 static gchar *extension_find_dot(gchar *path)
  64 {
  65         gchar *dot = NULL;
  66
  67         if (!path) return NULL;
  68
  69         while (*path != '\0')
  70                 {
  71                 if (*path == '.') dot = path;
  72                 path++;
  73                 }
  74
  75         return dot;
  76 }
  77
  78 static gboolean isempty(const gchar *path)
  79 {
  80         DIR *dp;
  81         struct dirent *dir;
  82         gchar *pathl;
  83
  84         pathl = path_from_utf8(path);
  85         dp = opendir(pathl);
  86         g_free(pathl);
  87         if (!dp) return FALSE;
  88
  89         while ((dir = readdir(dp)) != NULL)
  90                 {
  91                 gchar *name = dir->d_name;
  92
  93                 if (!(name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))) )
  94                         {
  95                         closedir(dp);
  96                         return FALSE;
  97                         }
  98                 }
  99
 100         closedir(dp);
 101         return TRUE;
 102 }
 103
 104 static void cache_maintain_home_close(CMData *cm)
 105 {
 106         if (cm->idle_id) g_source_remove(cm->idle_id);
 107         if (cm->gd) generic_dialog_close(cm->gd);
 108         filelist_free(cm->list);
 109         g_list_free(cm->done_list);
 110         g_free(cm);
 111 }
 112
 113 static void cache_maintain_home_stop(CMData *cm)
 114 {
 115         if (cm->idle_id)
 116                 {
 117                 g_source_remove(cm->idle_id);
 118                 cm->idle_id = 0;
 119                 }
 120
 121         if (!cm->remote)
 122                 {
 123                 gtk_entry_set_text(GTK_ENTRY(cm->entry), _("done"));
 124                 spinner_set_interval(cm->spinner, -1);
 125
 126                 gtk_widget_set_sensitive(cm->button_stop, FALSE);
 127                 gtk_widget_set_sensitive(cm->button_close, TRUE);
 128                 }
 129 }
 130
 131 static gboolean cache_maintain_home_cb(gpointer data)
 132 {
 133         CMData *cm = data;
 134         GList *dlist = NULL;
 135         GList *list = NULL;
 136         FileData *fd;
 137         gboolean just_done = FALSE;
 138         gboolean still_have_a_file = TRUE;
 139         gsize base_length;
 140         const gchar *cache_folder;
 141         gboolean filter_disable;
 142
 143         if (cm->metadata)
 144                 {
 145                 cache_folder = get_metadata_cache_dir();
 146                 }
 147         else
 148                 {
 149                 cache_folder = get_thumbnails_cache_dir();
 150                 }
 151
 152         base_length = strlen(cache_folder);
 153
 154         if (!cm->list)
 155                 {
 156                 DEBUG_1("purge chk done.");
 157                 cm->idle_id = 0;
 158                 cache_maintain_home_stop(cm);
 159                 return FALSE;
 160                 }
 161
 162         fd = cm->list->data;
 163
 164         DEBUG_1("purge chk (%d) \"%s\"", (cm->clear && !cm->metadata), fd->path);
 165
 166 /**
 167  * It is necessary to disable the file filter when clearing the cache,
 168  * otherwise the .sim (file similarity) files are not deleted.
 169  */
 170         filter_disable = options->file_filter.disable;
 171         options->file_filter.disable = TRUE;
 172
 173         if (g_list_find(cm->done_list, fd) == NULL)
 174                 {
 175                 cm->done_list = g_list_prepend(cm->done_list, fd);
 176
 177                 if (filelist_read(fd, &list, &dlist))
 178                         {
 179                         GList *work;
 180
 181                         just_done = TRUE;
 182                         still_have_a_file = FALSE;
 183
 184                         work = list;
 185                         while (work)
 186                                 {
 187                                 FileData *fd_list = work->data;
 188                                 gchar *path_buf = g_strdup(fd_list->path);
 189                                 gchar *dot;
 190
 191                                 dot = extension_find_dot(path_buf);
 192
 193                                 if (dot) *dot = '\0';
 194                                 if ((!cm->metadata && cm->clear) ||
 195                                     (strlen(path_buf) > base_length && !isfile(path_buf + base_length)) )
 196                                         {
 197                                         if (dot) *dot = '.';
 198                                         if (!unlink_file(path_buf)) log_printf("failed to delete:%s\n", path_buf);
 199                                         }
 200                                 else
 201                                         {
 202                                         still_have_a_file = TRUE;
 203                                         }
 204                                 g_free(path_buf);
 205                                 work = work->next;
 206                                 }
 207                         }
 208                 }
 209         options->file_filter.disable = filter_disable;
 210
 211         filelist_free(list);
 212
 213         cm->list = g_list_concat(dlist, cm->list);
 214
 215         if (cm->list && g_list_find(cm->done_list, cm->list->data) != NULL)
 216                 {
 217                 /* check if the dir is empty */
 218
 219                 if (cm->list->data == fd && just_done)
 220                         {
 221                         if (!still_have_a_file && !dlist && cm->list->next && !rmdir_utf8(fd->path))
 222                                 {
 223                                 log_printf("Unable to delete dir: %s\n", fd->path);
 224                                 }
 225                         }
 226                 else
 227                         {
 228                         /* must re-check for an empty dir */
 229                         if (isempty(fd->path) && cm->list->next && !rmdir_utf8(fd->path))
 230                                 {
 231                                 log_printf("Unable to delete dir: %s\n", fd->path);
 232                                 }
 233                         }
 234
 235                 fd = cm->list->data;
 236                 cm->done_list = g_list_remove(cm->done_list, fd);
 237                 cm->list = g_list_remove(cm->list, fd);
 238                 file_data_unref(fd);
 239                 }
 240
 241         if (cm->list && !cm->remote)
 242                 {
 243                 const gchar *buf;
 244
 245                 fd = cm->list->data;
 246                 if (strlen(fd->path) > base_length)
 247                         {
 248                         buf = fd->path + base_length;
 249                         }
 250                 else
 251                         {
 252                         buf = "...";
 253                         }
 254                 gtk_entry_set_text(GTK_ENTRY(cm->entry), buf);
 255                 }
 256
 257         return TRUE;
 258 }
 259
 260 static void cache_maintain_home_close_cb(GenericDialog *gd, gpointer data)
 261 {
 262         CMData *cm = data;
 263
 264         if (!gtk_widget_get_sensitive(cm->button_close)) return;
 265
 266         cache_maintain_home_close(cm);
 267 }
 268
 269 static void cache_maintain_home_stop_cb(GenericDialog *gd, gpointer data)
 270 {
 271         CMData *cm = data;
 272
 273         cache_maintain_home_stop(cm);
 274 }
 275
 276 /* sorry for complexity (cm->done_list), but need it to remove empty dirs */
 277 void cache_maintain_home(gboolean metadata, gboolean clear, GtkWidget *parent)
 278 {
 279         CMData *cm;
 280         GList *dlist;
 281         FileData *dir_fd;
 282         const gchar *msg;
 283         const gchar *cache_folder;
 284         GtkWidget *hbox;
 285
 286         if (metadata)
 287                 {
 288                 cache_folder = get_metadata_cache_dir();
 289                 }
 290         else
 291                 {
 292                 cache_folder = get_thumbnails_cache_dir();
 293                 }
 294
 295         dir_fd = file_data_new_dir(cache_folder);
 296         if (!filelist_read(dir_fd, NULL, &dlist))
 297                 {
 298                 file_data_unref(dir_fd);
 299                 return;
 300                 }
 301
 302         dlist = g_list_append(dlist, dir_fd);
 303
 304         cm = g_new0(CMData, 1);
 305         cm->list = dlist;
 306         cm->done_list = NULL;
 307         cm->clear = clear;
 308         cm->metadata = metadata;
 309         cm->remote = FALSE;
 310
 311         if (metadata)
 312                 {
 313                 msg = _("Removing old metadata...");
 314                 }
 315         else if (clear)
 316                 {
 317                 msg = _("Clearing cached thumbnails...");
 318                 }
 319         else
 320                 {
 321                 msg = _("Removing old thumbnails...");
 322                 }
 323
 324         cm->gd = generic_dialog_new(_("Maintenance"),
 325                                     "main_maintenance",
 326                                     parent, FALSE,
 327                                     NULL, cm);
 328         cm->gd->cancel_cb = cache_maintain_home_close_cb;
 329         cm->button_close = generic_dialog_add_button(cm->gd, GTK_STOCK_CLOSE, NULL,
 330                                                      cache_maintain_home_close_cb, FALSE);
 331         gtk_widget_set_sensitive(cm->button_close, FALSE);
 332         cm->button_stop = generic_dialog_add_button(cm->gd, GTK_STOCK_STOP, NULL,
 333                                                     cache_maintain_home_stop_cb, FALSE);
 334
 335         generic_dialog_add_message(cm->gd, NULL, msg, NULL);
 336         gtk_window_set_default_size(GTK_WINDOW(cm->gd->dialog), PURGE_DIALOG_WIDTH, -1);
 337
 338         hbox = gtk_hbox_new(FALSE, 0);
 339         gtk_box_pack_start(GTK_BOX(cm->gd->vbox), hbox, FALSE, FALSE, 5);
 340         gtk_widget_show(hbox);
 341
 342         cm->entry = gtk_entry_new();
 343         gtk_widget_set_can_focus(cm->entry, FALSE);
 344         gtk_editable_set_editable(GTK_EDITABLE(cm->entry), FALSE);
 345         gtk_box_pack_start(GTK_BOX(hbox), cm->entry, TRUE, TRUE, 0);
 346         gtk_widget_show(cm->entry);
 347
 348         cm->spinner = spinner_new(NULL, SPINNER_SPEED);
 349         gtk_box_pack_start(GTK_BOX(hbox), cm->spinner, FALSE, FALSE, 0);
 350         gtk_widget_show(cm->spinner);
 351
 352         gtk_widget_show(cm->gd->dialog);
 353
 354         cm->idle_id = g_idle_add(cache_maintain_home_cb, cm);
 355 }
 356
 357 void cache_maintain_home_remote(gboolean metadata, gboolean clear)
 358 {
 359         CMData *cm;
 360         GList *dlist;
 361         FileData *dir_fd;
 362         const gchar *cache_folder;
 363
 364         if (metadata)
 365                 {
 366                 cache_folder = get_metadata_cache_dir();
 367                 }
 368         else
 369                 {
 370                 cache_folder = get_thumbnails_cache_dir();
 371                 }
 372
 373         dir_fd = file_data_new_dir(cache_folder);
 374         if (!filelist_read(dir_fd, NULL, &dlist))
 375                 {
 376                 file_data_unref(dir_fd);
 377                 return;
 378                 }
 379
 380         dlist = g_list_append(dlist, dir_fd);
 381
 382         cm = g_new0(CMData, 1);
 383         cm->list = dlist;
 384         cm->done_list = NULL;
 385         cm->clear = clear;
 386         cm->metadata = metadata;
 387         cm->remote = TRUE;
 388
 389         cm->idle_id = g_idle_add(cache_maintain_home_cb, cm);
 390 }
 391
 392 static void cache_file_move(const gchar *src, const gchar *dest)
 393 {
 394         if (!dest || !src || !isfile(src)) return;
 395
 396         if (!move_file(src, dest))
 397                 {
 398                 DEBUG_1("Failed to move cache file \"%s\" to \"%s\"", src, dest);
 399                 /* we remove it anyway - it's stale */
 400                 unlink_file(src);
 401                 }
 402 }
 403
 404 static void cache_maint_moved(FileData *fd)
 405 {
 406         gchar *base;
 407         mode_t mode = 0755;
 408         const gchar *src = fd->change->source;
 409         const gchar *dest = fd->change->dest;
 410
 411         if (!src || !dest) return;
 412
 413         base = cache_get_location(CACHE_TYPE_THUMB, dest, FALSE, &mode);
 414         if (recursive_mkdir_if_not_exists(base, mode))
 415                 {
 416                 gchar *buf;
 417                 gchar *d;
 418
 419                 buf = cache_find_location(CACHE_TYPE_THUMB, src);
 420                 d = cache_get_location(CACHE_TYPE_THUMB, dest, TRUE, NULL);
 421                 cache_file_move(buf, d);
 422                 g_free(d);
 423                 g_free(buf);
 424
 425                 buf = cache_find_location(CACHE_TYPE_SIM, src);
 426                 d = cache_get_location(CACHE_TYPE_SIM, dest, TRUE, NULL);
 427                 cache_file_move(buf, d);
 428                 g_free(d);
 429                 g_free(buf);
 430                 }
 431         else
 432                 {
 433                 log_printf("Failed to create cache dir for move %s\n", base);
 434                 }
 435         g_free(base);
 436
 437         base = cache_get_location(CACHE_TYPE_METADATA, dest, FALSE, &mode);
 438         if (recursive_mkdir_if_not_exists(base, mode))
 439                 {
 440                 gchar *buf;
 441                 gchar *d;
 442
 443                 buf = cache_find_location(CACHE_TYPE_METADATA, src);
 444                 d = cache_get_location(CACHE_TYPE_METADATA, dest, TRUE, NULL);
 445                 cache_file_move(buf, d);
 446                 g_free(d);
 447                 g_free(buf);
 448                 }
 449         g_free(base);
 450
 451         if (options->thumbnails.enable_caching && options->thumbnails.spec_standard)
 452                 thumb_std_maint_moved(src, dest);
 453 }
 454
 455 static void cache_file_remove(const gchar *path)
 456 {
 457         if (path && isfile(path) && !unlink_file(path))
 458                 {
 459                 DEBUG_1("Failed to remove cache file %s", path);
 460                 }
 461 }
 462
 463 static void cache_maint_removed(FileData *fd)
 464 {
 465         gchar *buf;
 466
 467         buf = cache_find_location(CACHE_TYPE_THUMB, fd->path);
 468         cache_file_remove(buf);
 469         g_free(buf);
 470
 471         buf = cache_find_location(CACHE_TYPE_SIM, fd->path);
 472         cache_file_remove(buf);
 473         g_free(buf);
 474
 475         buf = cache_find_location(CACHE_TYPE_METADATA, fd->path);
 476         cache_file_remove(buf);
 477         g_free(buf);
 478
 479         if (options->thumbnails.enable_caching && options->thumbnails.spec_standard)
 480                 thumb_std_maint_removed(fd->path);
 481 }
 482
 483 static void cache_maint_copied(FileData *fd)
 484 {
 485         gchar *dest_base;
 486         gchar *src_cache;
 487         mode_t mode = 0755;
 488
 489         src_cache = cache_find_location(CACHE_TYPE_METADATA, fd->change->source);
 490         if (!src_cache) return;
 491
 492         dest_base = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, FALSE, &mode);
 493         if (recursive_mkdir_if_not_exists(dest_base, mode))
 494                 {
 495                 gchar *path;
 496
 497                 path = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, TRUE, NULL);
 498                 if (!copy_file(src_cache, path))
 499                         {
 500                         DEBUG_1("failed to copy metadata %s to %s", src_cache, path);
 501                         }
 502                 g_free(path);
 503                 }
 504
 505         g_free(dest_base);
 506         g_free(src_cache);
 507 }
 508
 509 void cache_notify_cb(FileData *fd, NotifyType type, gpointer data)
 510 {
 511         if (!(type & NOTIFY_CHANGE) || !fd->change) return;
 512
 513         DEBUG_1("Notify cache_maint: %s %04x", fd->path, type);
 514         switch (fd->change->type)
 515                 {
 516                 case FILEDATA_CHANGE_MOVE:
 517                 case FILEDATA_CHANGE_RENAME:
 518                         cache_maint_moved(fd);
 519                         break;
 520                 case FILEDATA_CHANGE_COPY:
 521                         cache_maint_copied(fd);
 522                         break;
 523                 case FILEDATA_CHANGE_DELETE:
 524                         cache_maint_removed(fd);
 525                         break;
 526                 case FILEDATA_CHANGE_UNSPECIFIED:
 527                 case FILEDATA_CHANGE_WRITE_METADATA:
 528                         break;
 529                 }
 530 }
 531
 532
 533 /*
 534  *-------------------------------------------------------------------
 535  * new cache maintenance utilities
 536  *-------------------------------------------------------------------
 537  */
 538
 539 typedef struct _CacheManager CacheManager;
 540 struct _CacheManager
 541 {
 542         GenericDialog *dialog;
 543         GtkWidget *folder_entry;
 544         GtkWidget *progress;
 545
 546         GList *list_todo;
 547
 548         gint count_total;
 549         gint count_done;
 550 };
 551
 552 typedef struct _CleanData CleanData;
 553 struct _CleanData
 554 {
 555         GenericDialog *gd;
 556         ThumbLoaderStd *tl;
 557
 558         GList *list;
 559         GList *list_dir;
 560
 561         gint days;
 562         gboolean clear;
 563
 564         GtkWidget *button_close;
 565         GtkWidget *button_stop;
 566         GtkWidget *button_start;
 567         GtkWidget *progress;
 568         GtkWidget *spinner;
 569
 570         GtkWidget *group;
 571         GtkWidget *entry;
 572
 573         gint count_total;
 574         gint count_done;
 575
 576         gboolean local;
 577         gboolean recurse;
 578
 579         gboolean remote;
 580
 581         guint idle_id; /* event source id */
 582 };
 583
 584 static void cache_manager_render_reset(CleanData *cd)
 585 {
 586         filelist_free(cd->list);
 587         cd->list = NULL;
 588
 589         filelist_free(cd->list_dir);
 590         cd->list_dir = NULL;
 591
 592         thumb_loader_free((ThumbLoader *)cd->tl);
 593         cd->tl = NULL;
 594 }
 595
 596 static void cache_manager_render_close_cb(GenericDialog *fd, gpointer data)
 597 {
 598         CleanData *cd = data;
 599
 600         if (!gtk_widget_get_sensitive(cd->button_close)) return;
 601
 602         cache_manager_render_reset(cd);
 603         generic_dialog_close(cd->gd);
 604         g_free(cd);
 605 }
 606
 607 static void cache_manager_render_finish(CleanData *cd)
 608 {
 609         cache_manager_render_reset(cd);
 610         if (!cd->remote)
 611                 {
 612                 gtk_entry_set_text(GTK_ENTRY(cd->progress), _("done"));
 613                 spinner_set_interval(cd->spinner, -1);
 614
 615                 gtk_widget_set_sensitive(cd->group, TRUE);
 616                 gtk_widget_set_sensitive(cd->button_start, TRUE);
 617                 gtk_widget_set_sensitive(cd->button_stop, FALSE);
 618                 gtk_widget_set_sensitive(cd->button_close, TRUE);
 619                 }
 620 }
 621
 622 static void cache_manager_render_stop_cb(GenericDialog *fd, gpointer data)
 623 {
 624         CleanData *cd = data;
 625
 626         cache_manager_render_finish(cd);
 627 }
 628
 629 static void cache_manager_render_folder(CleanData *cd, FileData *dir_fd)
 630 {
 631         GList *list_d = NULL;
 632         GList *list_f = NULL;
 633
 634         if (cd->recurse)
 635                 {
 636                 filelist_read(dir_fd, &list_f, &list_d);
 637                 }
 638         else
 639                 {
 640                 filelist_read(dir_fd, &list_f, NULL);
 641                 }
 642
 643         list_f = filelist_filter(list_f, FALSE);
 644         list_d = filelist_filter(list_d, TRUE);
 645
 646         cd->list = g_list_concat(list_f, cd->list);
 647         cd->list_dir = g_list_concat(list_d, cd->list_dir);
 648 }
 649
 650 static gboolean cache_manager_render_file(CleanData *cd);
 651
 652 static void cache_manager_render_thumb_done_cb(ThumbLoader *tl, gpointer data)
 653 {
 654         CleanData *cd = data;
 655
 656         thumb_loader_free((ThumbLoader *)cd->tl);
 657         cd->tl = NULL;
 658
 659         while (cache_manager_render_file(cd));
 660 }
 661
 662 static gboolean cache_manager_render_file(CleanData *cd)
 663 {
 664         if (cd->list)
 665                 {
 666                 FileData *fd;
 667                 gint success;
 668
 669                 fd = cd->list->data;
 670                 cd->list = g_list_remove(cd->list, fd);
 671
 672                 cd->tl = (ThumbLoaderStd *)thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
 673                 thumb_loader_set_callbacks((ThumbLoader *)cd->tl,
 674                                            cache_manager_render_thumb_done_cb,
 675                                            cache_manager_render_thumb_done_cb,
 676                                            NULL, cd);
 677                 thumb_loader_set_cache((ThumbLoader *)cd->tl, TRUE, cd->local, TRUE);
 678                 success = thumb_loader_start((ThumbLoader *)cd->tl, fd);
 679                 if (success)
 680                         {
 681                         if (!cd->remote)
 682                                 {
 683                                 gtk_entry_set_text(GTK_ENTRY(cd->progress), fd->path);
 684                                 }
 685                         }
 686                 else
 687                         {
 688                         thumb_loader_free((ThumbLoader *)cd->tl);
 689                         cd->tl = NULL;
 690                         }
 691
 692                 file_data_unref(fd);
 693
 694                 return (!success);
 695                 }
 696         else if (cd->list_dir)
 697                 {
 698                 FileData *fd;
 699
 700                 fd = cd->list_dir->data;
 701                 cd->list_dir = g_list_remove(cd->list_dir, fd);
 702
 703                 cache_manager_render_folder(cd, fd);
 704
 705                 file_data_unref(fd);
 706
 707                 return TRUE;
 708                 }
 709
 710         cache_manager_render_finish(cd);
 711
 712         return FALSE;
 713 }
 714
 715 static void cache_manager_render_start_cb(GenericDialog *fd, gpointer data)
 716 {
 717         CleanData *cd = data;
 718         gchar *path;
 719
 720         if(!cd->remote)
 721                 {
 722                 if (cd->list || !gtk_widget_get_sensitive(cd->button_start)) return;
 723                 }
 724
 725         path = remove_trailing_slash((gtk_entry_get_text(GTK_ENTRY(cd->entry))));
 726         parse_out_relatives(path);
 727
 728         if (!isdir(path))
 729                 {
 730                 if (!cd->remote)
 731                         {
 732                         warning_dialog(_("Invalid folder"),
 733                         _("The specified folder can not be found."),
 734                         GTK_STOCK_DIALOG_WARNING, cd->gd->dialog);
 735                         }
 736                 else
 737                         {
 738                         log_printf("The specified folder can not be found: %s\n", path);
 739                         }
 740                 }
 741         else
 742                 {
 743                 FileData *dir_fd;
 744                 if(!cd->remote)
 745                         {
 746                         gtk_widget_set_sensitive(cd->group, FALSE);
 747                         gtk_widget_set_sensitive(cd->button_start, FALSE);
 748                         gtk_widget_set_sensitive(cd->button_stop, TRUE);
 749                         gtk_widget_set_sensitive(cd->button_close, FALSE);
 750
 751                         spinner_set_interval(cd->spinner, SPINNER_SPEED);
 752                         }
 753                 dir_fd = file_data_new_dir(path);
 754                 cache_manager_render_folder(cd, dir_fd);
 755                 file_data_unref(dir_fd);
 756                 while (cache_manager_render_file(cd));
 757                 }
 758
 759         g_free(path);
 760 }
 761
 762 static void cache_manager_render_start_render_remote(CleanData *cd, const gchar *user_path)
 763 {
 764         gchar *path;
 765
 766         path = remove_trailing_slash(user_path);
 767         parse_out_relatives(path);
 768
 769         if (!isdir(path))
 770                 {
 771                 log_printf("The specified folder can not be found: %s\n", path);
 772                 }
 773         else
 774                 {
 775                 FileData *dir_fd;
 776
 777                 dir_fd = file_data_new_dir(path);
 778                 cache_manager_render_folder(cd, dir_fd);
 779                 file_data_unref(dir_fd);
 780                 while (cache_manager_render_file(cd));
 781                 }
 782
 783         g_free(path);
 784 }
 785
 786 static void cache_manager_render_dialog(GtkWidget *widget, const gchar *path)
 787 {
 788         CleanData *cd;
 789         GtkWidget *hbox;
 790         GtkWidget *label;
 791         GtkWidget *button;
 792
 793         cd = g_new0(CleanData, 1);
 794         cd->remote = FALSE;
 795
 796         cd->gd = generic_dialog_new(_("Create thumbnails"),
 797                                     "create_thumbnails",
 798                                     widget, FALSE,
 799                                     NULL, cd);
 800         gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
 801         cd->gd->cancel_cb = cache_manager_render_close_cb;
 802         cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
 803                                                      cache_manager_render_close_cb, FALSE);
 804         cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
 805                                                      cache_manager_render_start_cb, FALSE);
 806         cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
 807                                                     cache_manager_render_stop_cb, FALSE);
 808         gtk_widget_set_sensitive(cd->button_stop, FALSE);
 809
 810         generic_dialog_add_message(cd->gd, NULL, _("Create thumbnails"), NULL);
 811
 812         hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
 813         pref_spacer(hbox, PREF_PAD_INDENT);
 814         cd->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
 815
 816         hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 817         pref_label_new(hbox, _("Folder:"));
 818
 819         label = tab_completion_new(&cd->entry, path, NULL, NULL);
 820         tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
 821         gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
 822         gtk_widget_show(label);
 823
 824         pref_checkbox_new_int(cd->group, _("Include subfolders"), FALSE, &cd->recurse);
 825         button = pref_checkbox_new_int(cd->group, _("Store thumbnails local to source images"), FALSE, &cd->local);
 826         gtk_widget_set_sensitive(button, options->thumbnails.spec_standard);
 827
 828         pref_line(cd->gd->vbox, PREF_PAD_SPACE);
 829         hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 830
 831         cd->progress = gtk_entry_new();
 832         gtk_widget_set_can_focus(cd->progress, FALSE);
 833         gtk_editable_set_editable(GTK_EDITABLE(cd->progress), FALSE);
 834         gtk_entry_set_text(GTK_ENTRY(cd->progress), _("click start to begin"));
 835         gtk_box_pack_start(GTK_BOX(hbox), cd->progress, TRUE, TRUE, 0);
 836         gtk_widget_show(cd->progress);
 837
 838         cd->spinner = spinner_new(NULL, -1);
 839         gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
 840         gtk_widget_show(cd->spinner);
 841
 842         cd->list = NULL;
 843
 844         gtk_widget_show(cd->gd->dialog);
 845 }
 846
 847 void cache_manager_render_remote(const gchar *path, gboolean recurse, gboolean local)
 848 {
 849         CleanData *cd;
 850
 851         cd = g_new0(CleanData, 1);
 852         cd->recurse = recurse;
 853         cd->local = local;
 854         cd->remote = TRUE;
 855
 856         cache_manager_render_start_render_remote(cd, path);
 857 }
 858
 859 static void cache_manager_standard_clean_close_cb(GenericDialog *gd, gpointer data)
 860 {
 861         CleanData *cd = data;
 862
 863         if (!gtk_widget_get_sensitive(cd->button_close)) return;
 864
 865         generic_dialog_close(cd->gd);
 866
 867         thumb_loader_std_thumb_file_validate_cancel(cd->tl);
 868         filelist_free(cd->list);
 869         g_free(cd);
 870 }
 871
 872 static void cache_manager_standard_clean_done(CleanData *cd)
 873 {
 874         if (!cd->remote)
 875                 {
 876                 gtk_widget_set_sensitive(cd->button_stop, FALSE);
 877                 gtk_widget_set_sensitive(cd->button_close, TRUE);
 878
 879                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress), 1.0);
 880                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("done"));
 881                 }
 882         if (cd->idle_id)
 883                 {
 884                 g_source_remove(cd->idle_id);
 885                 cd->idle_id = 0;
 886                 }
 887
 888         thumb_loader_std_thumb_file_validate_cancel(cd->tl);
 889         cd->tl = NULL;
 890
 891         filelist_free(cd->list);
 892         cd->list = NULL;
 893 }
 894
 895 static void cache_manager_standard_clean_stop_cb(GenericDialog *gd, gpointer data)
 896 {
 897         CleanData *cd = data;
 898
 899         cache_manager_standard_clean_done(cd);
 900 }
 901
 902 static gint cache_manager_standard_clean_clear_cb(gpointer data)
 903 {
 904         CleanData *cd = data;
 905
 906         if (cd->list)
 907                 {
 908                 FileData *next_fd;
 909
 910                 next_fd = cd->list->data;
 911                 cd->list = g_list_remove(cd->list, next_fd);
 912
 913                 DEBUG_1("thumb removed: %s", next_fd->path);
 914
 915                 unlink_file(next_fd->path);
 916                 file_data_unref(next_fd);
 917
 918                 cd->count_done++;
 919                 if (!cd->remote)
 920                         {
 921                         if (cd->count_total != 0)
 922                                 {
 923                                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
 924                                                               (gdouble)cd->count_done / cd->count_total);
 925                                 }
 926                         }
 927
 928                 return TRUE;
 929                 }
 930
 931         cd->idle_id = 0;
 932         cache_manager_standard_clean_done(cd);
 933         return FALSE;
 934 }
 935
 936 static void cache_manager_standard_clean_valid_cb(const gchar *path, gboolean valid, gpointer data)
 937 {
 938         CleanData *cd = data;
 939
 940         if (path)
 941                 {
 942                 if (!valid)
 943                         {
 944                         DEBUG_1("thumb cleaned: %s", path);
 945                         unlink_file(path);
 946                         }
 947
 948                 cd->count_done++;
 949                 if (!cd->remote)
 950                         {
 951                         if (cd->count_total != 0)
 952                                 {
 953                                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
 954                                                               (gdouble)cd->count_done / cd->count_total);
 955                                 }
 956                         }
 957                 }
 958
 959         cd->tl = NULL;
 960         if (cd->list)
 961                 {
 962                 FileData *next_fd;
 963
 964                 next_fd = cd->list->data;
 965                 cd->list = g_list_remove(cd->list, next_fd);
 966
 967                 cd->tl = thumb_loader_std_thumb_file_validate(next_fd->path, cd->days,
 968                                                               cache_manager_standard_clean_valid_cb, cd);
 969                 file_data_unref(next_fd);
 970                 }
 971         else
 972                 {
 973                 cache_manager_standard_clean_done(cd);
 974                 }
 975 }
 976
 977 static void cache_manager_standard_clean_start(GenericDialog *gd, gpointer data)
 978 {
 979         CleanData *cd = data;
 980         GList *list;
 981         gchar *path;
 982         FileData *dir_fd;
 983
 984         if (!cd->remote)
 985         {
 986                 if (cd->list || !gtk_widget_get_sensitive(cd->button_start)) return;
 987
 988                 gtk_widget_set_sensitive(cd->button_start, FALSE);
 989                 gtk_widget_set_sensitive(cd->button_stop, TRUE);
 990                 gtk_widget_set_sensitive(cd->button_close, FALSE);
 991
 992                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("running..."));
 993         }
 994
 995         path = g_build_filename(homedir(), THUMB_FOLDER_GLOBAL, THUMB_FOLDER_NORMAL, NULL);
 996         dir_fd = file_data_new_dir(path);
 997         filelist_read(dir_fd, &list, NULL);
 998         cd->list = list;
 999         file_data_unref(dir_fd);
1000         g_free(path);
1001
1002         path = g_build_filename(homedir(), THUMB_FOLDER_GLOBAL, THUMB_FOLDER_LARGE, NULL);
1003         dir_fd = file_data_new_dir(path);
1004         filelist_read(dir_fd, &list, NULL);
1005         cd->list = g_list_concat(cd->list, list);
1006         file_data_unref(dir_fd);
1007         g_free(path);
1008
1009         path = g_build_filename(homedir(), THUMB_FOLDER_GLOBAL, THUMB_FOLDER_FAIL, NULL);
1010         dir_fd = file_data_new_dir(path);
1011         filelist_read(dir_fd, &list, NULL);
1012         cd->list = g_list_concat(cd->list, list);
1013         file_data_unref(dir_fd);
1014         g_free(path);
1015
1016         cd->count_total = g_list_length(cd->list);
1017         cd->count_done = 0;
1018
1019         /* start iterating */
1020         if (cd->clear)
1021                 {
1022                 cd->idle_id = g_idle_add(cache_manager_standard_clean_clear_cb, cd);
1023                 }
1024         else
1025                 {
1026                 cache_manager_standard_clean_valid_cb(NULL, TRUE, cd);
1027                 }
1028 }
1029
1030 static void cache_manager_standard_clean_start_cb(GenericDialog *gd, gpointer data)
1031 {
1032         cache_manager_standard_clean_start(gd, data);
1033 }
1034
1035 static void cache_manager_standard_process(GtkWidget *widget, gboolean clear)
1036 {
1037         CleanData *cd;
1038         const gchar *stock_id;
1039         const gchar *msg;
1040
1041         cd = g_new0(CleanData, 1);
1042         cd->clear = clear;
1043         cd->remote = FALSE;
1044
1045         if (clear)
1046                 {
1047                 stock_id = GTK_STOCK_DELETE;
1048                 msg = _("Clearing thumbnails...");
1049                 }
1050         else
1051                 {
1052                 stock_id = GTK_STOCK_CLEAR;
1053                 msg = _("Removing old thumbnails...");
1054                 }
1055
1056         cd->gd = generic_dialog_new(_("Maintenance"),
1057                                     "standard_maintenance",
1058                                     widget, FALSE,
1059                                     NULL, cd);
1060         cd->gd->cancel_cb = cache_manager_standard_clean_close_cb;
1061         cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
1062                                                      cache_manager_standard_clean_close_cb, FALSE);
1063         cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
1064                                                      cache_manager_standard_clean_start_cb, FALSE);
1065         cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
1066                                                     cache_manager_standard_clean_stop_cb, FALSE);
1067         gtk_widget_set_sensitive(cd->button_stop, FALSE);
1068
1069         generic_dialog_add_message(cd->gd, stock_id, msg, NULL);
1070
1071         cd->progress = gtk_progress_bar_new();
1072         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("click start to begin"));
1073 #if GTK_CHECK_VERSION(3,0,0)
1074         gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(cd->progress), TRUE);
1075 #endif
1076         gtk_box_pack_start(GTK_BOX(cd->gd->vbox), cd->progress, FALSE, FALSE, 0);
1077         gtk_widget_show(cd->progress);
1078
1079         cd->days = 30;
1080         cd->tl = NULL;
1081         cd->idle_id = 0;
1082
1083         gtk_widget_show(cd->gd->dialog);
1084 }
1085
1086 void cache_manager_standard_process_remote(gboolean clear)
1087 {
1088         CleanData *cd;
1089
1090         cd = g_new0(CleanData, 1);
1091         cd->clear = clear;
1092         cd->days = 30;
1093         cd->tl = NULL;
1094         cd->idle_id = 0;
1095         cd->remote = TRUE;
1096
1097         cache_manager_standard_clean_start(NULL, cd);
1098 }
1099
1100 static void cache_manager_standard_clean_cb(GtkWidget *widget, gpointer data)
1101 {
1102         cache_manager_standard_process(widget, FALSE);
1103 }
1104
1105 static void cache_manager_standard_clear_cb(GtkWidget *widget, gpointer data)
1106 {
1107         cache_manager_standard_process(widget, TRUE);
1108 }
1109
1110
1111 static void cache_manager_main_clean_cb(GtkWidget *widget, gpointer data)
1112 {
1113         cache_maintain_home(FALSE, FALSE, widget);
1114 }
1115
1116
1117 static void dummy_cancel_cb(GenericDialog *gd, gpointer data)
1118 {
1119         /* no op, only so cancel button appears */
1120 }
1121
1122 static void cache_manager_main_clear_ok_cb(GenericDialog *gd, gpointer data)
1123 {
1124         cache_maintain_home(FALSE, TRUE, NULL);
1125 }
1126
1127 void cache_manager_main_clear_confirm(GtkWidget *parent)
1128 {
1129         GenericDialog *gd;
1130
1131         gd = generic_dialog_new(_("Clear cache"),
1132                                 "clear_cache", parent, TRUE,
1133                                 dummy_cancel_cb, NULL);
1134         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Clear cache"),
1135                                    _("This will remove all thumbnails that have\nbeen saved to disk, continue?"));
1136         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, cache_manager_main_clear_ok_cb, TRUE);
1137
1138         gtk_widget_show(gd->dialog);
1139 }
1140
1141 static void cache_manager_main_clear_cb(GtkWidget *widget, gpointer data)
1142 {
1143         cache_manager_main_clear_confirm(widget);
1144 }
1145
1146 static void cache_manager_render_cb(GtkWidget *widget, gpointer data)
1147 {
1148         const gchar *path = layout_get_path(NULL);
1149
1150         if (!path || !*path) path = homedir();
1151         cache_manager_render_dialog(widget, path);
1152 }
1153
1154 static void cache_manager_metadata_clean_cb(GtkWidget *widget, gpointer data)
1155 {
1156         cache_maintain_home(TRUE, FALSE, widget);
1157 }
1158
1159
1160 static CacheManager *cache_manager = NULL;
1161
1162 static void cache_manager_close_cb(GenericDialog *gd, gpointer data)
1163 {
1164         generic_dialog_close(gd);
1165
1166         g_free(cache_manager);
1167         cache_manager = NULL;
1168 }
1169
1170 static void cache_manager_help_cb(GenericDialog *gd, gpointer data)
1171 {
1172         help_window_show("GuideReferenceManagement.html");
1173 }
1174
1175 static GtkWidget *cache_manager_location_label(GtkWidget *group, const gchar *subdir)
1176 {
1177         GtkWidget *label;
1178         gchar *buf;
1179
1180         buf = g_strdup_printf(_("Location: %s"), subdir);
1181         label = pref_label_new(group, buf);
1182         g_free(buf);
1183         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1184
1185         return label;
1186 }
1187
1188 void cache_manager_show(void)
1189 {
1190         GenericDialog *gd;
1191         GtkWidget *group;
1192         GtkWidget *button;
1193         GtkWidget *table;
1194         GtkSizeGroup *sizegroup;
1195         gchar *path;
1196
1197         if (cache_manager)
1198                 {
1199                 gtk_window_present(GTK_WINDOW(cache_manager->dialog->dialog));
1200                 return;
1201                 }
1202
1203         cache_manager = g_new0(CacheManager, 1);
1204
1205         cache_manager->dialog = generic_dialog_new(_("Cache Maintenance"),
1206                                                    "cache_manager",
1207                                                    NULL, FALSE,
1208                                                    NULL, cache_manager);
1209         gd = cache_manager->dialog;
1210
1211         gd->cancel_cb = cache_manager_close_cb;
1212         generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL,
1213                                   cache_manager_close_cb, FALSE);
1214         generic_dialog_add_button(gd, GTK_STOCK_HELP, NULL,
1215                                   cache_manager_help_cb, FALSE);
1216
1217         generic_dialog_add_message(gd, NULL, _("Cache and Data Maintenance"), NULL);
1218
1219         sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1220
1221         group = pref_group_new(gd->vbox, FALSE, _("Thumbnail cache"), GTK_ORIENTATION_VERTICAL);
1222
1223         cache_manager_location_label(group, get_thumbnails_cache_dir());
1224
1225         table = pref_table_new(group, 2, 2, FALSE, FALSE);
1226
1227         button = pref_table_button(table, 0, 0, GTK_STOCK_CLEAR, _("Clean up"), FALSE,
1228                                    G_CALLBACK(cache_manager_main_clean_cb), cache_manager);
1229         gtk_size_group_add_widget(sizegroup, button);
1230         pref_table_label(table, 1, 0, _("Remove orphaned or outdated thumbnails."), 0.0);
1231
1232         button = pref_table_button(table, 0, 1, GTK_STOCK_DELETE, _("Clear cache"), FALSE,
1233                                    G_CALLBACK(cache_manager_main_clear_cb), cache_manager);
1234         gtk_size_group_add_widget(sizegroup, button);
1235         pref_table_label(table, 1, 1, _("Delete all cached data."), 0.0);
1236
1237
1238         group = pref_group_new(gd->vbox, FALSE, _("Shared thumbnail cache"), GTK_ORIENTATION_VERTICAL);
1239
1240         path = g_build_filename(homedir(), THUMB_FOLDER_GLOBAL, NULL);
1241         cache_manager_location_label(group, path);
1242         g_free(path);
1243
1244         table = pref_table_new(group, 2, 2, FALSE, FALSE);
1245
1246         button = pref_table_button(table, 0, 0, GTK_STOCK_CLEAR, _("Clean up"), FALSE,
1247                                    G_CALLBACK(cache_manager_standard_clean_cb), cache_manager);
1248         gtk_size_group_add_widget(sizegroup, button);
1249         pref_table_label(table, 1, 0, _("Remove orphaned or outdated thumbnails."), 0.0);
1250
1251         button = pref_table_button(table, 0, 1, GTK_STOCK_DELETE, _("Clear cache"), FALSE,
1252                                    G_CALLBACK(cache_manager_standard_clear_cb), cache_manager);
1253         gtk_size_group_add_widget(sizegroup, button);
1254         pref_table_label(table, 1, 1, _("Delete all cached thumbnails."), 0.0);
1255
1256         group = pref_group_new(gd->vbox, FALSE, _("Create thumbnails"), GTK_ORIENTATION_VERTICAL);
1257
1258         table = pref_table_new(group, 2, 1, FALSE, FALSE);
1259
1260         button = pref_table_button(table, 0, 1, GTK_STOCK_EXECUTE, _("Render"), FALSE,
1261                                    G_CALLBACK(cache_manager_render_cb), cache_manager);
1262         gtk_size_group_add_widget(sizegroup, button);
1263         pref_table_label(table, 1, 1, _("Render thumbnails for a specific folder."), 0.0);
1264
1265         group = pref_group_new(gd->vbox, FALSE, _("Metadata"), GTK_ORIENTATION_VERTICAL);
1266
1267         cache_manager_location_label(group, get_metadata_cache_dir());
1268
1269         table = pref_table_new(group, 2, 1, FALSE, FALSE);
1270
1271         button = pref_table_button(table, 0, 0, GTK_STOCK_CLEAR, _("Clean up"), FALSE,
1272                                    G_CALLBACK(cache_manager_metadata_clean_cb), cache_manager);
1273         gtk_size_group_add_widget(sizegroup, button);
1274         pref_table_label(table, 1, 0, _("Remove orphaned keywords and comments."), 0.0);
1275
1276         gtk_widget_show(cache_manager->dialog->dialog);
1277 }
1278 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */