playlist.c

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

}


#ifdef HAVE_IFP
void
plist__send_songs_to_iriver_cb(gpointer data) {

        aifp_transfer_files();

}
#endif /* HAVE_IFP */

void
plist__fileinfo_cb(gpointer data) {

	GtkTreeIter dummy;

	show_file_info(fileinfo_name, fileinfo_file, 0, NULL, dummy);
}

void
plist__search_cb(gpointer data) {
	
	search_playlist_dialog();
}


static gboolean
add_cb(GtkWidget * widget, GdkEvent * event) {

        if (event->type == GDK_BUTTON_PRESS) {
                GdkEventButton * bevent = (GdkEventButton *) event;

                if (bevent->button == 3) {

			gtk_menu_popup(GTK_MENU(add_menu), NULL, NULL, NULL, NULL,
				       bevent->button, bevent->time);

			return TRUE;
		}
		return FALSE;
	}
	return FALSE;
}


static gboolean
sel_cb(GtkWidget * widget, GdkEvent * event) {

        if (event->type == GDK_BUTTON_PRESS) {
                GdkEventButton * bevent = (GdkEventButton *) event;

                if (bevent->button == 3) {

			gtk_menu_popup(GTK_MENU(sel_menu), NULL, NULL, NULL, NULL,
				       bevent->button, bevent->time);

			return TRUE;
		}
		return FALSE;
	}
	return FALSE;
}


static gboolean
rem_cb(GtkWidget * widget, GdkEvent * event) {

        if (event->type == GDK_BUTTON_PRESS) {
                GdkEventButton * bevent = (GdkEventButton *) event;

                if (bevent->button == 3) {

			gtk_menu_popup(GTK_MENU(rem_menu), NULL, NULL, NULL, NULL,
				       bevent->button, bevent->time);

			return TRUE;
		}
		return FALSE;
	}
	return FALSE;
}


/* physical_name should be UTF8 encoded */
/* if alt_name != NULL, it will be used as title if no meta is found */
playlist_filemeta *
playlist_filemeta_get(char * physical_name, char * alt_name, int composit) {

	char display_name[MAXLEN];
	char artist_name[MAXLEN];
	char record_name[MAXLEN];
	char track_name[MAXLEN];
	metadata * meta = NULL;
	int use_meta = 0;
	gchar * substr;

#if defined(HAVE_MOD) && (defined(HAVE_LIBZ) || defined(HAV_LIBBZ2))
        gchar * pos;
#endif /* (HAVE_MOD && (HAVE_LIBZ || HAVE_LIBBZ2)) */

#ifdef HAVE_MOD
        if (is_valid_mod_extension(physical_name)) {
                composit = 0;
        }

#ifdef HAVE_LIBZ	
        if ((pos = strrchr(physical_name, '.')) != NULL) {
                pos++;

                if (!strcasecmp(pos, "gz")) {
                    composit = 0;
                }

#ifdef HAVE_LIBBZ2
                if (!strcasecmp(pos, "bz2")) {
                    composit = 0;
                }
#endif /* HAVE LIBBZ2 */

        }
#endif /* HAVE LIBZ */

#endif /* HAVE_MOD */

	playlist_filemeta * plfm = calloc(1, sizeof(playlist_filemeta));
	if (!plfm) {
		fprintf(stderr, "calloc error in playlist_filemeta_get()\n");
		return NULL;
	}

	if ((plfm->duration = get_file_duration(physical_name)) <= 0.0f) {
		return NULL;
	}

	if (options.rva_is_enabled) {
		meta = meta_new();
		if (meta_read(meta, physical_name)) {
			if (!meta_get_rva(meta, &(plfm->voladj))) {
				plfm->voladj = 0.0f;
			}
		} else {
			plfm->voladj = 0.0f;
		}
		meta_free(meta);
		meta = NULL;
	} else {
		plfm->voladj = 0.0f;
	}
	
	artist_name[0] = '\0';
	record_name[0] = '\0';
	track_name[0] = '\0';

	if (options.auto_use_ext_meta_artist ||
	    options.auto_use_ext_meta_record ||
	    options.auto_use_ext_meta_track) {
		
		meta = meta_new();
		if (!meta_read(meta, physical_name)) {
			meta_free(meta);
			meta = NULL;
		}
	}
	
	use_meta = 0;
	if ((meta != NULL) && options.auto_use_ext_meta_artist) {
		meta_get_artist(meta, artist_name);
		if (artist_name[0] != '\0') {
			use_meta = 1;
		}
	}
	
	if ((meta != NULL) && options.auto_use_ext_meta_record) {
		meta_get_record(meta, record_name);
		if (record_name[0] != '\0') {
			use_meta = 1;
		}
	}
	
	if ((meta != NULL) && options.auto_use_ext_meta_track) {
		meta_get_title(meta, track_name);
		if (track_name[0] != '\0') {
			use_meta = 1;
		}
	}
	
	if ((artist_name[0] != '\0') ||
	    (record_name[0] != '\0') ||
	    (track_name[0] != '\0')) {
		
		if (artist_name[0] == '\0') {
			strcpy(artist_name, _("Unknown"));
		}
		if (record_name[0] == '\0') {
			strcpy(record_name, _("Unknown"));
		}
		if (track_name[0] == '\0') {
			strcpy(track_name, _("Unknown"));
		}
	} else {
		use_meta = 0;
	}
	
	if (use_meta && (meta != NULL)) {
		if (composit) {
			make_title_string(display_name, options.title_format,
					  artist_name, record_name, track_name);
		} else {
			strncpy(display_name, track_name, MAXLEN-1);

		}
	} else {
		if (alt_name != NULL) {
			strcpy(display_name, alt_name);
		} else {
    			if ((substr = strrchr(physical_name, '/')) == NULL)
            			substr = physical_name;
    			else
            			++substr;
			substr = g_filename_display_name(substr);
			strcpy(display_name, substr);
			g_free(substr);
		} 
	}
	if (meta != NULL) {
		meta_free(meta);
		meta = NULL;
	}

	plfm->title = strdup(display_name);

	return plfm;
}


