src/filelist.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  *
   5  * Author: John Ellis
   6  *
   7  * This software is released under the GNU General Public License (GNU GPL).
   8  * Please read the included file COPYING for more information.
   9  * This software comes with no warranty of any kind, use at your own risk!
  10  */
  11
  12
  13 #include "gqview.h"
  14 #include "filelist.h"
  15
  16 #include "cache.h"
  17 #include "rcfile.h"
  18 #include "thumb_standard.h"
  19 #include "ui_fileops.h"
  20
  21
  22 /*
  23  *-----------------------------------------------------------------------------
  24  * file filtering
  25  *-----------------------------------------------------------------------------
  26  */
  27
  28 static GList *filter_list = NULL;
  29 static GList *extension_list = NULL;
  30 static GList *sidecar_ext_list = NULL;
  31
  32 static GList *file_class_extension_list[FILE_FORMAT_CLASSES];
  33
  34
  35 gint ishidden(const gchar *name)
  36 {
  37         if (name[0] != '.') return FALSE;
  38         if (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')) return FALSE;
  39         return TRUE;
  40 }
  41
  42 static FilterEntry *filter_entry_new(const gchar *key, const gchar *description,
  43                                      const gchar *extensions, FileFormatClass file_class, gint enabled)
  44 {
  45         FilterEntry *fe;
  46
  47         fe = g_new0(FilterEntry, 1);
  48         fe->key = g_strdup(key);
  49         fe->description = g_strdup(description);
  50         fe->extensions = g_strdup(extensions);
  51         fe->enabled = enabled;
  52         fe->file_class = file_class;
  53
  54         return fe;
  55 }
  56
  57 static void filter_entry_free(FilterEntry *fe)
  58 {
  59         if (!fe) return;
  60
  61         g_free(fe->key);
  62         g_free(fe->description);
  63         g_free(fe->extensions);
  64         g_free(fe);
  65 }
  66
  67 GList *filter_get_list(void)
  68 {
  69         return filter_list;
  70 }
  71
  72 void filter_remove_entry(FilterEntry *fe)
  73 {
  74         if (!g_list_find(filter_list, fe)) return;
  75
  76         filter_list = g_list_remove(filter_list, fe);
  77         filter_entry_free(fe);
  78 }
  79
  80 static gint filter_key_exists(const gchar *key)
  81 {
  82         GList *work;
  83
  84         if (!key) return FALSE;
  85
  86         work = filter_list;
  87         while (work)
  88                 {
  89                 FilterEntry *fe = work->data;
  90                 work = work->next;
  91
  92                 if (strcmp(fe->key, key) == 0) return TRUE;
  93                 }
  94
  95         return FALSE;
  96 }
  97
  98 void filter_add(const gchar *key, const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled)
  99 {
 100         filter_list = g_list_append(filter_list, filter_entry_new(key, description, extensions, file_class, enabled));
 101 }
 102
 103 void filter_add_unique(const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled)
 104 {
 105         gchar *key;
 106         gint n;
 107
 108         key = g_strdup("user0");
 109         n = 1;
 110         while (filter_key_exists(key))
 111                 {
 112                 g_free(key);
 113                 if (n > 999) return;
 114                 key = g_strdup_printf("user%d", n);
 115                 n++;
 116                 }
 117
 118         filter_add(key, description, extensions, file_class, enabled);
 119         g_free(key);
 120 }
 121
 122 static void filter_add_if_missing(const gchar *key, const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled)
 123 {
 124         GList *work;
 125
 126         if (!key) return;
 127
 128         work = filter_list;
 129         while (work)
 130                 {
 131                 FilterEntry *fe = work->data;
 132                 work = work->next;
 133                 if (fe->key && strcmp(fe->key, key) == 0)
 134                         {
 135                         if (fe->file_class == FORMAT_CLASS_UNKNOWN)
 136                                 fe->file_class = file_class;    /* for compatibility */
 137                         return;
 138                         }
 139                 }
 140
 141         filter_add(key, description, extensions, file_class, enabled);
 142 }
 143
 144 void filter_reset(void)
 145 {
 146         GList *work;
 147
 148         work = filter_list;
 149         while (work)
 150                 {
 151                 FilterEntry *fe = work->data;
 152                 work = work->next;
 153                 filter_entry_free(fe);
 154                 }
 155
 156         g_list_free(filter_list);
 157         filter_list = NULL;
 158 }
 159
 160 void filter_add_defaults(void)
 161 {
 162         GSList *list, *work;
 163
 164         list = gdk_pixbuf_get_formats();
 165         work = list;
 166         while (work)
 167                 {
 168                 GdkPixbufFormat *format;
 169                 gchar *name;
 170                 gchar *desc;
 171                 gchar **extensions;
 172                 GString *filter = NULL;
 173                 gint i;
 174
 175                 format = work->data;
 176                 work = work->next;
 177
 178                 name = gdk_pixbuf_format_get_name(format);
 179                 desc = gdk_pixbuf_format_get_description(format);
 180                 extensions = gdk_pixbuf_format_get_extensions(format);
 181
 182                 i = 0;
 183                 while (extensions[i])
 184                         {
 185                         if (!filter)
 186                                 {
 187                                 filter = g_string_new(".");
 188                                 filter = g_string_append(filter, extensions[i]);
 189                                 }
 190                         else
 191                                 {
 192                                 filter = g_string_append(filter, ";.");
 193                                 filter = g_string_append(filter, extensions[i]);
 194                                 }
 195                         i++;
 196                         }
 197
 198                 if (debug) printf("loader reported [%s] [%s] [%s]\n", name, desc, filter->str);
 199
 200                 filter_add_if_missing(name, desc, filter->str, FORMAT_CLASS_IMAGE, TRUE);
 201
 202                 g_free(name);
 203                 g_free(desc);
 204                 g_strfreev(extensions);
 205                 g_string_free(filter, TRUE);
 206                 }
 207         g_slist_free(list);
 208
 209         /* add defaults even if gdk-pixbuf does not have them, but disabled */
 210         filter_add_if_missing("jpeg", "JPEG group", ".jpg;.jpeg;.jpe", FORMAT_CLASS_IMAGE, FALSE);
 211         filter_add_if_missing("png", "Portable Network Graphic", ".png", FORMAT_CLASS_IMAGE, FALSE);
 212         filter_add_if_missing("tiff", "Tiff", ".tif;.tiff", FORMAT_CLASS_IMAGE, FALSE);
 213         filter_add_if_missing("pnm", "Packed Pixel formats", ".pbm;.pgm;.pnm;.ppm", FORMAT_CLASS_IMAGE, FALSE);
 214         filter_add_if_missing("gif", "Graphics Interchange Format", ".gif", FORMAT_CLASS_IMAGE, FALSE);
 215         filter_add_if_missing("xbm", "X bitmap", ".xbm", FORMAT_CLASS_IMAGE, FALSE);
 216         filter_add_if_missing("xpm", "X pixmap", ".xpm", FORMAT_CLASS_IMAGE, FALSE);
 217         filter_add_if_missing("bmp", "Bitmap", ".bmp", FORMAT_CLASS_IMAGE, FALSE);
 218         filter_add_if_missing("ico", "Icon file", ".ico;.cur", FORMAT_CLASS_IMAGE, FALSE);
 219         filter_add_if_missing("ras", "Raster", ".ras", FORMAT_CLASS_IMAGE, FALSE);
 220         filter_add_if_missing("svg", "Scalable Vector Graphics", ".svg", FORMAT_CLASS_IMAGE, FALSE);
 221
 222         /* non-image files that might be desirable to show */
 223         filter_add_if_missing("xmp", "XMP sidecar", ".xmp", FORMAT_CLASS_META, TRUE);
 224
 225         /* These are the raw camera formats with embedded jpeg/exif.
 226          * (see format_raw.c and/or exiv2.cc)
 227          */
 228         filter_add_if_missing("arw", "Sony raw format", ".arw;.srf;.sr2", FORMAT_CLASS_RAWIMAGE, TRUE);
 229         filter_add_if_missing("crw", "Canon raw format", ".crw;.cr2", FORMAT_CLASS_RAWIMAGE, TRUE);
 230         filter_add_if_missing("kdc", "Kodak raw format", ".kdc;.dcr", FORMAT_CLASS_RAWIMAGE, TRUE);
 231         filter_add_if_missing("raf", "Fujifilm raw format", ".raf", FORMAT_CLASS_RAWIMAGE, TRUE);
 232         filter_add_if_missing("mef", "Mamiya raw format", ".mef;.mos", FORMAT_CLASS_RAWIMAGE, TRUE);
 233         filter_add_if_missing("mrw", "Minolta raw format", ".mrw", FORMAT_CLASS_RAWIMAGE, TRUE);
 234         filter_add_if_missing("nef", "Nikon raw format", ".nef", FORMAT_CLASS_RAWIMAGE, TRUE);
 235         filter_add_if_missing("orf", "Olympus raw format", ".orf", FORMAT_CLASS_RAWIMAGE, TRUE);
 236         filter_add_if_missing("pef", "Pentax raw format", ".pef;.ptx", FORMAT_CLASS_RAWIMAGE, TRUE);
 237         filter_add_if_missing("dng", "Adobe Digital Negative raw format", ".dng", FORMAT_CLASS_RAWIMAGE, TRUE);
 238         filter_add_if_missing("x3f", "Sigma raw format", ".x3f", FORMAT_CLASS_RAWIMAGE, TRUE);
 239         filter_add_if_missing("raw", "Panasonic raw format", ".raw", FORMAT_CLASS_RAWIMAGE, TRUE);
 240         filter_add_if_missing("r3d", "Red raw format", ".r3d", FORMAT_CLASS_RAWIMAGE, TRUE);
 241         filter_add_if_missing("3fr", "Hasselblad raw format", ".3fr", FORMAT_CLASS_RAWIMAGE, TRUE);
 242         filter_add_if_missing("erf", "Epson raw format", ".erf", FORMAT_CLASS_RAWIMAGE, TRUE);
 243 }
 244
 245 GList *filter_to_list(const gchar *extensions)
 246 {
 247         GList *list = NULL;
 248         const gchar *p;
 249
 250         if (!extensions) return NULL;
 251
 252         p = extensions;
 253         while (*p != '\0')
 254                 {
 255                 const gchar *b;
 256                 gint l = 0;
 257
 258                 b = p;
 259                 while (*p != '\0' && *p != ';')
 260                         {
 261                         p++;
 262                         l++;
 263                         }
 264                 list = g_list_append(list, g_strndup(b, l));
 265                 if (*p == ';') p++;
 266                 }
 267
 268         return list;
 269 }
 270
 271 void filter_rebuild(void)
 272 {
 273         GList *work;
 274         gint i;
 275
 276         string_list_free(extension_list);
 277         extension_list = NULL;
 278
 279         for (i = 0; i < FILE_FORMAT_CLASSES; i++)
 280                 {
 281                 string_list_free(file_class_extension_list[i]);
 282                 file_class_extension_list[i] = NULL;
 283                 }
 284
 285         work = filter_list;
 286         while (work)
 287                 {
 288                 FilterEntry *fe;
 289
 290                 fe = work->data;
 291                 work = work->next;
 292
 293                 if (fe->enabled)
 294                         {
 295                         GList *ext;
 296
 297                         ext = filter_to_list(fe->extensions);
 298                         if (ext) extension_list = g_list_concat(extension_list, ext);
 299
 300                         if (fe->file_class >= 0 && fe->file_class < FILE_FORMAT_CLASSES)
 301                                 {
 302                                 ext = filter_to_list(fe->extensions);
 303                                 if (ext) file_class_extension_list[fe->file_class] = g_list_concat(file_class_extension_list[fe->file_class], ext);
 304                                 }
 305                         else
 306                                 {
 307                                 printf("WARNING: invalid file class %d\n", fe->file_class);
 308                                 }
 309                         }
 310                 }
 311 }
 312
 313 gint filter_name_exists(const gchar *name)
 314 {
 315         GList *work;
 316         gint ln;
 317
 318         if (!extension_list || file_filter_disable) return TRUE;
 319
 320         ln = strlen(name);
 321         work = extension_list;
 322         while (work)
 323                 {
 324                 gchar *filter = work->data;
 325                 gint lf = strlen(filter);
 326
 327                 if (ln >= lf)
 328                         {
 329                         if (strncasecmp(name + ln - lf, filter, lf) == 0) return TRUE;
 330                         }
 331                 work = work->next;
 332                 }
 333
 334         return FALSE;
 335 }
 336
 337 gint filter_file_class(const gchar *name, FileFormatClass file_class)
 338 {
 339         GList *work;
 340         gint ln;
 341
 342         if (file_class < 0 || file_class >= FILE_FORMAT_CLASSES)
 343                 {
 344                 printf("WARNING: invalid file class %d\n", file_class);
 345                 return FALSE;
 346                 }
 347
 348         ln = strlen(name);
 349         work = file_class_extension_list[file_class];
 350         while (work)
 351                 {
 352                 gchar *filter = work->data;
 353                 gint lf = strlen(filter);
 354
 355                 if (ln >= lf)
 356                         {
 357                         if (strncasecmp(name + ln - lf, filter, lf) == 0) return TRUE;
 358                         }
 359                 work = work->next;
 360                 }
 361
 362         return FALSE;
 363 }
 364
 365 void filter_write_list(FILE *f)
 366 {
 367         GList *work;
 368
 369         work = filter_list;
 370         while (work)
 371                 {
 372                 FilterEntry *fe = work->data;
 373                 work = work->next;
 374
 375                 gchar *extensions = escquote_value(fe->extensions);
 376                 gchar *description = escquote_value(fe->description);
 377
 378                 fprintf(f, "filter_ext: \"%s%s\" %s %s\n", (fe->enabled) ? "" : "#",
 379                         fe->key, extensions, description);
 380                 g_free(extensions);
 381                 g_free(description);
 382                 }
 383 }
 384
 385 void filter_parse(const gchar *text)
 386 {
 387         const gchar *p;
 388         gchar *key;
 389         gchar *ext;
 390         gchar *desc;
 391         gint enabled = TRUE;
 392
 393         if (!text || text[0] != '"') return;
 394
 395         key = quoted_value(text, &p);
 396         if (!key) return;
 397
 398         ext = quoted_value(p, &p);
 399         desc = quoted_value(p, &p);
 400
 401         if (key && key[0] == '#')
 402                 {
 403                 gchar *tmp;
 404                 tmp = g_strdup(key + 1);
 405                 g_free(key);
 406                 key = tmp;
 407
 408                 enabled = FALSE;
 409                 }
 410
 411         if (key && strlen(key) > 0 && ext) filter_add(key, desc, ext, FORMAT_CLASS_UNKNOWN, enabled);
 412
 413         g_free(key);
 414         g_free(ext);
 415         g_free(desc);
 416 }
 417
 418 GList *path_list_filter(GList *list, gint is_dir_list)
 419 {
 420         GList *work;
 421
 422         if (!is_dir_list && file_filter_disable && show_dot_files) return list;
 423
 424         work = list;
 425         while (work)
 426                 {
 427                 gchar *name = work->data;
 428                 const gchar *base;
 429
 430                 base = filename_from_path(name);
 431
 432                 if ((!show_dot_files && ishidden(base)) ||
 433                     (!is_dir_list && !filter_name_exists(base)) ||
 434                     (is_dir_list && base[0] == '.' && (strcmp(base, GQVIEW_CACHE_LOCAL_THUMB) == 0 ||
 435                                                        strcmp(base, GQVIEW_CACHE_LOCAL_METADATA) == 0)) )
 436                         {
 437                         GList *link = work;
 438                         work = work->next;
 439                         list = g_list_remove_link(list, link);
 440                         g_free(name);
 441                         g_list_free(link);
 442                         }
 443                 else
 444                         {
 445                         work = work->next;
 446                         }
 447                 }
 448
 449         return list;
 450 }
 451
 452
 453 /*
 454  *-----------------------------------------------------------------------------
 455  * sidecar extension list
 456  *-----------------------------------------------------------------------------
 457  */
 458
 459 static GList *sidecar_ext_get_list(void)
 460 {
 461         return sidecar_ext_list;
 462 }
 463
 464 void sidecar_ext_parse(const gchar *text, gint quoted)
 465 {
 466         GList *work;
 467         gchar *value;
 468
 469         work = sidecar_ext_list;
 470         while (work)
 471                 {
 472                 gchar *ext = work->data;
 473                 work = work->next;
 474                 g_free(ext);
 475                 }
 476         g_list_free(sidecar_ext_list);
 477         sidecar_ext_list = NULL;
 478
 479         if (quoted)
 480                 value = quoted_value(text, NULL);
 481         else
 482                 value = g_strdup(text);
 483
 484         if (value == NULL) return;
 485
 486         sidecar_ext_list = filter_to_list(value);
 487
 488         g_free(value);
 489 }
 490
 491 void sidecar_ext_write(FILE *f)
 492 {
 493         GList *work;
 494         fprintf(f, "\nsidecar_ext: \"%s\"\n", sidecar_ext_to_string());
 495 }
 496
 497 char *sidecar_ext_to_string()
 498 {
 499         GList *work;
 500         GString *str = g_string_new("");
 501
 502         work = sidecar_ext_list;
 503         while (work)
 504                 {
 505                 gchar *ext = work->data;
 506                 work = work->next;
 507                 g_string_append(str, ext);
 508                 if (work) g_string_append(str, ";");
 509                 }
 510         return g_string_free(str, FALSE);
 511 }
 512
 513 void sidecar_ext_add_defaults()
 514 {
 515         sidecar_ext_parse(".jpg;.cr2;.nef;.crw;.xmp", FALSE);
 516 }
 517
 518 /*
 519  *-----------------------------------------------------------------------------
 520  * path list recursive
 521  *-----------------------------------------------------------------------------
 522  */
 523
 524 static gint path_list_sort_cb(gconstpointer a, gconstpointer b)
 525 {
 526         return CASE_SORT((gchar *)a, (gchar *)b);
 527 }
 528
 529 GList *path_list_sort(GList *list)
 530 {
 531         return g_list_sort(list, path_list_sort_cb);
 532 }
 533
 534 static void path_list_recursive_append(GList **list, GList *dirs)
 535 {
 536         GList *work;
 537
 538         work = dirs;
 539         while (work)
 540                 {
 541                 const gchar *path = work->data;
 542                 GList *f = NULL;
 543                 GList *d = NULL;
 544
 545                 if (path_list(path, &f, &d))
 546                         {
 547                         f = path_list_filter(f, FALSE);
 548                         f = path_list_sort(f);
 549                         *list = g_list_concat(*list, f);
 550
 551                         d = path_list_filter(d, TRUE);
 552                         d = path_list_sort(d);
 553                         path_list_recursive_append(list, d);
 554                         path_list_free(d);
 555                         }
 556
 557                 work = work->next;
 558                 }
 559 }
 560
 561 GList *path_list_recursive(const gchar *path)
 562 {
 563         GList *list = NULL;
 564         GList *d = NULL;
 565
 566         if (!path_list(path, &list, &d)) return NULL;
 567         list = path_list_filter(list, FALSE);
 568         list = path_list_sort(list);
 569
 570         d = path_list_filter(d, TRUE);
 571         d = path_list_sort(d);
 572         path_list_recursive_append(&list, d);
 573         path_list_free(d);
 574
 575         return list;
 576 }
 577
 578 /*
 579  *-----------------------------------------------------------------------------
 580  * text conversion utils
 581  *-----------------------------------------------------------------------------
 582  */
 583
 584 gchar *text_from_size(gint64 size)
 585 {
 586         gchar *a, *b;
 587         gchar *s, *d;
 588         gint l, n, i;
 589
 590         /* what I would like to use is printf("%'d", size)
 591          * BUT: not supported on every libc :(
 592          */
 593         if (size > G_MAXUINT)
 594                 {
 595                 /* the %lld conversion is not valid in all libcs, so use a simple work-around */
 596                 a = g_strdup_printf("%d%09d", (guint)(size / 1000000000), (guint)(size % 1000000000));
 597                 }
 598         else
 599                 {
 600                 a = g_strdup_printf("%d", (guint)size);
 601                 }
 602         l = strlen(a);
 603         n = (l - 1)/ 3;
 604         if (n < 1) return a;
 605
 606         b = g_new(gchar, l + n + 1);
 607
 608         s = a;
 609         d = b;
 610         i = l - n * 3;
 611         while (*s != '\0')
 612                 {
 613                 if (i < 1)
 614                         {
 615                         i = 3;
 616                         *d = ',';
 617                         d++;
 618                         }
 619
 620                 *d = *s;
 621                 s++;
 622                 d++;
 623                 i--;
 624                 }
 625         *d = '\0';
 626
 627         g_free(a);
 628         return b;
 629 }
 630
 631 gchar *text_from_size_abrev(gint64 size)
 632 {
 633         if (size < (gint64)1024)
 634                 {
 635                 return g_strdup_printf(_("%d bytes"), (gint)size);
 636                 }
 637         if (size < (gint64)1048576)
 638                 {
 639                 return g_strdup_printf(_("%.1f K"), (double)size / 1024.0);
 640                 }
 641         if (size < (gint64)1073741824)
 642                 {
 643                 return g_strdup_printf(_("%.1f MB"), (double)size / 1048576.0);
 644                 }
 645
 646         /* to avoid overflowing the double, do division in two steps */
 647         size /= 1048576;
 648         return g_strdup_printf(_("%.1f GB"), (double)size / 1024.0);
 649 }
 650
 651 /* note: returned string is valid until next call to text_from_time() */
 652 const gchar *text_from_time(time_t t)
 653 {
 654         static gchar *ret = NULL;
 655         gchar buf[128];
 656         gint buflen;
 657         struct tm *btime;
 658         GError *error = NULL;
 659
 660         btime = localtime(&t);
 661
 662         /* the %x warning about 2 digit years is not an error */
 663         buflen = strftime(buf, sizeof(buf), "%x %H:%M", btime);
 664         if (buflen < 1) return "";
 665
 666         g_free(ret);
 667         ret = g_locale_to_utf8(buf, buflen, NULL, NULL, &error);
 668         if (error)
 669                 {
 670                 printf("Error converting locale strftime to UTF-8: %s\n", error->message);
 671                 g_error_free(error);
 672                 return "";
 673                 }
 674
 675         return ret;
 676 }
 677
 678 /*
 679  *-----------------------------------------------------------------------------
 680  * file info struct
 681  *-----------------------------------------------------------------------------
 682  */
 683
 684 FileData *file_data_merge_sidecar_files(FileData *target, FileData *source);
 685 static void file_data_check_sidecars(FileData *fd);
 686 FileData *file_data_disconnect_sidecar_file(FileData *target, FileData *sfd);
 687
 688
 689 static void file_data_set_path(FileData *fd, const gchar *path)
 690 {
 691
 692         if (strcmp(path, "/") == 0)
 693                 {
 694                 fd->path = g_strdup(path);
 695                 fd->name = fd->path;
 696                 fd->extension = fd->name + 1;
 697                 return;
 698                 }
 699
 700         fd->path = g_strdup(path);
 701         fd->name = filename_from_path(fd->path);
 702
 703         if (strcmp(fd->name, "..") == 0)
 704                 {
 705                 gchar *dir = remove_level_from_path(path);
 706                 g_free(fd->path);
 707                 fd->path = remove_level_from_path(dir);
 708                 g_free(dir);
 709                 fd->name = "..";
 710                 fd->extension = fd->name + 2;
 711                 return;
 712                 }
 713         else if (strcmp(fd->name, ".") == 0)
 714                 {
 715                 g_free(fd->path);
 716                 fd->path = remove_level_from_path(path);
 717                 fd->name = ".";
 718                 fd->extension = fd->name + 1;
 719                 return;
 720                 }
 721
 722         fd->extension = extension_from_path(fd->path);
 723         if (fd->extension == NULL)
 724                 fd->extension = fd->name + strlen(fd->name);
 725 }
 726
 727 static void file_data_check_changed_files(FileData *fd, struct stat *st)
 728 {
 729         GList *work;
 730         if (fd->size != st->st_size ||
 731             fd->date != st->st_mtime)
 732                 {
 733                 fd->size = st->st_size;
 734                 fd->date = st->st_mtime;
 735                 if (fd->pixbuf) g_object_unref(fd->pixbuf);
 736                 fd->pixbuf = NULL;
 737                 }
 738
 739         work = fd->sidecar_files;
 740         while (work)
 741                 {
 742                 FileData *sfd = work->data;
 743                 struct stat st;
 744
 745                 if (!stat_utf8(sfd->path, &st))
 746                         {
 747                         file_data_disconnect_sidecar_file(fd, sfd);
 748                         }
 749
 750                 file_data_check_changed_files(sfd, &st);
 751                 work = work->next;
 752                 }
 753 }
 754
 755 static GHashTable *file_data_pool = NULL;
 756
 757 static FileData *file_data_new(const gchar *path_utf8, struct stat *st, gboolean check_sidecars)
 758 {
 759         FileData *fd;
 760
 761         if (debug) printf("file_data_new: '%s' %d\n", path_utf8, check_sidecars);
 762
 763         if (!file_data_pool)
 764                 file_data_pool = g_hash_table_new (g_str_hash, g_str_equal);
 765
 766         fd = g_hash_table_lookup(file_data_pool, path_utf8);
 767         if (fd)
 768                 {
 769                 file_data_check_changed_files(fd, st);
 770                 if (debug) printf("file_data_pool hit: '%s'\n", fd->path);
 771                 return file_data_ref(fd);
 772                 }
 773
 774         fd = g_new0(FileData, 1);
 775
 776         file_data_set_path(fd, path_utf8);
 777
 778         fd->original_path = g_strdup(path_utf8);
 779         fd->size = st->st_size;
 780         fd->date = st->st_mtime;
 781         fd->pixbuf = NULL;
 782         fd->sidecar_files = NULL;
 783         fd->ref = 1;
 784         fd->magick = 0x12345678;
 785
 786         g_hash_table_insert(file_data_pool, fd->original_path, fd);
 787
 788         if (check_sidecars && sidecar_file_priority(fd->extension))
 789                 file_data_check_sidecars(fd);
 790         return fd;
 791 }
 792
 793 static void file_data_check_sidecars(FileData *fd)
 794 {
 795         int i = 0;
 796         int base_len = fd->extension - fd->path;
 797         GString *fname = g_string_new_len(fd->path, base_len);
 798         FileData *parent_fd = NULL;
 799         GList *work = sidecar_ext_get_list();
 800         while (work)
 801                 {
 802                 /* check for possible sidecar files;
 803                    the sidecar files created here are referenced only via fd->sidecar_files or fd->parent,
 804                    they have fd->ref set to 0 and file_data unref must chack and free them all together
 805                    (using fd->ref would cause loops and leaks)
 806                 */
 807
 808                 FileData *new_fd;
 809
 810                 gchar *ext = work->data;
 811                 work = work->next;
 812
 813                 if (strcmp(ext, fd->extension) == 0)
 814                         {
 815                         new_fd = fd; /* processing the original file */
 816                         }
 817                 else
 818                         {
 819                         struct stat nst;
 820                         g_string_truncate(fname, base_len);
 821                         g_string_append(fname, ext);
 822
 823                         if (!stat_utf8(fname->str, &nst))
 824                                 continue;
 825
 826                         new_fd = file_data_new(fname->str, &nst, FALSE);
 827                         new_fd->ref--; /* do not use ref here */
 828                         }
 829
 830                 if (!parent_fd)
 831                         parent_fd = new_fd; /* parent is the one with the highest prio, found first */
 832                 else
 833                         file_data_merge_sidecar_files(parent_fd, new_fd);
 834                 }
 835         g_string_free(fname, TRUE);
 836 }
 837
 838
 839 static FileData *file_data_new_local(const gchar *path, struct stat *st, gboolean check_sidecars)
 840 {
 841         gchar *path_utf8 = path_to_utf8(path);
 842         FileData *ret = file_data_new(path_utf8, st, check_sidecars);
 843         g_free(path_utf8);
 844         return ret;
 845 }
 846
 847 FileData *file_data_new_simple(const gchar *path_utf8)
 848 {
 849         struct stat st;
 850
 851         if (!stat_utf8(path_utf8, &st))
 852                 {
 853                 st.st_size = 0;
 854                 st.st_mtime = 0;
 855                 }
 856
 857         return file_data_new(path_utf8, &st, TRUE);
 858 }
 859
 860 FileData *file_data_add_sidecar_file(FileData *target, FileData *sfd)
 861 {
 862         sfd->parent = target;
 863         if(!g_list_find(target->sidecar_files, sfd))
 864                 target->sidecar_files = g_list_prepend(target->sidecar_files, sfd);
 865         return target;
 866 }
 867
 868
 869 FileData *file_data_merge_sidecar_files(FileData *target, FileData *source)
 870 {
 871         GList *work;
 872         file_data_add_sidecar_file(target, source);
 873
 874         work = source->sidecar_files;
 875         while (work)
 876                 {
 877                 FileData *sfd = work->data;
 878                 file_data_add_sidecar_file(target, sfd);
 879                 work = work->next;
 880                 }
 881
 882         g_list_free(source->sidecar_files);
 883         source->sidecar_files = NULL;
 884
 885         target->sidecar_files = filelist_sort(target->sidecar_files, SORT_NAME, TRUE);
 886         return target;
 887 }
 888
 889
 890
 891 FileData *file_data_ref(FileData *fd)
 892 {
 893         if (fd == NULL) return NULL;
 894
 895 //      return g_memdup(fd, sizeof(FileData));
 896         g_assert(fd->magick == 0x12345678);
 897         fd->ref++;
 898         return fd;
 899 }
 900
 901 static void file_data_free(FileData *fd)
 902 {
 903         g_assert(fd->magick == 0x12345678);
 904         g_assert(fd->ref == 0);
 905
 906         g_hash_table_remove(file_data_pool, fd->original_path);
 907
 908         g_free(fd->path);
 909         g_free(fd->original_path);
 910         if (fd->pixbuf) g_object_unref(fd->pixbuf);
 911
 912
 913         g_assert(fd->sidecar_files == NULL); /* sidecar files must be freed before calling this */
 914
 915         file_data_change_info_free(NULL, fd);
 916         g_free(fd);
 917 }
 918
 919 void file_data_unref(FileData *fd)
 920 {
 921         if (fd == NULL) return;
 922         g_assert(fd->magick == 0x12345678);
 923         if (debug) printf("file_data_unref: '%s'\n", fd->path);
 924         fd->ref--;
 925         if (fd->ref == 0)
 926                 {
 927                 FileData *parent = fd->parent ? fd->parent : fd;
 928
 929                 GList *work;
 930
 931                 if (parent->ref > 0)
 932                         return;
 933
 934                 work = parent->sidecar_files;
 935                 while (work)
 936                         {
 937                         FileData *sfd = work->data;
 938                         if (sfd->ref > 0)
 939                                 return;
 940                         work = work->next;
 941                         }
 942
 943                 /* none of parent/children is referenced, we can free everything */
 944
 945                 if (debug) printf("file_data_unref: deleting '%s', parent '%s'\n", fd->path, parent->path);
 946
 947                 work = parent->sidecar_files;
 948                 while (work)
 949                         {
 950                         FileData *sfd = work->data;
 951                         file_data_free(sfd);
 952                         work = work->next;
 953                         }
 954
 955                 g_list_free(parent->sidecar_files);
 956                 parent->sidecar_files = NULL;
 957
 958                 file_data_free(parent);
 959
 960                 }
 961 }
 962
 963 FileData *file_data_disconnect_sidecar_file(FileData *target, FileData *sfd)
 964 {
 965         sfd->parent = target;
 966         g_assert(g_list_find(target->sidecar_files, sfd));
 967
 968         target->sidecar_files = g_list_remove(target->sidecar_files, sfd);
 969         sfd->parent = NULL;
 970
 971         if (sfd->ref == 0) {
 972                 file_data_free(sfd);
 973                 return NULL;
 974         }
 975
 976         return sfd;
 977 }
 978
 979 /* compare name without extension */
 980 gint file_data_compare_name_without_ext(FileData *fd1, FileData *fd2)
 981 {
 982         size_t len1 = fd1->extension - fd1->name;
 983         size_t len2 = fd2->extension - fd2->name;
 984
 985         if (len1 < len2) return -1;
 986         if (len1 > len2) return 1;
 987
 988         return strncmp(fd1->name, fd2->name, len1);
 989 }
 990
 991 FileData *file_data_do_change(FileData *fd)
 992 {
 993 //FIXME sidecars
 994         g_assert(fd->change);
 995         g_free(fd->path);
 996         g_hash_table_remove(file_data_pool, fd->original_path);
 997         g_free(fd->original_path);
 998         file_data_set_path(fd, fd->change->dest);
 999         fd->original_path = g_strdup(fd->change->dest);
1000         g_hash_table_insert(file_data_pool, fd->original_path, fd);
1001
1002 }
1003
1004 gboolean file_data_add_change_info(FileData *fd, FileDataChangeType type, const gchar *src, const gchar *dest)
1005 {
1006
1007         FileDataChangeInfo *fdci;
1008
1009         if (fd->change) return FALSE;
1010
1011         fdci = g_new0(FileDataChangeInfo, 1);
1012
1013         fdci->type = type;
1014
1015         if (src)
1016                 fdci->source = g_strdup(src);
1017         else
1018                 fdci->source = g_strdup(fd->path);
1019
1020         if (dest)
1021                 fdci->dest = g_strdup(dest);
1022
1023         fd->change = fdci;
1024         return TRUE;
1025 }
1026
1027 void file_data_change_info_free(FileDataChangeInfo *fdci, FileData *fd)
1028 {
1029         if (!fdci && fd)
1030                 fdci = fd->change;
1031
1032         if (!fdci)
1033                 return;
1034
1035         g_free(fdci->source);
1036         g_free(fdci->dest);
1037
1038         g_free(fdci);
1039
1040         if (fd)
1041                 fd->change = NULL;
1042 }
1043
1044
1045
1046
1047 /*
1048  *-----------------------------------------------------------------------------
1049  * sidecar file info struct
1050  *-----------------------------------------------------------------------------
1051  */
1052
1053
1054
1055 gint sidecar_file_priority(const gchar *path)
1056 {
1057         const char *extension = extension_from_path(path);
1058         int i = 1;
1059         GList *work;
1060         if (extension == NULL)
1061                 return 0;
1062
1063         work = sidecar_ext_get_list();
1064
1065         while (work) {
1066                 gchar *ext = work->data;
1067                 work = work->next;
1068                 if (strcmp(extension, ext) == 0) return i;
1069                 i++;
1070         }
1071         return 0;
1072 }
1073
1074 gchar *sidecar_file_data_list_to_string(FileData *fd)
1075 {
1076         GList *work;
1077         GString *result = g_string_new("");
1078
1079         work = fd->sidecar_files;
1080         while (work)
1081                 {
1082                 FileData *sfd = work->data;
1083                 result = g_string_append(result, "+ ");
1084                 result = g_string_append(result, sfd->extension);
1085                 work = work->next;
1086                 if (work) result = g_string_append_c(result, ' ');
1087                 }
1088
1089         return g_string_free(result, FALSE);
1090 }
1091
1092 /*
1093  *-----------------------------------------------------------------------------
1094  * load file list
1095  *-----------------------------------------------------------------------------
1096  */
1097
1098 static SortType filelist_sort_method = SORT_NONE;
1099 static gint filelist_sort_ascend = TRUE;
1100
1101
1102 gint filelist_sort_compare_filedata(FileData *fa, FileData *fb)
1103 {
1104         if (!filelist_sort_ascend)
1105                 {
1106                 FileData *tmp = fa;
1107                 fa = fb;
1108                 fb = tmp;
1109                 }
1110
1111         switch (filelist_sort_method)
1112                 {
1113                 case SORT_SIZE:
1114                         if (fa->size < fb->size) return -1;
1115                         if (fa->size > fb->size) return 1;
1116                         return CASE_SORT(fa->name, fb->name); /* fall back to name */
1117                         break;
1118                 case SORT_TIME:
1119                         if (fa->date < fb->date) return -1;
1120                         if (fa->date > fb->date) return 1;
1121                         return CASE_SORT(fa->name, fb->name); /* fall back to name */
1122                         break;
1123 #ifdef HAVE_STRVERSCMP
1124                 case SORT_NUMBER:
1125                         return strverscmp(fa->name, fb->name);
1126                         break;
1127 #endif
1128                 case SORT_NAME:
1129                 default:
1130                         return CASE_SORT(fa->name, fb->name);
1131                         break;
1132                 }
1133 }
1134
1135 gint filelist_sort_compare_filedata_full(FileData *fa, FileData *fb, SortType method, gint ascend)
1136 {
1137         filelist_sort_method = method;
1138         filelist_sort_ascend = ascend;
1139         return filelist_sort_compare_filedata(fa, fb);
1140 }
1141
1142 static gint filelist_sort_file_cb(void *a, void *b)
1143 {
1144         return filelist_sort_compare_filedata(a, b);
1145 }
1146
1147 GList *filelist_sort_full(GList *list, SortType method, gint ascend, GCompareFunc cb)
1148 {
1149         filelist_sort_method = method;
1150         filelist_sort_ascend = ascend;
1151         return g_list_sort(list, cb);
1152 }
1153
1154 GList *filelist_insert_sort_full(GList *list, void *data, SortType method, gint ascend, GCompareFunc cb)
1155 {
1156         filelist_sort_method = method;
1157         filelist_sort_ascend = ascend;
1158         return g_list_insert_sorted(list, data, cb);
1159 }
1160
1161 GList *filelist_sort(GList *list, SortType method, gint ascend)
1162 {
1163         return filelist_sort_full(list, method, ascend, (GCompareFunc) filelist_sort_file_cb);
1164 }
1165
1166 GList *filelist_insert_sort(GList *list, FileData *fd, SortType method, gint ascend)
1167 {
1168         return filelist_insert_sort_full(list, fd, method, ascend, (GCompareFunc) filelist_sort_file_cb);
1169 }
1170
1171
1172 static GList *filelist_filter_out_sidecars(GList *flist)
1173 {
1174         GList *work = flist;
1175         GList *flist_filtered = NULL;
1176
1177         while (work)
1178                 {
1179                 FileData *fd = work->data;
1180                 work = work->next;
1181                 if (fd->parent) /* remove fd's that are children */
1182                         file_data_unref(fd);
1183                 else
1184                         flist_filtered = g_list_prepend(flist_filtered, fd);
1185                 }
1186         g_list_free(flist);
1187         return flist_filtered;
1188 }
1189
1190 static gint filelist_read_real(const gchar *path, GList **files, GList **dirs, gint follow_symlinks)
1191 {
1192         DIR *dp;
1193         struct dirent *dir;
1194         struct stat ent_sbuf;
1195         gchar *pathl;
1196         GList *dlist;
1197         GList *flist;
1198
1199         dlist = NULL;
1200         flist = NULL;
1201
1202         pathl = path_from_utf8(path);
1203         if (!pathl || (dp = opendir(pathl)) == NULL)
1204                 {
1205                 g_free(pathl);
1206                 if (files) *files = NULL;
1207                 if (dirs) *dirs = NULL;
1208                 return FALSE;
1209                 }
1210
1211         /* root dir fix */
1212         if (pathl[0] == '/' && pathl[1] == '\0')
1213                 {
1214                 g_free(pathl);
1215                 pathl = g_strdup("");
1216                 }
1217
1218         while ((dir = readdir(dp)) != NULL)
1219                 {
1220                 gchar *name = dir->d_name;
1221                 if (show_dot_files || !ishidden(name))
1222                         {
1223                         gchar *filepath = g_strconcat(pathl, "/", name, NULL);
1224                         if ((follow_symlinks ?
1225                                 stat(filepath, &ent_sbuf) :
1226                                 lstat(filepath, &ent_sbuf)) >= 0)
1227                                 {
1228                                 if (S_ISDIR(ent_sbuf.st_mode))
1229                                         {
1230                                         /* we ignore the .thumbnails dir for cleanliness */
1231                                         if ((dirs) &&
1232                                             !(name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))) &&
1233                                             strcmp(name, GQVIEW_CACHE_LOCAL_THUMB) != 0 &&
1234                                             strcmp(name, GQVIEW_CACHE_LOCAL_METADATA) != 0 &&
1235                                             strcmp(name, THUMB_FOLDER_LOCAL) != 0)
1236                                                 {
1237                                                 dlist = g_list_prepend(dlist, file_data_new_local(filepath, &ent_sbuf, FALSE));
1238                                                 }
1239                                         }
1240                                 else
1241                                         {
1242                                         if ((files) && filter_name_exists(name))
1243                                                 {
1244                                                 flist = g_list_prepend(flist, file_data_new_local(filepath, &ent_sbuf, TRUE));
1245                                                 }
1246                                         }
1247                                 }
1248                         g_free(filepath);
1249                         }
1250                 }
1251
1252         closedir(dp);
1253
1254         g_free(pathl);
1255
1256         flist = filelist_filter_out_sidecars(flist);
1257
1258         if (dirs) *dirs = dlist;
1259         if (files) *files = flist;
1260
1261         return TRUE;
1262 }
1263
1264 gint filelist_read(const gchar *path, GList **files, GList **dirs)
1265 {
1266         return filelist_read_real(path, files, dirs, TRUE);
1267 }
1268
1269 gint filelist_read_lstat(const gchar *path, GList **files, GList **dirs)
1270 {
1271         return filelist_read_real(path, files, dirs, FALSE);
1272 }
1273
1274 void filelist_free(GList *list)
1275 {
1276         GList *work;
1277
1278         work = list;
1279         while (work)
1280                 {
1281                 file_data_unref((FileData *)work->data);
1282                 work = work->next;
1283                 }
1284
1285         g_list_free(list);
1286 }
1287
1288
1289 GList *filelist_copy(GList *list)
1290 {
1291         GList *new_list = NULL;
1292         GList *work;
1293
1294         work = list;
1295         while (work)
1296                 {
1297                 FileData *fd;
1298
1299                 fd = work->data;
1300                 work = work->next;
1301
1302                 new_list = g_list_prepend(new_list, file_data_ref(fd));
1303                 }
1304
1305         return g_list_reverse(new_list);
1306 }
1307
1308 GList *filelist_from_path_list(GList *list)
1309 {
1310         GList *new_list = NULL;
1311         GList *work;
1312
1313         work = list;
1314         while (work)
1315                 {
1316                 gchar *path;
1317
1318                 path = work->data;
1319                 work = work->next;
1320
1321                 new_list = g_list_prepend(new_list, file_data_new_simple(path));
1322                 }
1323
1324         return g_list_reverse(new_list);
1325 }
1326
1327 GList *filelist_to_path_list(GList *list)
1328 {
1329         GList *new_list = NULL;
1330         GList *work;
1331
1332         work = list;
1333         while (work)
1334                 {
1335                 FileData *fd;
1336
1337                 fd = work->data;
1338                 work = work->next;
1339
1340                 new_list = g_list_prepend(new_list, g_strdup(fd->path));
1341                 }
1342
1343         return g_list_reverse(new_list);
1344 }
1345
1346 GList *filelist_filter(GList *list, gint is_dir_list)
1347 {
1348         GList *work;
1349
1350         if (!is_dir_list && file_filter_disable && show_dot_files) return list;
1351
1352         work = list;
1353         while (work)
1354                 {
1355                 FileData *fd = (FileData *)(work->data);
1356                 const gchar *name = fd->name;
1357
1358                 if ((!show_dot_files && ishidden(name)) ||
1359                     (!is_dir_list && !filter_name_exists(name)) ||
1360                     (is_dir_list && name[0] == '.' && (strcmp(name, GQVIEW_CACHE_LOCAL_THUMB) == 0 ||
1361                                                        strcmp(name, GQVIEW_CACHE_LOCAL_METADATA) == 0)) )
1362                         {
1363                         GList *link = work;
1364                         work = work->next;
1365                         list = g_list_remove_link(list, link);
1366                         file_data_unref(fd);
1367                         g_list_free(link);
1368                         }
1369                 else
1370                         {
1371                         work = work->next;
1372                         }
1373                 }
1374
1375         return list;
1376 }
1377
1378 /*
1379  *-----------------------------------------------------------------------------
1380  * filelist recursive
1381  *-----------------------------------------------------------------------------
1382  */
1383
1384 static gint filelist_sort_path_cb(gconstpointer a, gconstpointer b)
1385 {
1386         return CASE_SORT(((FileData *)a)->path, ((FileData *)b)->path);
1387 }
1388
1389 GList *filelist_sort_path(GList *list)
1390 {
1391         return g_list_sort(list, filelist_sort_path_cb);
1392 }
1393
1394 static void filelist_recursive_append(GList **list, GList *dirs)
1395 {
1396         GList *work;
1397
1398         work = dirs;
1399         while (work)
1400                 {
1401                 FileData *fd = (FileData *)(work->data);
1402                 const gchar *path = fd->path;
1403                 GList *f = NULL;
1404                 GList *d = NULL;
1405
1406                 if (filelist_read(path, &f, &d))
1407                         {
1408                         f = filelist_filter(f, FALSE);
1409                         f = filelist_sort_path(f);
1410                         *list = g_list_concat(*list, f);
1411
1412                         d = filelist_filter(d, TRUE);
1413                         d = filelist_sort_path(d);
1414                         filelist_recursive_append(list, d);
1415                         filelist_free(d);
1416                         }
1417
1418                 work = work->next;
1419                 }
1420 }
1421
1422 GList *filelist_recursive(const gchar *path)
1423 {
1424         GList *list = NULL;
1425         GList *d = NULL;
1426
1427         if (!filelist_read(path, &list, &d)) return NULL;
1428         list = filelist_filter(list, FALSE);
1429         list = filelist_sort_path(list);
1430
1431         d = filelist_filter(d, TRUE);
1432         d = filelist_sort_path(d);
1433         filelist_recursive_append(&list, d);
1434         filelist_free(d);
1435
1436         return list;
1437 }