playlist.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

                show_active_position_in_playlist_toggle();
                return TRUE;
                break;
        case GDK_w:
        case GDK_W:
                gtk_tree_view_collapse_all(GTK_TREE_VIEW(play_list));  
                show_active_position_in_playlist();
                return TRUE;
                break;
        case GDK_Delete:
	case GDK_KP_Delete:
                if(kevent->state & GDK_SHIFT_MASK) {  /* SHIFT + Delete */
                        gtk_tree_store_clear(play_store);
			playlist_content_changed();
                } else {
			rem__sel_cb(NULL);
                }
                return TRUE;
		break;
#ifdef HAVE_IFP
	case GDK_t:
	case GDK_T:
                aifp_transfer_files();
		return TRUE;
		break;
#endif /* HAVE_IFP */

        case GDK_grave:
                expand_collapse_album_node();
                return TRUE;
		break;

	}

	return FALSE;
}


gint
doubleclick_handler(GtkWidget * widget, GdkEventButton * event, gpointer func_data) {

	GtkTreePath * path;
	GtkTreeViewColumn * column;
	GtkTreeIter iter;
	char * pname;
	char * pfile;

	if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
		
		if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(play_list), event->x, event->y,
						  &path, &column, NULL, NULL)) {
			start_playback_from_playlist(path);
		}
	}

	if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
		if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(play_list), event->x, event->y,
						  &path, &column, NULL, NULL) &&
		    gtk_tree_model_get_iter(GTK_TREE_MODEL(play_store), &iter, path) &&
		    !gtk_tree_model_iter_has_child(GTK_TREE_MODEL(play_store), &iter)) {

			gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter,
					   0, &pname, 1, &pfile, -1);
					
			strncpy(fileinfo_name, pname, MAXLEN-1);
			strncpy(fileinfo_file, pfile, MAXLEN-1);
			free(pname);
			free(pfile);
					
			gtk_widget_set_sensitive(plist__fileinfo, TRUE);
		} else {
			gtk_widget_set_sensitive(plist__fileinfo, FALSE);
		}

		gtk_widget_set_sensitive(plist__rva, (vol_window == NULL) ? TRUE : FALSE);

		gtk_menu_popup(GTK_MENU(plist_menu), NULL, NULL, NULL, NULL,
			       event->button, event->time);
		return TRUE;
	}
	return FALSE;
}


void
plist__save_cb(gpointer data) {

        GtkWidget * dialog;
        gchar * selected_filename;
	char filename[MAXLEN];


        dialog = gtk_file_chooser_dialog_new(_("Please specify the file to save the playlist to."), 
                                             options.playlist_is_embedded ? GTK_WINDOW(main_window) : GTK_WINDOW(playlist_window), 
                                             GTK_FILE_CHOOSER_ACTION_SAVE, 
                                             GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 
                                             NULL);

        deflicker();
        gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), options.currdir);
        gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "playlist.xml");

        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
        gtk_window_set_default_size(GTK_WINDOW(dialog), 580, 390);
        gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);

	if (options.show_hidden) {
		gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
	}

        if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {

                selected_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

		strncpy(filename, selected_filename, MAXLEN-1);
		save_playlist(filename);

                strncpy(options.currdir, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)),
                                                                         MAXLEN-1);

                g_free(selected_filename);
        }

        gtk_widget_destroy(dialog);
}


void
plist__load_cb(gpointer data) {

        GtkWidget * dialog;
        const gchar * selected_filename;
	char filename[MAXLEN];


        dialog = gtk_file_chooser_dialog_new(_("Please specify the file to load the playlist from."), 
                                             options.playlist_is_embedded ? GTK_WINDOW(main_window) : GTK_WINDOW(playlist_window), 
                                             GTK_FILE_CHOOSER_ACTION_OPEN, 
                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 
                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 
                                             NULL);

        deflicker();
        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
        gtk_window_set_default_size(GTK_WINDOW(dialog), 580, 390);
        gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), options.currdir);
        assign_playlist_fc_filters(GTK_FILE_CHOOSER(dialog));
        gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);

	if (options.show_hidden) {
		gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
	}

        if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {

                selected_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

                strncpy(filename, selected_filename, MAXLEN-1);
		switch (is_playlist(filename)) {
		case 0:
			fprintf(stderr,
				"error: %s does not appear to be a valid playlist\n", filename);
			break;
		case 1:
			load_playlist(filename, 0);
			break;
		case 2:
			load_m3u(filename, 0);
			break;
		case 3:
			load_pls(filename, 0);
			break;
		}

                strncpy(options.currdir, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)),
                                                                         MAXLEN-1);
        }

        gtk_widget_destroy(dialog);

	playlist_content_changed();
}