void
playlist_filemeta_free(playlist_filemeta * plfm) {

	free(plfm->title);
	free(plfm);
}


void
add_file_to_playlist(gchar *filename) {

	char voladj_str[32];
	char duration_str[MAXLEN];
	GtkTreeIter play_iter;
	playlist_filemeta * plfm = NULL;

	if ((plfm = playlist_filemeta_get(filename, NULL, 1)) == NULL) {
		return;
	}

        voladj2str(plfm->voladj, voladj_str);
        time2time(plfm->duration, duration_str);

        gtk_tree_store_append(play_store, &play_iter, NULL);
        gtk_tree_store_set(play_store, &play_iter, 0, plfm->title, 1, filename,
                           2, pl_color_inactive,
                           3, plfm->voladj, 4, voladj_str,
                           5, plfm->duration, 6, duration_str, 7, PANGO_WEIGHT_NORMAL, -1);

	playlist_filemeta_free(plfm);
}


static int
filter(const struct dirent * de) {

	return de->d_name[0] != '.';
}


void
add_dir_to_playlist(char * dirname) {

	int i;
	struct dirent ** ent;
	struct stat st_file;
	char path[MAXLEN];

	for (i = 0; i < scandir(dirname, &ent, filter, alphasort); i++) {

		snprintf(path, MAXLEN-1, "%s/%s", dirname, ent[i]->d_name);

		if (stat(path, &st_file) == -1) {
			continue;
		}

		if (S_ISDIR(st_file.st_mode)) {
			add_dir_to_playlist(path);
		} else {
			add_file_to_playlist(path);
		}
	}
}


void
add_files(GtkWidget * widget, gpointer data) {

        GtkWidget *dialog;

        dialog = gtk_file_chooser_dialog_new(_("Select files"), 
                                             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_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
        gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), options.currdir);
        assign_audio_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) {

		GSList *lfiles, *node;

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

                lfiles = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));

                node = lfiles;

                while (node) {

                        add_file_to_playlist((char *)node->data);
                        g_free(node->data);

                        node = node->next;
                }

                g_slist_free(lfiles);
        }


        gtk_widget_destroy(dialog);

	playlist_content_changed();

        delayed_playlist_rearrange(100);
}


void
add_directory(GtkWidget * widget, gpointer data) {

        GtkWidget *dialog;

        dialog = gtk_file_chooser_dialog_new(_("Select directory"), 
                                             options.playlist_is_embedded ? GTK_WINDOW(main_window) : GTK_WINDOW(playlist_window), 
					     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                                             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_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
        gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), options.currdir);
        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) {

		char dirname[MAXLEN];

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

                strncpy(dirname, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)),
			MAXLEN-1);

		add_dir_to_playlist(dirname);
        }


        gtk_widget_destroy(dialog);

	playlist_content_changed();

        delayed_playlist_rearrange(100);
}


void
add__files_cb(gpointer data) {

	add_files(NULL, NULL);
}


void
add__dir_cb(gpointer data) {

	add_directory(NULL, NULL);
}


void
select_all(GtkWidget * widget, gpointer data) {

	gtk_tree_selection_select_all(play_select);
}


void
sel__all_cb(gpointer data) {

	select_all(NULL, NULL);
}


void
sel__none_cb(gpointer data) {

	gtk_tree_selection_unselect_all(play_select);
}


void
invert_item_selection(GtkTreeIter * piter) {

	if (gtk_tree_selection_iter_is_selected(play_select, piter)) {
		gtk_tree_selection_unselect_iter(play_select, piter);
	} else {
		gtk_tree_selection_select_iter(play_select, piter);
	}
}


void
sel__inv_cb(gpointer data) {

	GtkTreeIter iter;
	int i = 0;

	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, i++)) {

		GtkTreeIter iter_child;
		int j = 0;

		invert_item_selection(&iter);

		while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter_child, &iter, j++)) {
			invert_item_selection(&iter_child);
		}
	}
}


void
rem__all_cb(gpointer data) {

	gtk_tree_store_clear(play_store);
        playlist_content_changed();
}


void
rem__sel_cb(gpointer data) {

	GtkTreeIter iter;
	int i = 0, old_pos = 0, old_pos_child = -1;
        GtkTreePath * visible_path;

	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, i++)) {

		GtkTreeIter iter_child;
		int j = 0;
		int modified = 0;
		char * str;