Mercurial > geeqie
annotate src/bar_info.c @ 793:baade53888be
used new notification in cache_maint
author | nadvornik |
---|---|
date | Fri, 06 Jun 2008 22:34:15 +0000 |
parents | e73d30e0c896 |
children | efed9a1520d6 |
rev | line source |
---|---|
9 | 1 /* |
196 | 2 * Geeqie |
9 | 3 * (C) 2004 John Ellis |
475 | 4 * Copyright (C) 2008 The Geeqie Team |
9 | 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 | |
281 | 14 #include "main.h" |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
15 #include "exif.h" |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
16 |
9 | 17 #include "bar_info.h" |
18 | |
19 #include "cache.h" | |
586 | 20 #include "filedata.h" |
9 | 21 #include "info.h" |
314 | 22 #include "secure_save.h" |
9 | 23 #include "utilops.h" |
24 #include "ui_bookmark.h" | |
25 #include "ui_fileops.h" | |
26 #include "ui_misc.h" | |
27 #include "ui_utildlg.h" | |
28 | |
29 | |
30 #define BAR_KEYWORD_AUTOSAVE_TIME 10000 | |
31 | |
32 | |
33 static const gchar *keyword_favorite_defaults[] = { | |
34 N_("Favorite"), | |
35 N_("Todo"), | |
36 N_("People"), | |
37 N_("Places"), | |
38 N_("Art"), | |
39 N_("Nature"), | |
40 N_("Possessions"), | |
41 NULL | |
42 }; | |
43 | |
44 | |
45 static void bar_info_keyword_update_all(void); | |
46 | |
47 | |
48 /* | |
49 *------------------------------------------------------------------- | |
50 * keyword / comment utils | |
51 *------------------------------------------------------------------- | |
52 */ | |
53 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
54 static gint comment_file_write(gchar *path, GList *keywords, const gchar *comment) |
9 | 55 { |
314 | 56 SecureSaveInfo *ssi; |
9 | 57 |
314 | 58 ssi = secure_open(path); |
59 if (!ssi) return FALSE; | |
9 | 60 |
314 | 61 secure_fprintf(ssi, "#%s comment (%s)\n\n", GQ_APPNAME, VERSION); |
9 | 62 |
314 | 63 secure_fprintf(ssi, "[keywords]\n"); |
64 while (keywords && secsave_errno == SS_ERR_NONE) | |
9 | 65 { |
66 const gchar *word = keywords->data; | |
67 keywords = keywords->next; | |
68 | |
314 | 69 secure_fprintf(ssi, "%s\n", word); |
9 | 70 } |
314 | 71 secure_fputc(ssi, '\n'); |
9 | 72 |
314 | 73 secure_fprintf(ssi, "[comment]\n"); |
74 secure_fprintf(ssi, "%s\n", (comment) ? comment : ""); | |
9 | 75 |
314 | 76 secure_fprintf(ssi, "#end\n"); |
9 | 77 |
314 | 78 return (secure_close(ssi) == 0); |
9 | 79 } |
80 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
81 static gint comment_legacy_write(FileData *fd, GList *keywords, const gchar *comment) |
9 | 82 { |
83 gchar *comment_path; | |
84 gint success = FALSE; | |
85 | |
86 /* If an existing metadata file exists, we will try writing to | |
87 * it's location regardless of the user's preference. | |
88 */ | |
138 | 89 comment_path = cache_find_location(CACHE_TYPE_METADATA, fd->path); |
9 | 90 if (comment_path && !access_file(comment_path, W_OK)) |
91 { | |
92 g_free(comment_path); | |
93 comment_path = NULL; | |
94 } | |
95 | |
96 if (!comment_path) | |
97 { | |
98 gchar *comment_dir; | |
99 mode_t mode = 0755; | |
100 | |
138 | 101 comment_dir = cache_get_location(CACHE_TYPE_METADATA, fd->path, FALSE, &mode); |
9 | 102 if (cache_ensure_dir_exists(comment_dir, mode)) |
103 { | |
700 | 104 gchar *filename = g_strconcat(fd->name, GQ_CACHE_EXT_METADATA, NULL); |
105 | |
106 comment_path = g_build_filename(comment_dir, filename, NULL); | |
107 g_free(filename); | |
9 | 108 } |
109 g_free(comment_dir); | |
110 } | |
111 | |
112 if (comment_path) | |
113 { | |
114 gchar *comment_pathl; | |
115 | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
116 DEBUG_1("Saving comment: %s", comment_path); |
9 | 117 |
118 comment_pathl = path_from_utf8(comment_path); | |
119 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
120 success = comment_file_write(comment_pathl, keywords, comment); |
9 | 121 |
122 g_free(comment_pathl); | |
123 g_free(comment_path); | |
124 } | |
125 | |
126 return success; | |
127 } | |
128 | |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
129 typedef enum { |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
130 MK_NONE, |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
131 MK_KEYWORDS, |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
132 MK_COMMENT |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
133 } MetadataKey; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
134 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
135 static gint comment_file_read(gchar *path, GList **keywords, gchar **comment) |
9 | 136 { |
137 FILE *f; | |
138 gchar s_buf[1024]; | |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
139 MetadataKey key = MK_NONE; |
9 | 140 GList *list = NULL; |
141 GString *comment_build = NULL; | |
142 | |
143 f = fopen(path, "r"); | |
144 if (!f) return FALSE; | |
145 | |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
146 while (fgets(s_buf, sizeof(s_buf), f)) |
9 | 147 { |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
148 gchar *ptr = s_buf; |
9 | 149 |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
150 if (*ptr == '#') continue; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
151 if (*ptr == '[') |
9 | 152 { |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
153 gchar *keystr = ++ptr; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
154 |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
155 key = MK_NONE; |
516 | 156 while (*ptr != ']' && *ptr != '\n' && *ptr != '\0') ptr++; |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
157 |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
158 if (*ptr == ']') |
9 | 159 { |
160 *ptr = '\0'; | |
604
0b203af63dbf
Use g_ascii_strcasecmp() instead of strcasecmp() where ascii-only strings
zas_
parents:
595
diff
changeset
|
161 if (g_ascii_strcasecmp(keystr, "keywords") == 0) |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
162 key = MK_KEYWORDS; |
604
0b203af63dbf
Use g_ascii_strcasecmp() instead of strcasecmp() where ascii-only strings
zas_
parents:
595
diff
changeset
|
163 else if (g_ascii_strcasecmp(keystr, "comment") == 0) |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
164 key = MK_COMMENT; |
9 | 165 } |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
166 continue; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
167 } |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
168 |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
169 switch(key) |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
170 { |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
171 case MK_NONE: |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
172 break; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
173 case MK_KEYWORDS: |
9 | 174 { |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
175 while (*ptr != '\n' && *ptr != '\0') ptr++; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
176 *ptr = '\0'; |
647
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
177 if (strlen(s_buf) > 0) |
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
178 { |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
179 gchar *kw = utf8_validate_or_convert(s_buf); |
647
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
180 |
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
181 list = g_list_prepend(list, kw); |
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
182 } |
9 | 183 } |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
184 break; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
185 case MK_COMMENT: |
9 | 186 if (!comment_build) comment_build = g_string_new(""); |
187 g_string_append(comment_build, s_buf); | |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
188 break; |
9 | 189 } |
190 } | |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
191 |
9 | 192 fclose(f); |
193 | |
194 *keywords = g_list_reverse(list); | |
195 if (comment_build) | |
196 { | |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
197 if (comment) |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
198 { |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
199 gint len; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
200 gchar *ptr = comment_build->str; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
201 |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
202 /* strip leading and trailing newlines */ |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
203 while (*ptr == '\n') ptr++; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
204 len = strlen(ptr); |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
205 while (len > 0 && ptr[len - 1] == '\n') len--; |
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
206 if (ptr[len] == '\n') len++; /* keep the last one */ |
647
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
207 if (len > 0) |
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
208 { |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
209 gchar *text = g_strndup(ptr, len); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
210 |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
211 *comment = utf8_validate_or_convert(text); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
212 g_free(text); |
647
42d36db921bc
Ensure that we end with UTF8 encoded comment and keywords.
zas_
parents:
646
diff
changeset
|
213 } |
445
89f8bffbce21
comment_file_read(): rewrite the parser, drop leading and trailing newlines
zas_
parents:
442
diff
changeset
|
214 } |
9 | 215 g_string_free(comment_build, TRUE); |
216 } | |
217 | |
218 return TRUE; | |
219 } | |
220 | |
204 | 221 static gint comment_delete_legacy(FileData *fd) |
222 { | |
223 gchar *comment_path; | |
224 gchar *comment_pathl; | |
225 gint success = FALSE; | |
226 if (!fd) return FALSE; | |
227 | |
228 comment_path = cache_find_location(CACHE_TYPE_METADATA, fd->path); | |
229 if (!comment_path) return FALSE; | |
230 | |
231 comment_pathl = path_from_utf8(comment_path); | |
232 | |
233 success = !unlink(comment_pathl); | |
234 | |
235 g_free(comment_pathl); | |
236 g_free(comment_path); | |
237 | |
238 return success; | |
239 } | |
240 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
241 static gint comment_legacy_read(FileData *fd, GList **keywords, gchar **comment) |
9 | 242 { |
243 gchar *comment_path; | |
244 gchar *comment_pathl; | |
245 gint success = FALSE; | |
138 | 246 if (!fd) return FALSE; |
9 | 247 |
138 | 248 comment_path = cache_find_location(CACHE_TYPE_METADATA, fd->path); |
9 | 249 if (!comment_path) return FALSE; |
250 | |
251 comment_pathl = path_from_utf8(comment_path); | |
252 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
253 success = comment_file_read(comment_pathl, keywords, comment); |
9 | 254 |
255 g_free(comment_pathl); | |
256 g_free(comment_path); | |
257 | |
258 return success; | |
259 } | |
260 | |
642
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
261 static GList *remove_duplicate_strings_from_list(GList *list) |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
262 { |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
263 GList *work = list; |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
264 GHashTable *hashtable = g_hash_table_new(g_str_hash, g_str_equal); |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
265 GList *newlist = NULL; |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
266 |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
267 while (work) |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
268 { |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
269 gchar *key = work->data; |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
270 |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
271 if (g_hash_table_lookup(hashtable, key) == NULL) |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
272 { |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
273 g_hash_table_insert(hashtable, (gpointer) key, GINT_TO_POINTER(1)); |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
274 newlist = g_list_prepend(newlist, key); |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
275 } |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
276 work = work->next; |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
277 } |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
278 |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
279 g_hash_table_destroy(hashtable); |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
280 g_list_free(list); |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
281 |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
282 return g_list_reverse(newlist); |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
283 } |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
284 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
285 #define COMMENT_KEY "Xmp.dc.description" |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
286 #define KEYWORD_KEY "Xmp.dc.subject" |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
287 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
288 static gint comment_xmp_read(FileData *fd, GList **keywords, gchar **comment) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
289 { |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
290 ExifData *exif; |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
291 |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
292 exif = exif_read_fd(fd); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
293 if (!exif) return FALSE; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
294 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
295 if (comment) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
296 { |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
297 gchar *text; |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
298 ExifItem *item = exif_get_item(exif, COMMENT_KEY); |
646
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
299 |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
300 text = exif_item_get_string(item, 0); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
301 *comment = utf8_validate_or_convert(text); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
302 g_free(text); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
303 } |
442 | 304 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
305 if (keywords) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
306 { |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
307 ExifItem *item; |
734
e6ebae313d46
Fix up some types, make some signed vs unsigned warnings quiet.
zas_
parents:
700
diff
changeset
|
308 guint i; |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
309 |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
310 *keywords = NULL; |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
311 item = exif_get_item(exif, KEYWORD_KEY); |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
312 for (i = 0; i < exif_item_get_elements(item); i++) |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
313 { |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
314 gchar *kw = exif_item_get_string(item, i); |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
315 gchar *utf8_kw; |
442 | 316 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
317 if (!kw) break; |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
318 |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
319 utf8_kw = utf8_validate_or_convert(kw); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
320 *keywords = g_list_append(*keywords, (gpointer) utf8_kw); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
321 g_free(kw); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
322 } |
646
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
323 |
643
eaf94facc190
Disable non-working Iptc.Application2.Keywords reading introduced in revision 736.
zas_
parents:
642
diff
changeset
|
324 /* FIXME: |
eaf94facc190
Disable non-working Iptc.Application2.Keywords reading introduced in revision 736.
zas_
parents:
642
diff
changeset
|
325 * Exiv2 handles Iptc keywords as multiple entries with the |
eaf94facc190
Disable non-working Iptc.Application2.Keywords reading introduced in revision 736.
zas_
parents:
642
diff
changeset
|
326 * same key, thus exif_get_item returns only the first keyword |
eaf94facc190
Disable non-working Iptc.Application2.Keywords reading introduced in revision 736.
zas_
parents:
642
diff
changeset
|
327 * and the only way to get all keywords is to iterate through |
eaf94facc190
Disable non-working Iptc.Application2.Keywords reading introduced in revision 736.
zas_
parents:
642
diff
changeset
|
328 * the item list. |
eaf94facc190
Disable non-working Iptc.Application2.Keywords reading introduced in revision 736.
zas_
parents:
642
diff
changeset
|
329 */ |
646
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
330 for (item = exif_get_first_item(exif); |
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
331 item; |
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
332 item = exif_get_next_item(exif)) |
642
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
333 { |
646
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
334 guint tag; |
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
335 |
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
336 tag = exif_item_get_tag_id(item); |
651
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
337 if (tag == 0x0019) |
646
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
338 { |
651
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
339 gchar *tag_name = exif_item_get_tag_name(item); |
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
340 |
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
341 if (strcmp(tag_name, "Iptc.Application2.Keywords") == 0) |
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
342 { |
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
343 gchar *kw; |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
344 gchar *utf8_kw; |
642
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
345 |
651
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
346 kw = exif_item_get_data_as_text(item); |
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
347 if (!kw) continue; |
767
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
348 |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
349 utf8_kw = utf8_validate_or_convert(kw); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
350 *keywords = g_list_append(*keywords, (gpointer) utf8_kw); |
e73d30e0c896
Make utf8_validate_or_convert() to always allocate a new string.
zas_
parents:
734
diff
changeset
|
351 g_free(kw); |
651
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
352 } |
ac87e9688188
Comparing tag id is not sufficient, check the tag name too.
zas_
parents:
647
diff
changeset
|
353 g_free(tag_name); |
646
91dfc98f3ca1
Reading of Iptc.Application2.Keywords should now be fixed.
zas_
parents:
643
diff
changeset
|
354 } |
642
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
355 } |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
356 } |
442 | 357 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
358 exif_free(exif); |
442 | 359 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
360 return (comment && *comment) || (keywords && *keywords); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
361 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
362 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
363 static gint comment_xmp_write(FileData *fd, GList *keywords, const gchar *comment) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
364 { |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
365 gint success; |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
366 gint write_comment = (comment && comment[0]); |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
367 ExifData *exif; |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
368 ExifItem *item; |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
369 |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
370 exif = exif_read_fd(fd); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
371 if (!exif) return FALSE; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
372 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
373 item = exif_get_item(exif, COMMENT_KEY); |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
374 if (item && !write_comment) |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
375 { |
442 | 376 exif_item_delete(exif, item); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
377 item = NULL; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
378 } |
442 | 379 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
380 if (!item && write_comment) item = exif_add_item(exif, COMMENT_KEY); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
381 if (item) exif_item_set_string(item, comment); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
382 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
383 while ((item = exif_get_item(exif, KEYWORD_KEY))) |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
384 { |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
385 exif_item_delete(exif, item); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
386 } |
442 | 387 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
388 if (keywords) |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
389 { |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
390 GList *work; |
442 | 391 |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
392 item = exif_add_item(exif, KEYWORD_KEY); |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
393 |
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
394 work = keywords; |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
395 while (work) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
396 { |
593
bb712693cad3
comment_xmp_read(), comment_xmp_write(): cleanup and improve readibility.
zas_
parents:
586
diff
changeset
|
397 exif_item_set_string(item, (gchar *) work->data); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
398 work = work->next; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
399 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
400 } |
442 | 401 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
402 success = exif_write(exif); |
442 | 403 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
404 exif_free(exif); |
442 | 405 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
406 return success; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
407 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
408 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
409 gint comment_write(FileData *fd, GList *keywords, const gchar *comment) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
410 { |
204 | 411 if (!fd) return FALSE; |
412 | |
594
4cfce4ed35e0
Use a dedicated option to enable keywords and comment saving as XMP tags
zas_
parents:
593
diff
changeset
|
413 if (options->save_metadata_in_image_file && |
204 | 414 comment_xmp_write(fd, keywords, comment)) |
415 { | |
416 comment_delete_legacy(fd); | |
417 return TRUE; | |
418 } | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
419 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
420 return comment_legacy_write(fd, keywords, comment); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
421 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
422 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
423 gint comment_read(FileData *fd, GList **keywords, gchar **comment) |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
424 { |
253 | 425 GList *keywords1 = NULL; |
426 GList *keywords2 = NULL; | |
427 gchar *comment1 = NULL; | |
428 gchar *comment2 = NULL; | |
204 | 429 gint res1, res2; |
430 | |
431 if (!fd) return FALSE; | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
432 |
204 | 433 res1 = comment_xmp_read(fd, &keywords1, &comment1); |
434 res2 = comment_legacy_read(fd, &keywords2, &comment2); | |
442 | 435 |
204 | 436 if (!res1 && !res2) |
437 { | |
438 return FALSE; | |
439 } | |
442 | 440 |
204 | 441 if (keywords) |
442 { | |
443 if (res1 && res2) | |
444 *keywords = g_list_concat(keywords1, keywords2); | |
445 else | |
446 *keywords = res1 ? keywords1 : keywords2; | |
642
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
447 |
9c74ff4bf1cd
Extract and append keywords from Iptc.Application2.Keywords tags.
zas_
parents:
604
diff
changeset
|
448 *keywords = remove_duplicate_strings_from_list(*keywords); |
204 | 449 } |
450 else | |
451 { | |
452 if (res1) string_list_free(keywords1); | |
453 if (res2) string_list_free(keywords2); | |
454 } | |
442 | 455 |
204 | 456 |
457 if (comment) | |
458 { | |
459 if (res1 && res2 && comment1 && comment2 && comment1[0] && comment2[0]) | |
460 *comment = g_strdup_printf("%s\n%s", comment1, comment2); | |
461 else | |
462 *comment = res1 ? comment1 : comment2; | |
463 } | |
464 if (res1 && (!comment || *comment != comment1)) g_free(comment1); | |
465 if (res2 && (!comment || *comment != comment2)) g_free(comment2); | |
442 | 466 |
204 | 467 return TRUE; |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
468 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
469 |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
470 |
9 | 471 static gchar *comment_pull(GtkWidget *textview) |
472 { | |
473 GtkTextBuffer *buffer; | |
474 GtkTextIter start, end; | |
442 | 475 |
9 | 476 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); |
477 gtk_text_buffer_get_bounds(buffer, &start, &end); | |
442 | 478 |
9 | 479 return gtk_text_buffer_get_text(buffer, &start, &end, FALSE); |
480 } | |
481 | |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
482 static gint keyword_list_find(GList *list, const gchar *keyword) |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
483 { |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
484 while (list) |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
485 { |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
486 gchar *haystack = list->data; |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
487 |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
488 if (haystack && keyword && strcmp(haystack, keyword) == 0) return TRUE; |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
489 |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
490 list = list->next; |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
491 } |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
492 |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
493 return FALSE; |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
494 } |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
495 |
9 | 496 GList *keyword_list_pull(GtkWidget *text_widget) |
497 { | |
498 GList *list = NULL; | |
499 gchar *text; | |
500 gchar *ptr; | |
501 | |
502 if (GTK_IS_TEXT_VIEW(text_widget)) | |
503 { | |
504 text = comment_pull(text_widget); | |
505 } | |
506 else if (GTK_IS_ENTRY(text_widget)) | |
507 { | |
508 text = g_strdup(gtk_entry_get_text(GTK_ENTRY(text_widget))); | |
509 } | |
510 else | |
511 { | |
512 return NULL; | |
513 } | |
514 | |
515 ptr = text; | |
516 while (*ptr != '\0') | |
517 { | |
518 gchar *begin; | |
519 gint l = 0; | |
520 | |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
521 #define KEYWORDS_SEPARATOR(c) ((c) == ',' || (c) == ';' || (c) == '\n' || (c) == '\r' || (c) == '\b') |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
522 while (KEYWORDS_SEPARATOR(*ptr)) ptr++; |
9 | 523 begin = ptr; |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
524 while (*ptr != '\0' && !KEYWORDS_SEPARATOR(*ptr)) |
9 | 525 { |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
526 ptr++; |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
527 l++; |
9 | 528 } |
442 | 529 |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
530 /* trim starting and ending whitespaces */ |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
531 while (l > 0 && g_ascii_isspace(*begin)) begin++, l--; |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
532 while (l > 0 && g_ascii_isspace(begin[l-1])) l--; |
9 | 533 |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
534 if (l > 0) |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
535 { |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
536 gchar *keyword = g_strndup(begin, l); |
442 | 537 |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
538 /* only add if not already in the list */ |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
539 if (keyword_list_find(list, keyword) == FALSE) |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
540 list = g_list_append(list, keyword); |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
541 else |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
542 g_free(keyword); |
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
543 } |
9 | 544 } |
545 | |
546 g_free(text); | |
547 | |
548 return list; | |
549 } | |
550 | |
551 void keyword_list_push(GtkWidget *textview, GList *list) | |
552 { | |
553 GtkTextBuffer *buffer; | |
554 GtkTextIter start, end; | |
555 | |
556 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); | |
557 gtk_text_buffer_get_bounds(buffer, &start, &end); | |
512
f9bf33be53ff
Remove whitespace between function name and first parenthesis for the sake of consistency.
zas_
parents:
507
diff
changeset
|
558 gtk_text_buffer_delete(buffer, &start, &end); |
9 | 559 |
560 while (list) | |
561 { | |
562 const gchar *word = list->data; | |
563 GtkTextIter iter; | |
564 | |
565 gtk_text_buffer_get_end_iter(buffer, &iter); | |
566 if (word) gtk_text_buffer_insert(buffer, &iter, word, -1); | |
567 gtk_text_buffer_get_end_iter(buffer, &iter); | |
568 gtk_text_buffer_insert(buffer, &iter, "\n", -1); | |
569 | |
570 list = list->next; | |
571 } | |
572 } | |
573 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
574 static void metadata_set_keywords(FileData *fd, GList *keywords_to_use, gchar *comment_to_use, gint add) |
9 | 575 { |
576 gchar *comment = NULL; | |
577 GList *keywords = NULL; | |
578 GList *save_list = NULL; | |
579 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
580 comment_read(fd, &keywords, &comment); |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
581 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
582 if (comment_to_use) |
9 | 583 { |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
584 if (add && comment && *comment) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
585 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
586 gchar *tmp = comment; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
587 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
588 comment = g_strconcat(tmp, comment_to_use, NULL); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
589 g_free(tmp); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
590 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
591 else |
9 | 592 { |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
593 g_free(comment); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
594 comment = g_strdup(comment_to_use); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
595 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
596 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
597 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
598 if (keywords_to_use) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
599 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
600 if (add && keywords && g_list_length(keywords) > 0) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
601 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
602 GList *work; |
9 | 603 |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
604 work = keywords_to_use; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
605 while (work) |
9 | 606 { |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
607 gchar *key; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
608 GList *p; |
9 | 609 |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
610 key = work->data; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
611 work = work->next; |
9 | 612 |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
613 p = keywords; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
614 while (p && key) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
615 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
616 gchar *needle = p->data; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
617 p = p->next; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
618 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
619 if (strcmp(needle, key) == 0) key = NULL; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
620 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
621 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
622 if (key) keywords = g_list_append(keywords, g_strdup(key)); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
623 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
624 save_list = keywords; |
9 | 625 } |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
626 else |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
627 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
628 save_list = keywords_to_use; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
629 } |
9 | 630 } |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
631 |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
632 comment_write(fd, save_list, comment); |
9 | 633 |
138 | 634 string_list_free(keywords); |
9 | 635 g_free(comment); |
636 } | |
637 | |
638 /* | |
639 *------------------------------------------------------------------- | |
640 * keyword list dialog | |
641 *------------------------------------------------------------------- | |
642 */ | |
643 | |
644 #define KEYWORD_DIALOG_WIDTH 200 | |
645 #define KEYWORD_DIALOG_HEIGHT 250 | |
646 | |
647 typedef struct _KeywordDlg KeywordDlg; | |
648 struct _KeywordDlg | |
649 { | |
650 GenericDialog *gd; | |
651 GtkWidget *treeview; | |
652 }; | |
653 | |
654 static KeywordDlg *keyword_dialog = NULL; | |
655 | |
656 | |
657 static void keyword_dialog_cancel_cb(GenericDialog *gd, gpointer data) | |
658 { | |
659 g_free(keyword_dialog); | |
660 keyword_dialog = NULL; | |
661 } | |
662 | |
663 static void keyword_dialog_ok_cb(GenericDialog *gd, gpointer data) | |
664 { | |
665 KeywordDlg *kd = data; | |
666 GtkTreeModel *store; | |
667 GtkTreeIter iter; | |
668 gint valid; | |
669 | |
670 history_list_free_key("keywords"); | |
671 | |
672 store = gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview)); | |
673 valid = gtk_tree_model_get_iter_first(store, &iter); | |
674 while (valid) | |
675 { | |
676 gchar *key; | |
677 | |
678 gtk_tree_model_get(store, &iter, 0, &key, -1); | |
679 valid = gtk_tree_model_iter_next(store, &iter); | |
680 | |
681 history_list_add_to_key("keywords", key, 0); | |
682 } | |
683 | |
684 keyword_dialog_cancel_cb(gd, data); | |
685 | |
686 bar_info_keyword_update_all(); | |
687 } | |
688 | |
689 static void keyword_dialog_add_cb(GtkWidget *button, gpointer data) | |
690 { | |
691 KeywordDlg *kd = data; | |
692 GtkTreeSelection *selection; | |
693 GtkTreeModel *store; | |
694 GtkTreeIter sibling; | |
695 GtkTreeIter iter; | |
696 GtkTreePath *tpath; | |
697 | |
698 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(kd->treeview)); | |
699 if (gtk_tree_selection_get_selected(selection, &store, &sibling)) | |
700 { | |
701 gtk_list_store_insert_before(GTK_LIST_STORE(store), &iter, &sibling); | |
702 } | |
703 else | |
704 { | |
705 store = gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview)); | |
706 gtk_list_store_append(GTK_LIST_STORE(store), &iter); | |
707 } | |
708 | |
709 gtk_list_store_set(GTK_LIST_STORE(store), &iter, 1, TRUE, -1); | |
710 | |
711 tpath = gtk_tree_model_get_path(store, &iter); | |
712 gtk_tree_view_set_cursor(GTK_TREE_VIEW(kd->treeview), tpath, | |
713 gtk_tree_view_get_column(GTK_TREE_VIEW(kd->treeview), 0), TRUE); | |
714 gtk_tree_path_free(tpath); | |
715 } | |
716 | |
717 static void keyword_dialog_remove_cb(GtkWidget *button, gpointer data) | |
718 { | |
719 KeywordDlg *kd = data; | |
720 GtkTreeSelection *selection; | |
721 GtkTreeModel *store; | |
722 GtkTreeIter iter; | |
723 GtkTreeIter next; | |
724 GtkTreePath *tpath; | |
725 | |
726 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(kd->treeview)); | |
727 if (!gtk_tree_selection_get_selected(selection, &store, &iter)) return; | |
728 | |
729 tpath = NULL; | |
730 next = iter; | |
731 if (gtk_tree_model_iter_next(store, &next)) | |
732 { | |
733 tpath = gtk_tree_model_get_path(store, &next); | |
734 } | |
735 else | |
736 { | |
737 tpath = gtk_tree_model_get_path(store, &iter); | |
738 if (!gtk_tree_path_prev(tpath)) | |
739 { | |
740 gtk_tree_path_free(tpath); | |
741 tpath = NULL; | |
742 } | |
743 } | |
744 if (tpath) | |
745 { | |
746 gtk_tree_view_set_cursor(GTK_TREE_VIEW(kd->treeview), tpath, | |
747 gtk_tree_view_get_column(GTK_TREE_VIEW(kd->treeview), 0), FALSE); | |
748 gtk_tree_path_free(tpath); | |
749 } | |
750 | |
751 gtk_list_store_remove(GTK_LIST_STORE(store), &iter); | |
752 } | |
753 | |
754 static void keyword_dialog_edit_cb(GtkCellRendererText *renderer, const gchar *path, | |
755 const gchar *new_text, gpointer data) | |
756 { | |
757 KeywordDlg *kd = data; | |
758 GtkTreeModel *store; | |
759 GtkTreeIter iter; | |
760 GtkTreePath *tpath; | |
761 | |
762 if (!new_text || strlen(new_text) == 0) return; | |
763 | |
764 store = gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview)); | |
765 | |
766 tpath = gtk_tree_path_new_from_string(path); | |
767 gtk_tree_model_get_iter(store, &iter, tpath); | |
768 gtk_tree_path_free(tpath); | |
769 | |
770 gtk_list_store_set(GTK_LIST_STORE(store), &iter, 0, new_text, -1); | |
771 } | |
772 | |
773 static void keyword_dialog_populate(KeywordDlg *kd) | |
774 { | |
775 GtkListStore *store; | |
776 GList *list; | |
777 | |
778 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview))); | |
779 gtk_list_store_clear(store); | |
780 | |
781 list = history_list_get_by_key("keywords"); | |
782 list = g_list_last(list); | |
783 while (list) | |
784 { | |
785 GtkTreeIter iter; | |
786 | |
787 gtk_list_store_append(store, &iter); | |
788 gtk_list_store_set(store, &iter, 0, list->data, | |
789 1, TRUE, -1); | |
790 | |
791 list = list->prev; | |
792 } | |
793 } | |
794 | |
795 static void keyword_dialog_show(void) | |
796 { | |
797 GtkWidget *scrolled; | |
798 GtkListStore *store; | |
799 GtkTreeViewColumn *column; | |
800 GtkCellRenderer *renderer; | |
801 GtkWidget *hbox; | |
802 GtkWidget *button; | |
803 | |
804 if (keyword_dialog) | |
805 { | |
806 gtk_window_present(GTK_WINDOW(keyword_dialog->gd->dialog)); | |
807 return; | |
808 } | |
809 | |
810 keyword_dialog = g_new0(KeywordDlg, 1); | |
811 | |
812 keyword_dialog->gd = generic_dialog_new(_("Keyword Presets"), | |
254
9faf34f047b1
Make the wmclass value unique among the code by defining
zas_
parents:
253
diff
changeset
|
813 GQ_WMCLASS, "keyword_presets", NULL, TRUE, |
9 | 814 keyword_dialog_cancel_cb, keyword_dialog); |
815 generic_dialog_add_message(keyword_dialog->gd, NULL, _("Favorite keywords list"), NULL); | |
816 | |
817 generic_dialog_add_button(keyword_dialog->gd, GTK_STOCK_OK, NULL, | |
818 keyword_dialog_ok_cb, TRUE); | |
819 | |
820 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
821 gtk_widget_set_size_request(scrolled, KEYWORD_DIALOG_WIDTH, KEYWORD_DIALOG_HEIGHT); | |
822 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
823 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
824 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
825 gtk_box_pack_start(GTK_BOX(keyword_dialog->gd->vbox), scrolled, TRUE, TRUE, 5); | |
826 gtk_widget_show(scrolled); | |
827 | |
828 store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_BOOLEAN); | |
829 keyword_dialog->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); | |
830 g_object_unref(store); | |
831 | |
832 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(keyword_dialog->treeview), FALSE); | |
833 gtk_tree_view_set_search_column(GTK_TREE_VIEW(keyword_dialog->treeview), 0); | |
834 gtk_tree_view_set_reorderable(GTK_TREE_VIEW(keyword_dialog->treeview), TRUE); | |
835 | |
836 column = gtk_tree_view_column_new(); | |
837 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); | |
838 renderer = gtk_cell_renderer_text_new(); | |
839 g_signal_connect(G_OBJECT(renderer), "edited", | |
840 G_CALLBACK(keyword_dialog_edit_cb), keyword_dialog); | |
841 gtk_tree_view_column_pack_start(column, renderer, TRUE); | |
842 gtk_tree_view_column_add_attribute(column, renderer, "text", 0); | |
843 gtk_tree_view_column_add_attribute(column, renderer, "editable", 1); | |
844 gtk_tree_view_append_column(GTK_TREE_VIEW(keyword_dialog->treeview), column); | |
845 | |
846 gtk_container_add(GTK_CONTAINER(scrolled), keyword_dialog->treeview); | |
847 gtk_widget_show(keyword_dialog->treeview); | |
848 | |
849 hbox = gtk_hbox_new(FALSE, 5); | |
850 gtk_box_pack_start(GTK_BOX(keyword_dialog->gd->vbox), hbox, FALSE, FALSE, 0); | |
851 gtk_widget_show(hbox); | |
852 | |
853 button = gtk_button_new_from_stock(GTK_STOCK_ADD); | |
854 g_signal_connect(G_OBJECT(button), "clicked", | |
855 G_CALLBACK(keyword_dialog_add_cb), keyword_dialog); | |
856 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); | |
857 gtk_widget_show(button); | |
858 | |
859 button = gtk_button_new_from_stock(GTK_STOCK_REMOVE); | |
860 g_signal_connect(G_OBJECT(button), "clicked", | |
861 G_CALLBACK(keyword_dialog_remove_cb), keyword_dialog); | |
862 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); | |
863 gtk_widget_show(button); | |
864 | |
865 keyword_dialog_populate(keyword_dialog); | |
866 | |
867 gtk_widget_show(keyword_dialog->gd->dialog); | |
868 } | |
869 | |
870 | |
871 static void bar_keyword_edit_cb(GtkWidget *button, gpointer data) | |
872 { | |
873 keyword_dialog_show(); | |
874 } | |
875 | |
876 | |
877 /* | |
878 *------------------------------------------------------------------- | |
879 * info bar | |
880 *------------------------------------------------------------------- | |
881 */ | |
882 | |
883 typedef enum { | |
884 BAR_SORT_COPY, | |
885 BAR_SORT_MOVE, | |
886 BAR_SORT_LINK | |
887 } SortActionType; | |
888 | |
889 enum { | |
890 KEYWORD_COLUMN_TOGGLE = 0, | |
891 KEYWORD_COLUMN_TEXT | |
892 }; | |
893 | |
894 typedef struct _BarInfoData BarInfoData; | |
895 struct _BarInfoData | |
896 { | |
897 GtkWidget *vbox; | |
898 GtkWidget *group_box; | |
899 GtkWidget *label_file_name; | |
900 GtkWidget *label_file_time; | |
901 | |
902 GtkWidget *keyword_view; | |
903 GtkWidget *keyword_treeview; | |
904 | |
905 GtkWidget *comment_view; | |
906 | |
907 GtkWidget *button_save; | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
908 GtkWidget *button_set_keywords_add; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
909 GtkWidget *button_set_keywords_replace; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
910 GtkWidget *button_set_comment_add; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
911 GtkWidget *button_set_comment_replace; |
9 | 912 |
138 | 913 FileData *fd; |
9 | 914 |
915 gint changed; | |
916 gint save_timeout_id; | |
917 | |
918 GList *(*list_func)(gpointer); | |
919 gpointer list_data; | |
920 }; | |
921 | |
922 | |
923 static GList *bar_list = NULL; | |
924 | |
925 | |
926 static void bar_info_write(BarInfoData *bd) | |
927 { | |
928 GList *list; | |
929 gchar *comment; | |
930 | |
138 | 931 if (!bd->fd) return; |
9 | 932 |
933 list = keyword_list_pull(bd->keyword_view); | |
934 comment = comment_pull(bd->comment_view); | |
935 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
936 comment_write(bd->fd, list, comment); |
9 | 937 |
138 | 938 string_list_free(list); |
9 | 939 g_free(comment); |
940 | |
941 bd->changed = FALSE; | |
942 gtk_widget_set_sensitive(bd->button_save, FALSE); | |
943 } | |
944 | |
945 static gint bar_info_autosave(gpointer data) | |
946 { | |
947 BarInfoData *bd = data; | |
948 | |
949 bar_info_write(bd); | |
950 | |
951 bd->save_timeout_id = -1; | |
952 | |
953 return FALSE; | |
954 } | |
955 | |
956 static void bar_info_save_update(BarInfoData *bd, gint enable) | |
957 { | |
958 if (bd->save_timeout_id != -1) | |
959 { | |
960 g_source_remove(bd->save_timeout_id); | |
961 bd->save_timeout_id = -1; | |
962 } | |
963 if (enable) | |
964 { | |
965 bd->save_timeout_id = g_timeout_add(BAR_KEYWORD_AUTOSAVE_TIME, bar_info_autosave, bd); | |
966 } | |
967 } | |
968 | |
969 static void bar_keyword_list_sync(BarInfoData *bd, GList *keywords) | |
970 { | |
971 GList *list; | |
972 GtkListStore *store; | |
973 GtkTreeIter iter; | |
974 | |
975 list = history_list_get_by_key("keywords"); | |
976 if (!list) | |
977 { | |
978 /* blank? set up a few example defaults */ | |
979 | |
980 gint i = 0; | |
981 | |
982 while (keyword_favorite_defaults[i] != NULL) | |
983 { | |
984 history_list_add_to_key("keywords", _(keyword_favorite_defaults[i]), 0); | |
985 i++; | |
986 } | |
987 | |
988 list = history_list_get_by_key("keywords"); | |
989 } | |
990 | |
991 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(bd->keyword_treeview))); | |
992 | |
993 gtk_list_store_clear(store); | |
994 | |
995 list = g_list_last(list); | |
996 while (list) | |
997 { | |
998 gchar *key = list->data; | |
999 | |
1000 gtk_list_store_append(store, &iter); | |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
1001 gtk_list_store_set(store, &iter, KEYWORD_COLUMN_TOGGLE, keyword_list_find(keywords, key), |
9 | 1002 KEYWORD_COLUMN_TEXT, key, -1); |
1003 | |
1004 list = list->prev; | |
1005 } | |
1006 } | |
1007 | |
1008 static void bar_info_keyword_update_all(void) | |
1009 { | |
1010 GList *work; | |
1011 | |
1012 work = bar_list; | |
1013 while (work) | |
1014 { | |
1015 BarInfoData *bd; | |
1016 GList *keywords; | |
1017 | |
1018 bd = work->data; | |
1019 work = work->next; | |
1020 | |
1021 keywords = keyword_list_pull(bd->keyword_view); | |
1022 bar_keyword_list_sync(bd, keywords); | |
138 | 1023 string_list_free(keywords); |
9 | 1024 } |
1025 } | |
1026 | |
1027 static void bar_info_update(BarInfoData *bd) | |
1028 { | |
1029 GList *keywords = NULL; | |
1030 gchar *comment = NULL; | |
1031 | |
1032 if (bd->label_file_name) | |
1033 { | |
138 | 1034 gtk_label_set_text(GTK_LABEL(bd->label_file_name), (bd->fd) ? bd->fd->name : ""); |
9 | 1035 } |
1036 if (bd->label_file_time) | |
1037 { | |
138 | 1038 gtk_label_set_text(GTK_LABEL(bd->label_file_time), (bd->fd) ? text_from_time(bd->fd->date) : ""); |
9 | 1039 } |
1040 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
138
diff
changeset
|
1041 if (comment_read(bd->fd, &keywords, &comment)) |
9 | 1042 { |
1043 keyword_list_push(bd->keyword_view, keywords); | |
1044 gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(bd->comment_view)), | |
1045 (comment) ? comment : "", -1); | |
1046 | |
1047 bar_keyword_list_sync(bd, keywords); | |
1048 | |
138 | 1049 string_list_free(keywords); |
9 | 1050 g_free(comment); |
1051 } | |
1052 else | |
1053 { | |
1054 gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(bd->keyword_view)), "", -1); | |
1055 gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(bd->comment_view)), "", -1); | |
1056 | |
1057 bar_keyword_list_sync(bd, NULL); | |
1058 } | |
1059 | |
1060 bar_info_save_update(bd, FALSE); | |
1061 bd->changed = FALSE; | |
1062 gtk_widget_set_sensitive(bd->button_save, FALSE); | |
1063 | |
138 | 1064 gtk_widget_set_sensitive(bd->group_box, (bd->fd != NULL)); |
9 | 1065 } |
1066 | |
138 | 1067 void bar_info_set(GtkWidget *bar, FileData *fd) |
9 | 1068 { |
1069 BarInfoData *bd; | |
1070 | |
1071 bd = g_object_get_data(G_OBJECT(bar), "bar_info_data"); | |
1072 if (!bd) return; | |
1073 | |
1074 if (bd->changed) bar_info_write(bd); | |
1075 | |
138 | 1076 file_data_unref(bd->fd); |
1077 bd->fd = file_data_ref(fd); | |
9 | 1078 |
1079 bar_info_update(bd); | |
1080 } | |
1081 | |
138 | 1082 void bar_info_maint_renamed(GtkWidget *bar, FileData *fd) |
9 | 1083 { |
1084 BarInfoData *bd; | |
1085 | |
1086 bd = g_object_get_data(G_OBJECT(bar), "bar_info_data"); | |
1087 if (!bd) return; | |
1088 | |
138 | 1089 file_data_unref(bd->fd); |
1090 bd->fd = file_data_ref(fd); | |
9 | 1091 |
1092 if (bd->label_file_name) | |
1093 { | |
138 | 1094 gtk_label_set_text(GTK_LABEL(bd->label_file_name), (bd->fd) ? bd->fd->name : ""); |
9 | 1095 } |
1096 } | |
1097 | |
1098 gint bar_info_event(GtkWidget *bar, GdkEvent *event) | |
1099 { | |
1100 BarInfoData *bd; | |
1101 | |
1102 bd = g_object_get_data(G_OBJECT(bar), "bar_info_data"); | |
1103 if (!bd) return FALSE; | |
1104 | |
1105 if (GTK_WIDGET_HAS_FOCUS(bd->keyword_view)) return gtk_widget_event(bd->keyword_view, event); | |
1106 if (GTK_WIDGET_HAS_FOCUS(bd->comment_view)) return gtk_widget_event(bd->comment_view, event); | |
1107 | |
1108 return FALSE; | |
1109 } | |
1110 | |
1111 static void bar_info_keyword_set(BarInfoData *bd, const gchar *keyword, gint active) | |
1112 { | |
1113 GList *list; | |
1114 gint found; | |
1115 | |
1116 if (!keyword) return; | |
1117 | |
1118 list = keyword_list_pull(bd->keyword_view); | |
427
134beb10d916
Accept keywords composed by two words ("Todo" = "A faire" in french).
zas_
parents:
318
diff
changeset
|
1119 found = keyword_list_find(list, keyword); |
9 | 1120 |
1121 if (active != found) | |
1122 { | |
1123 if (found) | |
1124 { | |
1125 GList *work = list; | |
1126 | |
1127 while (work) | |
1128 { | |
1129 gchar *key = work->data; | |
1130 work = work->next; | |
1131 | |
1132 if (key && keyword && strcmp(key, keyword) == 0) | |
1133 { | |
1134 list = g_list_remove(list, key); | |
1135 g_free(key); | |
1136 } | |
1137 } | |
1138 } | |
1139 else | |
1140 { | |
1141 list = g_list_append(list, g_strdup(keyword)); | |
1142 } | |
1143 | |
1144 keyword_list_push(bd->keyword_view, list); | |
1145 } | |
1146 | |
138 | 1147 string_list_free(list); |
9 | 1148 } |
1149 | |
1150 static void bar_info_keyword_toggle(GtkCellRendererToggle *toggle, const gchar *path, gpointer data) | |
1151 { | |
1152 BarInfoData *bd = data; | |
1153 GtkTreeModel *store; | |
1154 GtkTreeIter iter; | |
1155 GtkTreePath *tpath; | |
1156 gchar *key = NULL; | |
1157 gboolean active; | |
1158 | |
1159 store = gtk_tree_view_get_model(GTK_TREE_VIEW(bd->keyword_treeview)); | |
1160 | |
1161 tpath = gtk_tree_path_new_from_string(path); | |
1162 gtk_tree_model_get_iter(store, &iter, tpath); | |
1163 gtk_tree_path_free(tpath); | |
1164 | |
1165 gtk_tree_model_get(store, &iter, KEYWORD_COLUMN_TOGGLE, &active, | |
1166 KEYWORD_COLUMN_TEXT, &key, -1); | |
1167 active = (!active); | |
1168 gtk_list_store_set(GTK_LIST_STORE(store), &iter, KEYWORD_COLUMN_TOGGLE, active, -1); | |
1169 | |
1170 bar_info_keyword_set(bd, key, active); | |
1171 g_free(key); | |
1172 } | |
1173 | |
1174 static void bar_info_save(GtkWidget *button, gpointer data) | |
1175 { | |
1176 BarInfoData *bd = data; | |
1177 | |
1178 bar_info_save_update(bd, FALSE); | |
1179 bar_info_write(bd); | |
1180 } | |
1181 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1182 static void bar_info_set_selection(BarInfoData *bd, gint set_keywords, gint set_comment, gint add) |
9 | 1183 { |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1184 GList *keywords = NULL; |
9 | 1185 GList *list = NULL; |
1186 GList *work; | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1187 gchar *comment = NULL; |
9 | 1188 |
1189 if (!bd->list_func) return; | |
1190 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1191 if (set_keywords) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1192 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1193 keywords = keyword_list_pull(bd->keyword_view); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1194 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1195 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1196 if (set_comment) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1197 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1198 comment = comment_pull(bd->comment_view); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1199 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1200 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1201 if (add && !keywords && !comment) return; |
9 | 1202 |
1203 list = bd->list_func(bd->list_data); | |
1204 work = list; | |
1205 while (work) | |
1206 { | |
138 | 1207 FileData *fd = work->data; |
9 | 1208 work = work->next; |
1209 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1210 metadata_set_keywords(fd, keywords, comment, add); |
9 | 1211 } |
1212 | |
138 | 1213 filelist_free(list); |
1214 string_list_free(keywords); | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1215 g_free(comment); |
9 | 1216 } |
1217 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1218 static void bar_info_set_keywords_add(GtkWidget *button, gpointer data) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1219 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1220 BarInfoData *bd = data; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1221 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1222 bar_info_set_selection(bd, TRUE, FALSE, TRUE); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1223 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1224 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1225 static void bar_info_set_keywords_replace(GtkWidget *button, gpointer data) |
9 | 1226 { |
1227 BarInfoData *bd = data; | |
1228 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1229 bar_info_set_selection(bd, TRUE, FALSE, FALSE); |
9 | 1230 } |
1231 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1232 static void bar_info_set_comment_add(GtkWidget *button, gpointer data) |
9 | 1233 { |
1234 BarInfoData *bd = data; | |
1235 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1236 bar_info_set_selection(bd, FALSE, TRUE, TRUE); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1237 } |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1238 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1239 static void bar_info_set_comment_replace(GtkWidget *button, gpointer data) |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1240 { |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1241 BarInfoData *bd = data; |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1242 |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1243 bar_info_set_selection(bd, FALSE, TRUE, FALSE); |
9 | 1244 } |
1245 | |
1246 static void bar_info_changed(GtkTextBuffer *buffer, gpointer data) | |
1247 { | |
1248 BarInfoData *bd = data; | |
1249 | |
1250 bd->changed = TRUE; | |
1251 gtk_widget_set_sensitive(bd->button_save, TRUE); | |
1252 | |
1253 bar_info_save_update(bd, TRUE); | |
1254 } | |
1255 | |
1256 void bar_info_close(GtkWidget *bar) | |
1257 { | |
1258 BarInfoData *bd; | |
1259 | |
1260 bd = g_object_get_data(G_OBJECT(bar), "bar_info_data"); | |
1261 if (!bd) return; | |
1262 | |
1263 gtk_widget_destroy(bd->vbox); | |
1264 } | |
1265 | |
1266 static void bar_info_destroy(GtkWidget *widget, gpointer data) | |
1267 { | |
1268 BarInfoData *bd = data; | |
1269 | |
1270 if (bd->changed) bar_info_write(bd); | |
1271 bar_info_save_update(bd, FALSE); | |
1272 | |
1273 bar_list = g_list_remove(bar_list, bd); | |
1274 | |
138 | 1275 file_data_unref(bd->fd); |
9 | 1276 |
1277 g_free(bd); | |
1278 } | |
1279 | |
138 | 1280 GtkWidget *bar_info_new(FileData *fd, gint metadata_only, GtkWidget *bounding_widget) |
9 | 1281 { |
1282 BarInfoData *bd; | |
1283 GtkWidget *box; | |
1284 GtkWidget *hbox; | |
1285 GtkWidget *table; | |
1286 GtkWidget *scrolled; | |
1287 GtkTextBuffer *buffer; | |
1288 GtkWidget *label; | |
1289 GtkWidget *tbar; | |
1290 GtkListStore *store; | |
1291 GtkTreeViewColumn *column; | |
1292 GtkCellRenderer *renderer; | |
1293 | |
1294 bd = g_new0(BarInfoData, 1); | |
1295 | |
1296 bd->list_func = NULL; | |
1297 bd->list_data = NULL; | |
1298 | |
1299 bd->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP); | |
1300 g_object_set_data(G_OBJECT(bd->vbox), "bar_info_data", bd); | |
1301 g_signal_connect(G_OBJECT(bd->vbox), "destroy", | |
1302 G_CALLBACK(bar_info_destroy), bd); | |
1303 | |
1304 if (!metadata_only) | |
1305 { | |
1306 hbox = pref_box_new(bd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP); | |
1307 | |
1308 label = sizer_new(bd->vbox, bounding_widget, SIZER_POS_LEFT); | |
1309 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); | |
1310 gtk_widget_show(label); | |
1311 | |
1312 label = gtk_label_new(_("Keywords")); | |
1313 pref_label_bold(label, TRUE, FALSE); | |
1314 gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); | |
1315 gtk_widget_show(label); | |
1316 } | |
1317 | |
1318 bd->group_box = pref_box_new(bd->vbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP); | |
1319 | |
1320 if (!metadata_only) | |
1321 { | |
1322 GtkWidget *table; | |
1323 | |
1324 table = pref_table_new(bd->group_box, 2, 2, FALSE, FALSE); | |
1325 | |
1326 bd->label_file_name = table_add_line(table, 0, 0, _("Filename:"), NULL); | |
1327 bd->label_file_time = table_add_line(table, 0, 1, _("File date:"), NULL); | |
1328 } | |
1329 else | |
1330 { | |
1331 bd->label_file_name = NULL; | |
1332 bd->label_file_time = NULL; | |
1333 } | |
1334 | |
1335 table = gtk_table_new(3, 1, TRUE); | |
1336 gtk_table_set_row_spacings(GTK_TABLE(table), PREF_PAD_GAP); | |
1337 gtk_box_pack_start(GTK_BOX(bd->group_box), table, TRUE, TRUE, 0); | |
1338 gtk_widget_show(table); | |
1339 | |
1340 /* keyword entry */ | |
1341 | |
1342 box = gtk_vbox_new(FALSE, 0); | |
1343 gtk_table_attach(GTK_TABLE(table), box, 0, 1, 0, 2, | |
1344 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); | |
1345 gtk_widget_show(box); | |
1346 | |
1347 label = pref_label_new(box, _("Keywords:")); | |
1348 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); | |
1349 pref_label_bold(label, TRUE, FALSE); | |
1350 | |
1351 hbox = pref_box_new(box, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP); | |
1352 | |
1353 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
1354 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
1355 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
1356 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
1357 gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); | |
1358 gtk_widget_show(scrolled); | |
1359 | |
1360 bd->keyword_view = gtk_text_view_new(); | |
1361 gtk_container_add(GTK_CONTAINER(scrolled), bd->keyword_view); | |
1362 gtk_widget_show(bd->keyword_view); | |
1363 | |
1364 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(bd->keyword_view)); | |
1365 g_signal_connect(G_OBJECT(buffer), "changed", | |
1366 G_CALLBACK(bar_info_changed), bd); | |
1367 | |
1368 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
1369 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
1370 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
1371 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
1372 gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); | |
1373 gtk_widget_show(scrolled); | |
1374 | |
1375 store = gtk_list_store_new(2, G_TYPE_BOOLEAN, G_TYPE_STRING); | |
1376 bd->keyword_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); | |
1377 g_object_unref(store); | |
1378 | |
1379 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(bd->keyword_treeview), FALSE); | |
1380 | |
1381 if (metadata_only) | |
1382 { | |
1383 gtk_tree_view_set_search_column(GTK_TREE_VIEW(bd->keyword_treeview), KEYWORD_COLUMN_TEXT); | |
1384 } | |
1385 else | |
1386 { | |
1387 gtk_tree_view_set_enable_search(GTK_TREE_VIEW(bd->keyword_treeview), FALSE); | |
1388 } | |
1389 | |
1390 column = gtk_tree_view_column_new(); | |
1391 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); | |
1392 | |
1393 renderer = gtk_cell_renderer_toggle_new(); | |
1394 gtk_tree_view_column_pack_start(column, renderer, FALSE); | |
1395 gtk_tree_view_column_add_attribute(column, renderer, "active", KEYWORD_COLUMN_TOGGLE); | |
1396 g_signal_connect(G_OBJECT(renderer), "toggled", | |
1397 G_CALLBACK(bar_info_keyword_toggle), bd); | |
1398 | |
1399 renderer = gtk_cell_renderer_text_new(); | |
1400 gtk_tree_view_column_pack_start(column, renderer, TRUE); | |
1401 gtk_tree_view_column_add_attribute(column, renderer, "text", KEYWORD_COLUMN_TEXT); | |
1402 | |
1403 gtk_tree_view_append_column(GTK_TREE_VIEW(bd->keyword_treeview), column); | |
1404 | |
1405 gtk_container_add(GTK_CONTAINER(scrolled), bd->keyword_treeview); | |
1406 gtk_widget_show(bd->keyword_treeview); | |
1407 | |
1408 /* comment entry */ | |
1409 | |
1410 box = gtk_vbox_new(FALSE, 0); | |
1411 gtk_table_attach(GTK_TABLE(table), box, 0, 1, 2, 3, | |
1412 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); | |
1413 gtk_widget_show(box); | |
1414 | |
1415 label = pref_label_new(box, _("Comment:")); | |
1416 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); | |
1417 pref_label_bold(label, TRUE, FALSE); | |
1418 | |
1419 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
1420 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
1421 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
1422 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
1423 gtk_box_pack_start(GTK_BOX(box), scrolled, TRUE, TRUE, 0); | |
1424 gtk_widget_show(scrolled); | |
1425 | |
1426 bd->comment_view = gtk_text_view_new(); | |
1427 gtk_container_add(GTK_CONTAINER(scrolled), bd->comment_view); | |
1428 gtk_widget_show(bd->comment_view); | |
1429 | |
1430 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(bd->comment_view)); | |
1431 g_signal_connect(G_OBJECT(buffer), "changed", | |
1432 G_CALLBACK(bar_info_changed), bd); | |
1433 | |
1434 /* toolbar */ | |
1435 | |
1436 tbar = pref_toolbar_new(bd->group_box, GTK_TOOLBAR_ICONS); | |
1437 | |
41
6281cc38e5ca
Wed Apr 27 15:17:57 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1438 pref_toolbar_button(tbar, GTK_STOCK_INDEX, NULL, FALSE, |
9 | 1439 _("Edit favorite keywords list."), |
1440 G_CALLBACK(bar_keyword_edit_cb), bd); | |
1441 pref_toolbar_spacer(tbar); | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1442 bd->button_set_keywords_add = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE, |
9 | 1443 _("Add keywords to selected files"), |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1444 G_CALLBACK(bar_info_set_keywords_add), bd); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1445 bd->button_set_keywords_replace = pref_toolbar_button(tbar, GTK_STOCK_CONVERT, NULL, FALSE, |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1446 _("Add keywords to selected files, replacing existing ones"), |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1447 G_CALLBACK(bar_info_set_keywords_replace), bd); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1448 bd->button_set_comment_add = pref_toolbar_button(tbar, GTK_STOCK_DND_MULTIPLE, NULL, FALSE, |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1449 _("Add comment to selected files"), |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1450 G_CALLBACK(bar_info_set_comment_add), bd); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1451 bd->button_set_comment_replace = pref_toolbar_button(tbar, GTK_STOCK_DND, NULL, FALSE, |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1452 _("Add comment to selected files, replacing existing one"), |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1453 G_CALLBACK(bar_info_set_comment_replace), bd); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1454 |
9 | 1455 pref_toolbar_spacer(tbar); |
41
6281cc38e5ca
Wed Apr 27 15:17:57 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1456 bd->button_save = pref_toolbar_button(tbar, GTK_STOCK_SAVE, NULL, FALSE, |
9 | 1457 _("Save comment now"), |
1458 G_CALLBACK(bar_info_save), bd); | |
1459 | |
1460 bd->save_timeout_id = -1; | |
1461 | |
138 | 1462 bd->fd = file_data_ref(fd); |
9 | 1463 bar_info_update(bd); |
1464 | |
1465 bar_info_selection(bd->vbox, 0); | |
1466 | |
1467 bar_list = g_list_append(bar_list, bd); | |
442 | 1468 |
9 | 1469 return bd->vbox; |
1470 } | |
1471 | |
1472 void bar_info_set_selection_func(GtkWidget *bar, GList *(*list_func)(gpointer data), gpointer data) | |
1473 { | |
1474 BarInfoData *bd; | |
1475 | |
1476 bd = g_object_get_data(G_OBJECT(bar), "bar_info_data"); | |
1477 if (!bd) return; | |
1478 | |
1479 bd->list_func = list_func; | |
1480 bd->list_data = data; | |
1481 } | |
1482 | |
1483 void bar_info_selection(GtkWidget *bar, gint count) | |
1484 { | |
1485 BarInfoData *bd; | |
1486 gint enable; | |
1487 | |
1488 bd = g_object_get_data(G_OBJECT(bar), "bar_info_data"); | |
1489 if (!bd) return; | |
1490 | |
1491 enable = (count > 0 && bd->list_func != NULL); | |
1492 | |
595
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1493 gtk_widget_set_sensitive(bd->button_set_keywords_add, enable); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1494 gtk_widget_set_sensitive(bd->button_set_keywords_replace, enable); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1495 gtk_widget_set_sensitive(bd->button_set_comment_add, enable); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1496 gtk_widget_set_sensitive(bd->button_set_comment_replace, enable); |
15766932414c
Allow the user to append or replace comments for a group of selected files.
zas_
parents:
594
diff
changeset
|
1497 |
9 | 1498 } |