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