file_info.cpp

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

}
#endif /* HAVE_MPEG */


#ifdef HAVE_MPC
void
build_nb_pages_mpc(metadata * meta, GtkNotebook * nb, GtkWidget * hbox, fileinfo_mode_t mode) {

	TagLib::MPC::File * taglib_mpc_file =
		reinterpret_cast<TagLib::MPC::File *>(meta->taglib_file);

#ifdef HAVE_METAEDIT
	TagLib::File * taglib_file =
		dynamic_cast<TagLib::File *>(taglib_mpc_file);

	int edit_mode = taglib_file->readOnly() ? EDITABLE_NO : EDITABLE_YES;
#else
	int edit_mode = EDITABLE_NO;
#endif /* HAVE_METAEDIT */

	save_basic_t * save_basic = save_basic_new();
	trashlist_add(fileinfo_trash, save_basic);
	save_basic->taglib_mpc_file = taglib_mpc_file;
	save_basic->nb = nb;
	save_basic->hbox = hbox;
	save_basic->mode = mode;

	if (taglib_mpc_file->ID3v1Tag() && !taglib_mpc_file->ID3v1Tag()->isEmpty()) {
		save_basic->id3v1_page_no =
		    build_id3v1_page(save_basic, EDITABLE_NO, taglib_mpc_file->ID3v1Tag());
		save_basic->flags |= REMOVE_ID3v1;
	}
	if (taglib_mpc_file->APETag() && !taglib_mpc_file->APETag()->isEmpty()) {
		save_basic->ape_page_no =
		    build_ape_page(save_basic, edit_mode, taglib_mpc_file->APETag());
		save_basic->flags |= REMOVE_APE;
	} else {
		save_basic->flags |= CREATE_APE;
	}

	if (edit_mode) {
		build_tag_buttons(save_basic);
	}
}
#endif /* HAVE_MPC */
#endif /* HAVE_TAGLIB */

gboolean    
fi_cover_press_button_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data) {

	if (event->type == GDK_BUTTON_PRESS && event->button == 1) { /* LMB ? */
                display_zoomed_cover(info_window, fi_event_box, (gchar *) user_data);
        }
        return TRUE;
}    

