1 /*
2 | Copyright (C) 2002-2005 Jorg Schuler <jcsjcs at users sourceforge net>
3 | Part of the gtkpod project.
4 |
5 | URL: http://www.gtkpod.org/
6 | URL: http://gtkpod.sourceforge.net/
7 |
8 | This program is free software; you can redistribute it and/or modify
9 | it under the terms of the GNU General Public License as published by
10 | the Free Software Foundation; either version 2 of the License, or
11 | (at your option) any later version.
12 |
13 | This program is distributed in the hope that it will be useful,
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 | GNU General Public License for more details.
17 |
18 | You should have received a copy of the GNU General Public License
19 | along with this program; if not, write to the Free Software
20 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 |
22 | iTunes and iPod are trademarks of Apple
23 |
24 | This product is not supported/written/published by Apple!
25 |
26 | $Id$
27 */
28
29 #ifdef HAVE_CONFIG_H
30 # include <config.h>
31 #endif
32
33 #include "details.h"
34 #include "display_private.h"
35 #include "info.h"
36 #include "infodlg.h"
37 #include "ipod_init.h"
38 #include "file_convert.h"
39 #include "misc.h"
40 #include "misc_track.h"
41 #include "prefs.h"
42 #include "sort_window.h"
43 #include "repository.h"
44 #include "syncdir.h"
45 #include "tools.h"
46 #include <stdlib.h>
47 #include <string.h>
48 #include <cairo.h>
49 #include <glib/gprintf.h>
50
51 GladeXML *main_window_xml;
52 GtkWidget *gtkpod_window = NULL;
53
54 /* Create the listviews etc */
display_create(void)55 void display_create (void)
56 {
57 gint defx, defy;
58 GtkTooltips *main_tooltips;
59
60 g_return_if_fail (gtkpod_window);
61
62 /* x,y-size */
63 defx = prefs_get_int("size_gtkpod.x");
64 defy = prefs_get_int("size_gtkpod.y");
65 gtk_window_set_default_size (GTK_WINDOW (gtkpod_window), defx, defy);
66 /* we need to use the following line if the main window is already
67 displayed */
68 /* gtk_window_resize (GTK_WINDOW (gtkpod_window), defx, defy);*/
69
70 /* Create tooltips */
71 main_tooltips = gtk_tooltips_new ();
72 g_object_set_data (G_OBJECT (gtkpod_window),
73 "main_tooltips", main_tooltips);
74 /* indicate that main_tooltips was set up */
75 g_object_set_data (G_OBJECT (gtkpod_window),
76 "main_tooltips_initialised", "set");
77
78 tm_create_treeview ();
79 st_create_tabs ();
80 pm_create_treeview ();
81
82 /* initialize sorting */
83 tm_sort (prefs_get_int("tm_sortcol"), prefs_get_int("tm_sort"));
84
85 st_set_default_sizes ();
86
87 /* Hide/Show the toolbar */
88 display_show_hide_toolbar ();
89 /* Hide/Show tooltips */
90 display_show_hide_tooltips ();
91 /* Hide/Show searchbar */
92 display_show_hide_searchbar ();
93 /* change standard g_print () handler */
94 g_set_print_handler ((GPrintFunc)gtkpod_warning);
95
96 /* activate the delete menus correctly */
97 display_adjust_menus ();
98 /* activate status bars */
99 gtkpod_statusbar_init ();
100 gtkpod_tracks_statusbar_init ();
101 gtkpod_space_statusbar_init ();
102
103 /* Initialize the coverart display */
104 coverart_init_display ();
105
106 /* set the menu item for the info window correctly */
107 /* CAREFUL: must be done after calling ..._space_statusbar_init() */
108 display_set_info_window_menu ();
109 /* check if info window should be opened */
110 if (prefs_get_int("info_window"))
111 open_info_dialog ();
112 }
113
114 /* redisplay the entire display (playlists, sort tabs, track view) and
115 * reset the sorted treeviews to normal (according to @inst) */
116 /* @inst: which treeviews should be reset to normal?
117 -2: all treeviews
118 -1: only playlist
119 0...SORT_TAB_MAX-1: sort tab of instance @inst
120 SORT_TAB_MAX: track treeview
121 SORT_TAB_MAX+1: all sort tabs */
display_reset(gint inst)122 void display_reset (gint inst)
123 {
124 gint i;
125 Playlist *cur_pl;
126
127 /* remember */
128 cur_pl = pm_get_selected_playlist ();
129
130 /* remove all playlists from model (and reset "sortable") */
131 if ((inst == -2) || (inst == -1)) pm_remove_all_playlists (TRUE);
132 else pm_remove_all_playlists (FALSE);
133
134 /* reset the sort tabs and track view */
135 st_init (-1, 0);
136
137 /* reset "sortable" */
138 for (i=0; i<SORT_TAB_MAX; ++i)
139 {
140 if ((inst == -2) || (inst == i) || (inst == SORT_TAB_MAX+1))
141 st_remove_all_entries_from_model (i);
142 }
143
144 pm_set_selected_playlist (cur_pl);
145 /* add playlists back to model (without selecting) */
146 pm_add_all_itdbs ();
147 }
148
149
150 /* Clean up used memory (when quitting the program) */
display_cleanup(void)151 void display_cleanup (void)
152 {
153 st_cleanup ();
154 }
155
156
157 /* make sure only suitable menu items are available */
display_adjust_menus(void)158 void display_adjust_menus (void)
159 {
160 GtkWidget *delete;
161 GtkWidget *edit1, *edit2, *edit3, *edit4, *edit5;
162 GtkWidget *dtfpl, *dtfip, *dtfdb, *dtfhd;
163 GtkWidget *defpl, *defip, *defdb, *defhd;
164 GtkWidget *dpl, *dpltfip, *dpltfdb, *dpltfhd;
165 GtkWidget *dsep1, *dsep2;
166 GtkWidget *espl;
167 Playlist *pl;
168
169 delete = gtkpod_xml_get_widget (main_window_xml, "delete_menu");
170 edit1 = gtkpod_xml_get_widget (main_window_xml, "edit_details_menu");
171 edit2 = gtkpod_xml_get_widget (main_window_xml, "delete_menu");
172 edit3 = gtkpod_xml_get_widget (main_window_xml, "create_playlists_menu");
173 edit4 = gtkpod_xml_get_widget (main_window_xml, "randomize_current_playlist_menu");
174 edit5 = gtkpod_xml_get_widget (main_window_xml, "save_track_order_menu");
175
176 #if 0
177 edit6 = gtkpod_xml_get_widget (main_window_xml, "add_files1");
178 edit7 = gtkpod_xml_get_widget (main_window_xml, "add_directory1");
179 edit8 = gtkpod_xml_get_widget (main_window_xml, "add_playlist1");
180 #endif
181
182 dtfpl = gtkpod_xml_get_widget (main_window_xml,
183 "delete_selected_tracks_from_playlist");
184 dtfip = gtkpod_xml_get_widget (main_window_xml,
185 "delete_selected_tracks_from_ipod");
186 dtfdb = gtkpod_xml_get_widget (main_window_xml,
187 "delete_selected_tracks_from_database");
188 dtfhd = gtkpod_xml_get_widget (main_window_xml,
189 "delete_selected_tracks_from_harddisk");
190 defpl = gtkpod_xml_get_widget (main_window_xml,
191 "delete_selected_entry_from_playlist");
192 defip = gtkpod_xml_get_widget (main_window_xml,
193 "delete_selected_entry_from_ipod");
194 defdb = gtkpod_xml_get_widget (main_window_xml,
195 "delete_selected_entry_from_database");
196 defhd = gtkpod_xml_get_widget (main_window_xml,
197 "delete_selected_entry_from_harddisk");
198 dpl = gtkpod_xml_get_widget (main_window_xml,
199 "delete_selected_playlist");
200 dpltfip = gtkpod_xml_get_widget (main_window_xml,
201 "delete_selected_playlist_including_tracks_from_ipod");
202 dpltfdb = gtkpod_xml_get_widget (main_window_xml,
203 "delete_selected_playlist_including_tracks_from_database");
204 dpltfhd = gtkpod_xml_get_widget (main_window_xml,
205 "delete_selected_playlist_including_tracks_from_harddisk");
206 dsep1 = gtkpod_xml_get_widget (main_window_xml, "delete_separator1");
207 dsep2 = gtkpod_xml_get_widget (main_window_xml, "delete_separator2");
208 espl = gtkpod_xml_get_widget (main_window_xml,
209 "edit_smart_playlist");
210
211 #if 0
212 tb_edit1 = gtkpod_xml_get_widget (main_window_xml, "add_files_button");
213 tb_edit2 = gtkpod_xml_get_widget (main_window_xml, "add_dirs_button");
214 tb_edit3 = gtkpod_xml_get_widget (main_window_xml, "add_PL_button");
215 tb_edit4 = gtkpod_xml_get_widget (main_window_xml, "new_PL_button");
216 #endif
217
218 pl = pm_get_selected_playlist ();
219
220 if (pl == NULL)
221 {
222 gtk_widget_set_sensitive (delete, FALSE);
223 gtk_widget_set_sensitive (edit1, FALSE);
224 gtk_widget_set_sensitive (edit2, FALSE);
225 gtk_widget_set_sensitive (edit3, FALSE);
226 gtk_widget_set_sensitive (edit4, FALSE);
227 gtk_widget_set_sensitive (edit5, FALSE);
228 gtk_widget_set_sensitive (espl, FALSE);
229 }
230 else
231 {
232 iTunesDB *itdb = pl->itdb;
233 g_return_if_fail (itdb);
234
235 gtk_widget_set_sensitive (delete, TRUE);
236 gtk_widget_set_sensitive (edit1, TRUE);
237 gtk_widget_set_sensitive (edit2, TRUE);
238 gtk_widget_set_sensitive (edit3, TRUE);
239 gtk_widget_set_sensitive (edit4, TRUE);
240 gtk_widget_set_sensitive (edit5, TRUE);
241
242 gtk_widget_hide (dtfpl);
243 gtk_widget_hide (dtfip);
244 gtk_widget_hide (dtfdb);
245 gtk_widget_hide (dtfhd);
246
247 gtk_widget_hide (defpl);
248 gtk_widget_hide (defip);
249 gtk_widget_hide (defdb);
250 gtk_widget_hide (defhd);
251
252 gtk_widget_hide (dpl);
253 gtk_widget_hide (dpltfip);
254 gtk_widget_hide (dpltfdb);
255 gtk_widget_hide (dpltfhd);
256
257 gtk_widget_hide (dsep1);
258 gtk_widget_hide (dsep2);
259
260 gtk_widget_set_sensitive (espl, FALSE);
261
262 if (pl->is_spl)
263 {
264 gtk_widget_set_sensitive (espl, TRUE);
265 }
266
267 if (itdb->usertype & GP_ITDB_TYPE_IPOD)
268 {
269 if (itdb_playlist_is_mpl (pl))
270 {
271 gtk_widget_show (dtfip);
272 gtk_widget_show (defip);
273 }
274 else
275 {
276 if (itdb_playlist_is_podcasts (pl))
277 {
278 gtk_widget_show (dtfip);
279 gtk_widget_show (defip);
280 }
281 else
282 {
283 gtk_widget_show (dpl);
284 gtk_widget_show (dpltfip);
285
286 gtk_widget_show (dsep1);
287
288 gtk_widget_show (defpl);
289 gtk_widget_show (defip);
290
291 gtk_widget_show (dsep2);
292
293 gtk_widget_show (dtfpl);
294 gtk_widget_show (dtfip);
295 }
296 }
297 }
298 if (itdb->usertype & GP_ITDB_TYPE_LOCAL)
299 {
300 if (itdb_playlist_is_mpl (pl))
301 {
302 gtk_widget_show (dtfdb);
303 gtk_widget_show (dtfhd);
304
305 gtk_widget_show (dsep2);
306
307 gtk_widget_show (defdb);
308 gtk_widget_show (defhd);
309 }
310 else
311 {
312 gtk_widget_show (dtfpl);
313 gtk_widget_show (dtfdb);
314 gtk_widget_show (dtfhd);
315
316 gtk_widget_show (dsep1);
317
318 gtk_widget_show (defpl);
319 gtk_widget_show (defdb);
320 gtk_widget_show (defhd);
321
322 gtk_widget_show (dsep2);
323
324 gtk_widget_show (dpl);
325 gtk_widget_show (dpltfdb);
326 gtk_widget_show (dpltfhd);
327 }
328 }
329 if (itdb->usertype & GP_ITDB_TYPE_PODCASTS)
330 {
331 if (itdb_playlist_is_mpl (pl))
332 {
333 gtk_widget_show (dtfdb);
334 gtk_widget_show (dtfhd);
335
336 gtk_widget_show (dsep2);
337
338 gtk_widget_show (defdb);
339 gtk_widget_show (defhd);
340 }
341 else
342 {
343 gtk_widget_show (dtfpl);
344 gtk_widget_show (dtfdb);
345 gtk_widget_show (dtfhd);
346
347 gtk_widget_show (dsep1);
348
349 gtk_widget_show (defpl);
350 gtk_widget_show (defdb);
351 gtk_widget_show (defhd);
352
353 gtk_widget_show (dsep2);
354
355 gtk_widget_show (dpl);
356 gtk_widget_show (dpltfdb);
357 gtk_widget_show (dpltfhd);
358 }
359 }
360 }
361 }
362
363 /* make the toolbar visible or hide it depending on the value set in
364 the prefs */
display_show_hide_toolbar(void)365 void display_show_hide_toolbar (void)
366 {
367 GtkWidget *tb = gtkpod_xml_get_widget (main_window_xml, "toolbar");
368 GtkWidget *mi = gtkpod_xml_get_widget (main_window_xml, "toolbar_menu");
369
370 if (prefs_get_int("display_toolbar"))
371 {
372 gtk_toolbar_set_style (GTK_TOOLBAR (tb), prefs_get_int("toolbar_style"));
373 gtk_widget_show (tb);
374 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), TRUE);
375 }
376 else
377 {
378 gtk_widget_hide (tb);
379 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), FALSE);
380 }
381 }
382
383
384 /* call gtkpod_tracks_statusbar_update() in order to redraw the
385 * statusbar, making GTK aware of the changed position for the resize
386 * grip. */
display_redraw_statusbar(gpointer data)387 gboolean display_redraw_statusbar (gpointer data)
388 {
389 gtkpod_tracks_statusbar_update ();
390 return FALSE;
391 }
392
393
394 /* This is called (among others) when the window size changes. This
395 hack needed to make GTK aware of the changed position for the
396 resize grip of the statusbar */
397 G_MODULE_EXPORT gboolean
on_gtkpod_configure_event(GtkContainer * container,gpointer user_data)398 on_gtkpod_configure_event (GtkContainer *container,
399 gpointer user_data)
400 {
401 g_idle_add (display_redraw_statusbar, NULL);
402 return FALSE;
403 }
404
405
406
407 /* make the search bar visible or hide it depending on the value set in
408 * the prefs
409 */
display_show_hide_searchbar(void)410 void display_show_hide_searchbar (void)
411 {
412 GtkWidget *upbutton = gtkpod_xml_get_widget (main_window_xml, "searchbar_up_button");
413 GtkWidget *searchbar = gtkpod_xml_get_widget (main_window_xml, "searchbar_hpanel");
414 GtkCheckMenuItem *mi = GTK_CHECK_MENU_ITEM (gtkpod_xml_get_widget (main_window_xml, "filterbar_menu"));
415 GtkStatusbar *sb = GTK_STATUSBAR (gtkpod_xml_get_widget (main_window_xml, "tracks_statusbar"));
416
417 g_return_if_fail (upbutton);
418 g_return_if_fail (searchbar);
419 g_return_if_fail (mi);
420 g_return_if_fail (sb);
421
422 if (prefs_get_int ("display_search_entry"))
423 {
424 gtk_widget_show_all (searchbar);
425 gtk_widget_hide (upbutton);
426 gtk_check_menu_item_set_active (mi, TRUE);
427 gtk_statusbar_set_has_resize_grip (sb, TRUE);
428 /* hack needed to make GTK aware of the changed
429 position for the resize grip */
430 g_idle_add (display_redraw_statusbar, NULL);
431 }
432 else
433 {
434 gtk_widget_hide_all (searchbar);
435 gtk_widget_show (upbutton);
436 gtk_widget_set_sensitive (upbutton, TRUE);
437 gtk_check_menu_item_set_active (mi, FALSE);
438 gtk_statusbar_set_has_resize_grip (sb, FALSE);
439 }
440 }
441
442 /* Adjust the menu item status according on the value set in the
443 prefs. */
display_set_info_window_menu(void)444 void display_set_info_window_menu (void)
445 {
446 GtkWidget *mi = gtkpod_xml_get_widget (main_window_xml, "info_window_menu");
447
448 if (prefs_get_int("info_window"))
449 {
450 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), TRUE);
451 }
452 else
453 {
454 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), FALSE);
455 }
456 }
457
458 /* make the tooltips visible or hide it depending on the value set in
459 * the prefs (tooltips_main) */
display_show_hide_tooltips(void)460 void display_show_hide_tooltips (void)
461 {
462 GtkCheckMenuItem *mi;
463 GtkToolbar *tb;
464 GtkTooltips *mt;
465
466 g_return_if_fail (main_window_xml);
467 g_return_if_fail (gtkpod_window);
468
469 /* ignore calls before window was set up properly (called by
470 prefs) */
471 if (!g_object_get_data (G_OBJECT (gtkpod_window),
472 "main_tooltips_initialised")) return;
473
474 mi = GTK_CHECK_MENU_ITEM (
475 gtkpod_xml_get_widget (main_window_xml, "tooltips_menu"));
476 tb = GTK_TOOLBAR (gtkpod_xml_get_widget (main_window_xml, "toolbar"));
477 mt = g_object_get_data (G_OBJECT (gtkpod_window), "main_tooltips");
478
479 g_return_if_fail (mi);
480 g_return_if_fail (tb);
481 g_return_if_fail (mt);
482
483
484 if (prefs_get_int("display_tooltips_main"))
485 {
486 gtk_tooltips_enable (mt);
487 gtk_check_menu_item_set_active (mi, TRUE);
488 gtk_toolbar_set_tooltips (tb, TRUE);
489 }
490 else
491 {
492 gtk_tooltips_disable (mt);
493 gtk_check_menu_item_set_active (mi, FALSE);
494 gtk_toolbar_set_tooltips (tb, FALSE);
495 }
496 /* Show/Hide tooltips of the special sorttabs */
497 st_show_hide_tooltips ();
498 /* Show/Hide tooltips of the prefs window */
499 sort_window_show_hide_tooltips ();
500 }
501
502
503 /* update the cfg structure (preferences) with the current sizes /
504 positions:
505 x,y size of main window
506 column widths of track model
507 position of GtkPaned elements */
display_update_default_sizes(void)508 void display_update_default_sizes (void)
509 {
510 gint x,y;
511
512 /* x,y size of main window */
513 if (gtkpod_window)
514 {
515 gtk_window_get_size (GTK_WINDOW (gtkpod_window), &x, &y);
516 prefs_set_int("size_gtkpod.x", x);
517 prefs_set_int("size_gtkpod.y", y);
518 }
519 tm_update_default_sizes ();
520 st_update_default_sizes ();
521 info_dialog_update_default_sizes ();
522 details_update_default_sizes ();
523 file_convert_update_default_sizes ();
524 }
525
526 /**
527 * on_drawing_area_exposed:
528 *
529 * Callback for the drawing area. When the drwaing area is covered,
530 * resized, changed etc.. This will be called the draw() function is then
531 * called from this and the cairo redrawing takes place.
532 *
533 * @draw_area: drawing area where al the cairo drawing takes place
534 * @event: gdk expose event
535 *
536 * Returns:
537 * boolean indicating whether other handlers should be run.
538 */
on_coverart_preview_dialog_exposed(GtkWidget * drawarea,GdkEventExpose * event,gpointer data)539 static gboolean on_coverart_preview_dialog_exposed (GtkWidget *drawarea, GdkEventExpose *event, gpointer data)
540 {
541 GdkPixbuf *image = data;
542
543 /* Draw the image using cairo */
544 cairo_t *cairo_context;
545
546 /* get a cairo_t */
547 cairo_context = gdk_cairo_create (drawarea->window);
548 /* set a clip region for the expose event */
549 cairo_rectangle (cairo_context,
550 event->area.x, event->area.y,
551 event->area.width, event->area.height);
552 cairo_clip (cairo_context);
553
554 gdk_cairo_set_source_pixbuf (
555 cairo_context,
556 image,
557 0,
558 0);
559 cairo_paint (cairo_context);
560
561 cairo_destroy (cairo_context);
562 return FALSE;
563 }
564
565 /**
566 * display_image_dialog
567 *
568 * @GdkPixbuf: image
569 *
570 * function to load a transient dialog displaying the provided image at either
571 * it maximum size or the size of the screen (whichever is smallest).
572 *
573 */
display_image_dialog(GdkPixbuf * image)574 void display_image_dialog (GdkPixbuf *image)
575 {
576 g_return_if_fail (image);
577
578 GladeXML *preview_xml;
579 GtkWidget *dialog;
580 GtkWidget *drawarea;
581 GtkWidget *res_label;
582 GdkPixbuf *scaled = NULL;
583 gchar *text;
584
585 preview_xml = gtkpod_xml_new (xml_file, "coverart_preview_dialog");
586 dialog = gtkpod_xml_get_widget (preview_xml, "coverart_preview_dialog");
587 drawarea = gtkpod_xml_get_widget (preview_xml, "coverart_preview_dialog_drawarea");
588 res_label = gtkpod_xml_get_widget (preview_xml, "coverart_preview_dialog_res_lbl");
589 g_return_if_fail (dialog);
590 g_return_if_fail (drawarea);
591 g_return_if_fail (res_label);
592
593 /* Set the dialog parent */
594 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (gtkpod_window));
595
596 gint pixheight = gdk_pixbuf_get_height (image);
597 gint pixwidth = gdk_pixbuf_get_width (image);
598
599 /* Set the resolution in the label */
600 text = g_markup_printf_escaped (_("<b>Image Dimensions: %d x %d</b>"), pixwidth, pixheight);
601 gtk_label_set_markup (GTK_LABEL (res_label), text);
602 g_free (text);
603
604 gint scrheight = gdk_screen_height() - 100;
605 gint scrwidth = gdk_screen_width() - 100;
606
607 gdouble ratio = (gdouble) pixwidth / (gdouble) pixheight;
608 if (pixwidth > scrwidth)
609 {
610 pixwidth = scrwidth;
611 pixheight = pixwidth / ratio;
612 }
613
614 if (pixheight > scrheight)
615 {
616 pixheight = scrheight;
617 pixwidth = pixheight * ratio;
618 }
619
620 scaled = gdk_pixbuf_scale_simple (
621 image,
622 pixwidth,
623 pixheight,
624 GDK_INTERP_BILINEAR);
625
626 /* Set the draw area's minimum size */
627 gtk_widget_set_size_request (drawarea, pixwidth, pixheight);
628 g_signal_connect (G_OBJECT (drawarea), "expose_event", G_CALLBACK (on_coverart_preview_dialog_exposed), scaled);
629
630 /* Display the dialog and block everything else until the
631 * dialog is closed.
632 */
633 gtk_widget_show_all (dialog);
634 gtk_dialog_run (GTK_DIALOG(dialog));
635
636 /* Destroy the dialog as no longer required */
637
638 g_object_unref (scaled);
639 gtk_widget_destroy (GTK_WIDGET (dialog));
640 }
641
642 /* Utility function: returns a copy of the tracks currently
643 selected. This means:
644
645 @inst == -1:
646 return list of tracks in selected playlist
647
648 @inst == 0 ... prefs_get_sort_tab_num () - 1:
649 return list of tracks in passed on to the next instance: selected
650 tab entry (normal sort tab) or tracks matching specified
651 conditions in a special sort tab
652
653 @inst >= prefs_get_sort_tab_num ():
654 return list of tracks selected in the track view
655
656 You must g_list_free() the list after use.
657 */
display_get_selection(guint32 inst)658 GList *display_get_selection (guint32 inst)
659 {
660 if (inst == -1)
661 {
662 Playlist *pl = pm_get_selected_playlist ();
663 if (pl) return g_list_copy (pl->members);
664 else return NULL;
665 }
666 if ((inst >= 0) && (inst < prefs_get_int("sort_tab_num")))
667 return g_list_copy (st_get_selected_members (inst));
668 if (inst >= prefs_get_int("sort_tab_num"))
669 return tm_get_selected_tracks ();
670 return NULL;
671 }
672
673
674 /* Get the members that are passed on to the next instance.
675 @inst: -1: playlist view
676 0...prefs_get_sort_tab_num()-1: sort tabs
677 >= prefs_get_sort_tab_num(): return NULL
678 You must not g_list_free the list or otherwise modify it */
display_get_selected_members(gint inst)679 GList *display_get_selected_members (gint inst)
680 {
681 GList *tracks=NULL;
682 if (inst == -1)
683 {
684 Playlist *pl = pm_get_selected_playlist ();
685 if (pl) tracks = pl->members;
686 }
687 else
688 {
689 tracks = st_get_selected_members (inst);
690 }
691 return tracks;
692 }
693
694
695 /* ------------------------------------------------------------
696
697 Functions for treeview autoscroll (during DND)
698
699 ------------------------------------------------------------ */
700
_remove_scroll_row_timeout(GtkWidget * widget)701 static void _remove_scroll_row_timeout (GtkWidget *widget)
702 {
703 g_return_if_fail (widget);
704
705 g_object_set_data (G_OBJECT (widget),
706 "scroll_row_timeout", NULL);
707 g_object_set_data (G_OBJECT (widget),
708 "scroll_row_times", NULL);
709 }
710
display_remove_autoscroll_row_timeout(GtkWidget * widget)711 void display_remove_autoscroll_row_timeout (GtkWidget *widget)
712 {
713 guint timeout;
714
715 g_return_if_fail (widget);
716
717 timeout = GPOINTER_TO_UINT(g_object_get_data (G_OBJECT (widget),
718 "scroll_row_timeout"));
719
720 if (timeout != 0)
721 {
722 g_source_remove (timeout);
723 _remove_scroll_row_timeout (widget);
724 }
725 }
726
display_autoscroll_row_timeout(gpointer data)727 static gint display_autoscroll_row_timeout (gpointer data)
728 {
729 GtkTreeView *treeview = data;
730 gint px, py;
731 GdkModifierType mask;
732 GdkRectangle vis_rect;
733 guint times;
734 gboolean resp = TRUE;
735 const gint SCROLL_EDGE_SIZE = 12;
736
737 g_return_val_if_fail (data, FALSE);
738
739 gdk_threads_enter ();
740
741 times = GPOINTER_TO_UINT(g_object_get_data (G_OBJECT (data), "scroll_row_times"));
742
743 gdk_window_get_pointer (gtk_tree_view_get_bin_window (treeview),
744 &px, &py, &mask);
745 gtk_tree_view_get_visible_rect (treeview, &vis_rect);
746 /* printf ("px/py, w/h, mask: %d/%d, %d/%d, %d\n", px, py, */
747 /* vis_rect.width, vis_rect.height, mask); */
748 if ((vis_rect.height > 2.2 * SCROLL_EDGE_SIZE) &&
749 ((py < SCROLL_EDGE_SIZE) ||
750 (py > vis_rect.height-SCROLL_EDGE_SIZE)))
751 {
752 GtkTreePath *path = NULL;
753
754 if (py < SCROLL_EDGE_SIZE/3)
755 ++times;
756 if (py > vis_rect.height-SCROLL_EDGE_SIZE/3)
757 ++times;
758
759 if (times > 0)
760 {
761 if (gtk_tree_view_get_path_at_pos (treeview, px, py,
762 &path, NULL, NULL, NULL))
763 {
764 if (py < SCROLL_EDGE_SIZE)
765 gtk_tree_path_prev (path);
766 if (py > vis_rect.height-SCROLL_EDGE_SIZE)
767 gtk_tree_path_next (path);
768 gtk_tree_view_scroll_to_cell (treeview, path, NULL,
769 FALSE, 0, 0);
770 }
771 times = 0;
772 }
773 else
774 {
775 ++times;
776 }
777 }
778 else
779 {
780 times = 0;
781 }
782 g_object_set_data (G_OBJECT (data), "scroll_row_times",
783 GUINT_TO_POINTER(times));
784 if (mask == 0)
785 {
786 _remove_scroll_row_timeout (data);
787 resp = FALSE;
788 }
789 gdk_threads_leave ();
790 return resp;
791 }
792
display_install_autoscroll_row_timeout(GtkWidget * widget)793 void display_install_autoscroll_row_timeout (GtkWidget *widget)
794 {
795 if (!g_object_get_data (G_OBJECT (widget), "scroll_row_timeout"))
796 { /* install timeout function for autoscroll */
797 guint timeout = g_timeout_add (75, display_autoscroll_row_timeout,
798 widget);
799 g_object_set_data (G_OBJECT (widget), "scroll_row_timeout",
800 GUINT_TO_POINTER(timeout));
801 }
802 }
803
804
805
806 /* ------------------------------------------------------------
807
808 Callbacks for toolbar buttons and menu.
809
810 ------------------------------------------------------------ */
811
812 /* The following functions are called directly without using callbacks
813 in this section:
814
815 void handle_export (void)
816 void create_add_files_dialog (void)
817 void create_add_playlists_dialog(void)
818 void dirbrowser_create (void)
819 void open_about_window (void)
820 */
821
822
823 G_MODULE_EXPORT void
on_edit_details_selected_playlist(GtkMenuItem * menuitem,gpointer user_data)824 on_edit_details_selected_playlist (GtkMenuItem *menuitem,
825 gpointer user_data)
826 {
827 Playlist *pl = pm_get_selected_playlist ();
828
829 if (pl)
830 {
831 details_edit (pl->members);
832 }
833 else
834 {
835 message_sb_no_playlist_selected ();
836 }
837 }
838
839 G_MODULE_EXPORT void
on_edit_details_selected_tab_entry(GtkMenuItem * menuitem,gpointer user_data)840 on_edit_details_selected_tab_entry (GtkMenuItem *menuitem,
841 gpointer user_data)
842 {
843 gint inst = get_sort_tab_number (
844 _("Edit selected entry of which sort tab?"));
845
846 if (inst != -1)
847 {
848 TabEntry *entry = st_get_selected_entry (inst);
849 if (entry == NULL)
850 { /* no entry selected */
851 gtkpod_statusbar_message (_("No entry selected."));
852 return;
853 }
854 details_edit (entry->members);
855 }
856 }
857
858 G_MODULE_EXPORT void
on_edit_details_selected_tracks(GtkMenuItem * menuitem,gpointer user_data)859 on_edit_details_selected_tracks (GtkMenuItem *menuitem,
860 gpointer user_data)
861 {
862 GList *tracks = tm_get_selected_tracks ();
863
864 if (tracks)
865 {
866 details_edit (tracks);
867 g_list_free (tracks);
868 }
869 else
870 {
871 message_sb_no_tracks_selected ();
872 }
873 }
874
875
876 /* callback for "add new playlist" button */
877 G_MODULE_EXPORT void
on_new_playlist_button(GtkButton * button,gpointer user_data)878 on_new_playlist_button (GtkButton *button,
879 gpointer user_data)
880 {
881 iTunesDB *itdb = gp_get_selected_itdb();
882
883 if (itdb)
884 {
885 add_new_pl_or_spl_user_name (itdb, NULL, -1);
886 }
887 else
888 {
889 message_sb_no_itdb_selected ();
890 }
891 }
892
893
894 /* callback for "add new playlist" menu */
895 G_MODULE_EXPORT void
on_new_playlist1_activate(GtkMenuItem * menuitem,gpointer user_data)896 on_new_playlist1_activate (GtkMenuItem *menuitem,
897 gpointer user_data)
898 {
899 iTunesDB *itdb = gp_get_selected_itdb();
900
901 if (itdb)
902 {
903 add_new_pl_or_spl_user_name (itdb, NULL, -1);
904 }
905 else
906 {
907 message_sb_no_itdb_selected ();
908 }
909 }
910
911 G_MODULE_EXPORT void
on_edit_repository_options_activate(GtkMenuItem * menuitem,gpointer user_data)912 on_edit_repository_options_activate (GtkMenuItem *menuitem,
913 gpointer user_data)
914 {
915 Playlist *pl = pm_get_selected_playlist ();
916
917 if (pl)
918 {
919 repository_edit (pl->itdb, pl);
920 }
921 else
922 {
923 repository_edit (NULL, NULL);
924 }
925 }
926
927 G_MODULE_EXPORT void
on_load_ipods_mi(GtkMenuItem * menuitem,gpointer user_data)928 on_load_ipods_mi (GtkMenuItem *menuitem,
929 gpointer user_data)
930 {
931 gp_load_ipods ();
932 }
933
934
935 G_MODULE_EXPORT void
on_load_ipods_clicked(GtkButton * button,gpointer user_data)936 on_load_ipods_clicked (GtkButton *button,
937 gpointer user_data)
938 {
939 gp_load_ipods ();
940 }
941
942
943 G_MODULE_EXPORT void
on_save_changes_mi(GtkMenuItem * menuitem,gpointer user_data)944 on_save_changes_mi (GtkMenuItem *menuitem,
945 gpointer user_data)
946 {
947 handle_export ();
948 }
949
950
951
952 G_MODULE_EXPORT void
on_save_changes_clicked(GtkButton * button,gpointer user_data)953 on_save_changes_clicked (GtkButton *button,
954 gpointer user_data)
955 {
956 handle_export ();
957 }
958
959
960 G_MODULE_EXPORT
on_edit_smart_playlist(GtkMenuItem * mi,gpointer data)961 void on_edit_smart_playlist (GtkMenuItem *mi,
962 gpointer data)
963 {
964 Playlist *pl = pm_get_selected_playlist ();
965
966 if (pl)
967 {
968 spl_edit (pl);
969 }
970 else
971 {
972 message_sb_no_playlist_selected ();
973 }
974 }
975
976
delete_selected_tracks(DeleteAction deleteaction)977 static void delete_selected_tracks (DeleteAction deleteaction)
978 {
979 GList *tracks = tm_get_selected_tracks ();
980
981 if (tracks)
982 {
983 delete_track_head (deleteaction);
984 g_list_free (tracks);
985 }
986 else
987 {
988 message_sb_no_tracks_selected ();
989 }
990 }
991
delete_selected_entry(DeleteAction deleteaction,gchar * text)992 static void delete_selected_entry (DeleteAction deleteaction,
993 gchar *text)
994 {
995 TabEntry *entry;
996 gint inst;
997
998 inst = get_sort_tab_number (text);
999 if (inst == -1) return;
1000
1001 entry = st_get_selected_entry (inst);
1002 if (!entry)
1003 {
1004 gtkpod_statusbar_message (_("No entry selected in Sort Tab %d"),
1005 inst+1);
1006 return;
1007 }
1008 delete_entry_head (inst, deleteaction);
1009 }
1010
delete_selected_playlist(DeleteAction deleteaction)1011 static void delete_selected_playlist (DeleteAction deleteaction)
1012 {
1013 Playlist *pl = pm_get_selected_playlist ();
1014
1015 if (pl)
1016 {
1017 delete_playlist_head (deleteaction);
1018 }
1019 else
1020 {
1021 message_sb_no_playlist_selected ();
1022 }
1023 }
1024
1025 G_MODULE_EXPORT void
on_delete_selected_tracks_from_database(GtkMenuItem * mi,gpointer data)1026 on_delete_selected_tracks_from_database (GtkMenuItem *mi,
1027 gpointer data)
1028 {
1029 delete_selected_tracks (DELETE_ACTION_DATABASE);
1030 }
1031
1032 G_MODULE_EXPORT void
on_delete_selected_playlist_including_tracks_from_harddisk(GtkMenuItem * mi,gpointer data)1033 on_delete_selected_playlist_including_tracks_from_harddisk (GtkMenuItem *mi,
1034 gpointer data)
1035 {
1036 delete_selected_playlist (DELETE_ACTION_LOCAL);
1037 }
1038
1039
1040 G_MODULE_EXPORT void
on_delete_selected_entry_from_database(GtkMenuItem * mi,gpointer data)1041 on_delete_selected_entry_from_database (GtkMenuItem *mi,
1042 gpointer data)
1043 {
1044 delete_selected_entry (DELETE_ACTION_DATABASE,
1045 _("Remove entry of which sort tab from database?"));
1046 }
1047
1048
1049 G_MODULE_EXPORT void
on_delete_selected_entry_from_ipod(GtkMenuItem * mi,gpointer data)1050 on_delete_selected_entry_from_ipod (GtkMenuItem *mi,
1051 gpointer data)
1052 {
1053 delete_selected_entry (DELETE_ACTION_IPOD,
1054 _("Remove tracks in selected entry of which filter tab from the iPod?"));
1055 }
1056
1057
1058 G_MODULE_EXPORT void
on_delete_selected_tracks_from_playlist(GtkMenuItem * mi,gpointer data)1059 on_delete_selected_tracks_from_playlist (GtkMenuItem *mi,
1060 gpointer data)
1061 {
1062 delete_selected_tracks (DELETE_ACTION_PLAYLIST);
1063 }
1064
1065
1066 G_MODULE_EXPORT void
on_delete_selected_tracks_from_harddisk(GtkMenuItem * mi,gpointer data)1067 on_delete_selected_tracks_from_harddisk (GtkMenuItem *mi,
1068 gpointer data)
1069 {
1070 delete_selected_tracks (DELETE_ACTION_LOCAL);
1071 }
1072
1073
1074 G_MODULE_EXPORT void
on_delete_selected_entry_from_harddisk(GtkMenuItem * mi,gpointer data)1075 on_delete_selected_entry_from_harddisk (GtkMenuItem *mi,
1076 gpointer data)
1077 {
1078 delete_selected_entry (DELETE_ACTION_LOCAL,
1079 _("Remove tracks in selected entry of which filter tab from the harddisk?"));
1080 }
1081
1082
1083 G_MODULE_EXPORT void
on_delete_selected_tracks_from_ipod(GtkMenuItem * mi,gpointer data)1084 on_delete_selected_tracks_from_ipod (GtkMenuItem *mi,
1085 gpointer data)
1086 {
1087 delete_selected_tracks (DELETE_ACTION_IPOD);
1088 }
1089
1090
1091 G_MODULE_EXPORT void
on_delete_selected_playlist(GtkMenuItem * mi,gpointer data)1092 on_delete_selected_playlist (GtkMenuItem *mi,
1093 gpointer data)
1094 {
1095 delete_selected_playlist (DELETE_ACTION_PLAYLIST);
1096 }
1097
1098
1099 G_MODULE_EXPORT void
on_delete_selected_playlist_including_tracks_from_database(GtkMenuItem * mi,gpointer data)1100 on_delete_selected_playlist_including_tracks_from_database (GtkMenuItem *mi,
1101 gpointer data)
1102 {
1103 delete_selected_playlist (DELETE_ACTION_DATABASE);
1104 }
1105
1106
1107 G_MODULE_EXPORT void
on_delete_selected_entry_from_playlist(GtkMenuItem * mi,gpointer data)1108 on_delete_selected_entry_from_playlist (GtkMenuItem *mi,
1109 gpointer data)
1110 {
1111 delete_selected_entry (DELETE_ACTION_PLAYLIST,
1112 _("Remove tracks in selected entry of which filter tab from playlist?"));
1113 }
1114
1115
1116 G_MODULE_EXPORT void
on_delete_selected_playlist_including_tracks_from_ipod(GtkMenuItem * mi,gpointer data)1117 on_delete_selected_playlist_including_tracks_from_ipod (GtkMenuItem *mi,
1118 gpointer data)
1119 {
1120 delete_selected_playlist (DELETE_ACTION_IPOD);
1121 }
1122
1123
1124 G_MODULE_EXPORT void
on_ipod_directories_menu(GtkMenuItem * menuitem,gpointer user_data)1125 on_ipod_directories_menu (GtkMenuItem *menuitem,
1126 gpointer user_data)
1127 {
1128 iTunesDB *itdb = gp_get_ipod_itdb ();
1129 if (itdb)
1130 {
1131 ExtraiTunesDBData *eitdb = itdb->userdata;
1132
1133 g_return_if_fail (eitdb);
1134
1135
1136 if (!eitdb->itdb_imported)
1137 {
1138 gchar *mountpoint = get_itdb_prefs_string (itdb, KEY_MOUNTPOINT);
1139 gchar *str = g_strdup_printf (_("iPod at '%s' is not loaded.\nPlease load it first."), mountpoint);
1140 GtkWidget *dialog = gtk_message_dialog_new (
1141 GTK_WINDOW (gtkpod_window),
1142 GTK_DIALOG_DESTROY_WITH_PARENT,
1143 GTK_MESSAGE_WARNING,
1144 GTK_BUTTONS_OK,
1145 "%s", str);
1146 gtk_dialog_run (GTK_DIALOG (dialog));
1147 gtk_widget_destroy (dialog);
1148 g_free (str);
1149 g_free (mountpoint);
1150 }
1151 else
1152 {
1153 gp_ipod_init (itdb);
1154 }
1155 }
1156 else
1157 {
1158 message_sb_no_ipod_itdb_selected ();
1159 }
1160 }
1161
1162 G_MODULE_EXPORT void
on_check_ipod_files_activate(GtkMenuItem * menuitem,gpointer user_data)1163 on_check_ipod_files_activate (GtkMenuItem *menuitem,
1164 gpointer user_data)
1165 {
1166 iTunesDB *itdb = gp_get_ipod_itdb ();
1167 if (itdb)
1168 {
1169 ExtraiTunesDBData *eitdb = itdb->userdata;
1170
1171 g_return_if_fail (eitdb);
1172
1173
1174 if (!eitdb->itdb_imported)
1175 {
1176 gchar *mountpoint = get_itdb_prefs_string (itdb, KEY_MOUNTPOINT);
1177 gchar *str = g_strdup_printf (_("iPod at '%s' is not loaded.\nPlease load it first."), mountpoint);
1178 GtkWidget *dialog = gtk_message_dialog_new (
1179 GTK_WINDOW (gtkpod_window),
1180 GTK_DIALOG_DESTROY_WITH_PARENT,
1181 GTK_MESSAGE_WARNING,
1182 GTK_BUTTONS_OK,
1183 "%s", str);
1184 gtk_dialog_run (GTK_DIALOG (dialog));
1185 gtk_widget_destroy (dialog);
1186 g_free (str);
1187 g_free (mountpoint);
1188 }
1189 else
1190 {
1191 check_db (itdb);
1192 }
1193 }
1194 else
1195 {
1196 message_sb_no_ipod_itdb_selected ();
1197 }
1198 }
1199
1200
1201 G_MODULE_EXPORT void
on_update_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1202 on_update_playlist_activate (GtkMenuItem *menuitem,
1203 gpointer user_data)
1204 {
1205 gp_do_selected_playlist (update_tracks);
1206 }
1207
1208 /* update tracks in tab entry */
1209 G_MODULE_EXPORT void
on_update_tab_entry_activate(GtkMenuItem * menuitem,gpointer user_data)1210 on_update_tab_entry_activate (GtkMenuItem *menuitem,
1211 gpointer user_data)
1212 {
1213 gint inst = get_sort_tab_number (
1214 _("Update selected entry of which sort tab?"));
1215
1216 if (inst != -1) gp_do_selected_entry (update_tracks, inst);
1217 }
1218
1219 G_MODULE_EXPORT void
on_update_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1220 on_update_tracks_activate (GtkMenuItem *menuitem,
1221 gpointer user_data)
1222 {
1223 gp_do_selected_tracks (update_tracks);
1224 }
1225
1226 G_MODULE_EXPORT void
on_mserv_from_file_playlist_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1227 on_mserv_from_file_playlist_menu_activate
1228 (GtkMenuItem *menuitem,
1229 gpointer user_data)
1230 {
1231 gp_do_selected_playlist (mserv_from_file_tracks);
1232 }
1233
1234 G_MODULE_EXPORT void
on_mserv_from_file_tracks_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1235 on_mserv_from_file_tracks_menu_activate
1236 (GtkMenuItem *menuitem,
1237 gpointer user_data)
1238 {
1239 gp_do_selected_tracks (mserv_from_file_tracks);
1240 }
1241
1242
1243 G_MODULE_EXPORT void
on_mserv_from_file_entry_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1244 on_mserv_from_file_entry_menu_activate (GtkMenuItem *menuitem,
1245 gpointer user_data)
1246 {
1247 gint inst = get_sort_tab_number (
1248 _("Update selected entry of which sort tab?"));
1249
1250 if (inst != -1) gp_do_selected_entry (mserv_from_file_tracks, inst);
1251 }
1252
1253
1254 G_MODULE_EXPORT void
on_sync_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1255 on_sync_playlist_activate (GtkMenuItem *menuitem,
1256 gpointer user_data)
1257 {
1258 Playlist *pl;
1259
1260 pl = pm_get_selected_playlist();
1261 if (pl)
1262 {
1263 sync_playlist (pl, NULL,
1264 KEY_SYNC_CONFIRM_DIRS, 0,
1265 KEY_SYNC_DELETE_TRACKS, 0,
1266 KEY_SYNC_CONFIRM_DELETE, 0,
1267 KEY_SYNC_SHOW_SUMMARY, 0);
1268 }
1269 else
1270 {
1271 message_sb_no_playlist_selected ();
1272 }
1273 }
1274
1275 G_MODULE_EXPORT void
on_save_track_order1_activate(GtkMenuItem * menuitem,gpointer user_data)1276 on_save_track_order1_activate (GtkMenuItem *menuitem,
1277 gpointer user_data)
1278 {
1279 tm_rows_reordered ();
1280 }
1281
1282
1283 G_MODULE_EXPORT void
on_toolbar_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1284 on_toolbar_menu_activate (GtkMenuItem *menuitem,
1285 gpointer user_data)
1286 {
1287 prefs_set_int("display_toolbar",
1288 gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)));
1289 display_show_hide_toolbar();
1290 }
1291
1292
1293 G_MODULE_EXPORT void
on_filterbar_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1294 on_filterbar_menu_activate (GtkMenuItem *menuitem,
1295 gpointer user_data)
1296 {
1297 prefs_set_int("display_search_entry",
1298 gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)));
1299 display_show_hide_searchbar ();
1300 }
1301
1302
1303 G_MODULE_EXPORT void
on_more_sort_tabs_activate(GtkMenuItem * menuitem,gpointer user_data)1304 on_more_sort_tabs_activate (GtkMenuItem *menuitem,
1305 gpointer user_data)
1306 {
1307 prefs_set_int("sort_tab_num", prefs_get_int("sort_tab_num")+1);
1308 st_show_visible();
1309 }
1310
1311
1312 G_MODULE_EXPORT void
on_less_sort_tabs_activate(GtkMenuItem * menuitem,gpointer user_data)1313 on_less_sort_tabs_activate (GtkMenuItem *menuitem,
1314 gpointer user_data)
1315 {
1316 prefs_set_int("sort_tab_num", prefs_get_int("sort_tab_num")-1);
1317 st_show_visible();
1318 }
1319
1320 G_MODULE_EXPORT void
on_export_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1321 on_export_playlist_activate (GtkMenuItem *menuitem,
1322 gpointer user_data)
1323 {
1324 Playlist *pl = pm_get_selected_playlist ();
1325
1326 if (!pl)
1327 {
1328 export_files_init (pl->members, NULL, FALSE, NULL);
1329 }
1330 else
1331 {
1332 message_sb_no_playlist_selected ();
1333 }
1334 }
1335
1336
1337 G_MODULE_EXPORT void
on_export_tab_entry_activate(GtkMenuItem * menuitem,gpointer user_data)1338 on_export_tab_entry_activate (GtkMenuItem *menuitem,
1339 gpointer user_data)
1340 {
1341 TabEntry *entry;
1342 gint inst;
1343
1344 inst = get_sort_tab_number (_("Export selected entry of which sort tab?"));
1345 if (inst == -1) return;
1346
1347 entry = st_get_selected_entry (inst);
1348 if (!entry)
1349 {
1350 gtkpod_statusbar_message (_("No entry selected in Sort Tab %d"),
1351 inst+1);
1352 return;
1353 }
1354 export_files_init (entry->members, NULL, FALSE, NULL);
1355 }
1356
1357
1358 G_MODULE_EXPORT void
on_export_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1359 on_export_tracks_activate (GtkMenuItem *menuitem,
1360 gpointer user_data)
1361 {
1362 GList *tracks = tm_get_selected_tracks ();
1363
1364 if (tracks)
1365 {
1366 export_files_init (tracks, NULL, FALSE, NULL);
1367 g_list_free (tracks);
1368 }
1369 else
1370 {
1371 message_sb_no_tracks_selected ();
1372 }
1373 }
1374
1375
1376 G_MODULE_EXPORT void
on_playlist_file_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1377 on_playlist_file_playlist_activate (GtkMenuItem *menuitem,
1378 gpointer user_data)
1379 {
1380 Playlist *pl = pm_get_selected_playlist ();
1381
1382 if (pl)
1383 {
1384 export_playlist_file_init (pl->members);
1385 }
1386 else
1387 {
1388 message_sb_no_playlist_selected ();
1389 }
1390 }
1391
1392
1393 G_MODULE_EXPORT void
on_playlist_file_tab_entry_activate(GtkMenuItem * menuitem,gpointer user_data)1394 on_playlist_file_tab_entry_activate (GtkMenuItem *menuitem,
1395 gpointer user_data)
1396 {
1397 TabEntry *entry;
1398 gint inst;
1399
1400 inst = get_sort_tab_number (_("Create playlist file from selected entry of which sort tab?"));
1401 if (inst == -1) return;
1402
1403 entry = st_get_selected_entry (inst);
1404 if (!entry)
1405 {
1406 gtkpod_statusbar_message (_("No entry selected in Sort Tab %d"),
1407 inst+1);
1408 return;
1409 }
1410 export_playlist_file_init (entry->members);
1411 }
1412
1413
1414 G_MODULE_EXPORT void
on_playlist_file_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1415 on_playlist_file_tracks_activate (GtkMenuItem *menuitem,
1416 gpointer user_data)
1417 {
1418 GList *tracks = tm_get_selected_tracks ();
1419
1420 if (tracks)
1421 {
1422 export_playlist_file_init(tracks);
1423 g_list_free (tracks);
1424 }
1425 else
1426 {
1427 message_sb_no_tracks_selected ();
1428 }
1429 }
1430
1431 G_MODULE_EXPORT void
on_play_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1432 on_play_playlist_activate (GtkMenuItem *menuitem,
1433 gpointer user_data)
1434 {
1435 Playlist *pl = pm_get_selected_playlist ();
1436 if (pl)
1437 {
1438 tools_play_tracks (pl->members);
1439 }
1440 else
1441 {
1442 message_sb_no_playlist_selected ();
1443 }
1444 }
1445
1446
1447 G_MODULE_EXPORT void
on_play_tab_entry_activate(GtkMenuItem * menuitem,gpointer user_data)1448 on_play_tab_entry_activate (GtkMenuItem *menuitem,
1449 gpointer user_data)
1450 {
1451 TabEntry *entry;
1452 gint inst;
1453
1454 inst = get_sort_tab_number (_("Play tracks in selected entry of which sort tab?"));
1455 if (inst == -1) return;
1456
1457 entry = st_get_selected_entry (inst);
1458 if (!entry)
1459 {
1460 gtkpod_statusbar_message (_("No entry selected in Sort Tab %d"),
1461 inst+1);
1462 return;
1463 }
1464 tools_play_tracks (entry->members);
1465 }
1466
1467
1468 G_MODULE_EXPORT void
on_play_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1469 on_play_tracks_activate (GtkMenuItem *menuitem,
1470 gpointer user_data)
1471 {
1472 GList *tracks = tm_get_selected_tracks ();
1473 if (tracks)
1474 {
1475 tools_play_tracks (tracks);
1476 g_list_free (tracks);
1477 tracks = NULL;
1478 }
1479 else
1480 {
1481 message_sb_no_tracks_selected ();
1482 }
1483 }
1484
1485
1486 G_MODULE_EXPORT void
on_enqueue_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1487 on_enqueue_playlist_activate (GtkMenuItem *menuitem,
1488 gpointer user_data)
1489 {
1490 Playlist *pl = pm_get_selected_playlist ();
1491 if (pl)
1492 {
1493 tools_enqueue_tracks (pl->members);
1494 }
1495 else
1496 {
1497 message_sb_no_playlist_selected ();
1498 }
1499 }
1500
1501
1502 G_MODULE_EXPORT void
on_enqueue_tab_entry_activate(GtkMenuItem * menuitem,gpointer user_data)1503 on_enqueue_tab_entry_activate (GtkMenuItem *menuitem,
1504 gpointer user_data)
1505 {
1506 TabEntry *entry;
1507 gint inst;
1508
1509 inst = get_sort_tab_number (_("Enqueue tracks in selected entry of which sort tab?"));
1510 if (inst == -1) return;
1511
1512 entry = st_get_selected_entry (inst);
1513 if (!entry)
1514 {
1515 gtkpod_statusbar_message (_("No entry selected in Sort Tab %d"),
1516 inst+1);
1517 return;
1518 }
1519 tools_enqueue_tracks (entry->members);
1520 }
1521
1522
1523 G_MODULE_EXPORT void
on_enqueue_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1524 on_enqueue_tracks_activate (GtkMenuItem *menuitem,
1525 gpointer user_data)
1526 {
1527 GList *tracks = tm_get_selected_tracks ();
1528 if (tracks)
1529 {
1530 tools_enqueue_tracks (tracks);
1531 g_list_free (tracks);
1532 tracks = NULL;
1533 }
1534 else
1535 {
1536 message_sb_no_tracks_selected ();
1537 }
1538 }
1539
1540
1541 G_MODULE_EXPORT void
on_arrange_sort_tabs_activate(GtkMenuItem * menuitem,gpointer user_data)1542 on_arrange_sort_tabs_activate (GtkMenuItem *menuitem,
1543 gpointer user_data)
1544 {
1545 st_arrange_visible_sort_tabs ();
1546 }
1547
1548 G_MODULE_EXPORT void
on_tooltips_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1549 on_tooltips_menu_activate (GtkMenuItem *menuitem,
1550 gpointer user_data)
1551 {
1552 prefs_set_int("display_tooltips_main",
1553 gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)));
1554 display_show_hide_tooltips();
1555
1556 }
1557
1558 G_MODULE_EXPORT void
on_pl_containing_displayed_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1559 on_pl_containing_displayed_tracks_activate (GtkMenuItem *menuitem,
1560 gpointer user_data)
1561 {
1562 generate_displayed_playlist ();
1563 }
1564
1565 G_MODULE_EXPORT void
on_pl_containing_selected_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1566 on_pl_containing_selected_tracks_activate (GtkMenuItem *menuitem,
1567 gpointer user_data)
1568 {
1569 generate_selected_playlist ();
1570 }
1571
1572 G_MODULE_EXPORT void
on_pl_for_each_artist_activate(GtkMenuItem * menuitem,gpointer user_data)1573 on_pl_for_each_artist_activate (GtkMenuItem *menuitem,
1574 gpointer user_data)
1575 {
1576 iTunesDB *itdb = gp_get_selected_itdb();
1577
1578 if (itdb)
1579 {
1580 generate_category_playlists (itdb, T_ARTIST);
1581 }
1582 else
1583 {
1584 message_sb_no_itdb_selected ();
1585 }
1586 }
1587
1588 G_MODULE_EXPORT void
on_pl_for_each_album_activate(GtkMenuItem * menuitem,gpointer user_data)1589 on_pl_for_each_album_activate (GtkMenuItem *menuitem,
1590 gpointer user_data)
1591 {
1592 iTunesDB *itdb = gp_get_selected_itdb();
1593
1594 if (itdb)
1595 {
1596 generate_category_playlists (itdb, T_ALBUM);
1597 }
1598 else
1599 {
1600 message_sb_no_itdb_selected ();
1601 }
1602 }
1603
1604 G_MODULE_EXPORT void
on_pl_for_each_genre_activate(GtkMenuItem * menuitem,gpointer user_data)1605 on_pl_for_each_genre_activate (GtkMenuItem *menuitem,
1606 gpointer user_data)
1607 {
1608 iTunesDB *itdb = gp_get_selected_itdb();
1609
1610 if (itdb)
1611 {
1612 generate_category_playlists (itdb, T_GENRE);
1613 }
1614 else
1615 {
1616 message_sb_no_itdb_selected ();
1617 }
1618 }
1619
1620 G_MODULE_EXPORT void
on_pl_for_each_composer_activate(GtkMenuItem * menuitem,gpointer user_data)1621 on_pl_for_each_composer_activate (GtkMenuItem *menuitem,
1622 gpointer user_data)
1623 {
1624 iTunesDB *itdb = gp_get_selected_itdb();
1625
1626 if (itdb)
1627 {
1628 generate_category_playlists (itdb, T_COMPOSER);
1629 }
1630 else
1631 {
1632 message_sb_no_itdb_selected ();
1633 }
1634 }
1635
1636
1637 G_MODULE_EXPORT void
on_pl_for_each_year_activate(GtkMenuItem * menuitem,gpointer user_data)1638 on_pl_for_each_year_activate (GtkMenuItem *menuitem,
1639 gpointer user_data)
1640 {
1641 iTunesDB *itdb = gp_get_selected_itdb();
1642
1643 if (itdb)
1644 {
1645 generate_category_playlists (itdb, T_YEAR);
1646 }
1647 else
1648 {
1649 message_sb_no_itdb_selected ();
1650 }
1651 }
1652
1653
1654 G_MODULE_EXPORT void
on_most_listened_tracks1_activate(GtkMenuItem * menuitem,gpointer user_data)1655 on_most_listened_tracks1_activate (GtkMenuItem *menuitem,
1656 gpointer user_data)
1657 {
1658 iTunesDB *itdb = gp_get_selected_itdb();
1659
1660 if (itdb)
1661 {
1662 most_listened_pl (itdb);
1663 }
1664 else
1665 {
1666 message_sb_no_itdb_selected ();
1667 }
1668 }
1669
1670
1671 G_MODULE_EXPORT void
on_all_tracks_never_listened_to1_activate(GtkMenuItem * menuitem,gpointer user_data)1672 on_all_tracks_never_listened_to1_activate
1673 (GtkMenuItem *menuitem,
1674 gpointer user_data)
1675 {
1676 iTunesDB *itdb = gp_get_selected_itdb();
1677
1678 if (itdb)
1679 {
1680 never_listened_pl (itdb);
1681 }
1682 else
1683 {
1684 message_sb_no_itdb_selected ();
1685 }
1686 }
1687
1688 G_MODULE_EXPORT void
on_most_rated_tracks_playlist_s1_activate(GtkMenuItem * menuitem,gpointer user_data)1689 on_most_rated_tracks_playlist_s1_activate
1690 (GtkMenuItem *menuitem,
1691 gpointer user_data)
1692 {
1693 iTunesDB *itdb = gp_get_selected_itdb();
1694
1695 if (itdb)
1696 {
1697 most_rated_pl (itdb);
1698 }
1699 else
1700 {
1701 message_sb_no_itdb_selected ();
1702 }
1703 }
1704
1705
1706 G_MODULE_EXPORT void
on_most_recent_played_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1707 on_most_recent_played_tracks_activate (GtkMenuItem *menuitem,
1708 gpointer user_data)
1709 {
1710 iTunesDB *itdb = gp_get_selected_itdb();
1711
1712 if (itdb)
1713 {
1714 last_listened_pl (itdb);
1715 }
1716 else
1717 {
1718 message_sb_no_itdb_selected ();
1719 }
1720 }
1721
1722 G_MODULE_EXPORT void
on_played_since_last_time1_activate(GtkMenuItem * menuitem,gpointer user_data)1723 on_played_since_last_time1_activate (GtkMenuItem *menuitem,
1724 gpointer user_data)
1725 {
1726 iTunesDB *itdb = gp_get_selected_itdb();
1727
1728 if (itdb)
1729 {
1730 since_last_pl (itdb);
1731 }
1732 else
1733 {
1734 message_sb_no_itdb_selected ();
1735 }
1736 }
1737
1738 G_MODULE_EXPORT void
on_sorting_activate(GtkMenuItem * menuitem,gpointer user_data)1739 on_sorting_activate (GtkMenuItem *menuitem,
1740 gpointer user_data)
1741 {
1742 sort_window_create ();
1743 }
1744
1745 G_MODULE_EXPORT void
on_normalize_selected_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1746 on_normalize_selected_playlist_activate
1747 (GtkMenuItem *menuitem,
1748 gpointer user_data)
1749 {
1750 Playlist *pl = pm_get_selected_playlist ();
1751 if (pl)
1752 nm_tracks_list (pl->members);
1753 else
1754 message_sb_no_playlist_selected ();
1755 }
1756
1757
1758 G_MODULE_EXPORT void
on_normalize_selected_tab_entry_activate(GtkMenuItem * menuitem,gpointer user_data)1759 on_normalize_selected_tab_entry_activate
1760 (GtkMenuItem *menuitem,
1761 gpointer user_data)
1762 {
1763 TabEntry *entry;
1764 gint inst;
1765
1766 inst = get_sort_tab_number (_("Normalize tracks in selected entry of which sort tab?"));
1767 if (inst == -1) return;
1768
1769 entry = st_get_selected_entry (inst);
1770 if (entry)
1771 {
1772 nm_tracks_list (entry->members);
1773 }
1774 else
1775 {
1776 gtkpod_statusbar_message (_("No entry selected in Sort Tab %d"),
1777 inst+1);
1778 return;
1779 }
1780 }
1781
1782
1783 G_MODULE_EXPORT void
on_normalize_selected_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1784 on_normalize_selected_tracks_activate (GtkMenuItem *menuitem,
1785 gpointer user_data)
1786 {
1787 GList *tracks = tm_get_selected_tracks ();
1788 nm_tracks_list (tracks);
1789 g_list_free (tracks);
1790 }
1791
1792
1793 G_MODULE_EXPORT void
on_normalize_displayed_tracks_activate(GtkMenuItem * menuitem,gpointer user_data)1794 on_normalize_displayed_tracks_activate (GtkMenuItem *menuitem,
1795 gpointer user_data)
1796 {
1797 GList *tracks = tm_get_all_tracks ();
1798 nm_tracks_list (tracks);
1799 g_list_free (tracks);
1800 }
1801
1802
1803 G_MODULE_EXPORT void
on_normalize_all_tracks(GtkMenuItem * menuitem,gpointer user_data)1804 on_normalize_all_tracks (GtkMenuItem *menuitem,
1805 gpointer user_data)
1806 {
1807 iTunesDB *itdb = gp_get_selected_itdb ();
1808
1809 if (itdb)
1810 {
1811 Playlist *mpl = itdb_playlist_mpl (itdb);
1812 g_return_if_fail (mpl);
1813 nm_tracks_list (mpl->members);
1814 }
1815 else
1816 {
1817 message_sb_no_itdb_selected ();
1818 }
1819 }
1820
1821
1822 G_MODULE_EXPORT void
on_normalize_newly_added_tracks(GtkMenuItem * menuitem,gpointer user_data)1823 on_normalize_newly_added_tracks (GtkMenuItem *menuitem,
1824 gpointer user_data)
1825 {
1826 iTunesDB *itdb = gp_get_selected_itdb();
1827
1828 if (itdb)
1829 {
1830 nm_new_tracks (itdb);
1831 }
1832 else
1833 {
1834 message_sb_no_itdb_selected ();
1835 }
1836 }
1837
1838
1839 G_MODULE_EXPORT void
on_info_window1_activate(GtkMenuItem * menuitem,gpointer user_data)1840 on_info_window1_activate (GtkMenuItem *menuitem,
1841 gpointer user_data)
1842 {
1843 if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)))
1844 open_info_dialog ();
1845 else
1846 close_info_dialog ();
1847 }
1848
1849 G_MODULE_EXPORT void
on_conversion_log1_activate(GtkMenuItem * menuitem,gpointer user_data)1850 on_conversion_log1_activate (GtkMenuItem *menuitem,
1851 gpointer user_data)
1852 {
1853 gboolean state;
1854
1855 state = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
1856
1857 if (state != prefs_get_int (FILE_CONVERT_DISPLAY_LOG))
1858 {
1859 prefs_set_int (FILE_CONVERT_DISPLAY_LOG, state);
1860 file_convert_prefs_changed ();
1861 }
1862 }
1863
1864
1865 G_MODULE_EXPORT void
on_sync_all_activate(GtkMenuItem * menuitem,gpointer user_data)1866 on_sync_all_activate (GtkMenuItem *menuitem,
1867 gpointer user_data)
1868 {
1869 struct itdbs_head *itdbs_head = gp_get_itdbs_head (gtkpod_window);
1870 GList *gl;
1871
1872 g_return_if_fail (itdbs_head);
1873
1874 for (gl=itdbs_head->itdbs; gl; gl=gl->next)
1875 {
1876 iTunesDB *itdb = gl->data;
1877 g_return_if_fail (gl);
1878 if (itdb->usertype & GP_ITDB_TYPE_IPOD)
1879 {
1880 tools_sync_all (itdb);
1881 }
1882 }
1883 }
1884
1885
1886 G_MODULE_EXPORT void
on_sync_calendar_activate(GtkMenuItem * menuitem,gpointer user_data)1887 on_sync_calendar_activate (GtkMenuItem *menuitem,
1888 gpointer user_data)
1889 {
1890 iTunesDB *itdb = gp_get_ipod_itdb ();
1891 if (itdb)
1892 {
1893 tools_sync_calendar (itdb);
1894 }
1895 else
1896 {
1897 message_sb_no_ipod_itdb_selected ();
1898 }
1899 }
1900
1901
1902 G_MODULE_EXPORT void
on_sync_contacts_activate(GtkMenuItem * menuitem,gpointer user_data)1903 on_sync_contacts_activate (GtkMenuItem *menuitem,
1904 gpointer user_data)
1905 {
1906 iTunesDB *itdb = gp_get_ipod_itdb ();
1907 if (itdb)
1908 {
1909 tools_sync_contacts (itdb);
1910 }
1911 else
1912 {
1913 message_sb_no_ipod_itdb_selected ();
1914 }
1915 }
1916
1917 G_MODULE_EXPORT void
on_sync_notes_activate(GtkMenuItem * menuitem,gpointer user_data)1918 on_sync_notes_activate (GtkMenuItem *menuitem,
1919 gpointer user_data)
1920 {
1921 iTunesDB *itdb = gp_get_ipod_itdb ();
1922 if (itdb)
1923 {
1924 tools_sync_notes (itdb);
1925 }
1926 else
1927 {
1928 message_sb_no_ipod_itdb_selected ();
1929 }
1930 }
1931 G_MODULE_EXPORT void
on_all_tracks_not_listed_in_any_playlist1_activate(GtkMenuItem * menuitem,gpointer user_data)1932 on_all_tracks_not_listed_in_any_playlist1_activate
1933 (GtkMenuItem *menuitem,
1934 gpointer user_data)
1935 {
1936 iTunesDB *itdb = gp_get_selected_itdb();
1937
1938 if (itdb)
1939 {
1940 generate_not_listed_playlist (itdb);
1941 }
1942 else
1943 {
1944 message_sb_no_itdb_selected ();
1945 }
1946 }
1947
1948 G_MODULE_EXPORT void
on_random_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1949 on_random_playlist_activate (GtkMenuItem *menuitem,
1950 gpointer user_data)
1951 {
1952 iTunesDB *itdb = gp_get_selected_itdb();
1953
1954 if (itdb)
1955 {
1956 generate_random_playlist(itdb);
1957 }
1958 else
1959 {
1960 message_sb_no_itdb_selected ();
1961 }
1962 }
1963
1964 G_MODULE_EXPORT void
on_randomize_current_playlist_activate(GtkMenuItem * menuitem,gpointer user_data)1965 on_randomize_current_playlist_activate (GtkMenuItem *menuitem,
1966 gpointer user_data)
1967 {
1968 randomize_current_playlist();
1969 }
1970 G_MODULE_EXPORT void
on_pl_for_each_rating_activate(GtkMenuItem * menuitem,gpointer user_data)1971 on_pl_for_each_rating_activate (GtkMenuItem *menuitem,
1972 gpointer user_data)
1973 {
1974 iTunesDB *itdb = gp_get_selected_itdb();
1975
1976 if (itdb)
1977 {
1978 each_rating_pl (itdb);
1979 }
1980 else
1981 {
1982 message_sb_no_itdb_selected ();
1983 }
1984 }
1985