playlist.c

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

		int n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), &iter);

		if (gtk_tree_selection_iter_is_selected(play_select, &iter)) {
			gtk_tree_store_remove(play_store, &iter);
			--i;
                        old_pos = i;
			continue;
		}

		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)) {

				gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter_child, 2, &str, -1);
				if (strcmp(str, pl_color_active) == 0) {
					unmark_track(&iter_child);
				}

				g_free(str);

				gtk_tree_store_remove(play_store, &iter_child);
				--j;
                                old_pos_child = j;
				modified = 1;
			}
		}

		/* if all tracks have been removed, also remove album node; else recalc album node */
		if (n) {
			if (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), &iter) == 0) {
				gtk_tree_store_remove(play_store, &iter);
				--i;
                                old_pos = i;
			} else if (modified) {
				recalc_album_node(&iter);

				gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter, 2, &str, -1);
				if (strcmp(str, pl_color_active) == 0) {
					unmark_track(&iter);
					mark_track(&iter);
				}
				g_free(str);
			}
		}
	}


        if (old_pos_child == -1) {

                for(i=0; gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, i); i++);

                if (i) {
                        if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, old_pos)) {
                                gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, i-1);
                        }

                        if(!old_pos) {
                                gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter, NULL, 0);
                        }

                        visible_path = gtk_tree_model_get_path (GTK_TREE_MODEL(play_store), &iter);
                        if (visible_path) {
                                gtk_tree_view_set_cursor (GTK_TREE_VIEW (play_list), visible_path, NULL, TRUE);
                                gtk_tree_path_free(visible_path);
                        }
                }
        }

	playlist_content_changed();
}


void
rem__dead_cb(gpointer data) {

	GtkTreeIter iter;
	int i = 0;
        gchar *filename;

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

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

                int n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), &iter);

                if (!n && g_file_test (filename, G_FILE_TEST_IS_REGULAR) == FALSE) {
                        g_free (filename);
                        gtk_tree_store_remove(play_store, &iter);
                        --i;
                        continue;
                }

                g_free (filename);

		GtkTreeIter iter_child;
		int j = 0;

                if (n) {

                        while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter_child, &iter, j++)) {
                                gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter_child, 1, &filename, -1);

                                if (g_file_test (filename, G_FILE_TEST_IS_REGULAR) == FALSE) {
                                        gtk_tree_store_remove(play_store, &iter_child);
                                        --j;
                                }

                                g_free (filename);
                        }

                        /* remove album node if empty */
                        if (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), &iter) == 0) {
				gtk_tree_store_remove(play_store, &iter);
                                --i;
                        } else {
                                recalc_album_node(&iter);
                        }
                }

        }
	playlist_content_changed();
}

void
remove_sel(GtkWidget * widget, gpointer data) {

	rem__sel_cb(NULL);
}


/* playlist item is selected -> keep, else -> remove
 * ret: 0 if kept, 1 if removed track
 */
int
cut_track_item(GtkTreeIter * piter) {

	if (!gtk_tree_selection_iter_is_selected(play_select, piter)) {
		gtk_tree_store_remove(play_store, piter);
		return 1;
	}
	return 0;
}


/* ret: 1 if at least one of album node's children are selected; else 0 */
int
any_tracks_selected(GtkTreeIter * piter) {

	int j = 0;
	GtkTreeIter iter_child;

	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter_child, piter, j++)) {
		if (gtk_tree_selection_iter_is_selected(play_select, &iter_child)) {
			return 1;
		}
	}
	return 0;
}


/* cut selected callback */
void
cut__sel_cb(gpointer data) {

	GtkTreeIter iter;
	int i = 0;

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

		int n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), &iter);

		if (n) { /* album node */
			if (any_tracks_selected(&iter)) {
				int j = 0;
				GtkTreeIter iter_child;
				while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store),
								     &iter_child, &iter, j++)) {
					j -= cut_track_item(&iter_child);
				}

				recalc_album_node(&iter);
			} else {
				i -= cut_track_item(&iter);
			}
		} else { /* track node */
			i -= cut_track_item(&iter);
		}
	}
	gtk_tree_selection_unselect_all(play_select);
	playlist_content_changed();
}


