Mercurial > geeqie.yaz
annotate src/filedata.c @ 1211:e2bbe90b0dcd
most of the metadata options now works
author | nadvornik |
---|---|
date | Sun, 21 Dec 2008 21:20:36 +0000 |
parents | 3ff2aa99108b |
children | 97f30a17dc6b |
rev | line source |
---|---|
586 | 1 /* |
2 * Geeqie | |
3 * (C) 2006 John Ellis | |
4 * Copyright (C) 2008 The Geeqie Team | |
5 * | |
6 * Author: John Ellis | |
7 * | |
8 * This software is released under the GNU General Public License (GNU GPL). | |
9 * Please read the included file COPYING for more information. | |
10 * This software comes with no warranty of any kind, use at your own risk! | |
11 */ | |
12 | |
13 | |
14 #include "main.h" | |
15 #include "filedata.h" | |
16 | |
17 #include "filefilter.h" | |
18 #include "cache.h" | |
19 #include "thumb_standard.h" | |
20 #include "ui_fileops.h" | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
21 #include "metadata.h" |
586 | 22 |
23 | |
785 | 24 static GHashTable *file_data_pool = NULL; |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
25 static GHashTable *file_data_planned_change_hash = NULL; |
785 | 26 |
586 | 27 static gint sidecar_file_priority(const gchar *path); |
28 | |
29 | |
30 /* | |
31 *----------------------------------------------------------------------------- | |
32 * text conversion utils | |
33 *----------------------------------------------------------------------------- | |
34 */ | |
35 | |
36 gchar *text_from_size(gint64 size) | |
37 { | |
38 gchar *a, *b; | |
39 gchar *s, *d; | |
40 gint l, n, i; | |
41 | |
42 /* what I would like to use is printf("%'d", size) | |
43 * BUT: not supported on every libc :( | |
44 */ | |
45 if (size > G_MAXUINT) | |
46 { | |
47 /* the %lld conversion is not valid in all libcs, so use a simple work-around */ | |
48 a = g_strdup_printf("%d%09d", (guint)(size / 1000000000), (guint)(size % 1000000000)); | |
49 } | |
50 else | |
51 { | |
52 a = g_strdup_printf("%d", (guint)size); | |
53 } | |
54 l = strlen(a); | |
55 n = (l - 1)/ 3; | |
56 if (n < 1) return a; | |
57 | |
58 b = g_new(gchar, l + n + 1); | |
59 | |
60 s = a; | |
61 d = b; | |
62 i = l - n * 3; | |
63 while (*s != '\0') | |
64 { | |
65 if (i < 1) | |
66 { | |
67 i = 3; | |
68 *d = ','; | |
69 d++; | |
70 } | |
71 | |
72 *d = *s; | |
73 s++; | |
74 d++; | |
75 i--; | |
76 } | |
77 *d = '\0'; | |
78 | |
79 g_free(a); | |
80 return b; | |
81 } | |
82 | |
83 gchar *text_from_size_abrev(gint64 size) | |
84 { | |
85 if (size < (gint64)1024) | |
86 { | |
87 return g_strdup_printf(_("%d bytes"), (gint)size); | |
88 } | |
89 if (size < (gint64)1048576) | |
90 { | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
91 return g_strdup_printf(_("%.1f K"), (gdouble)size / 1024.0); |
586 | 92 } |
93 if (size < (gint64)1073741824) | |
94 { | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
95 return g_strdup_printf(_("%.1f MB"), (gdouble)size / 1048576.0); |
586 | 96 } |
97 | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
98 /* to avoid overflowing the gdouble, do division in two steps */ |
586 | 99 size /= 1048576; |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
100 return g_strdup_printf(_("%.1f GB"), (gdouble)size / 1024.0); |
586 | 101 } |
102 | |
103 /* note: returned string is valid until next call to text_from_time() */ | |
104 const gchar *text_from_time(time_t t) | |
105 { | |
106 static gchar *ret = NULL; | |
107 gchar buf[128]; | |
108 gint buflen; | |
109 struct tm *btime; | |
110 GError *error = NULL; | |
111 | |
112 btime = localtime(&t); | |
113 | |
114 /* the %x warning about 2 digit years is not an error */ | |
115 buflen = strftime(buf, sizeof(buf), "%x %H:%M", btime); | |
116 if (buflen < 1) return ""; | |
117 | |
118 g_free(ret); | |
119 ret = g_locale_to_utf8(buf, buflen, NULL, NULL, &error); | |
120 if (error) | |
121 { | |
673
fbebf5cf4a55
Do not use printf() directly but use new wrapper function log_printf() instead.
zas_
parents:
671
diff
changeset
|
122 log_printf("Error converting locale strftime to UTF-8: %s\n", error->message); |
586 | 123 g_error_free(error); |
124 return ""; | |
125 } | |
126 | |
127 return ret; | |
128 } | |
129 | |
130 /* | |
131 *----------------------------------------------------------------------------- | |
132 * file info struct | |
133 *----------------------------------------------------------------------------- | |
134 */ | |
135 | |
136 FileData *file_data_merge_sidecar_files(FileData *target, FileData *source); | |
137 static void file_data_check_sidecars(FileData *fd); | |
138 FileData *file_data_disconnect_sidecar_file(FileData *target, FileData *sfd); | |
139 | |
140 | |
763
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
141 void file_data_increment_version(FileData *fd) |
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
142 { |
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
143 fd->version++; |
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
144 if (fd->parent) fd->parent->version++; |
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
145 } |
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
146 |
785 | 147 static void file_data_set_collate_keys(FileData *fd) |
148 { | |
149 gchar *caseless_name; | |
1007
4303ee1e88ec
Removed converting fd->name to utf8 from file_data_set_collate_keys(), because fd->name is utf8.
bruclik
parents:
1002
diff
changeset
|
150 |
4303ee1e88ec
Removed converting fd->name to utf8 from file_data_set_collate_keys(), because fd->name is utf8.
bruclik
parents:
1002
diff
changeset
|
151 caseless_name = g_utf8_casefold(fd->name, -1); |
785 | 152 |
153 g_free(fd->collate_key_name); | |
154 g_free(fd->collate_key_name_nocase); | |
155 | |
156 #if GLIB_CHECK_VERSION(2, 8, 0) | |
1007
4303ee1e88ec
Removed converting fd->name to utf8 from file_data_set_collate_keys(), because fd->name is utf8.
bruclik
parents:
1002
diff
changeset
|
157 fd->collate_key_name = g_utf8_collate_key_for_filename(fd->name, -1); |
785 | 158 fd->collate_key_name_nocase = g_utf8_collate_key_for_filename(caseless_name, -1); |
159 #else | |
1007
4303ee1e88ec
Removed converting fd->name to utf8 from file_data_set_collate_keys(), because fd->name is utf8.
bruclik
parents:
1002
diff
changeset
|
160 fd->collate_key_name = g_utf8_collate_key(fd->name, -1); |
785 | 161 fd->collate_key_name_nocase = g_utf8_collate_key(caseless_name, -1); |
162 #endif | |
163 g_free(caseless_name); | |
164 } | |
763
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
165 |
586 | 166 static void file_data_set_path(FileData *fd, const gchar *path) |
167 { | |
790 | 168 g_assert(path /* && *path*/); /* view_dir_tree uses FileData with zero length path */ |
785 | 169 g_assert(file_data_pool); |
170 | |
171 g_free(fd->path); | |
172 | |
173 if (fd->original_path) | |
174 { | |
175 g_hash_table_remove(file_data_pool, fd->original_path); | |
176 g_free(fd->original_path); | |
177 } | |
915 | 178 |
179 g_assert(!g_hash_table_lookup(file_data_pool, path)); | |
180 | |
785 | 181 fd->original_path = g_strdup(path); |
182 g_hash_table_insert(file_data_pool, fd->original_path, fd); | |
586 | 183 |
725 | 184 if (strcmp(path, G_DIR_SEPARATOR_S) == 0) |
586 | 185 { |
186 fd->path = g_strdup(path); | |
187 fd->name = fd->path; | |
188 fd->extension = fd->name + 1; | |
785 | 189 file_data_set_collate_keys(fd); |
586 | 190 return; |
191 } | |
192 | |
193 fd->path = g_strdup(path); | |
194 fd->name = filename_from_path(fd->path); | |
195 | |
196 if (strcmp(fd->name, "..") == 0) | |
197 { | |
198 gchar *dir = remove_level_from_path(path); | |
199 g_free(fd->path); | |
200 fd->path = remove_level_from_path(dir); | |
201 g_free(dir); | |
202 fd->name = ".."; | |
203 fd->extension = fd->name + 2; | |
785 | 204 file_data_set_collate_keys(fd); |
586 | 205 return; |
206 } | |
207 else if (strcmp(fd->name, ".") == 0) | |
208 { | |
209 g_free(fd->path); | |
210 fd->path = remove_level_from_path(path); | |
211 fd->name = "."; | |
212 fd->extension = fd->name + 1; | |
785 | 213 file_data_set_collate_keys(fd); |
586 | 214 return; |
215 } | |
216 | |
217 fd->extension = extension_from_path(fd->path); | |
218 if (fd->extension == NULL) | |
219 fd->extension = fd->name + strlen(fd->name); | |
785 | 220 |
221 file_data_set_collate_keys(fd); | |
586 | 222 } |
223 | |
801 | 224 static gboolean file_data_check_changed_files_recursive(FileData *fd, struct stat *st) |
586 | 225 { |
801 | 226 gboolean ret = FALSE; |
586 | 227 GList *work; |
806 | 228 |
586 | 229 if (fd->size != st->st_size || |
230 fd->date != st->st_mtime) | |
231 { | |
232 fd->size = st->st_size; | |
233 fd->date = st->st_mtime; | |
945
fd84847c8231
speed-up of directory notification on deleting large number of files
nadvornik
parents:
942
diff
changeset
|
234 fd->mode = st->st_mode; |
845 | 235 if (fd->thumb_pixbuf) g_object_unref(fd->thumb_pixbuf); |
236 fd->thumb_pixbuf = NULL; | |
763
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
237 file_data_increment_version(fd); |
800 | 238 file_data_send_notification(fd, NOTIFY_TYPE_REREAD); |
801 | 239 ret = TRUE; |
586 | 240 } |
241 | |
242 work = fd->sidecar_files; | |
243 while (work) | |
244 { | |
245 FileData *sfd = work->data; | |
246 struct stat st; | |
801 | 247 work = work->next; |
586 | 248 |
249 if (!stat_utf8(sfd->path, &st)) | |
250 { | |
801 | 251 fd->size = 0; |
252 fd->date = 0; | |
586 | 253 file_data_disconnect_sidecar_file(fd, sfd); |
801 | 254 ret = TRUE; |
255 continue; | |
586 | 256 } |
257 | |
801 | 258 ret |= file_data_check_changed_files_recursive(sfd, &st); |
586 | 259 } |
801 | 260 return ret; |
261 } | |
262 | |
263 | |
888 | 264 gboolean file_data_check_changed_files(FileData *fd) |
801 | 265 { |
266 gboolean ret = FALSE; | |
267 struct stat st; | |
806 | 268 |
801 | 269 if (fd->parent) fd = fd->parent; |
270 | |
271 if (!stat_utf8(fd->path, &st)) | |
272 { | |
806 | 273 GList *work; |
274 FileData *sfd = NULL; | |
275 | |
801 | 276 /* parent is missing, we have to rebuild whole group */ |
277 ret = TRUE; | |
278 fd->size = 0; | |
279 fd->date = 0; | |
806 | 280 |
281 work = fd->sidecar_files; | |
801 | 282 while (work) |
283 { | |
284 sfd = work->data; | |
285 work = work->next; | |
286 | |
287 file_data_disconnect_sidecar_file(fd, sfd); | |
288 } | |
289 if (sfd) file_data_check_sidecars(sfd); /* this will group the sidecars back together */ | |
290 file_data_send_notification(fd, NOTIFY_TYPE_REREAD); | |
291 } | |
806 | 292 else |
293 { | |
801 | 294 ret |= file_data_check_changed_files_recursive(fd, &st); |
806 | 295 } |
296 | |
801 | 297 return ret; |
586 | 298 } |
299 | |
300 static FileData *file_data_new(const gchar *path_utf8, struct stat *st, gboolean check_sidecars) | |
301 { | |
302 FileData *fd; | |
303 | |
304 DEBUG_2("file_data_new: '%s' %d", path_utf8, check_sidecars); | |
305 | |
306 if (!file_data_pool) | |
307 file_data_pool = g_hash_table_new(g_str_hash, g_str_equal); | |
308 | |
918 | 309 fd = g_hash_table_lookup(file_data_pool, path_utf8); |
310 if (fd) | |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
311 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
312 file_data_ref(fd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
313 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
314 |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
315 if (!fd && file_data_planned_change_hash) |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
316 { |
918 | 317 fd = g_hash_table_lookup(file_data_planned_change_hash, path_utf8); |
318 if (fd) | |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
319 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
320 DEBUG_1("planned change: using %s -> %s", path_utf8, fd->path); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
321 file_data_ref(fd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
322 file_data_apply_ci(fd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
323 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
324 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
325 |
586 | 326 if (fd) |
327 { | |
801 | 328 gboolean changed; |
892
2022112583d0
increase reference count before sending notification in file_data_new
nadvornik
parents:
888
diff
changeset
|
329 |
801 | 330 if (fd->parent) |
331 changed = file_data_check_changed_files(fd); | |
332 else | |
333 changed = file_data_check_changed_files_recursive(fd, st); | |
334 if (changed && check_sidecars && sidecar_file_priority(fd->extension)) | |
335 file_data_check_sidecars(fd); | |
336 DEBUG_2("file_data_pool hit: '%s' %s", fd->path, changed ? "(changed)" : ""); | |
806 | 337 |
892
2022112583d0
increase reference count before sending notification in file_data_new
nadvornik
parents:
888
diff
changeset
|
338 return fd; |
586 | 339 } |
340 | |
341 fd = g_new0(FileData, 1); | |
785 | 342 |
343 fd->path = NULL; | |
344 fd->name = NULL; | |
345 fd->collate_key_name = NULL; | |
346 fd->collate_key_name_nocase = NULL; | |
347 fd->original_path = NULL; | |
586 | 348 |
349 fd->size = st->st_size; | |
350 fd->date = st->st_mtime; | |
945
fd84847c8231
speed-up of directory notification on deleting large number of files
nadvornik
parents:
942
diff
changeset
|
351 fd->mode = st->st_mode; |
845 | 352 fd->thumb_pixbuf = NULL; |
586 | 353 fd->sidecar_files = NULL; |
354 fd->ref = 1; | |
355 fd->magick = 0x12345678; | |
356 | |
785 | 357 file_data_set_path(fd, path_utf8); /* set path, name, collate_key_*, original_path */ |
586 | 358 |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
359 if (check_sidecars) |
586 | 360 file_data_check_sidecars(fd); |
785 | 361 |
586 | 362 return fd; |
363 } | |
364 | |
365 static void file_data_check_sidecars(FileData *fd) | |
366 { | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
367 gint base_len; |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
368 GString *fname; |
586 | 369 FileData *parent_fd = NULL; |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
370 GList *work; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
371 |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
372 if (fd->disable_grouping || !sidecar_file_priority(fd->extension)) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
373 return; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
374 |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
375 base_len = fd->extension - fd->path; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
376 fname = g_string_new_len(fd->path, base_len); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
377 work = sidecar_ext_get_list(); |
806 | 378 |
586 | 379 while (work) |
380 { | |
381 /* check for possible sidecar files; | |
382 the sidecar files created here are referenced only via fd->sidecar_files or fd->parent, | |
383 they have fd->ref set to 0 and file_data unref must chack and free them all together | |
384 (using fd->ref would cause loops and leaks) | |
385 */ | |
386 | |
387 FileData *new_fd; | |
806 | 388 gchar *ext = work->data; |
586 | 389 |
390 work = work->next; | |
391 | |
392 if (strcmp(ext, fd->extension) == 0) | |
393 { | |
394 new_fd = fd; /* processing the original file */ | |
395 } | |
396 else | |
397 { | |
398 struct stat nst; | |
399 g_string_truncate(fname, base_len); | |
400 g_string_append(fname, ext); | |
401 | |
402 if (!stat_utf8(fname->str, &nst)) | |
403 continue; | |
404 | |
405 new_fd = file_data_new(fname->str, &nst, FALSE); | |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
406 |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
407 if (new_fd->disable_grouping) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
408 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
409 file_data_unref(new_fd); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
410 continue; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
411 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
412 |
586 | 413 new_fd->ref--; /* do not use ref here */ |
414 } | |
415 | |
416 if (!parent_fd) | |
417 parent_fd = new_fd; /* parent is the one with the highest prio, found first */ | |
418 else | |
419 file_data_merge_sidecar_files(parent_fd, new_fd); | |
420 } | |
421 g_string_free(fname, TRUE); | |
422 } | |
423 | |
424 | |
425 static FileData *file_data_new_local(const gchar *path, struct stat *st, gboolean check_sidecars) | |
426 { | |
427 gchar *path_utf8 = path_to_utf8(path); | |
428 FileData *ret = file_data_new(path_utf8, st, check_sidecars); | |
806 | 429 |
586 | 430 g_free(path_utf8); |
431 return ret; | |
432 } | |
433 | |
434 FileData *file_data_new_simple(const gchar *path_utf8) | |
435 { | |
436 struct stat st; | |
437 | |
438 if (!stat_utf8(path_utf8, &st)) | |
439 { | |
440 st.st_size = 0; | |
441 st.st_mtime = 0; | |
442 } | |
443 | |
444 return file_data_new(path_utf8, &st, TRUE); | |
445 } | |
446 | |
447 FileData *file_data_add_sidecar_file(FileData *target, FileData *sfd) | |
448 { | |
449 sfd->parent = target; | |
855 | 450 if (!g_list_find(target->sidecar_files, sfd)) |
586 | 451 target->sidecar_files = g_list_prepend(target->sidecar_files, sfd); |
801 | 452 file_data_increment_version(sfd); /* increments both sfd and target */ |
586 | 453 return target; |
454 } | |
455 | |
456 | |
457 FileData *file_data_merge_sidecar_files(FileData *target, FileData *source) | |
458 { | |
459 GList *work; | |
806 | 460 |
586 | 461 file_data_add_sidecar_file(target, source); |
462 | |
463 work = source->sidecar_files; | |
464 while (work) | |
465 { | |
466 FileData *sfd = work->data; | |
467 file_data_add_sidecar_file(target, sfd); | |
468 work = work->next; | |
469 } | |
470 | |
471 g_list_free(source->sidecar_files); | |
472 source->sidecar_files = NULL; | |
473 | |
474 target->sidecar_files = filelist_sort(target->sidecar_files, SORT_NAME, TRUE); | |
806 | 475 |
586 | 476 return target; |
477 } | |
478 | |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
479 #ifdef DEBUG_FILEDATA |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
480 FileData *file_data_ref_debug(const gchar *file, gint line, FileData *fd) |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
481 #else |
586 | 482 FileData *file_data_ref(FileData *fd) |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
483 #endif |
586 | 484 { |
485 if (fd == NULL) return NULL; | |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
486 #ifdef DEBUG_FILEDATA |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
487 if (fd->magick != 0x12345678) |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
488 DEBUG_0("fd magick mismatch at %s:%d", file, line); |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
489 #endif |
586 | 490 g_assert(fd->magick == 0x12345678); |
491 fd->ref++; | |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
492 |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
493 #ifdef DEBUG_FILEDATA |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
494 DEBUG_2("file_data_ref (%d): '%s' @ %s:%d", fd->ref, fd->path, file, line); |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
495 #else |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
496 DEBUG_2("file_data_ref (%d): '%s'", fd->ref, fd->path); |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
497 #endif |
586 | 498 return fd; |
499 } | |
500 | |
501 static void file_data_free(FileData *fd) | |
502 { | |
503 g_assert(fd->magick == 0x12345678); | |
504 g_assert(fd->ref == 0); | |
505 | |
506 g_hash_table_remove(file_data_pool, fd->original_path); | |
507 | |
508 g_free(fd->path); | |
509 g_free(fd->original_path); | |
785 | 510 g_free(fd->collate_key_name); |
511 g_free(fd->collate_key_name_nocase); | |
845 | 512 if (fd->thumb_pixbuf) g_object_unref(fd->thumb_pixbuf); |
586 | 513 |
514 g_assert(fd->sidecar_files == NULL); /* sidecar files must be freed before calling this */ | |
515 | |
516 file_data_change_info_free(NULL, fd); | |
517 g_free(fd); | |
518 } | |
519 | |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
520 #ifdef DEBUG_FILEDATA |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
521 void file_data_unref_debug(const gchar *file, gint line, FileData *fd) |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
522 #else |
586 | 523 void file_data_unref(FileData *fd) |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
524 #endif |
586 | 525 { |
526 if (fd == NULL) return; | |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
527 #ifdef DEBUG_FILEDATA |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
528 if (fd->magick != 0x12345678) |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
529 DEBUG_0("fd magick mismatch @ %s:%d", file, line); |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
530 #endif |
586 | 531 g_assert(fd->magick == 0x12345678); |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
532 |
586 | 533 fd->ref--; |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
534 #ifdef DEBUG_FILEDATA |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
535 DEBUG_2("file_data_unref (%d): '%s' @ %s:%d", fd->ref, fd->path, file, line); |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
536 |
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
537 #else |
586 | 538 DEBUG_2("file_data_unref (%d): '%s'", fd->ref, fd->path); |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
539 #endif |
586 | 540 if (fd->ref == 0) |
541 { | |
806 | 542 GList *work; |
586 | 543 FileData *parent = fd->parent ? fd->parent : fd; |
806 | 544 |
586 | 545 if (parent->ref > 0) |
546 return; | |
547 | |
548 work = parent->sidecar_files; | |
549 while (work) | |
550 { | |
551 FileData *sfd = work->data; | |
552 if (sfd->ref > 0) | |
553 return; | |
554 work = work->next; | |
555 } | |
556 | |
557 /* none of parent/children is referenced, we can free everything */ | |
558 | |
874
fa39a4d786ad
Increase debugging info in file_data_ref() and file_data_unref().
zas_
parents:
855
diff
changeset
|
559 DEBUG_2("file_data_unref: deleting '%s', parent '%s'", fd->path, fd->parent ? parent->path : "-"); |
586 | 560 |
561 work = parent->sidecar_files; | |
562 while (work) | |
563 { | |
564 FileData *sfd = work->data; | |
565 file_data_free(sfd); | |
566 work = work->next; | |
567 } | |
568 | |
569 g_list_free(parent->sidecar_files); | |
570 parent->sidecar_files = NULL; | |
571 | |
572 file_data_free(parent); | |
573 } | |
574 } | |
575 | |
576 FileData *file_data_disconnect_sidecar_file(FileData *target, FileData *sfd) | |
577 { | |
578 sfd->parent = target; | |
579 g_assert(g_list_find(target->sidecar_files, sfd)); | |
801 | 580 |
581 file_data_increment_version(sfd); /* increments both sfd and target */ | |
586 | 582 |
583 target->sidecar_files = g_list_remove(target->sidecar_files, sfd); | |
584 sfd->parent = NULL; | |
585 | |
806 | 586 if (sfd->ref == 0) |
587 { | |
586 | 588 file_data_free(sfd); |
589 return NULL; | |
806 | 590 } |
586 | 591 |
592 return sfd; | |
593 } | |
594 | |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
595 /* disables / enables grouping for particular file, sends UPDATE notification */ |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
596 void file_data_disable_grouping(FileData *fd, gboolean disable) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
597 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
598 if (!fd->disable_grouping == !disable) return; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
599 fd->disable_grouping = !!disable; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
600 |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
601 if (disable) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
602 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
603 if (fd->parent) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
604 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
605 FileData *parent = file_data_ref(fd->parent); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
606 file_data_disconnect_sidecar_file(parent, fd); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
607 file_data_send_notification(fd, NOTIFY_TYPE_INTERNAL); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
608 file_data_send_notification(parent, NOTIFY_TYPE_INTERNAL); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
609 file_data_unref(parent); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
610 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
611 else if (fd->sidecar_files) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
612 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
613 GList *sidecar_files = filelist_copy(fd->sidecar_files); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
614 GList *work = sidecar_files; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
615 while (work) |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
616 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
617 FileData *sfd = work->data; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
618 work = work->next; |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
619 file_data_disconnect_sidecar_file(fd, sfd); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
620 file_data_send_notification(sfd, NOTIFY_TYPE_INTERNAL); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
621 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
622 file_data_send_notification(fd, NOTIFY_TYPE_INTERNAL); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
623 file_data_check_sidecars((FileData *)sidecar_files->data); /* this will group the sidecars back together */ |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
624 filelist_free(sidecar_files); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
625 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
626 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
627 else |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
628 { |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
629 file_data_check_sidecars(fd); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
630 file_data_send_notification(fd, NOTIFY_TYPE_INTERNAL); |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
631 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
632 } |
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
846
diff
changeset
|
633 |
586 | 634 /* compare name without extension */ |
635 gint file_data_compare_name_without_ext(FileData *fd1, FileData *fd2) | |
636 { | |
637 size_t len1 = fd1->extension - fd1->name; | |
638 size_t len2 = fd2->extension - fd2->name; | |
639 | |
640 if (len1 < len2) return -1; | |
641 if (len1 > len2) return 1; | |
642 | |
785 | 643 return strncmp(fd1->name, fd2->name, len1); /* FIXME: utf8 */ |
586 | 644 } |
645 | |
646 void file_data_change_info_free(FileDataChangeInfo *fdci, FileData *fd) | |
647 { | |
648 if (!fdci && fd) | |
649 fdci = fd->change; | |
650 | |
651 if (!fdci) | |
652 return; | |
653 | |
654 g_free(fdci->source); | |
655 g_free(fdci->dest); | |
656 | |
657 g_free(fdci); | |
658 | |
659 if (fd) | |
660 fd->change = NULL; | |
661 } | |
662 | |
663 | |
664 | |
665 | |
666 /* | |
667 *----------------------------------------------------------------------------- | |
668 * sidecar file info struct | |
669 *----------------------------------------------------------------------------- | |
670 */ | |
671 | |
672 | |
673 | |
674 static gint sidecar_file_priority(const gchar *path) | |
675 { | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
676 const gchar *extension = extension_from_path(path); |
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
677 gint i = 1; |
586 | 678 GList *work; |
806 | 679 |
586 | 680 if (extension == NULL) |
681 return 0; | |
682 | |
683 work = sidecar_ext_get_list(); | |
684 | |
685 while (work) { | |
686 gchar *ext = work->data; | |
806 | 687 |
586 | 688 work = work->next; |
689 if (strcmp(extension, ext) == 0) return i; | |
690 i++; | |
691 } | |
692 return 0; | |
693 } | |
694 | |
695 | |
696 /* | |
697 *----------------------------------------------------------------------------- | |
698 * load file list | |
699 *----------------------------------------------------------------------------- | |
700 */ | |
701 | |
702 static SortType filelist_sort_method = SORT_NONE; | |
703 static gint filelist_sort_ascend = TRUE; | |
704 | |
705 | |
706 gint filelist_sort_compare_filedata(FileData *fa, FileData *fb) | |
707 { | |
708 if (!filelist_sort_ascend) | |
709 { | |
710 FileData *tmp = fa; | |
711 fa = fb; | |
712 fb = tmp; | |
713 } | |
714 | |
715 switch (filelist_sort_method) | |
716 { | |
785 | 717 case SORT_NAME: |
718 break; | |
586 | 719 case SORT_SIZE: |
720 if (fa->size < fb->size) return -1; | |
721 if (fa->size > fb->size) return 1; | |
785 | 722 /* fall back to name */ |
586 | 723 break; |
724 case SORT_TIME: | |
725 if (fa->date < fb->date) return -1; | |
726 if (fa->date > fb->date) return 1; | |
785 | 727 /* fall back to name */ |
586 | 728 break; |
729 #ifdef HAVE_STRVERSCMP | |
730 case SORT_NUMBER: | |
731 return strverscmp(fa->name, fb->name); | |
732 break; | |
733 #endif | |
734 default: | |
735 break; | |
736 } | |
785 | 737 |
738 if (options->file_sort.case_sensitive) | |
739 return strcmp(fa->collate_key_name, fb->collate_key_name); | |
740 else | |
741 return strcmp(fa->collate_key_name_nocase, fb->collate_key_name_nocase); | |
586 | 742 } |
743 | |
744 gint filelist_sort_compare_filedata_full(FileData *fa, FileData *fb, SortType method, gint ascend) | |
745 { | |
746 filelist_sort_method = method; | |
747 filelist_sort_ascend = ascend; | |
748 return filelist_sort_compare_filedata(fa, fb); | |
749 } | |
750 | |
1002 | 751 static gint filelist_sort_file_cb(gpointer a, gpointer b) |
586 | 752 { |
753 return filelist_sort_compare_filedata(a, b); | |
754 } | |
755 | |
756 GList *filelist_sort_full(GList *list, SortType method, gint ascend, GCompareFunc cb) | |
757 { | |
758 filelist_sort_method = method; | |
759 filelist_sort_ascend = ascend; | |
760 return g_list_sort(list, cb); | |
761 } | |
762 | |
1002 | 763 GList *filelist_insert_sort_full(GList *list, gpointer data, SortType method, gint ascend, GCompareFunc cb) |
586 | 764 { |
765 filelist_sort_method = method; | |
766 filelist_sort_ascend = ascend; | |
767 return g_list_insert_sorted(list, data, cb); | |
768 } | |
769 | |
770 GList *filelist_sort(GList *list, SortType method, gint ascend) | |
771 { | |
772 return filelist_sort_full(list, method, ascend, (GCompareFunc) filelist_sort_file_cb); | |
773 } | |
774 | |
775 GList *filelist_insert_sort(GList *list, FileData *fd, SortType method, gint ascend) | |
776 { | |
777 return filelist_insert_sort_full(list, fd, method, ascend, (GCompareFunc) filelist_sort_file_cb); | |
778 } | |
779 | |
780 | |
781 static GList *filelist_filter_out_sidecars(GList *flist) | |
782 { | |
783 GList *work = flist; | |
784 GList *flist_filtered = NULL; | |
785 | |
786 while (work) | |
787 { | |
788 FileData *fd = work->data; | |
806 | 789 |
586 | 790 work = work->next; |
791 if (fd->parent) /* remove fd's that are children */ | |
792 file_data_unref(fd); | |
793 else | |
794 flist_filtered = g_list_prepend(flist_filtered, fd); | |
795 } | |
796 g_list_free(flist); | |
806 | 797 |
586 | 798 return flist_filtered; |
799 } | |
800 | |
783 | 801 static gint filelist_read_real(FileData *dir_fd, GList **files, GList **dirs, gint follow_symlinks) |
586 | 802 { |
803 DIR *dp; | |
804 struct dirent *dir; | |
805 gchar *pathl; | |
779 | 806 GList *dlist = NULL; |
807 GList *flist = NULL; | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
808 gint (*stat_func)(const gchar *path, struct stat *buf); |
586 | 809 |
779 | 810 g_assert(files || dirs); |
811 | |
812 if (files) *files = NULL; | |
813 if (dirs) *dirs = NULL; | |
586 | 814 |
783 | 815 pathl = path_from_utf8(dir_fd->path); |
779 | 816 if (!pathl) return FALSE; |
817 | |
818 dp = opendir(pathl); | |
819 if (dp == NULL) | |
586 | 820 { |
821 g_free(pathl); | |
822 return FALSE; | |
823 } | |
824 | |
779 | 825 if (follow_symlinks) |
826 stat_func = stat; | |
827 else | |
828 stat_func = lstat; | |
829 | |
586 | 830 while ((dir = readdir(dp)) != NULL) |
831 { | |
779 | 832 struct stat ent_sbuf; |
833 const gchar *name = dir->d_name; | |
834 gchar *filepath; | |
835 | |
836 if (!options->file_filter.show_hidden_files && ishidden(name)) | |
837 continue; | |
838 | |
839 filepath = g_build_filename(pathl, name, NULL); | |
840 if (stat_func(filepath, &ent_sbuf) >= 0) | |
586 | 841 { |
779 | 842 if (S_ISDIR(ent_sbuf.st_mode)) |
586 | 843 { |
779 | 844 /* we ignore the .thumbnails dir for cleanliness */ |
845 if (dirs && | |
846 !(name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))) && | |
847 strcmp(name, GQ_CACHE_LOCAL_THUMB) != 0 && | |
848 strcmp(name, GQ_CACHE_LOCAL_METADATA) != 0 && | |
849 strcmp(name, THUMB_FOLDER_LOCAL) != 0) | |
586 | 850 { |
779 | 851 dlist = g_list_prepend(dlist, file_data_new_local(filepath, &ent_sbuf, FALSE)); |
586 | 852 } |
853 } | |
779 | 854 else |
855 { | |
856 if (files && filter_name_exists(name)) | |
857 { | |
858 flist = g_list_prepend(flist, file_data_new_local(filepath, &ent_sbuf, TRUE)); | |
859 } | |
860 } | |
586 | 861 } |
779 | 862 g_free(filepath); |
586 | 863 } |
864 | |
865 closedir(dp); | |
779 | 866 |
586 | 867 g_free(pathl); |
868 | |
869 if (dirs) *dirs = dlist; | |
779 | 870 if (files) *files = filelist_filter_out_sidecars(flist); |
586 | 871 |
872 return TRUE; | |
873 } | |
874 | |
783 | 875 gint filelist_read(FileData *dir_fd, GList **files, GList **dirs) |
586 | 876 { |
783 | 877 return filelist_read_real(dir_fd, files, dirs, TRUE); |
586 | 878 } |
879 | |
783 | 880 gint filelist_read_lstat(FileData *dir_fd, GList **files, GList **dirs) |
586 | 881 { |
783 | 882 return filelist_read_real(dir_fd, files, dirs, FALSE); |
586 | 883 } |
884 | |
885 void filelist_free(GList *list) | |
886 { | |
887 GList *work; | |
888 | |
889 work = list; | |
890 while (work) | |
891 { | |
892 file_data_unref((FileData *)work->data); | |
893 work = work->next; | |
894 } | |
895 | |
896 g_list_free(list); | |
897 } | |
898 | |
899 | |
900 GList *filelist_copy(GList *list) | |
901 { | |
902 GList *new_list = NULL; | |
903 GList *work; | |
904 | |
905 work = list; | |
906 while (work) | |
907 { | |
908 FileData *fd; | |
909 | |
910 fd = work->data; | |
911 work = work->next; | |
912 | |
913 new_list = g_list_prepend(new_list, file_data_ref(fd)); | |
914 } | |
915 | |
916 return g_list_reverse(new_list); | |
917 } | |
918 | |
919 GList *filelist_from_path_list(GList *list) | |
920 { | |
921 GList *new_list = NULL; | |
922 GList *work; | |
923 | |
924 work = list; | |
925 while (work) | |
926 { | |
927 gchar *path; | |
928 | |
929 path = work->data; | |
930 work = work->next; | |
931 | |
932 new_list = g_list_prepend(new_list, file_data_new_simple(path)); | |
933 } | |
934 | |
935 return g_list_reverse(new_list); | |
936 } | |
937 | |
938 GList *filelist_to_path_list(GList *list) | |
939 { | |
940 GList *new_list = NULL; | |
941 GList *work; | |
942 | |
943 work = list; | |
944 while (work) | |
945 { | |
946 FileData *fd; | |
947 | |
948 fd = work->data; | |
949 work = work->next; | |
950 | |
951 new_list = g_list_prepend(new_list, g_strdup(fd->path)); | |
952 } | |
953 | |
954 return g_list_reverse(new_list); | |
955 } | |
956 | |
957 GList *filelist_filter(GList *list, gint is_dir_list) | |
958 { | |
959 GList *work; | |
960 | |
961 if (!is_dir_list && options->file_filter.disable && options->file_filter.show_hidden_files) return list; | |
962 | |
963 work = list; | |
964 while (work) | |
965 { | |
966 FileData *fd = (FileData *)(work->data); | |
967 const gchar *name = fd->name; | |
968 | |
969 if ((!options->file_filter.show_hidden_files && ishidden(name)) || | |
970 (!is_dir_list && !filter_name_exists(name)) || | |
971 (is_dir_list && name[0] == '.' && (strcmp(name, GQ_CACHE_LOCAL_THUMB) == 0 || | |
972 strcmp(name, GQ_CACHE_LOCAL_METADATA) == 0)) ) | |
973 { | |
974 GList *link = work; | |
806 | 975 |
586 | 976 list = g_list_remove_link(list, link); |
977 file_data_unref(fd); | |
978 g_list_free(link); | |
979 } | |
806 | 980 |
981 work = work->next; | |
586 | 982 } |
983 | |
984 return list; | |
985 } | |
986 | |
987 /* | |
988 *----------------------------------------------------------------------------- | |
989 * filelist recursive | |
990 *----------------------------------------------------------------------------- | |
991 */ | |
992 | |
993 static gint filelist_sort_path_cb(gconstpointer a, gconstpointer b) | |
994 { | |
995 return CASE_SORT(((FileData *)a)->path, ((FileData *)b)->path); | |
996 } | |
997 | |
998 GList *filelist_sort_path(GList *list) | |
999 { | |
1000 return g_list_sort(list, filelist_sort_path_cb); | |
1001 } | |
1002 | |
1003 static void filelist_recursive_append(GList **list, GList *dirs) | |
1004 { | |
1005 GList *work; | |
1006 | |
1007 work = dirs; | |
1008 while (work) | |
1009 { | |
1010 FileData *fd = (FileData *)(work->data); | |
780
44128da39e13
Drop initialization to NULL since filelist_read() will take care of it.
zas_
parents:
779
diff
changeset
|
1011 GList *f; |
44128da39e13
Drop initialization to NULL since filelist_read() will take care of it.
zas_
parents:
779
diff
changeset
|
1012 GList *d; |
586 | 1013 |
783 | 1014 if (filelist_read(fd, &f, &d)) |
586 | 1015 { |
1016 f = filelist_filter(f, FALSE); | |
1017 f = filelist_sort_path(f); | |
1018 *list = g_list_concat(*list, f); | |
1019 | |
1020 d = filelist_filter(d, TRUE); | |
1021 d = filelist_sort_path(d); | |
1022 filelist_recursive_append(list, d); | |
1023 filelist_free(d); | |
1024 } | |
1025 | |
1026 work = work->next; | |
1027 } | |
1028 } | |
1029 | |
783 | 1030 GList *filelist_recursive(FileData *dir_fd) |
586 | 1031 { |
780
44128da39e13
Drop initialization to NULL since filelist_read() will take care of it.
zas_
parents:
779
diff
changeset
|
1032 GList *list; |
44128da39e13
Drop initialization to NULL since filelist_read() will take care of it.
zas_
parents:
779
diff
changeset
|
1033 GList *d; |
586 | 1034 |
783 | 1035 if (!filelist_read(dir_fd, &list, &d)) return NULL; |
586 | 1036 list = filelist_filter(list, FALSE); |
1037 list = filelist_sort_path(list); | |
1038 | |
1039 d = filelist_filter(d, TRUE); | |
1040 d = filelist_sort_path(d); | |
1041 filelist_recursive_append(&list, d); | |
1042 filelist_free(d); | |
1043 | |
1044 return list; | |
1045 } | |
590 | 1046 |
1047 | |
800 | 1048 /* |
1049 * marks and orientation | |
1050 */ | |
995 | 1051 |
1052 | |
800 | 1053 gboolean file_data_get_mark(FileData *fd, gint n) |
1054 { | |
1055 return !!(fd->marks & (1 << n)); | |
1056 } | |
1057 | |
966 | 1058 guint file_data_get_marks(FileData *fd) |
1059 { | |
1060 return fd->marks; | |
1061 } | |
1062 | |
800 | 1063 void file_data_set_mark(FileData *fd, gint n, gboolean value) |
1064 { | |
965 | 1065 guint old = fd->marks; |
800 | 1066 if (!value == !(fd->marks & (1 << n))) return; |
1067 | |
1068 fd->marks = fd->marks ^ (1 << n); | |
965 | 1069 |
1070 if (old && !fd->marks) /* keep files with non-zero marks in memory */ | |
1071 { | |
1072 file_data_unref(fd); | |
1073 } | |
1074 else if (!old && fd->marks) | |
1075 { | |
1076 file_data_ref(fd); | |
1077 } | |
1078 | |
800 | 1079 file_data_increment_version(fd); |
1080 file_data_send_notification(fd, NOTIFY_TYPE_INTERNAL); | |
1081 } | |
1082 | |
964 | 1083 gboolean file_data_filter_marks(FileData *fd, guint filter) |
1084 { | |
1085 return ((fd->marks & filter) == filter); | |
1086 } | |
1087 | |
1088 GList *file_data_filter_marks_list(GList *list, guint filter) | |
1089 { | |
1090 GList *work; | |
1091 | |
1092 work = list; | |
1093 while (work) | |
1094 { | |
1095 FileData *fd = work->data; | |
1096 GList *link = work; | |
1097 work = work->next; | |
1098 | |
1099 if (!file_data_filter_marks(fd, filter)) | |
1100 { | |
1101 list = g_list_remove_link(list, link); | |
1102 file_data_unref(fd); | |
1103 g_list_free(link); | |
1104 } | |
1105 } | |
1106 | |
1107 return list; | |
1108 } | |
1109 | |
800 | 1110 gint file_data_get_user_orientation(FileData *fd) |
1111 { | |
1112 return fd->user_orientation; | |
1113 } | |
1114 | |
1115 void file_data_set_user_orientation(FileData *fd, gint value) | |
1116 { | |
1117 if (fd->user_orientation == value) return; | |
1118 | |
1119 fd->user_orientation = value; | |
1120 file_data_increment_version(fd); | |
1121 file_data_send_notification(fd, NOTIFY_TYPE_INTERNAL); | |
1122 } | |
1123 | |
1124 | |
590 | 1125 /* |
1126 * file_data - operates on the given fd | |
1127 * file_data_sc - operates on the given fd + sidecars - all fds linked via fd->sidecar_files or fd->parent | |
1128 */ | |
1129 | |
1130 | |
1131 /* return list of sidecar file extensions in a string */ | |
596 | 1132 gchar *file_data_sc_list_to_string(FileData *fd) |
1133 { | |
1134 GList *work; | |
1135 GString *result = g_string_new(""); | |
1136 | |
1137 work = fd->sidecar_files; | |
1138 while (work) | |
1139 { | |
1140 FileData *sfd = work->data; | |
806 | 1141 |
596 | 1142 result = g_string_append(result, "+ "); |
1143 result = g_string_append(result, sfd->extension); | |
1144 work = work->next; | |
1145 if (work) result = g_string_append_c(result, ' '); | |
1146 } | |
1147 | |
1148 return g_string_free(result, FALSE); | |
1149 } | |
590 | 1150 |
1151 | |
995 | 1152 |
1153 /* | |
1154 * add FileDataChangeInfo (see typedefs.h) for the given operation | |
590 | 1155 * uses file_data_add_change_info |
1156 * | |
1157 * fails if the fd->change already exists - change operations can't run in parallel | |
1158 * fd->change_info works as a lock | |
1159 * | |
1160 * dest can be NULL - in this case the current name is used for now, it will | |
995 | 1161 * be changed later |
590 | 1162 */ |
1163 | |
1164 /* | |
1165 FileDataChangeInfo types: | |
1166 COPY | |
950 | 1167 MOVE - path is changed, name may be changed too |
590 | 1168 RENAME - path remains unchanged, name is changed |
1169 extension should remain (FIXME should we allow editing extension? it will make problems wth grouping) | |
1170 sidecar names are changed too, extensions are not changed | |
1171 DELETE | |
995 | 1172 UPDATE - file size, date or grouping has been changed |
590 | 1173 */ |
1174 | |
1175 gboolean file_data_add_ci(FileData *fd, FileDataChangeType type, const gchar *src, const gchar *dest) | |
1176 { | |
1177 FileDataChangeInfo *fdci; | |
1178 | |
1179 if (fd->change) return FALSE; | |
1180 | |
1181 fdci = g_new0(FileDataChangeInfo, 1); | |
1182 | |
1183 fdci->type = type; | |
1184 | |
1185 if (src) | |
1186 fdci->source = g_strdup(src); | |
1187 else | |
1188 fdci->source = g_strdup(fd->path); | |
1189 | |
1190 if (dest) | |
1191 fdci->dest = g_strdup(dest); | |
1192 | |
1193 fd->change = fdci; | |
1194 | |
1195 return TRUE; | |
1196 } | |
1197 | |
912
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1198 static void file_data_planned_change_remove(FileData *fd) |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1199 { |
995 | 1200 if (file_data_planned_change_hash && |
912
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1201 (fd->change->type == FILEDATA_CHANGE_MOVE || fd->change->type == FILEDATA_CHANGE_RENAME)) |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1202 { |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1203 if (g_hash_table_lookup(file_data_planned_change_hash, fd->change->dest) == fd) |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1204 { |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1205 DEBUG_1("planned change: removing %s -> %s", fd->change->dest, fd->path); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1206 g_hash_table_remove(file_data_planned_change_hash, fd->change->dest); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1207 file_data_unref(fd); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1208 if (g_hash_table_size(file_data_planned_change_hash) == 0) |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1209 { |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1210 g_hash_table_destroy(file_data_planned_change_hash); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1211 file_data_planned_change_hash = NULL; |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1212 DEBUG_1("planned change: empty"); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1213 } |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1214 } |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1215 } |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1216 } |
995 | 1217 |
912
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1218 |
590 | 1219 void file_data_free_ci(FileData *fd) |
1220 { | |
1221 FileDataChangeInfo *fdci = fd->change; | |
1222 | |
1223 if (!fdci) | |
1224 return; | |
1225 | |
912
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1226 file_data_planned_change_remove(fd); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
1227 |
590 | 1228 g_free(fdci->source); |
1229 g_free(fdci->dest); | |
1230 | |
1231 g_free(fdci); | |
1232 | |
1233 fd->change = NULL; | |
1234 } | |
1235 | |
995 | 1236 |
590 | 1237 static gboolean file_data_sc_add_ci(FileData *fd, FileDataChangeType type) |
1238 { | |
1239 GList *work; | |
806 | 1240 |
590 | 1241 if (fd->parent) fd = fd->parent; |
1242 | |
1243 if (fd->change) return FALSE; | |
806 | 1244 |
590 | 1245 work = fd->sidecar_files; |
1246 while (work) | |
1247 { | |
1248 FileData *sfd = work->data; | |
806 | 1249 |
590 | 1250 if (sfd->change) return FALSE; |
1251 work = work->next; | |
1252 } | |
1253 | |
1254 file_data_add_ci(fd, type, NULL, NULL); | |
1255 | |
1256 work = fd->sidecar_files; | |
1257 while (work) | |
1258 { | |
1259 FileData *sfd = work->data; | |
806 | 1260 |
590 | 1261 file_data_add_ci(sfd, type, NULL, NULL); |
1262 work = work->next; | |
1263 } | |
1264 | |
995 | 1265 return TRUE; |
590 | 1266 } |
1267 | |
1268 static gboolean file_data_sc_check_ci(FileData *fd, FileDataChangeType type) | |
1269 { | |
1270 GList *work; | |
806 | 1271 |
590 | 1272 if (fd->parent) fd = fd->parent; |
1273 | |
806 | 1274 if (!fd->change || fd->change->type != type) return FALSE; |
1275 | |
590 | 1276 work = fd->sidecar_files; |
1277 while (work) | |
1278 { | |
1279 FileData *sfd = work->data; | |
806 | 1280 |
1281 if (!sfd->change || sfd->change->type != type) return FALSE; | |
590 | 1282 work = work->next; |
1283 } | |
806 | 1284 |
590 | 1285 return TRUE; |
1286 } | |
1287 | |
1288 | |
751 | 1289 gboolean file_data_sc_add_ci_copy(FileData *fd, const gchar *dest_path) |
590 | 1290 { |
1291 if (!file_data_sc_add_ci(fd, FILEDATA_CHANGE_COPY)) return FALSE; | |
1292 file_data_sc_update_ci_copy(fd, dest_path); | |
1293 return TRUE; | |
1294 } | |
1295 | |
751 | 1296 gboolean file_data_sc_add_ci_move(FileData *fd, const gchar *dest_path) |
590 | 1297 { |
1298 if (!file_data_sc_add_ci(fd, FILEDATA_CHANGE_MOVE)) return FALSE; | |
1299 file_data_sc_update_ci_move(fd, dest_path); | |
1300 return TRUE; | |
1301 } | |
1302 | |
751 | 1303 gboolean file_data_sc_add_ci_rename(FileData *fd, const gchar *dest_path) |
590 | 1304 { |
1305 if (!file_data_sc_add_ci(fd, FILEDATA_CHANGE_RENAME)) return FALSE; | |
1306 file_data_sc_update_ci_rename(fd, dest_path); | |
1307 return TRUE; | |
1308 } | |
1309 | |
1310 gboolean file_data_sc_add_ci_delete(FileData *fd) | |
1311 { | |
1312 return file_data_sc_add_ci(fd, FILEDATA_CHANGE_DELETE); | |
1313 } | |
1314 | |
753 | 1315 gboolean file_data_sc_add_ci_unspecified(FileData *fd, const gchar *dest_path) |
590 | 1316 { |
753 | 1317 if (!file_data_sc_add_ci(fd, FILEDATA_CHANGE_UNSPECIFIED)) return FALSE; |
1318 file_data_sc_update_ci_unspecified(fd, dest_path); | |
1319 return TRUE; | |
590 | 1320 } |
1321 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1322 gboolean file_data_add_ci_write_metadata(FileData *fd) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1323 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1324 return file_data_add_ci(fd, FILEDATA_CHANGE_WRITE_METADATA, NULL, NULL); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1325 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1326 |
590 | 1327 void file_data_sc_free_ci(FileData *fd) |
1328 { | |
1329 GList *work; | |
806 | 1330 |
590 | 1331 if (fd->parent) fd = fd->parent; |
1332 | |
1333 file_data_free_ci(fd); | |
1334 | |
1335 work = fd->sidecar_files; | |
1336 while (work) | |
1337 { | |
1338 FileData *sfd = work->data; | |
806 | 1339 |
590 | 1340 file_data_free_ci(sfd); |
1341 work = work->next; | |
1342 } | |
1343 } | |
1344 | |
751 | 1345 gboolean file_data_sc_add_ci_delete_list(GList *fd_list) |
1346 { | |
1347 GList *work; | |
1348 gboolean ret = TRUE; | |
806 | 1349 |
751 | 1350 work = fd_list; |
1351 while (work) | |
1352 { | |
1353 FileData *fd = work->data; | |
806 | 1354 |
751 | 1355 if (!file_data_sc_add_ci_delete(fd)) ret = FALSE; |
1356 work = work->next; | |
1357 } | |
806 | 1358 |
751 | 1359 return ret; |
1360 } | |
1361 | |
913 | 1362 static void file_data_sc_revert_ci_list(GList *fd_list) |
751 | 1363 { |
1364 GList *work; | |
806 | 1365 |
751 | 1366 work = fd_list; |
1367 while (work) | |
1368 { | |
1369 FileData *fd = work->data; | |
806 | 1370 |
913 | 1371 file_data_sc_free_ci(fd); |
1372 work = work->prev; | |
1373 } | |
1374 } | |
1375 | |
923 | 1376 static gboolean file_data_sc_add_ci_list_call_func(GList *fd_list, const gchar *dest, gboolean (*func)(FileData *, const gchar *)) |
913 | 1377 { |
1378 GList *work; | |
1379 | |
1380 work = fd_list; | |
1381 while (work) | |
1382 { | |
1383 FileData *fd = work->data; | |
1384 | |
995 | 1385 if (!func(fd, dest)) |
913 | 1386 { |
1387 file_data_sc_revert_ci_list(work->prev); | |
1388 return FALSE; | |
1389 } | |
751 | 1390 work = work->next; |
1391 } | |
806 | 1392 |
913 | 1393 return TRUE; |
751 | 1394 } |
1395 | |
923 | 1396 gboolean file_data_sc_add_ci_copy_list(GList *fd_list, const gchar *dest) |
1397 { | |
1398 return file_data_sc_add_ci_list_call_func(fd_list, dest, file_data_sc_add_ci_copy); | |
1399 } | |
1400 | |
751 | 1401 gboolean file_data_sc_add_ci_move_list(GList *fd_list, const gchar *dest) |
1402 { | |
923 | 1403 return file_data_sc_add_ci_list_call_func(fd_list, dest, file_data_sc_add_ci_move); |
751 | 1404 } |
1405 | |
1406 gboolean file_data_sc_add_ci_rename_list(GList *fd_list, const gchar *dest) | |
1407 { | |
923 | 1408 return file_data_sc_add_ci_list_call_func(fd_list, dest, file_data_sc_add_ci_rename); |
751 | 1409 } |
1410 | |
753 | 1411 gboolean file_data_sc_add_ci_unspecified_list(GList *fd_list, const gchar *dest) |
1412 { | |
923 | 1413 return file_data_sc_add_ci_list_call_func(fd_list, dest, file_data_sc_add_ci_unspecified); |
753 | 1414 } |
1415 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1416 gboolean file_data_add_ci_write_metadata_list(GList *fd_list) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1417 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1418 GList *work; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1419 gboolean ret = TRUE; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1420 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1421 work = fd_list; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1422 while (work) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1423 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1424 FileData *fd = work->data; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1425 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1426 if (!file_data_add_ci_write_metadata(fd)) ret = FALSE; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1427 work = work->next; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1428 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1429 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1430 return ret; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1431 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1432 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1433 void file_data_free_ci_list(GList *fd_list) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1434 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1435 GList *work; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1436 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1437 work = fd_list; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1438 while (work) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1439 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1440 FileData *fd = work->data; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1441 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1442 file_data_free_ci(fd); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1443 work = work->next; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1444 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1445 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1446 |
751 | 1447 void file_data_sc_free_ci_list(GList *fd_list) |
1448 { | |
1449 GList *work; | |
806 | 1450 |
751 | 1451 work = fd_list; |
1452 while (work) | |
1453 { | |
1454 FileData *fd = work->data; | |
806 | 1455 |
751 | 1456 file_data_sc_free_ci(fd); |
1457 work = work->next; | |
1458 } | |
1459 } | |
590 | 1460 |
995 | 1461 /* |
590 | 1462 * update existing fd->change, it will be used from dialog callbacks for interactive editing |
1463 * fails if fd->change does not exist or the change type does not match | |
1464 */ | |
1465 | |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1466 static void file_data_update_planned_change_hash(FileData *fd, const gchar *old_path, gchar *new_path) |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1467 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1468 FileDataChangeType type = fd->change->type; |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1469 |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1470 if (type == FILEDATA_CHANGE_MOVE || type == FILEDATA_CHANGE_RENAME) |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1471 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1472 FileData *ofd; |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1473 |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1474 if (!file_data_planned_change_hash) |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1475 file_data_planned_change_hash = g_hash_table_new(g_str_hash, g_str_equal); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1476 |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1477 if (old_path && g_hash_table_lookup(file_data_planned_change_hash, old_path) == fd) |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1478 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1479 DEBUG_1("planned change: removing %s -> %s", old_path, fd->path); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1480 g_hash_table_remove(file_data_planned_change_hash, old_path); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1481 file_data_unref(fd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1482 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1483 |
918 | 1484 ofd = g_hash_table_lookup(file_data_planned_change_hash, new_path); |
1485 if (ofd != fd) | |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1486 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1487 if (ofd) |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1488 { |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1489 DEBUG_1("planned change: replacing %s -> %s", new_path, ofd->path); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1490 g_hash_table_remove(file_data_planned_change_hash, new_path); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1491 file_data_unref(ofd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1492 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1493 |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1494 DEBUG_1("planned change: inserting %s -> %s", new_path, fd->path); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1495 file_data_ref(fd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1496 g_hash_table_insert(file_data_planned_change_hash, new_path, fd); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1497 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1498 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1499 } |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1500 |
751 | 1501 static void file_data_update_ci_dest(FileData *fd, const gchar *dest_path) |
590 | 1502 { |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1503 gchar *old_path = fd->change->dest; |
918 | 1504 |
590 | 1505 fd->change->dest = g_strdup(dest_path); |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1506 file_data_update_planned_change_hash(fd, old_path, fd->change->dest); |
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1507 g_free(old_path); |
590 | 1508 } |
1509 | |
751 | 1510 static void file_data_update_ci_dest_preserve_ext(FileData *fd, const gchar *dest_path) |
590 | 1511 { |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
998
diff
changeset
|
1512 const gchar *extension = extension_from_path(fd->change->source); |
751 | 1513 gchar *base = remove_extension_from_path(dest_path); |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1514 gchar *old_path = fd->change->dest; |
806 | 1515 |
920
408879d2a660
Use g_strconcat() instead of g_strdup_printf("%s%s", ...).
zas_
parents:
918
diff
changeset
|
1516 fd->change->dest = g_strconcat(base, extension, NULL); |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1517 file_data_update_planned_change_hash(fd, old_path, fd->change->dest); |
806 | 1518 |
899
5d9c0b4e6d5f
fixed the case when a renamed file is detected by directory scanning
nadvornik
parents:
896
diff
changeset
|
1519 g_free(old_path); |
751 | 1520 g_free(base); |
590 | 1521 } |
1522 | |
751 | 1523 static void file_data_sc_update_ci(FileData *fd, const gchar *dest_path) |
590 | 1524 { |
1525 GList *work; | |
751 | 1526 gchar *dest_path_full = NULL; |
806 | 1527 |
590 | 1528 if (fd->parent) fd = fd->parent; |
1529 | |
995 | 1530 if (!dest_path) |
934 | 1531 { |
1532 dest_path = fd->path; | |
1533 } | |
1534 else if (!strchr(dest_path, G_DIR_SEPARATOR)) /* we got only filename, not a full path */ | |
751 | 1535 { |
1536 gchar *dir = remove_level_from_path(fd->path); | |
806 | 1537 |
751 | 1538 dest_path_full = g_build_filename(dir, dest_path, NULL); |
1539 g_free(dir); | |
1540 dest_path = dest_path_full; | |
1541 } | |
934 | 1542 else if (fd->change->type != FILEDATA_CHANGE_RENAME && isdir(dest_path)) /* rename should not move files between directories */ |
751 | 1543 { |
1544 dest_path_full = g_build_filename(dest_path, fd->name, NULL); | |
1545 dest_path = dest_path_full; | |
1546 } | |
806 | 1547 |
1548 file_data_update_ci_dest(fd, dest_path); | |
751 | 1549 |
590 | 1550 work = fd->sidecar_files; |
1551 while (work) | |
1552 { | |
1553 FileData *sfd = work->data; | |
806 | 1554 |
590 | 1555 file_data_update_ci_dest_preserve_ext(sfd, dest_path); |
1556 work = work->next; | |
1557 } | |
806 | 1558 |
751 | 1559 g_free(dest_path_full); |
590 | 1560 } |
1561 | |
950 | 1562 static gint file_data_sc_check_update_ci(FileData *fd, const gchar *dest_path, FileDataChangeType type) |
590 | 1563 { |
950 | 1564 if (!file_data_sc_check_ci(fd, type)) return FALSE; |
590 | 1565 file_data_sc_update_ci(fd, dest_path); |
1566 return TRUE; | |
1567 } | |
1568 | |
950 | 1569 gint file_data_sc_update_ci_copy(FileData *fd, const gchar *dest_path) |
1570 { | |
1571 return file_data_sc_check_update_ci(fd, dest_path, FILEDATA_CHANGE_COPY); | |
1572 } | |
1573 | |
1574 gint file_data_sc_update_ci_move(FileData *fd, const gchar *dest_path) | |
1575 { | |
1576 return file_data_sc_check_update_ci(fd, dest_path, FILEDATA_CHANGE_MOVE); | |
1577 } | |
1578 | |
751 | 1579 gint file_data_sc_update_ci_rename(FileData *fd, const gchar *dest_path) |
590 | 1580 { |
950 | 1581 return file_data_sc_check_update_ci(fd, dest_path, FILEDATA_CHANGE_RENAME); |
590 | 1582 } |
1583 | |
753 | 1584 gint file_data_sc_update_ci_unspecified(FileData *fd, const gchar *dest_path) |
1585 { | |
950 | 1586 return file_data_sc_check_update_ci(fd, dest_path, FILEDATA_CHANGE_UNSPECIFIED); |
753 | 1587 } |
1588 | |
950 | 1589 static gboolean file_data_sc_update_ci_list_call_func(GList *fd_list, |
1590 const gchar *dest, | |
1591 gboolean (*func)(FileData *, const gchar *)) | |
751 | 1592 { |
1593 GList *work; | |
1594 gboolean ret = TRUE; | |
806 | 1595 |
751 | 1596 work = fd_list; |
1597 while (work) | |
1598 { | |
1599 FileData *fd = work->data; | |
806 | 1600 |
950 | 1601 if (!func(fd, dest)) ret = FALSE; |
751 | 1602 work = work->next; |
1603 } | |
806 | 1604 |
751 | 1605 return ret; |
1606 } | |
1607 | |
950 | 1608 gboolean file_data_sc_update_ci_move_list(GList *fd_list, const gchar *dest) |
1609 { | |
1610 return file_data_sc_update_ci_list_call_func(fd_list, dest, file_data_sc_update_ci_move); | |
1611 } | |
1612 | |
751 | 1613 gboolean file_data_sc_update_ci_copy_list(GList *fd_list, const gchar *dest) |
1614 { | |
950 | 1615 return file_data_sc_update_ci_list_call_func(fd_list, dest, file_data_sc_update_ci_copy); |
751 | 1616 } |
1617 | |
753 | 1618 gboolean file_data_sc_update_ci_unspecified_list(GList *fd_list, const gchar *dest) |
1619 { | |
950 | 1620 return file_data_sc_update_ci_list_call_func(fd_list, dest, file_data_sc_update_ci_unspecified); |
753 | 1621 } |
1622 | |
590 | 1623 |
1624 /* | |
929 | 1625 * verify source and dest paths - dest image exists, etc. |
590 | 1626 * it should detect all possible problems with the planned operation |
1627 */ | |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1628 |
928 | 1629 gint file_data_verify_ci(FileData *fd) |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1630 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1631 gint ret = CHANGE_OK; |
929 | 1632 gchar *dir; |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1633 |
942 | 1634 if (!fd->change) |
1635 { | |
1636 DEBUG_1("Change checked: no change info: %s", fd->path); | |
995 | 1637 return ret; |
942 | 1638 } |
929 | 1639 |
1211 | 1640 if (!isname(fd->path) && |
1641 !filter_file_class(fd->extension, FORMAT_CLASS_META)) /* xmp sidecar can be eventually created from scratch */ | |
929 | 1642 { |
1643 /* this probably should not happen */ | |
1644 ret |= CHANGE_NO_SRC; | |
1645 DEBUG_1("Change checked: file does not exist: %s", fd->path); | |
995 | 1646 return ret; |
929 | 1647 } |
1648 | |
1649 dir = remove_level_from_path(fd->path); | |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1650 |
995 | 1651 if (fd->change->type != FILEDATA_CHANGE_DELETE && |
1211 | 1652 fd->change->type != FILEDATA_CHANGE_WRITE_METADATA && |
929 | 1653 !access_file(fd->path, R_OK)) |
1654 { | |
1655 ret |= CHANGE_NO_READ_PERM; | |
1656 DEBUG_1("Change checked: no read permission: %s", fd->path); | |
1657 } | |
1658 else if ((fd->change->type == FILEDATA_CHANGE_DELETE || fd->change->type == FILEDATA_CHANGE_MOVE) && | |
995 | 1659 !access_file(dir, W_OK)) |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1660 { |
929 | 1661 ret |= CHANGE_NO_WRITE_PERM_DIR; |
1662 DEBUG_1("Change checked: source dir is readonly: %s", fd->path); | |
1663 } | |
995 | 1664 else if (fd->change->type != FILEDATA_CHANGE_COPY && |
1665 fd->change->type != FILEDATA_CHANGE_UNSPECIFIED && | |
1211 | 1666 fd->change->type != FILEDATA_CHANGE_WRITE_METADATA && |
995 | 1667 !access_file(fd->path, W_OK)) |
929 | 1668 { |
1669 ret |= CHANGE_WARN_NO_WRITE_PERM; | |
1670 DEBUG_1("Change checked: no write permission: %s", fd->path); | |
1671 } | |
1211 | 1672 /* WRITE_METADATA is special because it can be configured to silently write to ~/.geeqie/... |
1673 - that means that there are no hard errors and warnings can be disabled | |
1674 */ | |
1675 else if (fd->change->type == FILEDATA_CHANGE_WRITE_METADATA && | |
1676 options->metadata.save_in_image_file && options->metadata.warn_on_write_problems) | |
1677 { | |
1678 if (isname(fd->path) && !access_file(fd->path, W_OK)) | |
1679 { | |
1680 ret |= CHANGE_WARN_NO_WRITE_PERM; | |
1681 DEBUG_1("Change checked: file is readonly: %s", fd->path); | |
1682 } | |
1683 | |
1684 else if (!access_file(dir, W_OK)) | |
1685 { | |
1686 ret |= CHANGE_WARN_NO_WRITE_PERM; | |
1687 DEBUG_1("Change checked: dir is readonly: %s", fd->path); | |
1688 } | |
1689 } | |
1690 | |
929 | 1691 if (fd->change->dest) |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1692 { |
953 | 1693 gboolean same; |
951 | 1694 gchar *dest_dir; |
955 | 1695 |
953 | 1696 same = (strcmp(fd->path, fd->change->dest) == 0); |
1697 | |
955 | 1698 if (!same) |
933 | 1699 { |
955 | 1700 const gchar *dest_ext = extension_from_path(fd->change->dest); |
1701 if (!dest_ext) dest_ext = ""; | |
933 | 1702 |
955 | 1703 if (strcasecmp(fd->extension, dest_ext) != 0) |
1704 { | |
1705 ret |= CHANGE_WARN_CHANGED_EXT; | |
1706 DEBUG_1("Change checked: source and destination have different extensions: %s -> %s", fd->path, fd->change->dest); | |
1707 } | |
1708 } | |
1709 else | |
933 | 1710 { |
955 | 1711 if (fd->change->type != FILEDATA_CHANGE_UNSPECIFIED) /* FIXME this is now needed for running editors */ |
1712 { | |
1713 ret |= CHANGE_WARN_SAME; | |
1714 DEBUG_1("Change checked: source and destination are the same: %s -> %s", fd->path, fd->change->dest); | |
1715 } | |
1716 } | |
933 | 1717 |
951 | 1718 dest_dir = remove_level_from_path(fd->change->dest); |
1719 | |
995 | 1720 if (!isdir(dest_dir)) |
929 | 1721 { |
1722 ret |= CHANGE_NO_DEST_DIR; | |
1723 DEBUG_1("Change checked: destination dir does not exist: %s -> %s", fd->path, fd->change->dest); | |
1724 } | |
1725 else if (!access_file(dest_dir, W_OK)) | |
1726 { | |
1727 ret |= CHANGE_NO_WRITE_PERM_DEST_DIR; | |
1728 DEBUG_1("Change checked: destination dir is readonly: %s -> %s", fd->path, fd->change->dest); | |
1729 } | |
955 | 1730 else if (!same) |
929 | 1731 { |
955 | 1732 if (isfile(fd->change->dest)) |
952 | 1733 { |
955 | 1734 if (!access_file(fd->change->dest, W_OK)) |
1735 { | |
1736 ret |= CHANGE_NO_WRITE_PERM_DEST; | |
1737 DEBUG_1("Change checked: destination file exists and is readonly: %s -> %s", fd->path, fd->change->dest); | |
1738 } | |
1739 else | |
1740 { | |
1741 ret |= CHANGE_WARN_DEST_EXISTS; | |
1742 DEBUG_1("Change checked: destination exists: %s -> %s", fd->path, fd->change->dest); | |
1743 } | |
952 | 1744 } |
955 | 1745 else if (isdir(fd->change->dest)) |
952 | 1746 { |
955 | 1747 ret |= CHANGE_DEST_EXISTS; |
952 | 1748 DEBUG_1("Change checked: destination exists: %s -> %s", fd->path, fd->change->dest); |
1749 } | |
929 | 1750 } |
951 | 1751 |
1752 g_free(dest_dir); | |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1753 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1754 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1755 fd->change->error = ret; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1756 if (ret == 0) DEBUG_1("Change checked: OK: %s", fd->path); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1757 |
929 | 1758 g_free(dir); |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1759 return ret; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1760 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1761 |
995 | 1762 |
928 | 1763 gint file_data_sc_verify_ci(FileData *fd) |
590 | 1764 { |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1765 GList *work; |
928 | 1766 gint ret; |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1767 |
928 | 1768 ret = file_data_verify_ci(fd); |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1769 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1770 work = fd->sidecar_files; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1771 while (work) |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1772 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1773 FileData *sfd = work->data; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1774 |
928 | 1775 ret |= file_data_verify_ci(sfd); |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1776 work = work->next; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1777 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1778 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
913
diff
changeset
|
1779 return ret; |
590 | 1780 } |
1781 | |
928 | 1782 gchar *file_data_get_error_string(gint error) |
1783 { | |
1784 GString *result = g_string_new(""); | |
590 | 1785 |
929 | 1786 if (error & CHANGE_NO_SRC) |
1787 { | |
1788 if (result->len > 0) g_string_append(result, ", "); | |
1789 g_string_append(result, _("file or directory does not exist")); | |
1790 } | |
1791 | |
1792 if (error & CHANGE_DEST_EXISTS) | |
1793 { | |
1794 if (result->len > 0) g_string_append(result, ", "); | |
1795 g_string_append(result, _("destination already exists")); | |
1796 } | |
1797 | |
1798 if (error & CHANGE_NO_WRITE_PERM_DEST) | |
1799 { | |
1800 if (result->len > 0) g_string_append(result, ", "); | |
1801 g_string_append(result, _("destination can't be overwritten")); | |
1802 } | |
1803 | |
1804 if (error & CHANGE_NO_WRITE_PERM_DEST_DIR) | |
1805 { | |
1806 if (result->len > 0) g_string_append(result, ", "); | |
1807 g_string_append(result, _("destination directory is not writable")); | |
1808 } | |
1809 | |
1810 if (error & CHANGE_NO_DEST_DIR) | |
1811 { | |
1812 if (result->len > 0) g_string_append(result, ", "); | |
1813 g_string_append(result, _("destination directory does not exist")); | |
1814 } | |
1815 | |
1816 if (error & CHANGE_NO_WRITE_PERM_DIR) | |
1817 { | |
1818 if (result->len > 0) g_string_append(result, ", "); | |
1819 g_string_append(result, _("source directory is not writable")); | |
1820 } | |
1821 | |
1822 if (error & CHANGE_NO_READ_PERM) | |
928 | 1823 { |
1824 if (result->len > 0) g_string_append(result, ", "); | |
1825 g_string_append(result, _("no read permission")); | |
1826 } | |
1827 | |
929 | 1828 if (error & CHANGE_WARN_NO_WRITE_PERM) |
928 | 1829 { |
1830 if (result->len > 0) g_string_append(result, ", "); | |
929 | 1831 g_string_append(result, _("file is readonly")); |
1832 } | |
1833 | |
1834 if (error & CHANGE_WARN_DEST_EXISTS) | |
1835 { | |
1836 if (result->len > 0) g_string_append(result, ", "); | |
1837 g_string_append(result, _("destination already exists and will be overwritten")); | |
1838 } | |
933 | 1839 |
929 | 1840 if (error & CHANGE_WARN_SAME) |
1841 { | |
1842 if (result->len > 0) g_string_append(result, ", "); | |
948 | 1843 g_string_append(result, _("source and destination are the same")); |
928 | 1844 } |
1845 | |
933 | 1846 if (error & CHANGE_WARN_CHANGED_EXT) |
1847 { | |
1848 if (result->len > 0) g_string_append(result, ", "); | |
1849 g_string_append(result, _("source and destination have different extension")); | |
1850 } | |
1851 | |
928 | 1852 return g_string_free(result, FALSE); |
1853 } | |
1854 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1855 gint file_data_verify_ci_list(GList *list, gchar **desc, gboolean with_sidecars) |
928 | 1856 { |
956 | 1857 GList *work; |
928 | 1858 gint all_errors = 0; |
995 | 1859 gint common_errors = ~0; |
928 | 1860 gint num; |
1861 gint *errors; | |
1862 gint i; | |
1863 | |
1864 if (!list) return 0; | |
1865 | |
1866 num = g_list_length(list); | |
1867 errors = g_new(int, num); | |
956 | 1868 work = list; |
928 | 1869 i = 0; |
1870 while (work) | |
1871 { | |
1872 FileData *fd; | |
1873 gint error; | |
1874 | |
1875 fd = work->data; | |
1876 work = work->next; | |
1877 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1878 error = with_sidecars ? file_data_sc_verify_ci(fd) : file_data_verify_ci(fd); |
928 | 1879 all_errors |= error; |
1880 common_errors &= error; | |
1881 | |
1882 errors[i] = error; | |
1883 | |
1884 i++; | |
1885 } | |
1886 | |
1887 if (desc && all_errors) | |
1888 { | |
956 | 1889 GList *work; |
928 | 1890 GString *result = g_string_new(""); |
1891 | |
1892 if (common_errors) | |
1893 { | |
1894 gchar *str = file_data_get_error_string(common_errors); | |
1895 g_string_append(result, str); | |
1896 g_string_append(result, "\n"); | |
1897 g_free(str); | |
1898 } | |
1899 | |
956 | 1900 work = list; |
928 | 1901 i = 0; |
1902 while (work) | |
1903 { | |
1904 FileData *fd; | |
1905 gint error; | |
1906 | |
1907 fd = work->data; | |
1908 work = work->next; | |
1909 | |
1910 error = errors[i] & ~common_errors; | |
1911 | |
1912 if (error) | |
1913 { | |
1914 gchar *str = file_data_get_error_string(error); | |
1915 g_string_append_printf(result, "%s: %s\n", fd->name, str); | |
1916 g_free(str); | |
1917 } | |
1918 i++; | |
1919 } | |
1920 *desc = g_string_free(result, FALSE); | |
1921 } | |
1922 | |
1923 g_free(errors); | |
1924 return all_errors; | |
1925 } | |
590 | 1926 |
1927 | |
1928 /* | |
1929 * perform the change described by FileFataChangeInfo | |
995 | 1930 * it is used for internal operations, |
590 | 1931 * this function actually operates with files on the filesystem |
1932 * it should implement safe delete | |
1933 */ | |
995 | 1934 |
590 | 1935 static gboolean file_data_perform_move(FileData *fd) |
1936 { | |
1937 g_assert(!strcmp(fd->change->source, fd->path)); | |
1938 return move_file(fd->change->source, fd->change->dest); | |
1939 } | |
1940 | |
1941 static gboolean file_data_perform_copy(FileData *fd) | |
1942 { | |
1943 g_assert(!strcmp(fd->change->source, fd->path)); | |
1944 return copy_file(fd->change->source, fd->change->dest); | |
1945 } | |
1946 | |
1947 static gboolean file_data_perform_delete(FileData *fd) | |
1948 { | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
892
diff
changeset
|
1949 if (isdir(fd->path) && !islink(fd->path)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
892
diff
changeset
|
1950 return rmdir_utf8(fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
892
diff
changeset
|
1951 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
892
diff
changeset
|
1952 return unlink_file(fd->path); |
590 | 1953 } |
1954 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1955 gboolean file_data_perform_ci(FileData *fd) |
590 | 1956 { |
1957 FileDataChangeType type = fd->change->type; | |
1958 switch (type) | |
1959 { | |
1960 case FILEDATA_CHANGE_MOVE: | |
1961 return file_data_perform_move(fd); | |
1962 case FILEDATA_CHANGE_COPY: | |
1963 return file_data_perform_copy(fd); | |
1964 case FILEDATA_CHANGE_RENAME: | |
1965 return file_data_perform_move(fd); /* the same as move */ | |
1966 case FILEDATA_CHANGE_DELETE: | |
1967 return file_data_perform_delete(fd); | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1968 case FILEDATA_CHANGE_WRITE_METADATA: |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
1969 return metadata_write_perform(fd); |
753 | 1970 case FILEDATA_CHANGE_UNSPECIFIED: |
596 | 1971 /* nothing to do here */ |
590 | 1972 break; |
1973 } | |
1974 return TRUE; | |
1975 } | |
1976 | |
1977 | |
1978 | |
1979 gboolean file_data_sc_perform_ci(FileData *fd) | |
1980 { | |
1981 GList *work; | |
1982 gboolean ret = TRUE; | |
1983 FileDataChangeType type = fd->change->type; | |
806 | 1984 |
590 | 1985 if (!file_data_sc_check_ci(fd, type)) return FALSE; |
1986 | |
1987 work = fd->sidecar_files; | |
1988 while (work) | |
1989 { | |
1990 FileData *sfd = work->data; | |
806 | 1991 |
590 | 1992 if (!file_data_perform_ci(sfd)) ret = FALSE; |
1993 work = work->next; | |
1994 } | |
806 | 1995 |
590 | 1996 if (!file_data_perform_ci(fd)) ret = FALSE; |
806 | 1997 |
590 | 1998 return ret; |
1999 } | |
2000 | |
2001 /* | |
2002 * updates FileData structure according to FileDataChangeInfo | |
2003 */ | |
912
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
2004 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
2005 gint file_data_apply_ci(FileData *fd) |
590 | 2006 { |
2007 FileDataChangeType type = fd->change->type; | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
2008 |
590 | 2009 /* FIXME delete ?*/ |
773 | 2010 if (type == FILEDATA_CHANGE_MOVE || type == FILEDATA_CHANGE_RENAME) |
590 | 2011 { |
912
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
2012 DEBUG_1("planned change: applying %s -> %s", fd->change->dest, fd->path); |
9108a7158c02
remove items from file_data_planned_change_hash when the operation is
nadvornik
parents:
910
diff
changeset
|
2013 file_data_planned_change_remove(fd); |
915 | 2014 |
2015 if (g_hash_table_lookup(file_data_pool, fd->change->dest)) | |
2016 { | |
2017 /* this change overwrites another file which is already known to other modules | |
2018 renaming fd would create duplicate FileData structure | |
2019 the best thing we can do is nothing | |
2020 FIXME: maybe we could copy stuff like marks | |
2021 */ | |
2022 DEBUG_1("can't rename fd, target exists %s -> %s", fd->change->dest, fd->path); | |
2023 } | |
2024 else | |
2025 { | |
2026 file_data_set_path(fd, fd->change->dest); | |
2027 } | |
590 | 2028 } |
763
81f9e8dbb4bf
improved infrastructure for tracing changes, optimized vflist_populate_view
nadvornik
parents:
753
diff
changeset
|
2029 file_data_increment_version(fd); |
800 | 2030 file_data_send_notification(fd, NOTIFY_TYPE_CHANGE); |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
2031 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1055
diff
changeset
|
2032 return TRUE; |
590 | 2033 } |
2034 | |
596 | 2035 gint file_data_sc_apply_ci(FileData *fd) |
590 | 2036 { |
2037 GList *work; | |
2038 FileDataChangeType type = fd->change->type; | |
806 | 2039 |
590 | 2040 if (!file_data_sc_check_ci(fd, type)) return FALSE; |
2041 | |
2042 work = fd->sidecar_files; | |
2043 while (work) | |
2044 { | |
2045 FileData *sfd = work->data; | |
806 | 2046 |
590 | 2047 file_data_apply_ci(sfd); |
2048 work = work->next; | |
2049 } | |
806 | 2050 |
590 | 2051 file_data_apply_ci(fd); |
806 | 2052 |
590 | 2053 return TRUE; |
2054 } | |
2055 | |
2056 /* | |
2057 * notify other modules about the change described by FileFataChangeInfo | |
2058 */ | |
995 | 2059 |
590 | 2060 /* might use file_maint_ functions for now, later it should be changed to a system of callbacks |
2061 FIXME do we need the ignore_list? It looks like a workaround for ineffective | |
2062 implementation in view_file_list.c */ | |
2063 | |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2064 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2065 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2066 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2067 typedef struct _NotifyData NotifyData; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2068 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2069 struct _NotifyData { |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2070 FileDataNotifyFunc func; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2071 gpointer data; |
791 | 2072 NotifyPriority priority; |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2073 }; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2074 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2075 static GList *notify_func_list = NULL; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2076 |
791 | 2077 static gint file_data_notify_sort(gconstpointer a, gconstpointer b) |
2078 { | |
2079 NotifyData *nda = (NotifyData *)a; | |
2080 NotifyData *ndb = (NotifyData *)b; | |
806 | 2081 |
791 | 2082 if (nda->priority < ndb->priority) return -1; |
2083 if (nda->priority > ndb->priority) return 1; | |
2084 return 0; | |
2085 } | |
2086 | |
2087 gint file_data_register_notify_func(FileDataNotifyFunc func, gpointer data, NotifyPriority priority) | |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2088 { |
806 | 2089 NotifyData *nd; |
2090 | |
2091 nd = g_new(NotifyData, 1); | |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2092 nd->func = func; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2093 nd->data = data; |
791 | 2094 nd->priority = priority; |
806 | 2095 |
791 | 2096 notify_func_list = g_list_insert_sorted(notify_func_list, nd, file_data_notify_sort); |
2097 DEBUG_1("Notify func registered: %p", nd); | |
806 | 2098 |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2099 return TRUE; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2100 } |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2101 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2102 gint file_data_unregister_notify_func(FileDataNotifyFunc func, gpointer data) |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2103 { |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2104 GList *work = notify_func_list; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2105 |
806 | 2106 while (work) |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2107 { |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2108 NotifyData *nd = (NotifyData *)work->data; |
806 | 2109 |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2110 if (nd->func == func && nd->data == data) |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2111 { |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2112 notify_func_list = g_list_delete_link(notify_func_list, work); |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2113 g_free(nd); |
791 | 2114 DEBUG_1("Notify func unregistered: %p", nd); |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2115 return TRUE; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2116 } |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2117 work = work->next; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2118 } |
806 | 2119 |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2120 return FALSE; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2121 } |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2122 |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2123 |
792 | 2124 void file_data_send_notification(FileData *fd, NotifyType type) |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2125 { |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2126 GList *work = notify_func_list; |
806 | 2127 |
2128 while (work) | |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2129 { |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2130 NotifyData *nd = (NotifyData *)work->data; |
806 | 2131 |
791 | 2132 DEBUG_1("Notify func calling: %p %s", nd, fd->path); |
792 | 2133 nd->func(fd, type, nd->data); |
784
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2134 work = work->next; |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2135 } |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2136 } |
16b3a5c8aedc
new notification system (used only in vflist for now)
nadvornik
parents:
783
diff
changeset
|
2137 |
791 | 2138 static GHashTable *file_data_monitor_pool = NULL; |
2139 static gint realtime_monitor_id = -1; | |
2140 | |
2141 static void realtime_monitor_check_cb(gpointer key, gpointer value, gpointer data) | |
2142 { | |
2143 FileData *fd = key; | |
2144 | |
801 | 2145 file_data_check_changed_files(fd); |
791 | 2146 |
2147 DEBUG_1("monitor %s", fd->path); | |
2148 } | |
2149 | |
2150 static gboolean realtime_monitor_cb(gpointer data) | |
2151 { | |
903
c93823609f15
periodic testing of changed files can be now disabled
nadvornik
parents:
899
diff
changeset
|
2152 if (!options->update_on_time_change) return TRUE; |
791 | 2153 g_hash_table_foreach(file_data_monitor_pool, realtime_monitor_check_cb, NULL); |
2154 return TRUE; | |
2155 } | |
2156 | |
2157 gint file_data_register_real_time_monitor(FileData *fd) | |
2158 { | |
950 | 2159 gint count; |
791 | 2160 |
2161 file_data_ref(fd); | |
2162 | |
2163 if (!file_data_monitor_pool) | |
2164 file_data_monitor_pool = g_hash_table_new(g_direct_hash, g_direct_equal); | |
2165 | |
2166 count = GPOINTER_TO_INT(g_hash_table_lookup(file_data_monitor_pool, fd)); | |
2167 | |
2168 DEBUG_1("Register realtime %d %s", count, fd->path); | |
2169 | |
2170 count++; | |
2171 g_hash_table_insert(file_data_monitor_pool, fd, GINT_TO_POINTER(count)); | |
2172 | |
2173 if (realtime_monitor_id == -1) | |
2174 { | |
2175 realtime_monitor_id = g_timeout_add(5000, realtime_monitor_cb, NULL); | |
2176 } | |
806 | 2177 |
791 | 2178 return TRUE; |
2179 } | |
2180 | |
2181 gint file_data_unregister_real_time_monitor(FileData *fd) | |
2182 { | |
2183 gint count; | |
806 | 2184 |
791 | 2185 g_assert(file_data_monitor_pool); |
2186 | |
2187 count = GPOINTER_TO_INT(g_hash_table_lookup(file_data_monitor_pool, fd)); | |
2188 | |
2189 DEBUG_1("Unregister realtime %d %s", count, fd->path); | |
2190 | |
2191 g_assert(count > 0); | |
2192 | |
2193 count--; | |
2194 | |
2195 if (count == 0) | |
2196 g_hash_table_remove(file_data_monitor_pool, fd); | |
2197 else | |
2198 g_hash_table_insert(file_data_monitor_pool, fd, GINT_TO_POINTER(count)); | |
2199 | |
2200 file_data_unref(fd); | |
2201 | |
2202 if (g_hash_table_size(file_data_monitor_pool) == 0) | |
2203 { | |
2204 g_source_remove(realtime_monitor_id); | |
2205 realtime_monitor_id = -1; | |
2206 return FALSE; | |
2207 } | |
806 | 2208 |
791 | 2209 return TRUE; |
2210 } | |
1055
1646720364cf
Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents:
1023
diff
changeset
|
2211 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ |