Mercurial > geeqie
annotate src/collect.c @ 91:d063f97503b7
Wed Nov 1 11:39:48 2006 John Ellis <johne@verizon.net>
* gqview.h, main.c (window_set_icon): Change to use inline pixbufs
instead of xpms.
* collect.c, img-view.c, layout.c, preferences.c: Use new icons.
* pixbuf_util.[ch]: Add new icons.
* icons/Makefile.am: Update generated inline pixbufs.
* icons/collect.xpm, icons/config.xpm, icons/icon.xpm, icons/tools.xpm,
icons/view.xpm: Remove old xpm icons.
* icons/gqview_icon.png, icons/icon_book.png, icons/icon_config.png,
icons/icon_tools.png, icons/icon_view.png: The new icons in png format.
* icons/svg/*.svg: Add svg sources for icons, they are not used or
anything, but this way I can not misplace them again.
author | gqview |
---|---|
date | Wed, 01 Nov 2006 17:47:14 +0000 |
parents | 9d5c75b5ec28 |
children | 50dc5a14d37b |
rev | line source |
---|---|
9 | 1 /* |
2 * GQview | |
3 * (C) 2004 John Ellis | |
4 * | |
5 * Author: John Ellis | |
6 * | |
7 * This software is released under the GNU General Public License (GNU GPL). | |
8 * Please read the included file COPYING for more information. | |
9 * This software comes with no warranty of any kind, use at your own risk! | |
10 */ | |
11 | |
12 | |
13 #include "gqview.h" | |
14 #include "collect.h" | |
15 | |
16 #include "collect-dlg.h" | |
17 #include "collect-io.h" | |
18 #include "collect-table.h" | |
19 #include "editors.h" | |
20 #include "filelist.h" | |
21 #include "img-view.h" | |
22 #include "info.h" | |
23 #include "layout.h" | |
24 #include "layout_image.h" | |
91
d063f97503b7
Wed Nov 1 11:39:48 2006 John Ellis <johne@verizon.net>
gqview
parents:
85
diff
changeset
|
25 #include "pixbuf_util.h" |
9 | 26 #include "utilops.h" |
27 #include "ui_fileops.h" | |
28 #include "ui_tree_edit.h" | |
29 | |
30 #include <gdk/gdkkeysyms.h> /* for keyboard values */ | |
31 | |
32 | |
33 #define COLLECT_DEF_WIDTH 440 | |
34 #define COLLECT_DEF_HEIGHT 450 | |
35 | |
36 static GList *collection_list = NULL; | |
37 static GList *collection_window_list = NULL; | |
38 | |
39 static void collection_window_get_geometry(CollectWindow *cw); | |
40 static void collection_window_refresh(CollectWindow *cw); | |
41 static void collection_window_update_title(CollectWindow *cw); | |
42 static void collection_window_add(CollectWindow *cw, CollectInfo *ci); | |
43 static void collection_window_insert(CollectWindow *cw, CollectInfo *ci); | |
44 static void collection_window_remove(CollectWindow *cw, CollectInfo *ci); | |
45 static void collection_window_update(CollectWindow *cw, CollectInfo *ci); | |
46 | |
47 static void collection_window_close(CollectWindow *cw); | |
48 | |
49 /* | |
50 *------------------------------------------------------------------- | |
51 * data, list handling | |
52 *------------------------------------------------------------------- | |
53 */ | |
54 | |
55 CollectInfo *collection_info_new(const gchar *path, struct stat *st, GdkPixbuf *pixbuf) | |
56 { | |
57 CollectInfo *ci; | |
58 | |
59 if (!path) return NULL; | |
60 | |
61 ci = g_new0(CollectInfo, 1); | |
62 ci->path = g_strdup(path); | |
63 ci->size = st->st_size; | |
64 ci->date = st->st_mtime; | |
65 | |
66 ci->pixbuf = pixbuf; | |
67 if (ci->pixbuf) g_object_ref(ci->pixbuf); | |
68 | |
69 return ci; | |
70 } | |
71 | |
72 void collection_info_free_thumb(CollectInfo *ci) | |
73 { | |
74 if (ci->pixbuf) g_object_unref(ci->pixbuf); | |
75 ci->pixbuf = NULL; | |
76 } | |
77 | |
78 void collection_info_free(CollectInfo *ci) | |
79 { | |
80 if (!ci) return; | |
81 | |
82 g_free(ci->path); | |
83 collection_info_free_thumb(ci); | |
84 g_free(ci); | |
85 } | |
86 | |
87 void collection_info_set_thumb(CollectInfo *ci, GdkPixbuf *pixbuf) | |
88 { | |
89 if (pixbuf) g_object_ref(pixbuf); | |
90 collection_info_free_thumb(ci); | |
91 ci->pixbuf = pixbuf; | |
92 } | |
93 | |
94 gint collection_info_load_thumb(CollectInfo *ci) | |
95 { | |
96 if (!ci) return FALSE; | |
97 | |
98 collection_info_free_thumb(ci); | |
99 | |
100 printf("collection_info_load_thumb not implemented!\n(because an instant thumb loader not implemented)"); | |
101 return FALSE; | |
102 #if 0 | |
103 if (create_thumbnail(ci->path, &ci->pixmap, &ci->mask) < 0) return FALSE; | |
104 | |
105 if (ci->pixmap) gdk_pixmap_ref(ci->pixmap); | |
106 if (ci->mask) gdk_bitmap_ref(ci->mask); | |
107 | |
108 return TRUE; | |
109 #endif | |
110 } | |
111 | |
112 void collection_list_free(GList *list) | |
113 { | |
114 GList *work; | |
115 work = list; | |
116 while(work) | |
117 { | |
118 collection_info_free((CollectInfo *)work->data); | |
119 work = work->next; | |
120 } | |
121 g_list_free(list); | |
122 } | |
123 | |
124 /* an ugly static var, well what ya gonna do ? */ | |
125 static SortType collection_list_sort_method = SORT_NAME; | |
126 | |
127 static gint collection_list_sort_cb(gconstpointer a, gconstpointer b) | |
128 { | |
129 const CollectInfo *cia = a; | |
130 const CollectInfo *cib = b; | |
131 | |
132 switch(collection_list_sort_method) | |
133 { | |
134 case SORT_NONE: | |
135 return 0; | |
136 break; | |
137 case SORT_SIZE: | |
138 if (cia->size < cib->size) return -1; | |
139 if (cia->size > cib->size) return 1; | |
140 return 0; | |
141 break; | |
142 case SORT_TIME: | |
143 if (cia->date < cib->date) return -1; | |
144 if (cia->date > cib->date) return 1; | |
145 return 0; | |
146 break; | |
147 case SORT_PATH: | |
148 return CASE_SORT(cia->path, cib->path); | |
149 break; | |
150 #ifdef HAVE_STRVERSCMP | |
151 case SORT_NUMBER: | |
152 return strverscmp(filename_from_path(cia->path), filename_from_path(cib->path)); | |
153 break; | |
154 #endif | |
155 case SORT_NAME: | |
156 default: | |
157 return CASE_SORT(filename_from_path(cia->path), filename_from_path(cib->path)); | |
158 break; | |
159 } | |
160 | |
161 return 0; | |
162 } | |
163 | |
164 GList *collection_list_sort(GList *list, SortType method) | |
165 { | |
166 if (method == SORT_NONE) return list; | |
167 | |
168 collection_list_sort_method = method; | |
169 | |
170 return g_list_sort(list, collection_list_sort_cb); | |
171 } | |
172 | |
173 GList *collection_list_add(GList *list, CollectInfo *ci, SortType method) | |
174 { | |
175 if (method != SORT_NONE) | |
176 { | |
177 collection_list_sort_method = method; | |
178 list = g_list_insert_sorted(list, ci, collection_list_sort_cb); | |
179 } | |
180 else | |
181 { | |
182 list = g_list_append(list, ci); | |
183 } | |
184 | |
185 return list; | |
186 } | |
187 | |
188 GList *collection_list_insert(GList *list, CollectInfo *ci, CollectInfo *insert_ci, SortType method) | |
189 { | |
190 if (method != SORT_NONE) | |
191 { | |
192 collection_list_sort_method = method; | |
193 list = g_list_insert_sorted(list, ci, collection_list_sort_cb); | |
194 } | |
195 else | |
196 { | |
197 GList *point; | |
198 | |
199 point = g_list_find(list, insert_ci); | |
200 list = uig_list_insert_link(list, point, ci); | |
201 } | |
202 | |
203 return list; | |
204 } | |
205 | |
206 GList *collection_list_remove(GList *list, CollectInfo *ci) | |
207 { | |
208 list = g_list_remove(list, ci); | |
209 collection_info_free(ci); | |
210 return list; | |
211 } | |
212 | |
213 CollectInfo *collection_list_find(GList *list, const gchar *path) | |
214 { | |
215 GList *work = list; | |
216 | |
217 while(work) | |
218 { | |
219 CollectInfo *ci = work->data; | |
220 if (strcmp(ci->path, path) == 0) return ci; | |
221 work = work->next; | |
222 } | |
223 | |
224 return NULL; | |
225 } | |
226 | |
227 #if 0 | |
228 static GList *collection_list_find_link(GList *list, gchar *path) | |
229 { | |
230 GList *work = list; | |
231 | |
232 while(work) | |
233 { | |
234 CollectInfo *ci = work->data; | |
235 if (strcmp(ci->path, path) == 0) return work; | |
236 work = work->next; | |
237 } | |
238 | |
239 return NULL; | |
240 } | |
241 | |
242 static gint collection_list_find_index(GList *list, gchar *path) | |
243 { | |
244 gint c = 0; | |
245 GList *work = list; | |
246 | |
247 while(work) | |
248 { | |
249 CollectInfo *ci = work->data; | |
250 if (strcmp(ci->path, path) == 0) return c; | |
251 work = work->next; | |
252 c++; | |
253 } | |
254 | |
255 return -1; | |
256 } | |
257 #endif | |
258 | |
259 GList *collection_list_to_path_list(GList *list) | |
260 { | |
261 GList *pathlist = NULL; | |
262 GList *work = list; | |
263 | |
264 while (work) | |
265 { | |
266 CollectInfo *info = work->data; | |
267 pathlist = g_list_prepend(pathlist, g_strdup(info->path)); | |
268 work = work->next; | |
269 } | |
270 | |
271 pathlist = g_list_reverse(pathlist); | |
272 return pathlist; | |
273 } | |
274 | |
275 CollectWindow *collection_window_find(CollectionData *cd) | |
276 { | |
277 GList *work; | |
278 | |
279 work = collection_window_list; | |
280 while (work) | |
281 { | |
282 CollectWindow *cw = work->data; | |
283 if (cw->cd == cd) return cw; | |
284 work = work->next; | |
285 } | |
286 | |
287 return NULL; | |
288 } | |
289 | |
290 CollectWindow *collection_window_find_by_path(const gchar *path) | |
291 { | |
292 GList *work; | |
293 | |
294 if (!path) return NULL; | |
295 | |
296 work = collection_window_list; | |
297 while (work) | |
298 { | |
299 CollectWindow *cw = work->data; | |
300 if (cw->cd->path && strcmp(cw->cd->path, path) == 0) return cw; | |
301 work = work->next; | |
302 } | |
303 | |
304 return NULL; | |
305 } | |
306 | |
307 /* | |
308 *------------------------------------------------------------------- | |
309 * please use these to actually add/remove stuff | |
310 *------------------------------------------------------------------- | |
311 */ | |
312 | |
313 CollectionData *collection_new(const gchar *path) | |
314 { | |
315 CollectionData *cd; | |
316 static gint untitled_counter = 0; | |
317 | |
318 cd = g_new0(CollectionData, 1); | |
319 | |
320 collection_list = g_list_append(collection_list, cd); | |
321 | |
322 cd->ref = 1; /* starts with a ref of 1 */ | |
323 | |
324 cd->list = NULL; | |
325 cd->sort_method = SORT_NONE; | |
326 cd->thumb_loader = NULL; | |
327 cd->info_updated_func = NULL; | |
328 | |
329 cd->window_read = FALSE; | |
330 cd->window_x = 0; | |
331 cd->window_y = 0; | |
332 cd->window_w = COLLECT_DEF_WIDTH; | |
333 cd->window_h = COLLECT_DEF_HEIGHT; | |
334 | |
335 cd->changed = FALSE; | |
336 | |
337 if (path) | |
338 { | |
339 cd->path = g_strdup(path); | |
340 cd->name = g_strdup(filename_from_path(cd->path)); | |
341 /* load it */ | |
342 } | |
343 else | |
344 { | |
345 cd->path = NULL; | |
346 | |
347 if (untitled_counter == 0) | |
348 { | |
349 cd->name = g_strdup(_("Untitled")); | |
350 } | |
351 else | |
352 { | |
353 cd->name = g_strdup_printf(_("Untitled (%d)"), untitled_counter + 1); | |
354 } | |
355 | |
356 untitled_counter++; | |
357 } | |
358 | |
359 return cd; | |
360 } | |
361 | |
362 void collection_free(CollectionData *cd) | |
363 { | |
364 if (!cd) return; | |
365 | |
366 if (debug) printf("collection \"%s\" freed\n", cd->name); | |
367 | |
368 collection_load_stop(cd); | |
369 collection_list_free(cd->list); | |
370 | |
371 collection_list = g_list_remove(collection_list, cd); | |
372 | |
373 g_free(cd->path); | |
374 g_free(cd->name); | |
375 | |
376 g_free(cd); | |
377 } | |
378 | |
379 void collection_ref(CollectionData *cd) | |
380 { | |
381 cd->ref++; | |
382 | |
383 if (debug) printf("collection \"%s\" ref count = %d\n", cd->name, cd->ref); | |
384 } | |
385 | |
386 void collection_unref(CollectionData *cd) | |
387 { | |
388 cd->ref--; | |
389 | |
390 if (debug) printf("collection \"%s\" ref count = %d\n", cd->name, cd->ref); | |
391 | |
392 if (cd->ref < 1) | |
393 { | |
394 collection_free(cd); | |
395 } | |
396 } | |
397 | |
398 void collection_path_changed(CollectionData *cd) | |
399 { | |
400 collection_window_update_title(collection_window_find(cd)); | |
401 } | |
402 | |
403 gint collection_to_number(CollectionData *cd) | |
404 { | |
405 return g_list_index(collection_list, cd); | |
406 } | |
407 | |
408 CollectionData *collection_from_number(gint n) | |
409 { | |
410 return g_list_nth_data(collection_list, n); | |
411 } | |
412 | |
413 CollectionData *collection_from_dnd_data(const gchar *data, GList **list, GList **info_list) | |
414 { | |
415 CollectionData *cd; | |
416 gint n; | |
417 | |
418 if (strncmp(data, "COLLECTION:", 11) != 0) return NULL; | |
419 | |
420 n = (gint)strtol(data + 11, NULL, 10); | |
421 cd = collection_from_number(n); | |
422 | |
423 if (!cd || (!list && !info_list)) | |
424 { | |
425 return cd; | |
426 } | |
427 else | |
428 { | |
429 GList *work = NULL; | |
430 GList *infol = NULL; | |
431 gint b, e; | |
432 | |
433 b = 0; | |
434 while(data[b] != '\0' && data[b] != '\n' ) b++; | |
435 b++; | |
436 e = b; | |
437 | |
438 while (data[b] != '\0') | |
439 { | |
440 CollectInfo *info; | |
441 | |
442 while (data[e] != '\n' && data[e] != '\0') e++; | |
443 n = (gint)strtol(data + b, NULL, 10); | |
444 | |
445 info = g_list_nth_data(cd->list, n); | |
446 if (info && list) work = g_list_append(work, g_strdup(info->path)); | |
447 if (info && info_list) infol = g_list_append(infol, info); | |
448 | |
449 while (data[e] == '\n') e++; | |
450 b = e; | |
451 } | |
452 if (list) *list = work; | |
453 if (info_list) *info_list = infol; | |
454 } | |
455 | |
456 return cd; | |
457 } | |
458 | |
459 gchar *collection_info_list_to_dnd_data(CollectionData *cd, GList *list, gint *length) | |
460 { | |
461 gchar *uri_text = NULL; | |
462 gint total; | |
463 GList *work; | |
464 gint n; | |
465 GList *temp; | |
466 gchar *ptr; | |
467 | |
468 n = collection_to_number(cd); | |
469 | |
470 if (!list || n < 0) | |
471 { | |
472 *length = 0; | |
473 return NULL; | |
474 } | |
475 | |
476 temp = NULL; | |
477 temp = g_list_prepend(temp, g_strdup_printf("COLLECTION:%d\n", n)); | |
478 work = list; | |
479 while(work) | |
480 { | |
481 n = g_list_index(cd->list, work->data); | |
482 if (n >= 0) | |
483 { | |
484 temp = g_list_prepend(temp, g_strdup_printf("%d\n", n)); | |
485 } | |
486 work = work->next; | |
487 } | |
488 | |
489 total = 0; | |
490 work = temp; | |
491 while(work) | |
492 { | |
493 total += strlen((gchar *)work->data); | |
494 work = work->next; | |
495 } | |
496 total += 1; | |
497 | |
498 uri_text = g_malloc(total); | |
499 ptr = uri_text; | |
500 | |
501 work = g_list_last(temp); | |
502 while(work) | |
503 { | |
504 gchar *text = work->data; | |
505 | |
506 work = work->prev; | |
507 | |
508 strcpy(ptr, text); | |
509 ptr += strlen(text); | |
510 } | |
511 | |
512 ptr[0] = '\0'; | |
513 | |
514 path_list_free(temp); | |
515 | |
516 *length = total; | |
517 | |
518 return uri_text; | |
519 } | |
520 | |
521 gint collection_info_valid(CollectionData *cd, CollectInfo *info) | |
522 { | |
523 if (collection_to_number(cd) < 0) return FALSE; | |
524 | |
525 return (g_list_index(cd->list, info) != 0); | |
526 } | |
527 | |
528 CollectInfo *collection_next_by_info(CollectionData *cd, CollectInfo *info) | |
529 { | |
530 GList *work; | |
531 | |
532 work = g_list_find(cd->list, info); | |
533 | |
534 if (!work) return NULL; | |
535 work = work->next; | |
536 if (work) return work->data; | |
537 return NULL; | |
538 } | |
539 | |
540 CollectInfo *collection_prev_by_info(CollectionData *cd, CollectInfo *info) | |
541 { | |
542 GList *work; | |
543 | |
544 work = g_list_find(cd->list, info); | |
545 | |
546 if (!work) return NULL; | |
547 work = work->prev; | |
548 if (work) return work->data; | |
549 return NULL; | |
550 } | |
551 | |
552 CollectInfo *collection_get_first(CollectionData *cd) | |
553 { | |
554 if (cd->list) return cd->list->data; | |
555 | |
556 return NULL; | |
557 } | |
558 | |
559 CollectInfo *collection_get_last(CollectionData *cd) | |
560 { | |
561 GList *list; | |
562 | |
563 list = g_list_last(cd->list); | |
564 | |
565 if (list) return list->data; | |
566 | |
567 return NULL; | |
568 } | |
569 | |
570 void collection_set_sort_method(CollectionData *cd, SortType method) | |
571 { | |
572 if (!cd) return; | |
573 | |
574 if (cd->sort_method == method) return; | |
575 | |
576 cd->sort_method = method; | |
577 cd->list = collection_list_sort(cd->list, cd->sort_method); | |
578 if (cd->list) cd->changed = TRUE; | |
579 | |
580 collection_window_refresh(collection_window_find(cd)); | |
581 } | |
582 | |
583 void collection_set_update_info_func(CollectionData *cd, | |
584 void (*func)(CollectionData *, CollectInfo *, gpointer), gpointer data) | |
585 { | |
586 cd->info_updated_func = func; | |
587 cd->info_updated_data = data; | |
588 } | |
589 | |
590 gint collection_add_check(CollectionData *cd, const gchar *path, gint sorted, gint must_exist) | |
591 { | |
592 struct stat st; | |
593 gint valid; | |
594 | |
595 if (must_exist) | |
596 { | |
597 valid = (stat_utf8(path, &st) && !S_ISDIR(st.st_mode)); | |
598 } | |
599 else | |
600 { | |
601 valid = TRUE; | |
602 st.st_size = 0; | |
603 st.st_mtime = 0; | |
604 } | |
605 | |
606 if (valid) | |
607 { | |
608 CollectInfo *ci; | |
609 ci = collection_info_new(path, &st, NULL); | |
610 cd->list = collection_list_add(cd->list, ci, sorted ? cd->sort_method : SORT_NONE); | |
611 cd->changed = TRUE; | |
612 | |
613 if (!sorted || cd->sort_method == SORT_NONE) | |
614 { | |
615 collection_window_add(collection_window_find(cd), ci); | |
616 } | |
617 else | |
618 { | |
619 collection_window_insert(collection_window_find(cd), ci); | |
620 } | |
621 } | |
622 | |
623 return valid; | |
624 } | |
625 | |
626 gint collection_add(CollectionData *cd, const gchar *path, gint sorted) | |
627 { | |
628 return collection_add_check(cd, path, sorted, TRUE); | |
629 } | |
630 | |
631 gint collection_insert(CollectionData *cd, const gchar *path, CollectInfo *insert_ci, gint sorted) | |
632 { | |
633 struct stat st; | |
634 | |
635 if (!insert_ci) return collection_add(cd, path, sorted); | |
636 | |
637 if (stat_utf8(path, &st) >= 0 && !S_ISDIR(st.st_mode)) | |
638 { | |
639 CollectInfo *ci; | |
640 ci = collection_info_new(path, &st, NULL); | |
641 cd->list = collection_list_insert(cd->list, ci, insert_ci, sorted ? cd->sort_method : SORT_NONE); | |
642 cd->changed = TRUE; | |
643 | |
644 collection_window_insert(collection_window_find(cd), ci); | |
645 | |
646 return TRUE; | |
647 } | |
648 | |
649 return FALSE; | |
650 } | |
651 | |
652 gint collection_remove(CollectionData *cd, const gchar *path) | |
653 { | |
654 CollectInfo *ci; | |
655 | |
656 ci = collection_list_find(cd->list, path); | |
657 | |
658 if (!ci) return FALSE; | |
659 | |
660 cd->list = g_list_remove(cd->list, ci); | |
661 cd->changed = TRUE; | |
662 | |
663 collection_window_remove(collection_window_find(cd), ci); | |
664 collection_info_free(ci); | |
665 | |
666 return TRUE; | |
667 } | |
668 | |
669 static void collection_remove_by_info(CollectionData *cd, CollectInfo *info) | |
670 { | |
671 if (!info || !g_list_find(cd->list, info)) return; | |
672 | |
673 cd->list = g_list_remove(cd->list, info); | |
674 cd->changed = (cd->list != NULL); | |
675 | |
676 collection_window_remove(collection_window_find(cd), info); | |
677 collection_info_free(info); | |
678 } | |
679 | |
680 void collection_remove_by_info_list(CollectionData *cd, GList *list) | |
681 { | |
682 GList *work; | |
683 | |
684 if (!list) return; | |
685 | |
686 if (!list->next) | |
687 { | |
688 /* more efficient (in collect-table) to remove a single item this way */ | |
689 collection_remove_by_info(cd, (CollectInfo *)list->data); | |
690 return; | |
691 } | |
692 | |
693 work = list; | |
694 while(work) | |
695 { | |
696 cd->list = collection_list_remove(cd->list, work->data); | |
697 work = work->next; | |
698 } | |
699 cd->changed = (cd->list != NULL); | |
700 | |
701 collection_window_refresh(collection_window_find(cd)); | |
702 } | |
703 | |
704 gint collection_rename(CollectionData *cd, const gchar *source, const gchar *dest) | |
705 { | |
706 CollectInfo *ci; | |
707 | |
708 ci = collection_list_find(cd->list, source); | |
709 | |
710 if (!ci) return FALSE; | |
711 | |
712 g_free(ci->path); | |
713 ci->path = g_strdup(dest); | |
714 cd->changed = TRUE; | |
715 | |
716 collection_window_update(collection_window_find(cd), ci); | |
717 | |
718 return TRUE; | |
719 } | |
720 | |
721 void collection_update_geometry(CollectionData *cd) | |
722 { | |
723 collection_window_get_geometry(collection_window_find(cd)); | |
724 } | |
725 | |
726 /* | |
727 *------------------------------------------------------------------- | |
728 * simple maintenance for renaming, deleting | |
729 *------------------------------------------------------------------- | |
730 */ | |
731 | |
732 void collection_maint_removed(const gchar *path) | |
733 { | |
734 GList *work; | |
735 | |
736 work = collection_list; | |
737 while(work) | |
738 { | |
739 CollectionData *cd = work->data; | |
740 work = work->next; | |
741 | |
742 while(collection_remove(cd, path)); | |
743 } | |
744 #if 0 | |
745 /* Do we really need to do this? removed files are | |
746 * automatically ignored when loading a collection. | |
747 */ | |
748 collect_manager_moved(path, NULL); | |
749 #endif | |
750 } | |
751 | |
752 void collection_maint_renamed(const gchar *source, const gchar *dest) | |
753 { | |
754 GList *work; | |
755 | |
756 work = collection_list; | |
757 while(work) | |
758 { | |
759 CollectionData *cd = work->data; | |
760 work = work->next; | |
761 | |
762 while(collection_rename(cd, source, dest)); | |
763 } | |
764 | |
765 collect_manager_moved(source, dest); | |
766 } | |
767 | |
768 /* | |
769 *------------------------------------------------------------------- | |
770 * window key presses | |
771 *------------------------------------------------------------------- | |
772 */ | |
773 | |
774 static gint collection_window_keypress(GtkWidget *widget, GdkEventKey *event, gpointer data) | |
775 { | |
776 CollectWindow *cw = data; | |
777 gint stop_signal = FALSE; | |
778 gint edit_val = -1; | |
779 GList *list; | |
780 | |
781 if (event->state & GDK_CONTROL_MASK) | |
782 { | |
85
9d5c75b5ec28
Fri Oct 20 09:20:10 2006 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
783 stop_signal = TRUE; |
9 | 784 switch (event->keyval) |
785 { | |
786 case '1': | |
787 edit_val = 0; | |
788 break; | |
789 case '2': | |
790 edit_val = 1; | |
791 break; | |
792 case '3': | |
793 edit_val = 2; | |
794 break; | |
795 case '4': | |
796 edit_val = 3; | |
797 break; | |
798 case '5': | |
799 edit_val = 4; | |
800 break; | |
801 case '6': | |
802 edit_val = 5; | |
803 break; | |
804 case '7': | |
805 edit_val = 6; | |
806 break; | |
807 case '8': | |
808 edit_val = 7; | |
809 break; | |
810 case '9': | |
811 edit_val = 8; | |
812 break; | |
813 case '0': | |
814 edit_val = 9; | |
815 break; | |
816 case 'A': case 'a': | |
817 if (event->state & GDK_SHIFT_MASK) | |
818 { | |
819 collection_table_unselect_all(cw->table); | |
820 } | |
821 else | |
822 { | |
823 collection_table_select_all(cw->table); | |
824 } | |
825 break; | |
826 case 'L': case 'l': | |
827 list = layout_list(NULL); | |
828 if (list) | |
829 { | |
830 collection_table_add_path_list(cw->table, list); | |
831 path_list_free(list); | |
832 } | |
833 break; | |
834 case 'C': case 'c': | |
835 file_util_copy(NULL, collection_table_selection_get_list(cw->table), NULL, cw->window); | |
836 break; | |
837 case 'M': case 'm': | |
838 file_util_move(NULL, collection_table_selection_get_list(cw->table), NULL, cw->window); | |
839 break; | |
840 case 'R': case 'r': | |
841 file_util_rename(NULL, collection_table_selection_get_list(cw->table), cw->window); | |
842 break; | |
843 case 'D': case 'd': | |
844 file_util_delete(NULL, collection_table_selection_get_list(cw->table), cw->window); | |
845 break; | |
846 case 'P': case 'p': | |
847 info_window_new(NULL, collection_table_selection_get_list(cw->table)); | |
848 break; | |
849 case 'S': case 's': | |
850 collection_dialog_save_as(NULL, cw->cd); | |
851 break; | |
852 case 'W': case 'w': | |
853 collection_window_close(cw); | |
854 break; | |
855 default: | |
85
9d5c75b5ec28
Fri Oct 20 09:20:10 2006 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
856 stop_signal = FALSE; |
9 | 857 break; |
858 } | |
859 } | |
860 else | |
861 { | |
85
9d5c75b5ec28
Fri Oct 20 09:20:10 2006 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
862 stop_signal = TRUE; |
9 | 863 switch (event->keyval) |
864 { | |
865 case GDK_Return: case GDK_KP_Enter: | |
866 layout_image_set_collection(NULL, cw->cd, | |
867 collection_table_get_focus_info(cw->table)); | |
868 break; | |
869 case 'V': case 'v': | |
870 view_window_new_from_collection(cw->cd, | |
871 collection_table_get_focus_info(cw->table)); | |
872 break; | |
873 case 'S': case 's': | |
874 if (!cw->cd->path) | |
875 { | |
876 collection_dialog_save_as(NULL, cw->cd); | |
877 } | |
878 else if (!collection_save(cw->cd, cw->cd->path)) | |
879 { | |
880 printf("failed saving to collection path: %s\n", cw->cd->path); | |
881 } | |
882 break; | |
883 case 'A': case 'a': | |
85
9d5c75b5ec28
Fri Oct 20 09:20:10 2006 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
884 collection_dialog_append(NULL, cw->cd); |
9 | 885 break; |
886 case 'N': case 'n': | |
887 collection_set_sort_method(cw->cd, SORT_NAME); | |
888 break; | |
889 #ifdef HAVE_STRVERSCMP | |
890 case 'I': case 'i': | |
891 collection_set_sort_method(cw->cd, SORT_NUMBER); | |
892 break; | |
893 #endif | |
894 case 'D': case 'd': | |
895 collection_set_sort_method(cw->cd, SORT_TIME); | |
896 break; | |
897 case 'B': case 'b': | |
898 collection_set_sort_method(cw->cd, SORT_SIZE); | |
899 break; | |
900 case 'P': case 'p': | |
901 collection_set_sort_method(cw->cd, SORT_PATH); | |
902 break; | |
903 case GDK_Delete: case GDK_KP_Delete: | |
904 list = g_list_copy(cw->table->selection); | |
905 if (list) | |
906 { | |
907 collection_remove_by_info_list(cw->cd, list); | |
908 g_list_free(list); | |
909 } | |
910 else | |
911 { | |
912 collection_remove_by_info(cw->cd, collection_table_get_focus_info(cw->table)); | |
913 } | |
914 break; | |
915 default: | |
85
9d5c75b5ec28
Fri Oct 20 09:20:10 2006 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
916 stop_signal = FALSE; |
9 | 917 break; |
918 } | |
919 } | |
920 | |
921 if (edit_val != -1) | |
922 { | |
923 list = collection_table_selection_get_list(cw->table); | |
924 start_editor_from_path_list(edit_val, list); | |
925 path_list_free(list); | |
926 } | |
927 | |
928 return stop_signal; | |
929 } | |
930 | |
931 /* | |
932 *------------------------------------------------------------------- | |
933 * window | |
934 *------------------------------------------------------------------- | |
935 */ | |
936 static void collection_window_get_geometry(CollectWindow *cw) | |
937 { | |
938 CollectionData *cd; | |
939 | |
940 if (!cw) return; | |
941 | |
942 cd = cw->cd; | |
943 gdk_window_get_position (cw->window->window, &cd->window_x, &cd->window_y); | |
944 gdk_drawable_get_size(cw->window->window, &cd->window_w, &cd->window_h); | |
945 cd->window_read = TRUE; | |
946 } | |
947 | |
948 static void collection_window_refresh(CollectWindow *cw) | |
949 { | |
950 if (!cw) return; | |
951 | |
952 collection_table_refresh(cw->table); | |
953 } | |
954 | |
955 static void collection_window_update_title(CollectWindow *cw) | |
956 { | |
957 gchar *buf; | |
958 | |
959 if (!cw) return; | |
960 | |
961 buf = g_strdup_printf(_("%s - GQview Collection"), cw->cd->name); | |
962 gtk_window_set_title(GTK_WINDOW(cw->window), buf); | |
963 g_free(buf); | |
964 } | |
965 | |
966 static void collection_window_update_info(CollectionData *cd, CollectInfo *ci, gpointer data) | |
967 { | |
968 CollectWindow *cw = data; | |
969 | |
970 collection_table_file_update(cw->table, ci); | |
971 } | |
972 | |
973 static void collection_window_add(CollectWindow *cw, CollectInfo *ci) | |
974 { | |
975 if (!cw) return; | |
976 | |
977 if (!ci->pixbuf) collection_load_thumb_idle(cw->cd); | |
978 collection_table_file_add(cw->table, ci); | |
979 } | |
980 | |
981 static void collection_window_insert(CollectWindow *cw, CollectInfo *ci) | |
982 { | |
983 if (!cw) return; | |
984 | |
985 if (!ci->pixbuf) collection_load_thumb_idle(cw->cd); | |
986 collection_table_file_insert(cw->table, ci); | |
987 if (!cw) return; | |
988 } | |
989 | |
990 #if 0 | |
991 static void collection_window_move(CollectWindow *cw, CollectInfo *ci) | |
992 { | |
993 if (!cw) return; | |
994 } | |
995 #endif | |
996 | |
997 static void collection_window_remove(CollectWindow *cw, CollectInfo *ci) | |
998 { | |
999 if (!cw) return; | |
1000 | |
1001 collection_table_file_remove(cw->table, ci); | |
1002 } | |
1003 | |
1004 static void collection_window_update(CollectWindow *cw, CollectInfo *ci) | |
1005 { | |
1006 if (!cw) return; | |
1007 | |
1008 collection_table_file_update(cw->table, ci); | |
1009 collection_table_file_update(cw->table, NULL); | |
1010 } | |
1011 | |
1012 static void collection_window_close_final(CollectWindow *cw) | |
1013 { | |
1014 if (cw->close_dialog) return; | |
1015 | |
1016 collection_window_list = g_list_remove(collection_window_list, cw); | |
1017 collection_window_get_geometry(cw); | |
1018 | |
1019 gtk_widget_destroy(cw->window); | |
1020 | |
1021 collection_set_update_info_func(cw->cd, NULL, NULL); | |
1022 collection_unref(cw->cd); | |
1023 | |
1024 g_free(cw); | |
1025 } | |
1026 | |
1027 static void collection_close_save_cb(GenericDialog *gd, gpointer data) | |
1028 { | |
1029 CollectWindow *cw = data; | |
1030 | |
1031 cw->close_dialog = NULL; | |
1032 generic_dialog_close(gd); | |
1033 | |
1034 if (!cw->cd->path) | |
1035 { | |
1036 collection_dialog_save_close(NULL, cw->cd); | |
1037 return; | |
1038 } | |
1039 else if (!collection_save(cw->cd, cw->cd->path)) | |
1040 { | |
1041 gchar *buf; | |
1042 buf = g_strdup_printf(_("Failed to save the collection:\n%s"), cw->cd->path); | |
1043 warning_dialog(_("Save Failed"), buf, GTK_STOCK_DIALOG_ERROR, cw->window); | |
1044 g_free(buf); | |
1045 return; | |
1046 } | |
1047 | |
1048 collection_window_close_final(cw); | |
1049 } | |
1050 | |
1051 static void collection_close_close_cb(GenericDialog *gd, gpointer data) | |
1052 { | |
1053 CollectWindow *cw = data; | |
1054 | |
1055 cw->close_dialog = NULL; | |
1056 generic_dialog_close(gd); | |
1057 | |
1058 collection_window_close_final(cw); | |
1059 } | |
1060 | |
1061 static void collection_close_cancel_cb(GenericDialog *gd, gpointer data) | |
1062 { | |
1063 CollectWindow *cw = data; | |
1064 | |
1065 cw->close_dialog = NULL; | |
1066 generic_dialog_close(gd); | |
1067 } | |
1068 | |
1069 static void collection_close_dlg_show(CollectWindow *cw) | |
1070 { | |
1071 GenericDialog *gd; | |
1072 | |
1073 if (cw->close_dialog) | |
1074 { | |
1075 gtk_window_present(GTK_WINDOW(cw->close_dialog)); | |
1076 return; | |
1077 } | |
1078 | |
1079 gd = generic_dialog_new(_("Close collection"), | |
1080 "GQview", "close_collection", cw->window, FALSE, | |
1081 collection_close_cancel_cb, cw); | |
1082 generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, | |
1083 _("Close collection"), | |
1084 _("Collection has been modified.\nSave first?")); | |
1085 | |
1086 generic_dialog_add_button(gd, GTK_STOCK_SAVE, NULL, collection_close_save_cb, TRUE); | |
1087 generic_dialog_add_button(gd, GTK_STOCK_DELETE, _("_Discard"), collection_close_close_cb, FALSE); | |
1088 | |
1089 cw->close_dialog = gd->dialog; | |
1090 | |
1091 gtk_widget_show(gd->dialog); | |
1092 } | |
1093 | |
1094 static void collection_window_close(CollectWindow *cw) | |
1095 { | |
1096 if (!cw->cd->changed && !cw->close_dialog) | |
1097 { | |
1098 collection_window_close_final(cw); | |
1099 return; | |
1100 } | |
1101 | |
1102 collection_close_dlg_show(cw); | |
1103 } | |
1104 | |
1105 void collection_window_close_by_collection(CollectionData *cd) | |
1106 { | |
1107 CollectWindow *cw; | |
1108 | |
1109 cw = collection_window_find(cd); | |
1110 if (cw) collection_window_close_final(cw); | |
1111 } | |
1112 | |
1113 gint collection_window_modified_exists(void) | |
1114 { | |
1115 GList *work; | |
1116 | |
1117 work = collection_window_list; | |
1118 while (work) | |
1119 { | |
1120 CollectWindow *cw = work->data; | |
1121 if (cw->cd->changed) return TRUE; | |
1122 work = work->next; | |
1123 } | |
1124 | |
1125 return FALSE; | |
1126 } | |
1127 | |
1128 static gint collection_window_delete(GtkWidget *widget, GdkEvent *event, gpointer data) | |
1129 { | |
1130 CollectWindow *cw = data; | |
1131 collection_window_close(cw); | |
1132 | |
1133 return TRUE; | |
1134 } | |
1135 | |
1136 CollectWindow *collection_window_new(const gchar *path) | |
1137 { | |
1138 CollectWindow *cw; | |
1139 GtkWidget *vbox; | |
1140 GtkWidget *frame; | |
1141 GtkWidget *status_label; | |
1142 GtkWidget *extra_label; | |
1143 GdkGeometry geometry; | |
1144 | |
1145 cw = g_new0(CollectWindow, 1); | |
1146 | |
1147 cw->close_dialog = NULL; | |
1148 | |
1149 collection_window_list = g_list_append(collection_window_list, cw); | |
1150 | |
1151 cw->cd = collection_new(path); | |
1152 | |
1153 cw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); | |
91
d063f97503b7
Wed Nov 1 11:39:48 2006 John Ellis <johne@verizon.net>
gqview
parents:
85
diff
changeset
|
1154 window_set_icon(cw->window, PIXBUF_INLINE_ICON_BOOK, NULL); |
9 | 1155 |
1156 geometry.min_width = 32; | |
1157 geometry.min_height = 32; | |
1158 geometry.base_width = COLLECT_DEF_WIDTH; | |
1159 geometry.base_height = COLLECT_DEF_HEIGHT; | |
1160 gtk_window_set_geometry_hints(GTK_WINDOW(cw->window), NULL, &geometry, | |
1161 GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE); | |
1162 | |
1163 | |
1164 if (save_window_positions && path && collection_load_only_geometry(cw->cd, path)) | |
1165 { | |
1166 /* FIXME: x, y is not implemented */ | |
1167 gtk_window_set_default_size(GTK_WINDOW(cw->window), cw->cd->window_w, cw->cd->window_h); | |
1168 } | |
1169 else | |
1170 { | |
1171 gtk_window_set_default_size(GTK_WINDOW(cw->window), COLLECT_DEF_WIDTH, COLLECT_DEF_HEIGHT); | |
1172 } | |
1173 | |
1174 gtk_window_set_resizable(GTK_WINDOW(cw->window), TRUE); | |
1175 collection_window_update_title(cw); | |
1176 gtk_window_set_wmclass(GTK_WINDOW(cw->window), "collection", "GQview"); | |
1177 gtk_container_set_border_width (GTK_CONTAINER (cw->window), 0); | |
1178 | |
1179 g_signal_connect(G_OBJECT(cw->window), "delete_event", | |
1180 G_CALLBACK(collection_window_delete), cw); | |
1181 | |
1182 g_signal_connect(G_OBJECT(cw->window),"key_press_event", | |
1183 G_CALLBACK(collection_window_keypress), cw); | |
1184 | |
1185 vbox = gtk_vbox_new(FALSE, 0); | |
1186 gtk_container_add(GTK_CONTAINER(cw->window), vbox); | |
1187 gtk_widget_show(vbox); | |
1188 | |
1189 cw->table = collection_table_new(cw->cd); | |
1190 gtk_box_pack_start(GTK_BOX(vbox), cw->table->scrolled, TRUE, TRUE, 0); | |
1191 gtk_widget_show(cw->table->scrolled); | |
1192 | |
1193 cw->status_box = gtk_hbox_new(TRUE, 0); | |
1194 gtk_box_pack_start(GTK_BOX(vbox), cw->status_box, FALSE, FALSE, 0); | |
1195 gtk_widget_show(cw->status_box); | |
1196 | |
1197 frame = gtk_frame_new(NULL); | |
1198 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); | |
1199 gtk_box_pack_start(GTK_BOX(cw->status_box), frame, TRUE, TRUE, 0); | |
1200 gtk_widget_show(frame); | |
1201 | |
1202 status_label = gtk_label_new(""); | |
1203 gtk_container_add(GTK_CONTAINER(frame), status_label); | |
1204 gtk_widget_show(status_label); | |
1205 | |
1206 extra_label = gtk_progress_bar_new(); | |
1207 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(extra_label), 0.0); | |
1208 gtk_box_pack_start(GTK_BOX(cw->status_box), extra_label, TRUE, TRUE, 0); | |
1209 gtk_widget_show(extra_label); | |
1210 | |
1211 collection_table_set_labels(cw->table, status_label, extra_label); | |
1212 | |
1213 gtk_widget_show(cw->window); | |
1214 gtk_widget_grab_focus(cw->table->listview); | |
1215 | |
1216 collection_set_update_info_func(cw->cd, collection_window_update_info, cw); | |
1217 | |
1218 if (path && *path == '/') collection_load_begin(cw->cd, NULL, FALSE); | |
1219 | |
1220 return cw; | |
1221 } | |
1222 |