gint
playlist_rearrange_timeout_cb(gpointer data) {   

	playlist_size_allocate(NULL, NULL);

	return FALSE;
}


void
delayed_playlist_rearrange(int delay) {

	g_timeout_add(delay, playlist_rearrange_timeout_cb, NULL);
}


gint
playlist_size_allocate(GtkWidget * widget, GdkEventConfigure * event) {

	int avail;
	int track_width;
	int rva_width;
	int length_width;


	avail = play_list->allocation.width;

	if (gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(rva_column))) {
		gtk_tree_view_column_cell_get_size(GTK_TREE_VIEW_COLUMN(rva_column),
						   NULL, NULL, NULL, &rva_width, NULL);
	} else {
		rva_width = 1;
	}

	if (gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(length_column))) {
		gtk_tree_view_column_cell_get_size(GTK_TREE_VIEW_COLUMN(length_column),
						   NULL, NULL, NULL, &length_width, NULL);
	} else {
		length_width = 1;
	}

	track_width = avail - rva_width - length_width;
	if (track_width < 1)
		track_width = 1;

	gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(track_column), track_width);
	gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(rva_column), rva_width);
	gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(length_column), length_width);


	if (options.playlist_is_embedded) {
		if (main_window->window != NULL) {
			gtk_widget_queue_draw(main_window);
		}
	} else {
		if (playlist_window->window != NULL) {
			gtk_widget_queue_draw(playlist_window);
		}
	}
        return TRUE;
}


void
playlist_child_stats(GtkTreeIter * iter, int * count, float * duration, float * songs_size, int selected) {

	int j = 0;
	gchar * tstr;
	struct stat statbuf;
	GtkTreeIter iter_child;

	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter_child, iter, j++)) {
		
		if (!selected || gtk_tree_selection_iter_is_selected(play_select, &iter_child)) {
			
			float len = 0;

			gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter_child, 5, &len, 1, &tstr, -1);
			*duration += len;
			(*count)++;
			if (stat(tstr, &statbuf) != -1) {
				*songs_size += statbuf.st_size / 1024.0;
			}
			g_free(tstr);
		}
	}
}


/* if selected == true -> stats for selected tracks; else: all tracks */
void
playlist_stats(int selected) {

	GtkTreeIter iter;
	int i = 0;

	int count = 0;
	float duration = 0;
	float len = 0;
	char str[MAXLEN];
	char time[MAXLEN];
        gchar * tstr;
        float songs_size, m_size;
        struct stat statbuf;

	if (!options.enable_playlist_statusbar) return;

        songs_size = 0;

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

		int n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), &iter);
		if (n > 0) { /* album node -- count children tracks */
			if (gtk_tree_selection_iter_is_selected(play_select, &iter)) {
				playlist_child_stats(&iter, &count, &duration, &songs_size, 0/*false*/);
			} else {
				playlist_child_stats(&iter, &count, &duration, &songs_size, selected);
			}
		} else {
			if (!selected || gtk_tree_selection_iter_is_selected(play_select, &iter)) {
				gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter, 5, &len, 1, &tstr, -1);
				duration += len;
				count++;
				if (stat(tstr, &statbuf) != -1) {
					songs_size += statbuf.st_size / 1024.0;
				}
				g_free(tstr);
			}
                }
	}


	time2time(duration, time);
        m_size = songs_size / 1024.0;

	if (count == 1) {
                if (options.pl_statusbar_show_size) {
                        if(m_size < 1024) {
                                sprintf(str, _("%d track [%s] (%.1f MB)"), count, time, m_size);
                        } else {
                                sprintf(str, _("%d track [%s] (%.1f GB)"), count, time, m_size / 1024.0);
                        }
                } else {
                        sprintf(str, _("%d track [%s] "), count, time);
                }
	} else {
                if (options.pl_statusbar_show_size) {
                        if(m_size < 1024) {
                                sprintf(str, _("%d tracks [%s] (%.1f MB)"), count, time, m_size);
                        } else {
                                sprintf(str, _("%d tracks [%s] (%.1f GB)"), count, time, m_size / 1024.0);
                        }
                } else {
                        sprintf(str, _("%d tracks [%s] "), count, time);
                }
	}

	if (selected) {
		gtk_label_set_text(GTK_LABEL(statusbar_selected), str);
	} else {
		gtk_label_set_text(GTK_LABEL(statusbar_total), str);
	}
}