void
show_file_info(char * name, char * file, int is_called_from_browser,
	       GtkTreeModel * model, GtkTreeIter track_iter) {

        char str[MAXLEN];
	gchar *file_display;

	GtkWidget * vbox;
	GtkWidget * hbox_tagbuttons;
	GtkWidget * hbox_t;
	GtkWidget * table;
	GtkWidget * hbox_name;
	GtkWidget * label_name;
	GtkWidget * entry_name;
	GtkWidget * hbox_path;
	GtkWidget * label_path;
	GtkWidget * entry_path;
	GtkWidget * dismiss_btn;
	GtkWidget * fi_cover_image_area;

	GtkWidget * vbox_file;
	GtkWidget * label_file;
	GtkWidget * table_file;
	GtkWidget * hbox;
	GtkWidget * label;
	GtkWidget * entry;

#ifdef HAVE_MOD_INFO
        mod_info * mdi;
	GtkWidget * vbox_mod;
	GtkWidget * label_mod;
#endif /* HAVE_MOD_INFO */

	metadata * meta = meta_new();

	fileinfo_mode_t mode;
	mode.is_called_from_browser = is_called_from_browser;
	mode.model = model;
	mode.track_iter = track_iter;

	if (info_window != NULL) {
		gtk_widget_destroy(info_window);
		info_window = NULL;
	}

	if (fileinfo_trash != NULL) {
		trashlist_free(fileinfo_trash);
		fileinfo_trash = NULL;
	}
	fileinfo_trash = trashlist_new();

	if (!meta_read(meta, file)) {
		fprintf(stderr, "show_file_info(): meta_read() returned an error\n");
		meta_free(meta);
		return;
	}

	info_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_title(GTK_WINDOW(info_window), _("File info"));
	gtk_window_set_transient_for(GTK_WINDOW(info_window), GTK_WINDOW(main_window));
	gtk_window_set_position(GTK_WINDOW(info_window), GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_default_size(GTK_WINDOW(info_window), 600, 500);
        gtk_window_set_resizable(GTK_WINDOW(info_window), TRUE);
	g_signal_connect(G_OBJECT(info_window), "delete_event",
			 G_CALLBACK(info_window_close), (gpointer)meta);
        g_signal_connect(G_OBJECT(info_window), "key_press_event",
			 G_CALLBACK(info_window_key_pressed), (gpointer)meta);
	gtk_container_set_border_width(GTK_CONTAINER(info_window), 5);

	vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(info_window), vbox);

	hbox_t = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox_t, FALSE, FALSE, 5);

	table = gtk_table_new(2, 2, FALSE);
	gtk_box_pack_start(GTK_BOX(hbox_t), table, TRUE, TRUE, 4);

        hbox_name = gtk_hbox_new(FALSE, 0);
	label_name = gtk_label_new(_("Track:"));
	gtk_box_pack_start(GTK_BOX(hbox_name), label_name, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table), hbox_name, 0, 1, 0, 1,
			 GTK_FILL, GTK_FILL, 5, 2);

	entry_name = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry_name, GTK_CAN_FOCUS);
	gtk_entry_set_text(GTK_ENTRY(entry_name), name);
	gtk_editable_set_editable(GTK_EDITABLE(entry_name), FALSE);
	gtk_table_attach(GTK_TABLE(table), entry_name, 1, 2, 0, 1,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 2);

	hbox_path = gtk_hbox_new(FALSE, 0);
	label_path = gtk_label_new(_("File:"));
	gtk_box_pack_start(GTK_BOX(hbox_path), label_path, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table), hbox_path, 0, 1, 1, 2,
			 GTK_FILL, GTK_FILL, 5, 2);

	file_display=g_filename_display_name(file);
	entry_path = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry_path, GTK_CAN_FOCUS);
	gtk_entry_set_text(GTK_ENTRY(entry_path), file_display);
	g_free(file_display);
	gtk_editable_set_editable(GTK_EDITABLE(entry_path), FALSE);
	gtk_table_attach(GTK_TABLE(table), entry_path, 1, 2, 1, 2,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 2);

        fi_cover_image_area = gtk_image_new();
        fi_event_box = gtk_event_box_new ();
	gtk_box_pack_start(GTK_BOX(hbox_t), fi_event_box, FALSE, FALSE, 0);
        gtk_container_add (GTK_CONTAINER (fi_event_box), fi_cover_image_area);
        g_signal_connect(G_OBJECT(fi_event_box), "button_press_event",
                         G_CALLBACK(fi_cover_press_button_cb), file);

        display_cover(fi_cover_image_area, fi_event_box, 48, 48, file, FALSE, TRUE);

	hbox_tagbuttons = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_end(GTK_BOX(vbox), hbox_tagbuttons, FALSE, FALSE, 5);

	nb = gtk_notebook_new();
	gtk_box_pack_start(GTK_BOX(vbox), nb, TRUE, TRUE, 5);

	/* Audio data notebook page */

	vbox_file = gtk_vbox_new(FALSE, 4);
	table_file = gtk_table_new(6, 2, FALSE);
	gtk_box_pack_start(GTK_BOX(vbox_file), table_file, TRUE, TRUE, 10);
	label_file = gtk_label_new(_("Audio data"));
	gtk_notebook_append_page(GTK_NOTEBOOK(nb), vbox_file, label_file);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Format:"));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table_file), hbox, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 5, 3);
	entry = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
	assembly_format_label(str, meta->format_major, meta->format_minor);
	gtk_entry_set_text(GTK_ENTRY(entry), str);
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_table_attach(GTK_TABLE(table_file), entry, 1, 2, 0, 1,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Length:"));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table_file), hbox, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 5, 3);
	entry = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
	sample2time(meta->sample_rate, meta->total_samples, str, 0);
	gtk_entry_set_text(GTK_ENTRY(entry), str);
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_table_attach(GTK_TABLE(table_file), entry, 1, 2, 1, 2,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Samplerate:"));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table_file), hbox, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 5, 3);
	entry = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
	sprintf(str, _("%ld Hz"), meta->sample_rate);
	gtk_entry_set_text(GTK_ENTRY(entry), str);
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_table_attach(GTK_TABLE(table_file), entry, 1, 2, 2, 3,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Channel count:"));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table_file), hbox, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 5, 3);
	entry = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
	if (meta->is_mono)
		strcpy(str, _("MONO"));
	else
		strcpy(str, _("STEREO"));
	gtk_entry_set_text(GTK_ENTRY(entry), str);
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_table_attach(GTK_TABLE(table_file), entry, 1, 2, 3, 4,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Bandwidth:"));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table_file), hbox, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 5, 3);
	entry = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
	sprintf(str, _("%.1f kbit/s"), meta->bps / 1000.0f);
	gtk_entry_set_text(GTK_ENTRY(entry), str);
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_table_attach(GTK_TABLE(table_file), entry, 1, 2, 4, 5,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Total samples:"));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table_file), hbox, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 5, 3);
	entry = gtk_entry_new();
        GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
	sprintf(str, "%lld", meta->total_samples);
	gtk_entry_set_text(GTK_ENTRY(entry), str);
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_table_attach(GTK_TABLE(table_file), entry, 1, 2, 5, 6,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);


#ifdef HAVE_TAGLIB
	switch (meta->format_major) {
#ifdef HAVE_FLAC
	case FORMAT_FLAC:
		build_nb_pages_flac(meta, GTK_NOTEBOOK(nb), hbox_tagbuttons, mode);
		break;
#endif /* HAVE_FLAC */
#ifdef HAVE_OGG_VORBIS
	case FORMAT_VORBIS:
		build_nb_pages_oggv(meta, GTK_NOTEBOOK(nb), hbox_tagbuttons, mode);
		break;
#endif /* HAVE_OGG_VORBIS */
#ifdef HAVE_MPEG
	case FORMAT_MAD:
		build_nb_pages_mpeg(meta, GTK_NOTEBOOK(nb), hbox_tagbuttons, mode);
		break;
#endif /* HAVE_MPEG */
#ifdef HAVE_MPC
	case FORMAT_MPC:
		build_nb_pages_mpc(meta, GTK_NOTEBOOK(nb), hbox_tagbuttons, mode);
		break;
#endif /* HAVE_MPC */
	}
#endif /* HAVE_TAGLIB */

#ifdef HAVE_MOD_INFO
	mdi = meta->mod_root;
	if (mdi->active) {
                if ((md_fdec = file_decoder_new()) == NULL) {
                        fprintf(stderr, "show_file_info(): error: file_decoder_new() returned NULL\n");
                }

                if (file_decoder_open(md_fdec, file)) {
                        fprintf(stderr, "file_decoder_open() failed on %s\n", file);
                }

                if (md_fdec->file_lib == MOD_LIB) {

                        vbox_mod = gtk_vbox_new(FALSE, 4);
                        label_mod = gtk_label_new(_("Module info"));
                        gtk_notebook_append_page(GTK_NOTEBOOK(nb), vbox_mod, label_mod);
                        fill_module_info_page(mdi, vbox_mod, file);
                } else {

                        file_decoder_close(md_fdec);
                        file_decoder_delete(md_fdec);
                }
        }
#endif /* HAVE_MOD_INFO */

	/* end of notebook stuff */

	gtk_widget_grab_focus(nb);

        dismiss_btn = gtk_button_new_from_stock (GTK_STOCK_CLOSE); 
	g_signal_connect(dismiss_btn, "clicked", G_CALLBACK(dismiss), (gpointer)meta);
        gtk_widget_set_size_request(dismiss_btn, 80, -1);
	gtk_box_pack_end(GTK_BOX(hbox_tagbuttons), dismiss_btn, FALSE, FALSE, 3);

	gtk_widget_show_all(info_window);

	n_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(nb));

        if (n_pages > 1) {
                gtk_notebook_set_current_page(GTK_NOTEBOOK(nb), options.tags_tab_first ? 1 : 0);
        }

	/* metadata object is freed in info_window destroy handlers */
}


#ifdef HAVE_MOD_INFO
/*
 * type = 0 for sample list
 * type != 0 for instrument list
 */
void
show_list (gint type) {
GtkTreeIter iter;
gint i, len;
gchar temp[MAXLEN], number[MAXLEN];
decoder_t * md_dec;
mod_pdata_t * md_pd;
        
        md_dec = (decoder_t *)(md_fdec->pdec);
        md_pd = (mod_pdata_t *)md_dec->pdata;

        if (type) {
                len = ModPlug_NumInstruments(md_pd->mpf);
        } else {
                len = ModPlug_NumSamples(md_pd->mpf);
        }

        if (len) {
                gtk_list_store_clear(smp_instr_list_store);
                for(i = 0; i < len; i++) {
                        memset(temp, 0, MAXLEN-1);

                        if (type) {
                                ModPlug_InstrumentName(md_pd->mpf, i, temp);
                        } else {
                                ModPlug_SampleName(md_pd->mpf, i, temp);
                        }

                        sprintf(number, "%2d", i);
                        gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(smp_instr_list_store), &iter, NULL, i);
                        gtk_list_store_append(smp_instr_list_store, &iter);
                        gtk_list_store_set(smp_instr_list_store, &iter, 0, number, 1, temp, -1);
                }
        }
}

void
set_first_row (void) {
GtkTreeIter iter;
GtkTreePath * visible_path;

        gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(smp_instr_list_store), &iter, NULL, 0);
        visible_path = gtk_tree_model_get_path (GTK_TREE_MODEL(smp_instr_list_store), &iter);
        gtk_tree_view_set_cursor (GTK_TREE_VIEW (smp_instr_list), visible_path, NULL, TRUE);
        gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (smp_instr_list), visible_path,
                                      NULL, TRUE, 1.0, 0.0);
        gtk_widget_grab_focus(GTK_WIDGET(smp_instr_list));
}

void 
radio_buttons_cb (GtkToggleButton *toggle_button, gboolean state) {

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button))) {
                show_list (0);
        } else {
                show_list (1);
        }
        set_first_row();
}

void
fill_module_info_page(mod_info *mdi, GtkWidget *vbox, char *file) {

gchar *a_type[] = {
        "None", "MOD", "S3M", "XM", "MED", "MTM", "IT", "669",
        "ULT", "STM", "FAR", "WAV", "AMF", "AMS", "DSM", "MDL",
        "OKT", "MID", "DMF", "PTM", "DBM", "MT2", "AMF0", "PSM",
        "J2B", "UMX"
};

gint i, n;
gchar temp[MAXLEN];
GtkWidget *table;
GtkWidget *label;
GtkWidget *mod_type_label;
GtkWidget *mod_channels_label;
GtkWidget *mod_patterns_label;
GtkWidget *mod_samples_label;
GtkWidget *mod_instruments_label;
GtkWidget *