void
plist__enqueue_cb(gpointer data) {

        GtkWidget * dialog;
        const gchar * selected_filename;
	char filename[MAXLEN];


        dialog = gtk_file_chooser_dialog_new(_("Please specify the file to load the playlist from."), 
                                             options.playlist_is_embedded ? GTK_WINDOW(main_window) : GTK_WINDOW(playlist_window), 
                                             GTK_FILE_CHOOSER_ACTION_OPEN, 
                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 
                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 
                                             NULL);

        deflicker();
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), options.currdir);
        assign_playlist_fc_filters(GTK_FILE_CHOOSER(dialog));

        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
        gtk_window_set_default_size(GTK_WINDOW(dialog), 580, 390);
        gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);

	if (options.show_hidden) {
		gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
	}

        if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {

                selected_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

                strncpy(filename, selected_filename, MAXLEN-1);
		switch (is_playlist(filename)) {
		case 0:
			fprintf(stderr,
				"error: %s does not appear to be a valid playlist\n", filename);
			break;
		case 1:
			load_playlist(filename, 1);
			break;
		case 2:
			load_m3u(filename, 1);
			break;
		case 3:
			load_pls(filename, 1);
			break;
		}

                strncpy(options.currdir, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)),
                                                                         MAXLEN-1);
        }

        gtk_widget_destroy(dialog);

        playlist_content_changed();
}


gint
watch_vol_calc(gpointer data) {

        float * volumes = (float *)data;

        if (!vol_finished) {
                return TRUE;
        }

	if (vol_index != vol_n_tracks) {
		free(volumes);
		volumes = NULL;
		return FALSE;
	}

	if (vol_is_average) {
		char voladj_str[32];
		float voladj = rva_from_multiple_volumes(vol_n_tracks, volumes,
							 options.rva_use_linear_thresh,
							 options.rva_avg_linear_thresh,
							 options.rva_avg_stddev_thresh,
							 options.rva_refvol,
							 options.rva_steepness);
		int i;

		voladj2str(voladj, voladj_str);

		for (i = 0; i < vol_n_tracks; i++) {

			if (gtk_tree_store_iter_is_valid(play_store, &vol_iters[i])) {
				gtk_tree_store_set(play_store, &vol_iters[i],
						   3, voladj, 4, voladj_str, -1);
			}
		}
	} else {
		float voladj;
		char voladj_str[32];

		int i;

		for (i = 0; i < vol_n_tracks; i++) {
			if (gtk_tree_store_iter_is_valid(play_store, &vol_iters[i])) {
				voladj = rva_from_volume(volumes[i],
							 options.rva_refvol,
							 options.rva_steepness);
				voladj2str(voladj, voladj_str);
				gtk_tree_store_set(play_store, &vol_iters[i], 3, voladj,
						   4, voladj_str, -1);
			}
		}
	}

	free(volumes);
	volumes = NULL;
	free(vol_iters);
	vol_iters = NULL;
        return FALSE;
}


void
plist_setup_vol_foreach(GtkTreeIter * iter, void * data) {

        char * pfile;

	gtk_tree_model_get(GTK_TREE_MODEL(play_store), iter, 1, &pfile, -1);

	if (pl_vol_queue == NULL) {
		pl_vol_queue = vol_queue_push(NULL, pfile, *iter/*dummy*/);
	} else {
		vol_queue_push(pl_vol_queue, pfile, *iter/*dummy*/);
	}
	++vol_n_tracks;

	vol_iters = (GtkTreeIter *)realloc(vol_iters, vol_n_tracks * sizeof(GtkTreeIter));
	if (!vol_iters) {
		fprintf(stderr, "realloc error in plist_setup_vol_calc()\n");
		return;
	}
	vol_iters[vol_n_tracks-1] = *iter;

	g_free(pfile);
}