void
recalc_album_node(GtkTreeIter * iter) {
	int count = 0;
	float duration = 0;
	float songs_size;
	char time[MAXLEN];

	playlist_child_stats(iter, &count, &duration, &songs_size, 0/*false*/);
	time2time(duration, time);
	gtk_tree_store_set(play_store, iter, 5, duration, 6, time, -1);
}


void
playlist_selection_changed(GtkTreeSelection * sel, gpointer data) {

	playlist_stats(1/* true */);
}


void
playlist_content_changed(void) {

	playlist_stats(0/*false*/);
}


void
playlist_drag_begin(GtkWidget * widget, GdkDragContext * drag_context, gpointer data) {

	GtkTargetEntry target_table[] = {
		{ "", GTK_TARGET_SAME_APP, 0 }
	};

	gtk_drag_dest_set(play_list,
			  GTK_DEST_DEFAULT_ALL,
			  target_table,
			  1,
			  GDK_ACTION_MOVE);
}


void
playlist_drag_data_get(GtkWidget * widget, GdkDragContext * drag_context,
		      GtkSelectionData * data, guint info, guint time, gpointer user_data) {

	gtk_selection_data_set(data, data->target, 8, (const guchar *) "list\0", 5);
}


void
playlist_perform_drag(GtkTreeModel * model,
		      GtkTreeIter * sel_iter, GtkTreePath * sel_path,
		      GtkTreeIter * pos_iter, GtkTreePath * pos_path) {

	int cmp = gtk_tree_path_compare(sel_path, pos_path);
	int sel_depth = gtk_tree_path_get_depth(sel_path);
	int pos_depth = gtk_tree_path_get_depth(pos_path);

	int * sel_idx = gtk_tree_path_get_indices(sel_path);
	int * pos_idx = gtk_tree_path_get_indices(pos_path);

	if (cmp == 0) {
		return;
	}

	if (sel_depth == pos_depth && (sel_depth == 1 /* top */ || sel_idx[0] == pos_idx[0])) {

		GtkTreeIter parent;

		if (cmp == 1) {
			gtk_tree_store_move_before(play_store, sel_iter, pos_iter);
		} else {
			gtk_tree_store_move_after(play_store, sel_iter, pos_iter);
		}

		if (gtk_tree_model_iter_parent(model, &parent, sel_iter)) {
			unmark_track(&parent);
			mark_track(&parent);
		}
	} else {

		GtkTreeIter iter;
		GtkTreeIter sel_parent;
		GtkTreeIter pos_parent;
		int recalc_sel_parent = 0;
		int recalc_pos_parent = 0;
		char * tname;
		char * fname;
		char * color;
		float voladj;
		char * voldisp;
		float duration;
		char * durdisp;
		int fontw;

		if (gtk_tree_model_iter_has_child(model, sel_iter)) {
			return;
		}

		if (gtk_tree_model_iter_parent(model, &sel_parent, sel_iter)) {
			recalc_sel_parent = 1;
		}

		if (gtk_tree_model_iter_parent(model, &pos_parent, pos_iter)) {
			recalc_pos_parent = 1;
		}

		gtk_tree_model_get(model, sel_iter, 0, &tname, 1, &fname, 2, &color,
				   3, &voladj, 4, &voldisp, 5, &duration,
				   6, &durdisp, 7, &fontw, -1);

		if (cmp == 1) {
			gtk_tree_store_insert_before(play_store, &iter, NULL, pos_iter);
		} else {
			gtk_tree_store_insert_after(play_store, &iter, NULL, pos_iter);
		}

		gtk_tree_store_set(play_store, &iter, 0, tname, 1, fname, 2, color,
				   3, voladj, 4, voldisp, 5, duration,
				   6, durdisp, 7, fontw, -1);

		gtk_tree_store_remove(play_store, sel_iter);

		if (recalc_sel_parent) {
			if (gtk_tree_model_iter_has_child(model, &sel_parent)) {
				recalc_album_node(&sel_parent);
				unmark_track(&sel_parent);
				mark_track(&sel_parent);
			} else {
				gtk_tree_store_remove(play_store, &sel_parent);
			}