Mercurial > audlegacy
comparison src/audlegacy/ui_fileinfo.c @ 4811:7bf7f83a217e
rename src/audacious src/audlegacy so that both audlegacy and audacious can coexist.
author | Yoshiki Yazawa <yaz@honeyplanet.jp> |
---|---|
date | Wed, 26 Nov 2008 00:44:56 +0900 |
parents | src/audacious/ui_fileinfo.c@b87f8c707b7f |
children | 62cb85252393 |
comparison
equal
deleted
inserted
replaced
4810:c10e53092037 | 4811:7bf7f83a217e |
---|---|
1 /* | |
2 * Audacious: A cross-platform multimedia player | |
3 * Copyright (c) 2006 William Pitcock, Tony Vroon, George Averill, | |
4 * Giacomo Lozito, Derek Pomery and Yoshiki Yazawa. | |
5 * Copyright (c) 2008 Eugene Zagidullin | |
6 * | |
7 * This program is free software; you can redistribute it and/or modify | |
8 * it under the terms of the GNU General Public License as published by | |
9 * the Free Software Foundation; under version 3 of the License. | |
10 * | |
11 * This program is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License | |
17 * along with this program. If not, see <http://www.gnu.org/licenses>. | |
18 * | |
19 * The Audacious team does not consider modular code linking to | |
20 * Audacious or using our public API to be a derived work. | |
21 */ | |
22 | |
23 #ifdef HAVE_CONFIG_H | |
24 # include "config.h" | |
25 #endif | |
26 | |
27 #include <glib.h> | |
28 #include <glib/gi18n.h> | |
29 #include <gtk/gtk.h> | |
30 #include <string.h> | |
31 #include <stddef.h> | |
32 #include <stdio.h> | |
33 #include <stdarg.h> | |
34 #include <sys/types.h> | |
35 #include <dirent.h> | |
36 #include <unistd.h> | |
37 #include <errno.h> | |
38 #include <sys/types.h> | |
39 #include <sys/stat.h> | |
40 | |
41 #include "plugin.h" | |
42 #include "pluginenum.h" | |
43 #include "input.h" | |
44 #include "effect.h" | |
45 #include "strings.h" | |
46 #include "general.h" | |
47 #include "output.h" | |
48 #include "visualization.h" | |
49 | |
50 #include "main.h" | |
51 #include "util.h" | |
52 #include "dnd.h" | |
53 #include "tuple.h" | |
54 #include "vfs.h" | |
55 | |
56 #include "playlist.h" | |
57 | |
58 #include "build_stamp.h" | |
59 #include "ui_fileinfo.h" | |
60 | |
61 #define G_FREE_CLEAR(a) if(a != NULL) { g_free(a); a = NULL; } | |
62 #define STATUS_TIMEOUT 3*1000 | |
63 | |
64 GtkWidget *fileinfo_win = NULL; | |
65 | |
66 GtkWidget *entry_location; | |
67 GtkWidget *entry_title; | |
68 GtkWidget *entry_artist; | |
69 GtkWidget *entry_album; | |
70 GtkWidget *entry_comment; | |
71 GtkWidget *entry_year; | |
72 GtkWidget *entry_track; | |
73 GtkWidget *entry_genre; | |
74 | |
75 GtkWidget *image_artwork; | |
76 | |
77 GtkWidget *image_fileicon; | |
78 GtkWidget *label_format_name; | |
79 GtkWidget *label_quality; | |
80 GtkWidget *label_bitrate; | |
81 GtkWidget *btn_apply; | |
82 GtkWidget *label_mini_status; | |
83 GtkWidget *arrow_rawdata; | |
84 GtkWidget *treeview_rawdata; | |
85 | |
86 enum { | |
87 RAWDATA_KEY, | |
88 RAWDATA_VALUE, | |
89 RAWDATA_N_COLS | |
90 }; | |
91 | |
92 static gchar *current_file = NULL; | |
93 static InputPlugin *current_ip = NULL; | |
94 static gboolean something_changed = FALSE; | |
95 | |
96 /* stolen from Audacious 1.4 vorbis plugin. --nenolod */ | |
97 static const gchar *genre_table[] = { | |
98 N_("Blues"), N_("Classic Rock"), N_("Country"), N_("Dance"), | |
99 N_("Disco"), N_("Funk"), N_("Grunge"), N_("Hip-Hop"), | |
100 N_("Jazz"), N_("Metal"), N_("New Age"), N_("Oldies"), | |
101 N_("Other"), N_("Pop"), N_("R&B"), N_("Rap"), N_("Reggae"), | |
102 N_("Rock"), N_("Techno"), N_("Industrial"), N_("Alternative"), | |
103 N_("Ska"), N_("Death Metal"), N_("Pranks"), N_("Soundtrack"), | |
104 N_("Euro-Techno"), N_("Ambient"), N_("Trip-Hop"), N_("Vocal"), | |
105 N_("Jazz+Funk"), N_("Fusion"), N_("Trance"), N_("Classical"), | |
106 N_("Instrumental"), N_("Acid"), N_("House"), N_("Game"), | |
107 N_("Sound Clip"), N_("Gospel"), N_("Noise"), N_("AlternRock"), | |
108 N_("Bass"), N_("Soul"), N_("Punk"), N_("Space"), | |
109 N_("Meditative"), N_("Instrumental Pop"), | |
110 N_("Instrumental Rock"), N_("Ethnic"), N_("Gothic"), | |
111 N_("Darkwave"), N_("Techno-Industrial"), N_("Electronic"), | |
112 N_("Pop-Folk"), N_("Eurodance"), N_("Dream"), | |
113 N_("Southern Rock"), N_("Comedy"), N_("Cult"), | |
114 N_("Gangsta Rap"), N_("Top 40"), N_("Christian Rap"), | |
115 N_("Pop/Funk"), N_("Jungle"), N_("Native American"), | |
116 N_("Cabaret"), N_("New Wave"), N_("Psychedelic"), N_("Rave"), | |
117 N_("Showtunes"), N_("Trailer"), N_("Lo-Fi"), N_("Tribal"), | |
118 N_("Acid Punk"), N_("Acid Jazz"), N_("Polka"), N_("Retro"), | |
119 N_("Musical"), N_("Rock & Roll"), N_("Hard Rock"), N_("Folk"), | |
120 N_("Folk/Rock"), N_("National Folk"), N_("Swing"), | |
121 N_("Fast-Fusion"), N_("Bebob"), N_("Latin"), N_("Revival"), | |
122 N_("Celtic"), N_("Bluegrass"), N_("Avantgarde"), | |
123 N_("Gothic Rock"), N_("Progressive Rock"), | |
124 N_("Psychedelic Rock"), N_("Symphonic Rock"), N_("Slow Rock"), | |
125 N_("Big Band"), N_("Chorus"), N_("Easy Listening"), | |
126 N_("Acoustic"), N_("Humour"), N_("Speech"), N_("Chanson"), | |
127 N_("Opera"), N_("Chamber Music"), N_("Sonata"), N_("Symphony"), | |
128 N_("Booty Bass"), N_("Primus"), N_("Porn Groove"), | |
129 N_("Satire"), N_("Slow Jam"), N_("Club"), N_("Tango"), | |
130 N_("Samba"), N_("Folklore"), N_("Ballad"), N_("Power Ballad"), | |
131 N_("Rhythmic Soul"), N_("Freestyle"), N_("Duet"), | |
132 N_("Punk Rock"), N_("Drum Solo"), N_("A Cappella"), | |
133 N_("Euro-House"), N_("Dance Hall"), N_("Goa"), | |
134 N_("Drum & Bass"), N_("Club-House"), N_("Hardcore"), | |
135 N_("Terror"), N_("Indie"), N_("BritPop"), N_("Negerpunk"), | |
136 N_("Polsk Punk"), N_("Beat"), N_("Christian Gangsta Rap"), | |
137 N_("Heavy Metal"), N_("Black Metal"), N_("Crossover"), | |
138 N_("Contemporary Christian"), N_("Christian Rock"), | |
139 N_("Merengue"), N_("Salsa"), N_("Thrash Metal"), | |
140 N_("Anime"), N_("JPop"), N_("Synthpop") | |
141 }; | |
142 | |
143 static GList *genre_list = NULL; | |
144 | |
145 static void | |
146 fileinfo_entry_set_text(GtkWidget *widget, const char *text) | |
147 { | |
148 if (widget == NULL) | |
149 return; | |
150 | |
151 gtk_entry_set_text(GTK_ENTRY(widget), text != NULL ? text : ""); | |
152 } | |
153 | |
154 static void | |
155 set_entry_str_from_field(GtkWidget *widget, Tuple *tuple, gint fieldn, gboolean editable) | |
156 { | |
157 gchar *text; | |
158 | |
159 if(widget != NULL) { | |
160 text = (gchar*)tuple_get_string(tuple, fieldn, NULL); | |
161 gtk_entry_set_text(GTK_ENTRY(widget), text != NULL ? text : ""); | |
162 gtk_editable_set_editable(GTK_EDITABLE(widget), editable); | |
163 } | |
164 } | |
165 | |
166 static void | |
167 set_entry_int_from_field(GtkWidget *widget, Tuple *tuple, gint fieldn, gboolean editable) | |
168 { | |
169 gchar *text; | |
170 | |
171 if(widget == NULL) return; | |
172 | |
173 if(tuple_get_value_type(tuple, fieldn, NULL) == TUPLE_INT) { | |
174 text = g_strdup_printf("%d", tuple_get_int(tuple, fieldn, NULL)); | |
175 gtk_entry_set_text(GTK_ENTRY(widget), text); | |
176 gtk_editable_set_editable(GTK_EDITABLE(widget), editable); | |
177 g_free(text); | |
178 } else { | |
179 gtk_entry_set_text(GTK_ENTRY(widget), ""); | |
180 gtk_editable_set_editable(GTK_EDITABLE(widget), editable); | |
181 } | |
182 } | |
183 | |
184 static void | |
185 set_field_str_from_entry(Tuple *tuple, gint fieldn, GtkWidget *widget) | |
186 { | |
187 if(widget == NULL) return; | |
188 tuple_associate_string(tuple, fieldn, NULL, gtk_entry_get_text(GTK_ENTRY(widget))); | |
189 } | |
190 | |
191 static void | |
192 set_field_int_from_entry(Tuple *tuple, gint fieldn, GtkWidget *widget) | |
193 { | |
194 gchar *tmp; | |
195 if(widget == NULL) return; | |
196 | |
197 tmp = (gchar*)gtk_entry_get_text(GTK_ENTRY(widget)); | |
198 if(*tmp != '\0') | |
199 tuple_associate_int(tuple, fieldn, NULL, atoi(tmp)); | |
200 else | |
201 tuple_associate_int(tuple, fieldn, NULL, -1); | |
202 } | |
203 | |
204 static void | |
205 fileinfo_label_set_text(GtkWidget *widget, const char *text) | |
206 { | |
207 gchar *tmp; | |
208 | |
209 if (widget == NULL) | |
210 return; | |
211 | |
212 if (text) { | |
213 tmp = g_strdup_printf("<span size=\"small\">%s</span>", text); | |
214 gtk_label_set_text(GTK_LABEL(widget), tmp); | |
215 gtk_label_set_use_markup(GTK_LABEL(widget), TRUE); | |
216 g_free(tmp); | |
217 } else { | |
218 gtk_label_set_text(GTK_LABEL(widget), _("<span size=\"small\">n/a</span>")); | |
219 gtk_label_set_use_markup(GTK_LABEL(widget), TRUE); | |
220 } | |
221 } | |
222 | |
223 static void | |
224 fileinfo_entry_set_image(GtkWidget *widget, const char *text) | |
225 { | |
226 GdkPixbuf *pixbuf; | |
227 int width, height; | |
228 double aspect; | |
229 GdkPixbuf *pixbuf2; | |
230 | |
231 if (widget == NULL) | |
232 return; | |
233 | |
234 pixbuf = gdk_pixbuf_new_from_file(text, NULL); | |
235 | |
236 if (pixbuf == NULL) | |
237 return; | |
238 | |
239 width = gdk_pixbuf_get_width(GDK_PIXBUF(pixbuf)); | |
240 height = gdk_pixbuf_get_height(GDK_PIXBUF(pixbuf)); | |
241 | |
242 if (strcmp(DATA_DIR "/images/audio.png", text)) { | |
243 if (width == 0) | |
244 width = 1; | |
245 aspect = (double)height / (double)width; | |
246 | |
247 if (aspect > 1.0) { | |
248 height = (int)(cfg.filepopup_pixelsize * aspect); | |
249 width = cfg.filepopup_pixelsize; | |
250 } else { | |
251 height = cfg.filepopup_pixelsize; | |
252 width = (int)(cfg.filepopup_pixelsize / aspect); | |
253 } | |
254 | |
255 pixbuf2 = gdk_pixbuf_scale_simple(GDK_PIXBUF(pixbuf), width, height, GDK_INTERP_BILINEAR); | |
256 g_object_unref(G_OBJECT(pixbuf)); | |
257 pixbuf = pixbuf2; | |
258 } | |
259 | |
260 gtk_image_set_from_pixbuf(GTK_IMAGE(widget), GDK_PIXBUF(pixbuf)); | |
261 g_object_unref(G_OBJECT(pixbuf)); | |
262 } | |
263 | |
264 static void | |
265 fileinfo_hide(gpointer unused) | |
266 { | |
267 if(GTK_WIDGET_VISIBLE(fileinfo_win)) gtk_widget_hide(fileinfo_win); | |
268 | |
269 /* Clear it out. */ | |
270 fileinfo_entry_set_text(entry_title, ""); | |
271 fileinfo_entry_set_text(entry_artist, ""); | |
272 fileinfo_entry_set_text(entry_album, ""); | |
273 fileinfo_entry_set_text(entry_comment, ""); | |
274 fileinfo_entry_set_text(gtk_bin_get_child(GTK_BIN(entry_genre)), ""); | |
275 fileinfo_entry_set_text(entry_year, ""); | |
276 fileinfo_entry_set_text(entry_track, ""); | |
277 fileinfo_entry_set_text(entry_location, ""); | |
278 | |
279 fileinfo_label_set_text(label_format_name, NULL); | |
280 fileinfo_label_set_text(label_quality, NULL); | |
281 fileinfo_label_set_text(label_bitrate, NULL); | |
282 | |
283 if (label_mini_status != NULL) { | |
284 gtk_label_set_text(GTK_LABEL(label_mini_status), "<span size=\"small\"></span>"); | |
285 gtk_label_set_use_markup(GTK_LABEL(label_mini_status), TRUE); | |
286 } | |
287 | |
288 something_changed = FALSE; | |
289 gtk_widget_set_sensitive(btn_apply, FALSE); | |
290 | |
291 current_ip = NULL; | |
292 G_FREE_CLEAR(current_file); | |
293 | |
294 fileinfo_entry_set_image(image_artwork, DATA_DIR "/images/audio.png"); | |
295 } | |
296 | |
297 static void | |
298 entry_changed (GtkEditable *editable, gpointer user_data) | |
299 { | |
300 if(current_file != NULL && current_ip != NULL && current_ip->update_song_tuple != NULL) { | |
301 something_changed = TRUE; | |
302 gtk_widget_set_sensitive(btn_apply, TRUE); | |
303 } | |
304 } | |
305 | |
306 static gboolean | |
307 ministatus_timeout_proc (gpointer data) | |
308 { | |
309 GtkLabel *status = GTK_LABEL(data); | |
310 gtk_label_set_text(status, "<span size=\"small\"></span>"); | |
311 gtk_label_set_use_markup(status, TRUE); | |
312 | |
313 return FALSE; | |
314 } | |
315 | |
316 static void | |
317 ministatus_display_message(gchar *text) | |
318 { | |
319 if(label_mini_status != NULL) { | |
320 gchar *tmp = g_strdup_printf("<span size=\"small\">%s</span>", text); | |
321 gtk_label_set_text(GTK_LABEL(label_mini_status), tmp); | |
322 g_free(tmp); | |
323 gtk_label_set_use_markup(GTK_LABEL(label_mini_status), TRUE); | |
324 g_timeout_add (STATUS_TIMEOUT, (GSourceFunc) ministatus_timeout_proc, (gpointer) label_mini_status); | |
325 } | |
326 } | |
327 | |
328 static void | |
329 message_update_successfull() | |
330 { | |
331 ministatus_display_message(_("Metadata updated successfully")); | |
332 } | |
333 | |
334 static void | |
335 message_update_failed() | |
336 { | |
337 ministatus_display_message(_("Metadata updating failed")); | |
338 } | |
339 | |
340 static void | |
341 fileinfo_update_tuple(gpointer data) | |
342 { | |
343 Tuple *tuple; | |
344 VFSFile *fd; | |
345 | |
346 if (current_file != NULL && current_ip != NULL && current_ip->update_song_tuple != NULL && something_changed) { | |
347 tuple = tuple_new(); | |
348 fd = vfs_fopen(current_file, "r+b"); | |
349 | |
350 if (fd != NULL) { | |
351 set_field_str_from_entry(tuple, FIELD_TITLE, entry_title); | |
352 set_field_str_from_entry(tuple, FIELD_ARTIST, entry_artist); | |
353 set_field_str_from_entry(tuple, FIELD_ALBUM, entry_album); | |
354 set_field_str_from_entry(tuple, FIELD_COMMENT, entry_comment); | |
355 set_field_str_from_entry(tuple, FIELD_GENRE, gtk_bin_get_child(GTK_BIN(entry_genre))); | |
356 | |
357 set_field_int_from_entry(tuple, FIELD_YEAR, entry_year); | |
358 set_field_int_from_entry(tuple, FIELD_TRACK_NUMBER, entry_track); | |
359 | |
360 plugin_set_current((Plugin *)current_ip); | |
361 if (current_ip->update_song_tuple(tuple, fd)) { | |
362 message_update_successfull(); | |
363 something_changed = FALSE; | |
364 gtk_widget_set_sensitive(btn_apply, FALSE); | |
365 } else | |
366 message_update_failed(); | |
367 | |
368 vfs_fclose(fd); | |
369 | |
370 } else | |
371 message_update_failed(); | |
372 | |
373 mowgli_object_unref(tuple); | |
374 } | |
375 } | |
376 | |
377 /** | |
378 * Looks up an icon from a NULL-terminated list of icon names. | |
379 * | |
380 * size: the requested size | |
381 * name: the default name | |
382 * ... : a NULL-terminated list of alternates | |
383 */ | |
384 GdkPixbuf * | |
385 themed_icon_lookup(gint size, const gchar *name, ...) | |
386 { | |
387 GtkIconTheme *icon_theme; | |
388 GdkPixbuf *pixbuf; | |
389 GError *error = NULL; | |
390 gchar *n; | |
391 va_list par; | |
392 | |
393 icon_theme = gtk_icon_theme_get_default (); | |
394 pixbuf = gtk_icon_theme_load_icon (icon_theme, name, size, 0, &error); | |
395 | |
396 if (pixbuf != NULL) | |
397 return pixbuf; | |
398 | |
399 if (error != NULL) | |
400 g_error_free(error); | |
401 | |
402 /* fallback */ | |
403 va_start(par, name); | |
404 while((n = (gchar*)va_arg(par, gchar *)) != NULL) { | |
405 error = NULL; | |
406 pixbuf = gtk_icon_theme_load_icon (icon_theme, n, size, 0, &error); | |
407 | |
408 if (pixbuf) { | |
409 va_end(par); | |
410 return pixbuf; | |
411 } | |
412 | |
413 if (error != NULL) | |
414 g_error_free(error); | |
415 } | |
416 | |
417 return NULL; | |
418 } | |
419 | |
420 /** | |
421 * Intelligently looks up an icon for a mimetype. Supports | |
422 * HIDEOUSLY BROKEN gnome icon naming scheme too. | |
423 * | |
424 * size : the requested size | |
425 * mime_type: the mime type. | |
426 */ | |
427 GdkPixbuf * | |
428 mime_icon_lookup(gint size, const gchar *mime_type) /* smart icon resolving routine :) */ | |
429 { | |
430 gchar *mime_as_is; /* audio-x-mp3 */ | |
431 gchar *mime_gnome; /* gnome-mime-audio-x-mp3 */ | |
432 gchar *mime_generic; /* audio-x-generic */ | |
433 gchar *mime_gnome_generic; /* gnome-mime-audio */ | |
434 | |
435 GdkPixbuf *icon = NULL; | |
436 | |
437 gchar **s = g_strsplit(mime_type, "/", 2); | |
438 if(s[1] != NULL) { | |
439 mime_as_is = g_strdup_printf("%s-%s", s[0], s[1]); | |
440 mime_gnome = g_strdup_printf("gnome-mime-%s-%s", s[0], s[1]); | |
441 mime_generic = g_strdup_printf("%s-x-generic", s[0]); | |
442 mime_gnome_generic = g_strdup_printf("gnome-mime-%s", s[0]); | |
443 icon = themed_icon_lookup(size, mime_as_is, mime_gnome, mime_generic, mime_gnome_generic, s[0], NULL); /* s[0] is category */ | |
444 g_free(mime_gnome_generic); | |
445 g_free(mime_generic); | |
446 g_free(mime_gnome); | |
447 g_free(mime_as_is); | |
448 } | |
449 g_strfreev(s); | |
450 | |
451 return icon; | |
452 } | |
453 | |
454 void | |
455 create_fileinfo_window(void) | |
456 { | |
457 GtkWidget *hbox; | |
458 GtkWidget *hbox_status_and_bbox; | |
459 GtkWidget *vbox0; | |
460 GtkWidget *vbox1; | |
461 GtkWidget *vbox2; | |
462 GtkWidget *vbox3; | |
463 GtkWidget *label_title; | |
464 GtkWidget *label_artist; | |
465 GtkWidget *label_album; | |
466 GtkWidget *label_comment; | |
467 GtkWidget *label_genre; | |
468 GtkWidget *label_year; | |
469 GtkWidget *label_track; | |
470 GtkWidget *label_location; | |
471 GtkWidget *label_general; | |
472 GtkWidget *label_format; | |
473 GtkWidget *label_quality_label; | |
474 GtkWidget *label_bitrate_label; | |
475 GtkWidget *codec_hbox; | |
476 GtkWidget *codec_table; | |
477 GtkWidget *table1; | |
478 GtkWidget *bbox_close; | |
479 GtkWidget *btn_close; | |
480 GtkWidget *alignment; | |
481 GtkWidget *separator; | |
482 GtkWidget *scrolledwindow; | |
483 GtkTreeViewColumn *column; | |
484 GtkCellRenderer *renderer; | |
485 gint i; | |
486 | |
487 fileinfo_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); | |
488 gtk_container_set_border_width(GTK_CONTAINER(fileinfo_win), 6); | |
489 gtk_window_set_title(GTK_WINDOW(fileinfo_win), _("Track Information")); | |
490 gtk_window_set_position(GTK_WINDOW(fileinfo_win), GTK_WIN_POS_CENTER); | |
491 gtk_window_set_resizable(GTK_WINDOW(fileinfo_win), FALSE); | |
492 gtk_window_set_type_hint(GTK_WINDOW(fileinfo_win), GDK_WINDOW_TYPE_HINT_DIALOG); | |
493 gtk_window_set_transient_for(GTK_WINDOW(fileinfo_win), GTK_WINDOW(mainwin)); | |
494 | |
495 vbox0 = gtk_vbox_new(FALSE, 0); | |
496 gtk_container_add(GTK_CONTAINER(fileinfo_win), vbox0); | |
497 | |
498 hbox = gtk_hbox_new(FALSE, 6); | |
499 gtk_box_pack_start(GTK_BOX(vbox0), hbox, TRUE, TRUE, 0); | |
500 | |
501 image_artwork = gtk_image_new(); | |
502 gtk_box_pack_start(GTK_BOX(hbox), image_artwork, FALSE, FALSE, 0); | |
503 gtk_misc_set_alignment(GTK_MISC(image_artwork), 0.5, 0); | |
504 gtk_image_set_from_file(GTK_IMAGE(image_artwork), DATA_DIR "/images/audio.png"); | |
505 separator = gtk_vseparator_new(); | |
506 gtk_box_pack_start(GTK_BOX(hbox), separator, FALSE, FALSE, 0); | |
507 | |
508 vbox1 = gtk_vbox_new(FALSE, 0); | |
509 gtk_box_pack_start(GTK_BOX(hbox), vbox1, TRUE, TRUE, 0); | |
510 | |
511 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
512 gtk_box_pack_start(GTK_BOX(vbox1), alignment, TRUE, TRUE, 0); | |
513 | |
514 vbox2 = gtk_vbox_new(FALSE, 0); | |
515 gtk_container_add(GTK_CONTAINER(alignment), vbox2); | |
516 | |
517 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
518 gtk_box_pack_start(GTK_BOX(vbox1), alignment, TRUE, TRUE, 0); | |
519 | |
520 vbox3 = gtk_vbox_new(FALSE, 0); | |
521 gtk_container_add(GTK_CONTAINER(alignment), vbox3); | |
522 | |
523 label_general = gtk_label_new(_("<span size=\"small\">General</span>")); | |
524 gtk_box_pack_start (GTK_BOX (vbox2), label_general, FALSE, FALSE, 0); | |
525 gtk_label_set_use_markup(GTK_LABEL(label_general), TRUE); | |
526 gtk_misc_set_alignment(GTK_MISC(label_general), 0, 0.5); | |
527 | |
528 alignment = gtk_alignment_new (0.5, 0.5, 1, 1); | |
529 gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 6, 0, 0); | |
530 gtk_box_pack_start (GTK_BOX (vbox2), alignment, FALSE, FALSE, 0); | |
531 | |
532 codec_hbox = gtk_hbox_new(FALSE, 6); | |
533 gtk_container_add (GTK_CONTAINER(alignment), codec_hbox); | |
534 | |
535 image_fileicon = gtk_image_new_from_stock (GTK_STOCK_MISSING_IMAGE, GTK_ICON_SIZE_DIALOG); | |
536 gtk_box_pack_start (GTK_BOX (codec_hbox), image_fileicon, FALSE, FALSE, 0); | |
537 | |
538 codec_table = gtk_table_new(3, 2, FALSE); | |
539 gtk_table_set_row_spacings (GTK_TABLE(codec_table), 6); | |
540 gtk_table_set_col_spacings (GTK_TABLE(codec_table), 12); | |
541 gtk_box_pack_start (GTK_BOX (codec_hbox), codec_table, FALSE, FALSE, 0); | |
542 | |
543 label_format = gtk_label_new(_("<span size=\"small\">Format:</span>")); | |
544 gtk_label_set_use_markup(GTK_LABEL(label_format), TRUE); | |
545 gtk_misc_set_alignment(GTK_MISC(label_format), 0, 0.5); | |
546 label_quality_label = gtk_label_new(_("<span size=\"small\">Quality:</span>")); | |
547 gtk_label_set_use_markup(GTK_LABEL(label_quality_label), TRUE); | |
548 gtk_misc_set_alignment(GTK_MISC(label_quality_label), 0, 0.5); | |
549 label_bitrate_label = gtk_label_new(_("<span size=\"small\">Bitrate:</span>")); | |
550 gtk_label_set_use_markup(GTK_LABEL(label_bitrate_label), TRUE); | |
551 gtk_misc_set_alignment(GTK_MISC(label_bitrate_label), 0, 0.5); | |
552 | |
553 label_format_name = gtk_label_new(_("<span size=\"small\">n/a</span>")); | |
554 gtk_label_set_use_markup(GTK_LABEL(label_format_name), TRUE); | |
555 gtk_misc_set_alignment(GTK_MISC(label_format_name), 0, 0.5); | |
556 label_quality = gtk_label_new(_("<span size=\"small\">n/a</span>")); | |
557 gtk_label_set_use_markup(GTK_LABEL(label_quality), TRUE); | |
558 gtk_misc_set_alignment(GTK_MISC(label_quality), 0, 0.5); | |
559 label_bitrate = gtk_label_new(_("<span size=\"small\">n/a</span>")); | |
560 gtk_label_set_use_markup(GTK_LABEL(label_bitrate), TRUE); | |
561 gtk_misc_set_alignment(GTK_MISC(label_bitrate), 0, 0.5); | |
562 | |
563 gtk_table_attach(GTK_TABLE(codec_table), label_format, 0, 1, 0, 1, | |
564 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
565 (GtkAttachOptions) (0), 0, 0); | |
566 gtk_table_attach(GTK_TABLE(codec_table), label_format_name, 1, 2, 0, 1, | |
567 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
568 (GtkAttachOptions) (0), 0, 0); | |
569 gtk_table_attach(GTK_TABLE(codec_table), label_quality_label, 0, 1, 1, 2, | |
570 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
571 (GtkAttachOptions) (0), 0, 0); | |
572 gtk_table_attach(GTK_TABLE(codec_table), label_quality, 1, 2, 1, 2, | |
573 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
574 (GtkAttachOptions) (0), 0, 0); | |
575 gtk_table_attach(GTK_TABLE(codec_table), label_bitrate_label, 0, 1, 2, 3, | |
576 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
577 (GtkAttachOptions) (0), 0, 0); | |
578 gtk_table_attach(GTK_TABLE(codec_table), label_bitrate, 1, 2, 2, 3, | |
579 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
580 (GtkAttachOptions) (0), 0, 0); | |
581 | |
582 label_title = gtk_label_new(_("<span size=\"small\">Title</span>")); | |
583 gtk_box_pack_start(GTK_BOX(vbox2), label_title, FALSE, FALSE, 0); | |
584 gtk_label_set_use_markup(GTK_LABEL(label_title), TRUE); | |
585 gtk_misc_set_alignment(GTK_MISC(label_title), 0, 0); | |
586 | |
587 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
588 gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 0); | |
589 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 6, 0, 0); | |
590 entry_title = gtk_entry_new(); | |
591 gtk_container_add(GTK_CONTAINER(alignment), entry_title); | |
592 g_signal_connect(G_OBJECT(entry_title), "changed", (GCallback) entry_changed, NULL); | |
593 | |
594 label_artist = gtk_label_new(_("<span size=\"small\">Artist</span>")); | |
595 gtk_box_pack_start(GTK_BOX(vbox2), label_artist, FALSE, FALSE, 0); | |
596 gtk_label_set_use_markup(GTK_LABEL(label_artist), TRUE); | |
597 gtk_misc_set_alignment(GTK_MISC(label_artist), 0, 0.5); | |
598 | |
599 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
600 gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 0); | |
601 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 6, 0, 0); | |
602 entry_artist = gtk_entry_new(); | |
603 gtk_container_add(GTK_CONTAINER(alignment), entry_artist); | |
604 g_signal_connect(G_OBJECT(entry_artist), "changed", (GCallback) entry_changed, NULL); | |
605 | |
606 label_album = gtk_label_new(_("<span size=\"small\">Album</span>")); | |
607 gtk_box_pack_start(GTK_BOX(vbox2), label_album, FALSE, FALSE, 0); | |
608 gtk_label_set_use_markup(GTK_LABEL(label_album), TRUE); | |
609 gtk_misc_set_alignment(GTK_MISC(label_album), 0, 0.5); | |
610 | |
611 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
612 gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 0); | |
613 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 6, 0, 0); | |
614 entry_album = gtk_entry_new(); | |
615 gtk_container_add(GTK_CONTAINER(alignment), entry_album); | |
616 g_signal_connect(G_OBJECT(entry_album), "changed", (GCallback) entry_changed, NULL); | |
617 | |
618 label_comment = gtk_label_new(_("<span size=\"small\">Comment</span>")); | |
619 gtk_box_pack_start(GTK_BOX(vbox2), label_comment, FALSE, FALSE, 0); | |
620 gtk_label_set_use_markup(GTK_LABEL(label_comment), TRUE); | |
621 gtk_misc_set_alignment(GTK_MISC(label_comment), 0, 0.5); | |
622 | |
623 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
624 gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 0); | |
625 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 6, 0, 0); | |
626 entry_comment = gtk_entry_new(); | |
627 gtk_container_add (GTK_CONTAINER(alignment), entry_comment); | |
628 g_signal_connect(G_OBJECT(entry_comment), "changed", (GCallback) entry_changed, NULL); | |
629 | |
630 label_genre = gtk_label_new(_("<span size=\"small\">Genre</span>")); | |
631 gtk_box_pack_start(GTK_BOX(vbox2), label_genre, FALSE, FALSE, 0); | |
632 gtk_label_set_use_markup(GTK_LABEL(label_genre), TRUE); | |
633 gtk_misc_set_alignment(GTK_MISC(label_genre), 0, 0.5); | |
634 | |
635 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
636 gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 0); | |
637 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 6, 0, 0); | |
638 entry_genre = gtk_combo_box_entry_new_text(); | |
639 | |
640 if (!genre_list) { | |
641 GList *iter; | |
642 | |
643 for (i = 0; i < G_N_ELEMENTS(genre_table); i++) | |
644 genre_list = g_list_prepend(genre_list, _(genre_table[i])); | |
645 genre_list = g_list_sort(genre_list, (GCompareFunc) g_utf8_collate); | |
646 | |
647 MOWGLI_ITER_FOREACH(iter, genre_list) | |
648 gtk_combo_box_append_text(GTK_COMBO_BOX(entry_genre), iter->data); | |
649 } | |
650 | |
651 gtk_container_add(GTK_CONTAINER(alignment), entry_genre); | |
652 g_signal_connect(G_OBJECT(entry_genre), "changed", (GCallback) entry_changed, NULL); | |
653 | |
654 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
655 gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 0); | |
656 gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 6, 0, 0); | |
657 table1 = gtk_table_new(2, 2, FALSE); | |
658 gtk_container_add(GTK_CONTAINER(alignment), table1); | |
659 gtk_table_set_col_spacings(GTK_TABLE(table1), 6); | |
660 | |
661 label_year = gtk_label_new(_("<span size=\"small\">Year</span>")); | |
662 gtk_table_attach(GTK_TABLE(table1), label_year, 0, 1, 0, 1, | |
663 (GtkAttachOptions) (GTK_FILL), | |
664 (GtkAttachOptions) (0), 0, 0); | |
665 gtk_label_set_use_markup(GTK_LABEL(label_year), TRUE); | |
666 gtk_misc_set_alignment(GTK_MISC(label_year), 0, 0.5); | |
667 | |
668 entry_year = gtk_entry_new(); | |
669 gtk_table_attach(GTK_TABLE(table1), entry_year, 0, 1, 1, 2, | |
670 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
671 (GtkAttachOptions) (0), 0, 0); | |
672 g_signal_connect(G_OBJECT(entry_year), "changed", (GCallback) entry_changed, NULL); | |
673 | |
674 label_track = gtk_label_new(_("<span size=\"small\">Track Number</span>")); | |
675 gtk_table_attach(GTK_TABLE(table1), label_track, 1, 2, 0, 1, | |
676 (GtkAttachOptions) (GTK_FILL), | |
677 (GtkAttachOptions) (0), 0, 0); | |
678 gtk_label_set_use_markup(GTK_LABEL(label_track), TRUE); | |
679 gtk_misc_set_alignment(GTK_MISC(label_track), 0, 0.5); | |
680 | |
681 entry_track = gtk_entry_new(); | |
682 gtk_table_attach(GTK_TABLE(table1), entry_track, 1, 2, 1, 2, | |
683 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), | |
684 (GtkAttachOptions) (0), 0, 0); | |
685 g_signal_connect(G_OBJECT(entry_track), "changed", (GCallback) entry_changed, NULL); | |
686 | |
687 label_location = gtk_label_new(_("<span size=\"small\">Location</span>")); | |
688 gtk_box_pack_start(GTK_BOX(vbox2), label_location, FALSE, FALSE, 0); | |
689 gtk_label_set_use_markup(GTK_LABEL(label_location), TRUE); | |
690 gtk_misc_set_alignment(GTK_MISC(label_location), 0, 0.5); | |
691 | |
692 alignment = gtk_alignment_new (0.5, 0.5, 1, 1); | |
693 gtk_box_pack_start (GTK_BOX (vbox2), alignment, FALSE, FALSE, 0); | |
694 gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 6, 0, 0); | |
695 | |
696 entry_location = gtk_entry_new(); | |
697 gtk_container_add(GTK_CONTAINER(alignment), entry_location); | |
698 gtk_editable_set_editable(GTK_EDITABLE(entry_location), FALSE); | |
699 | |
700 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
701 hbox = gtk_hbox_new(FALSE, 0); | |
702 gtk_container_add(GTK_CONTAINER(alignment), hbox); | |
703 gtk_box_pack_start(GTK_BOX(vbox3), alignment, TRUE, TRUE, 0); | |
704 | |
705 alignment = gtk_alignment_new(0.5, 0.5, 1, 1); | |
706 gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 6, 0, 0); | |
707 arrow_rawdata = gtk_expander_new(_("<span size=\"small\">Raw Metadata</span>")); | |
708 gtk_expander_set_use_markup(GTK_EXPANDER(arrow_rawdata), TRUE); | |
709 gtk_container_add(GTK_CONTAINER(alignment), arrow_rawdata); | |
710 gtk_box_pack_start(GTK_BOX(hbox), alignment, TRUE, TRUE, 0); | |
711 | |
712 scrolledwindow = gtk_scrolled_window_new (NULL, NULL); | |
713 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); | |
714 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); | |
715 gtk_container_add(GTK_CONTAINER(arrow_rawdata), scrolledwindow); | |
716 | |
717 treeview_rawdata = gtk_tree_view_new(); | |
718 gtk_container_add(GTK_CONTAINER(scrolledwindow), treeview_rawdata); | |
719 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview_rawdata), TRUE); | |
720 gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview_rawdata), TRUE); | |
721 gtk_widget_set_size_request(treeview_rawdata, -1, 130); | |
722 | |
723 column = gtk_tree_view_column_new(); | |
724 gtk_tree_view_column_set_title(column, _("Key")); | |
725 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); | |
726 gtk_tree_view_column_set_spacing(column, 4); | |
727 gtk_tree_view_column_set_resizable(column, FALSE); | |
728 gtk_tree_view_column_set_fixed_width(column, 50); | |
729 | |
730 renderer = gtk_cell_renderer_text_new(); | |
731 gtk_tree_view_column_pack_start(column, renderer, FALSE); | |
732 gtk_tree_view_column_set_attributes(column, renderer, | |
733 "text", RAWDATA_KEY, NULL); | |
734 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_rawdata), column); | |
735 | |
736 column = gtk_tree_view_column_new(); | |
737 gtk_tree_view_column_set_title(column, _("Value")); | |
738 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); | |
739 gtk_tree_view_column_set_spacing(column, 4); | |
740 gtk_tree_view_column_set_resizable(column, FALSE); | |
741 gtk_tree_view_column_set_fixed_width(column, 50); | |
742 | |
743 renderer = gtk_cell_renderer_text_new(); | |
744 gtk_tree_view_column_pack_start(column, renderer, FALSE); | |
745 gtk_tree_view_column_set_attributes(column, renderer, | |
746 "text", RAWDATA_VALUE, NULL); | |
747 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_rawdata), column); | |
748 | |
749 hbox_status_and_bbox = gtk_hbox_new(FALSE, 0); | |
750 gtk_box_pack_start (GTK_BOX (vbox0), hbox_status_and_bbox, FALSE, FALSE, 0); | |
751 | |
752 label_mini_status = gtk_label_new("<span size=\"small\"></span>"); | |
753 gtk_label_set_use_markup(GTK_LABEL(label_mini_status), TRUE); | |
754 gtk_misc_set_alignment(GTK_MISC(label_mini_status), 0, 0.5); | |
755 gtk_box_pack_start (GTK_BOX (hbox_status_and_bbox), label_mini_status, TRUE, TRUE, 0); | |
756 | |
757 bbox_close = gtk_hbutton_box_new(); | |
758 gtk_box_set_spacing(GTK_BOX(bbox_close), 6); | |
759 gtk_box_pack_start(GTK_BOX(hbox_status_and_bbox), bbox_close, FALSE, FALSE, 0); | |
760 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox_close), GTK_BUTTONBOX_END); | |
761 | |
762 btn_apply = gtk_button_new_from_stock("gtk-save"); | |
763 gtk_container_add(GTK_CONTAINER(bbox_close), btn_apply); | |
764 g_signal_connect(G_OBJECT(btn_apply), "clicked", (GCallback) fileinfo_update_tuple, NULL); | |
765 gtk_widget_set_sensitive(btn_apply, FALSE); | |
766 | |
767 btn_close = gtk_button_new_from_stock("gtk-close"); | |
768 gtk_container_add(GTK_CONTAINER(bbox_close), btn_close); | |
769 GTK_WIDGET_SET_FLAGS(btn_close, GTK_CAN_DEFAULT); | |
770 g_signal_connect(G_OBJECT(btn_close), "clicked", (GCallback) fileinfo_hide, NULL); | |
771 | |
772 gtk_widget_show_all (vbox0); | |
773 } | |
774 | |
775 static void | |
776 fileinfo_show_for_tuple(Tuple *tuple, gboolean updating_enabled) | |
777 { | |
778 gchar *tmp = NULL; | |
779 GdkPixbuf *icon = NULL; | |
780 GtkTreeIter iter; | |
781 GtkListStore *store; | |
782 mowgli_dictionary_iteration_state_t state; | |
783 TupleValue *tvalue; | |
784 gint i; | |
785 | |
786 if (tuple == NULL) | |
787 return; | |
788 | |
789 if(!updating_enabled) { | |
790 current_ip = NULL; | |
791 G_FREE_CLEAR(current_file); | |
792 } | |
793 | |
794 something_changed = FALSE; | |
795 | |
796 if (fileinfo_win == NULL) | |
797 create_fileinfo_window(); | |
798 | |
799 if (!GTK_WIDGET_REALIZED(fileinfo_win)) | |
800 gtk_widget_realize(fileinfo_win); | |
801 | |
802 set_entry_str_from_field(entry_title, tuple, FIELD_TITLE, updating_enabled); | |
803 set_entry_str_from_field(entry_artist, tuple, FIELD_ARTIST, updating_enabled); | |
804 set_entry_str_from_field(entry_album, tuple, FIELD_ALBUM, updating_enabled); | |
805 set_entry_str_from_field(entry_comment, tuple, FIELD_COMMENT, updating_enabled); | |
806 set_entry_str_from_field(gtk_bin_get_child(GTK_BIN(entry_genre)), tuple, FIELD_GENRE, updating_enabled); | |
807 | |
808 tmp = g_strdup_printf("%s/%s", | |
809 tuple_get_string(tuple, FIELD_FILE_PATH, NULL), | |
810 tuple_get_string(tuple, FIELD_FILE_NAME, NULL)); | |
811 | |
812 if (tmp) { | |
813 fileinfo_entry_set_text(entry_location, tmp); | |
814 g_free(tmp); | |
815 } | |
816 | |
817 /* set empty string if field not availaible. --eugene */ | |
818 set_entry_int_from_field(entry_year, tuple, FIELD_YEAR, updating_enabled); | |
819 set_entry_int_from_field(entry_track, tuple, FIELD_TRACK_NUMBER, updating_enabled); | |
820 | |
821 fileinfo_label_set_text(label_format_name, tuple_get_string(tuple, FIELD_CODEC, NULL)); | |
822 fileinfo_label_set_text(label_quality, tuple_get_string(tuple, FIELD_QUALITY, NULL)); | |
823 | |
824 if (tuple_get_value_type(tuple, FIELD_BITRATE, NULL) == TUPLE_INT) { | |
825 tmp = g_strdup_printf(_("%d kb/s"), tuple_get_int(tuple, FIELD_BITRATE, NULL)); | |
826 fileinfo_label_set_text(label_bitrate, tmp); | |
827 g_free(tmp); | |
828 } else | |
829 fileinfo_label_set_text(label_bitrate, NULL); | |
830 | |
831 tmp = (gchar *)tuple_get_string(tuple, FIELD_MIMETYPE, NULL); | |
832 icon = mime_icon_lookup(48, tmp ? tmp : "audio/x-generic"); | |
833 if (icon) { | |
834 if (image_fileicon) gtk_image_set_from_pixbuf (GTK_IMAGE(image_fileicon), icon); | |
835 g_object_unref(icon); | |
836 } | |
837 | |
838 tmp = fileinfo_recursive_get_image( | |
839 tuple_get_string(tuple, FIELD_FILE_PATH, NULL), | |
840 tuple_get_string(tuple, FIELD_FILE_NAME, NULL), 0); | |
841 | |
842 if (tmp) { | |
843 fileinfo_entry_set_image(image_artwork, tmp); | |
844 g_free(tmp); | |
845 } | |
846 | |
847 gtk_widget_set_sensitive(btn_apply, FALSE); | |
848 | |
849 if (label_mini_status != NULL) { | |
850 gtk_label_set_text(GTK_LABEL(label_mini_status), "<span size=\"small\"></span>"); | |
851 gtk_label_set_use_markup(GTK_LABEL(label_mini_status), TRUE); | |
852 } | |
853 | |
854 store = gtk_list_store_new(RAWDATA_N_COLS, G_TYPE_STRING, G_TYPE_STRING); | |
855 | |
856 for (i = 0; i < FIELD_LAST; i++) { | |
857 gchar *key, *value; | |
858 | |
859 if (!tuple->values[i]) | |
860 continue; | |
861 | |
862 if (tuple->values[i]->type != TUPLE_INT && tuple->values[i]->value.string) | |
863 value = g_strdup(tuple->values[i]->value.string); | |
864 else if (tuple->values[i]->type == TUPLE_INT) | |
865 value = g_strdup_printf("%d", tuple->values[i]->value.integer); | |
866 else | |
867 continue; | |
868 | |
869 key = g_strdup(tuple_fields[i].name); | |
870 | |
871 gtk_list_store_append(store, &iter); | |
872 gtk_list_store_set(store, &iter, | |
873 RAWDATA_KEY, key, | |
874 RAWDATA_VALUE, value, -1); | |
875 | |
876 g_free(key); | |
877 g_free(value); | |
878 } | |
879 | |
880 /* non-standard values are stored in a dictionary. */ | |
881 MOWGLI_DICTIONARY_FOREACH(tvalue, &state, tuple->dict) { | |
882 gchar *key, *value; | |
883 | |
884 if (tvalue->type != TUPLE_INT && tvalue->value.string) | |
885 value = g_strdup(tvalue->value.string); | |
886 else if (tvalue->type == TUPLE_INT) | |
887 value = g_strdup_printf("%d", tvalue->value.integer); | |
888 else | |
889 continue; | |
890 | |
891 key = g_strdup(state.cur->key); | |
892 | |
893 gtk_list_store_append(store, &iter); | |
894 gtk_list_store_set(store, &iter, | |
895 RAWDATA_KEY, key, | |
896 RAWDATA_VALUE, value, -1); | |
897 | |
898 g_free(key); | |
899 g_free(value); | |
900 } | |
901 | |
902 gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_rawdata), GTK_TREE_MODEL(store)); | |
903 g_object_unref(store); | |
904 | |
905 if (!GTK_WIDGET_VISIBLE(fileinfo_win)) | |
906 gtk_widget_show(fileinfo_win); | |
907 } | |
908 | |
909 static void | |
910 fileinfo_show_for_path(gchar *path) | |
911 { | |
912 Tuple *tuple = input_get_song_tuple(path); | |
913 | |
914 if (tuple == NULL) { | |
915 input_file_info_box(path); | |
916 return; | |
917 } | |
918 | |
919 fileinfo_show_for_tuple(tuple, FALSE); | |
920 | |
921 mowgli_object_unref(tuple); | |
922 } | |
923 | |
924 static void | |
925 fileinfo_show_editor_for_path(gchar *path, InputPlugin *ip) | |
926 { | |
927 G_FREE_CLEAR(current_file); | |
928 current_file = g_strdup(path); | |
929 current_ip = ip; | |
930 | |
931 Tuple *tuple = input_get_song_tuple(path); | |
932 | |
933 if (tuple == NULL) { | |
934 input_file_info_box(path); | |
935 return; | |
936 } | |
937 | |
938 fileinfo_show_for_tuple(tuple, TRUE); | |
939 | |
940 mowgli_object_unref(tuple); | |
941 } | |
942 | |
943 static void | |
944 ui_fileinfo_show_entry(Playlist *playlist, PlaylistEntry *entry) | |
945 { | |
946 gchar *path = g_strdup(entry->filename); | |
947 Tuple *tuple = entry->tuple; | |
948 | |
949 /* plugin is capable of updating tags. we need to bypass tuple cache. --eugene */ | |
950 /* maybe code cleanup required... */ | |
951 if (entry != NULL && | |
952 entry->decoder != NULL && | |
953 entry->decoder->update_song_tuple != NULL && | |
954 entry->decoder->file_info_box == NULL && | |
955 path != NULL && !vfs_is_remote(path)) | |
956 { | |
957 fileinfo_show_editor_for_path(path, entry->decoder); | |
958 g_free(path); | |
959 } | |
960 else | |
961 { | |
962 if (tuple != NULL) | |
963 { | |
964 if (entry->decoder != NULL) | |
965 { | |
966 if (entry->decoder->file_info_box == NULL) | |
967 fileinfo_show_for_tuple(tuple, FALSE); | |
968 else | |
969 { | |
970 plugin_set_current((Plugin *)(entry->decoder)); | |
971 entry->decoder->file_info_box(path); | |
972 } | |
973 } | |
974 else | |
975 fileinfo_show_for_path(path); | |
976 g_free(path); | |
977 } | |
978 else if (path != NULL) | |
979 { | |
980 if (entry != NULL && | |
981 entry->decoder != NULL && | |
982 entry->decoder->file_info_box != NULL) | |
983 { | |
984 plugin_set_current((Plugin *)(entry->decoder)); | |
985 entry->decoder->file_info_box(path); | |
986 } | |
987 else | |
988 fileinfo_show_for_path(path); | |
989 g_free(path); | |
990 } | |
991 } | |
992 } | |
993 | |
994 void | |
995 ui_fileinfo_show(Playlist *playlist, guint pos) | |
996 { | |
997 GList *node = NULL; | |
998 | |
999 PLAYLIST_LOCK(playlist); | |
1000 | |
1001 if ((node = g_list_nth(playlist->entries, pos))) | |
1002 ui_fileinfo_show_entry(playlist, node->data); | |
1003 | |
1004 PLAYLIST_UNLOCK(playlist); | |
1005 } | |
1006 | |
1007 void | |
1008 ui_fileinfo_show_current(Playlist *playlist) | |
1009 { | |
1010 PLAYLIST_LOCK(playlist); | |
1011 | |
1012 if (playlist->entries && playlist->position) | |
1013 ui_fileinfo_show_entry(playlist, playlist->position); | |
1014 | |
1015 PLAYLIST_UNLOCK(playlist); | |
1016 } |