void
plist_setup_vol_calc(void) {

	float * volumes = NULL;

	pl_vol_queue = NULL;

        if (vol_window != NULL) {
                return;
        }

	vol_n_tracks = 0;

	playlist_foreach_selected(plist_setup_vol_foreach, NULL);

	if (vol_n_tracks == 0)
		return;

	if (!options.rva_is_enabled) {

		GtkWidget * dialog = gtk_dialog_new_with_buttons(
				 _("Warning"),
				 options.playlist_is_embedded ?
				 GTK_WINDOW(main_window) : GTK_WINDOW(playlist_window),
				 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
				 GTK_STOCK_YES, GTK_RESPONSE_ACCEPT,
				 GTK_STOCK_NO, GTK_RESPONSE_REJECT,
				 NULL);

		GtkWidget * label =  gtk_label_new(_("Playback RVA is currently disabled.\n"
						     "Do you want to enable it now?"));

		gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, TRUE, 10);
		gtk_widget_show(label);

		if (aqualung_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
			free(vol_iters);
			vol_iters = NULL;
			gtk_widget_destroy(dialog);

			return;
		} else {
			options.rva_is_enabled = 1;
			gtk_widget_destroy(dialog);
		}
	}

	if ((volumes = calloc(vol_n_tracks, sizeof(float))) == NULL) {
		fprintf(stderr, "calloc error in plist__rva_separate_cb()\n");
		free(vol_iters);
		vol_iters = NULL;
		return;
	}


	calculate_volume(pl_vol_queue, volumes);
	gtk_timeout_add(200, watch_vol_calc, (gpointer)volumes);
}


void
plist__rva_separate_cb(gpointer data) {

	vol_is_average = 0;
	plist_setup_vol_calc();
}


void
plist__rva_average_cb(gpointer data) {

	vol_is_average = 1;
	plist_setup_vol_calc();
}


void
plist__reread_file_meta_foreach(GtkTreeIter * iter, void * data) {

	gchar * title;
	gchar * fullname;
	char voladj_str[32];
	char duration_str[MAXLEN];
	int composit;
	playlist_filemeta * plfm = NULL;
	GtkTreeIter dummy;


	gtk_tree_model_get(GTK_TREE_MODEL(play_store), iter,
			   0, &title,
			   1, &fullname,
			   -1);

	if (gtk_tree_model_iter_parent(GTK_TREE_MODEL(play_store), &dummy, iter)) {
		composit = 0;
	} else {
		composit = 1;
	}

	plfm = playlist_filemeta_get(fullname, title, composit);
	if (plfm == NULL) {
		fprintf(stderr, "plist__reread_file_meta_foreach(): "
			"playlist_filemeta_get() returned NULL\n");
		return;
	}
			
	voladj2str(plfm->voladj, voladj_str);
	time2time(plfm->duration, duration_str);
			
	gtk_tree_store_set(play_store, iter,
			   0, plfm->title,
			   1, fullname,
			   3, plfm->voladj, 4, voladj_str,
			   5, plfm->duration, 6, duration_str,
			   -1);
			
	playlist_filemeta_free(plfm);
	plfm = NULL;
	g_free(title);
	g_free(fullname);
}


void
plist__reread_file_meta_cb(gpointer data) {
	
	GtkTreeIter iter;
	GtkTreeIter iter_child;
	int i = 0;
	int j = 0;
	int reread = 0;
	
	playlist_foreach_selected(plist__reread_file_meta_foreach, NULL);
	
	i = 0;
	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, i++)) {
		
		if (gtk_tree_model_iter_has_child(GTK_TREE_MODEL(play_store), &iter)) {
			
			reread = 0;
			
			if (gtk_tree_selection_iter_is_selected(play_select, &iter)) {
				reread = 1;
			} else {
				j = 0;
				while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store),
								     &iter_child, &iter, j++)) {
					if (gtk_tree_selection_iter_is_selected(play_select,
										&iter_child)) {
						reread = 1;
						break;
					}
				}
			}
			
			if (reread) {
				recalc_album_node(&iter);
			}
		}
	}
	
	delayed_playlist_rearrange(100);