file_info.cpp

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

/*                                                     -*- linux-c -*-
    Copyright (C) 2004 Tom Szilagyi

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    $Id: file_info.cpp,v 1.31 2006/10/02 17:50:26 peterszilagyi Exp $
*/

#include <config.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <sys/stat.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <glib.h>
#include <glib/gstdio.h>

#ifdef HAVE_MOD_INFO
#include <libmodplug/modplug.h>
#endif /* HAVE_MOD_INFO */

#ifdef HAVE_MOD
#include "decoder/dec_mod.h"
#endif /* HAVE_MOD */

#ifdef HAVE_TAGLIB
#include <id3v1tag.h>
#include <id3v2tag.h>
#include <apetag.h>
#include <xiphcomment.h>

#include <apeitem.h>
#include <attachedpictureframe.h>
#include <relativevolumeframe.h>
#include <textidentificationframe.h>

#include <mpegfile.h>
#include <mpcfile.h>
#include <flacfile.h>
#include <vorbisfile.h>

#include <tmap.h>
#include <tlist.h>
#include <tbytevector.h>
#include <tfile.h>
#include <tstring.h>
#endif /* HAVE_TAGLIB */

#include "common.h"
#include "core.h"
#include "cover.h"
#include "decoder/file_decoder.h"
#include "music_browser.h"
#include "gui_main.h"
#include "options.h"
#include "trashlist.h"
#include "build_store.h"
#include "i18n.h"
#include "meta_decoder.h"
#include "file_info.h"


/* import destination codes */
#define IMPORT_DEST_ARTIST   1
#define IMPORT_DEST_RECORD   2
#define IMPORT_DEST_TITLE    3
#define IMPORT_DEST_NUMBER   4
#define IMPORT_DEST_COMMENT  5
#define IMPORT_DEST_RVA      6


extern options_t options;
extern GtkWidget* gui_stock_label_button(gchar *label, const gchar *stock);

GtkWidget * fi_event_box;

typedef struct {
        GtkTreeModel * model;
        GtkTreeIter track_iter;
        int dest_type; /* one of the above codes */
        char str[MAXLEN];
        float fval;
} import_data_t;

typedef struct {
	int is_called_from_browser;
	GtkTreeModel * model;
	GtkTreeIter track_iter;
} fileinfo_mode_t;

typedef struct {
	char savefile[MAXLEN];
	unsigned int image_size;
	void * image_data;
} save_pic_t;


#ifdef HAVE_TAGLIB

/* edit modes */
#define EDITABLE_NO    0x00
#define EDITABLE_YES   0x01
#define EDITABLE_GENRE 0x02


/* used in flags below */
#define CREATE_ID3v2 0x02
#define CREATE_APE   0x04
#define REMOVE_ID3v1 0x10
#define REMOVE_ID3v2 0x20
#define REMOVE_APE   0x40

typedef struct {
	TagLib::FLAC::File * taglib_flac_file;
	TagLib::Ogg::Vorbis::File * taglib_oggv_file;
	TagLib::MPEG::File * taglib_mpeg_file;
	TagLib::MPC::File * taglib_mpc_file;

	TagLib::ID3v1::Tag * id3v1_tag;
	TagLib::ID3v2::Tag * id3v2_tag;
	TagLib::APE::Tag * ape_tag;
	TagLib::Ogg::XiphComment * oxc;

	GtkWidget * entry_title;
	GtkWidget * entry_artist;
	GtkWidget * entry_album;
	GtkWidget * entry_track;
	GtkWidget * entry_year;
	GtkWidget * entry_genre;
	GtkWidget * entry_comment;

	GtkNotebook * nb;
	GtkWidget * hbox;
	GtkWidget * hbox_inner;
	fileinfo_mode_t mode;

	int flags;
	int id3v1_page_no;
	int id3v2_page_no;
	int ape_page_no;
	int oxc_page_no;
} save_basic_t;

typedef struct {
	int flags; /* only the exact action associated w/ button */
	save_basic_t * save_basic;
} tagbutton_data_t;

typedef struct {
	int save_page_no; /* only the exact page to save */
	save_basic_t * save_basic;
} savepage_data_t;
#endif /* HAVE_TAGLIB */


extern GtkWidget * main_window;
extern GtkTreeStore * music_store;
extern GtkTreeSelection * music_select;
extern GtkWidget * music_tree;

GtkWidget * info_window = NULL;
trashlist_t * fileinfo_trash = NULL;

gint n_pages = 0;       /* number of notebook pages */
GtkWidget * nb;         /* notebook widget */

#ifdef HAVE_MOD_INFO
file_decoder_t * md_fdec = NULL;
GtkWidget * smp_instr_list;
GtkListStore * smp_instr_list_store = NULL;
void fill_module_info_page(mod_info *mdi, GtkWidget *vbox, char *file);
#endif /* HAVE_MOD_INFO */

import_data_t *
import_data_new(void) {

	import_data_t * data;

	if ((data = (import_data_t *)calloc(1, sizeof(import_data_t))) == NULL) {
		fprintf(stderr, "error: import_data_new(): calloc error\n");
		return NULL;
	}
	return data;
}


#ifdef HAVE_TAGLIB
save_basic_t *
save_basic_new(void) {

	save_basic_t * save_basic = (save_basic_t *)calloc(1, sizeof(save_basic_t));
	if (!save_basic) {
		fprintf(stderr, "error: save_basic_new(): calloc error\n");
		return NULL;
	}

	save_basic->id3v1_page_no = -1;
	save_basic->id3v2_page_no = -1;
	save_basic->ape_page_no = -1;
	save_basic->oxc_page_no = -1;

	return save_basic;
}


tagbutton_data_t *
tagbutton_data_new(void) {

	tagbutton_data_t * tdata = (tagbutton_data_t *)calloc(1, sizeof(tagbutton_data_t));
	if (!tdata) {
		fprintf(stderr, "error: tagbutton_data_new(): calloc error\n");
		return NULL;
	}

	return tdata;
}


savepage_data_t *
savepage_data_new(void) {

	savepage_data_t * sdata = (savepage_data_t *)calloc(1, sizeof(savepage_data_t));
	if (!sdata) {
		fprintf(stderr, "error: savepage_data_new(): calloc error\n");
		return NULL;
	}

	sdata->save_page_no = -1;

	return sdata;
}
#endif /* HAVE_TAGLIB */


gint
dismiss(GtkWidget * widget, gpointer data) {

	metadata * meta = (metadata *)data;
	meta_free(meta);

#ifdef HAVE_MOD_INFO
        if (md_fdec) {
                file_decoder_close(md_fdec);
                file_decoder_delete(md_fdec);
                md_fdec = NULL;
        }
#endif /* HAVE_MOD_INFO */

        gtk_widget_destroy(info_window);
	info_window = NULL;
	trashlist_free(fileinfo_trash);
	fileinfo_trash = NULL;
	return TRUE;
}


gint
info_window_close(GtkWidget * widget, GdkEventAny * event, gpointer data) {

	metadata * meta = (metadata *)data;
	meta_free(meta);

	info_window = NULL;
	trashlist_free(fileinfo_trash);
	fileinfo_trash = NULL;
	return FALSE;
}


gint
info_window_key_pressed(GtkWidget * widget, GdkEventKey * kevent, gpointer data) {

	switch (kevent->keyval) {
	case GDK_Escape:
		dismiss(NULL, data);
		return TRUE;
		break;
	case GDK_Return:
		int page = (gtk_notebook_get_current_page(GTK_NOTEBOOK(nb)) + 1) % n_pages;
		gtk_notebook_set_current_page(GTK_NOTEBOOK(nb), page);
		break;
	}
	return FALSE;
}


char *
lookup_id3v1_genre(int code) {

	switch (code) {
	case 0: return "Blues";
	case 1: return "Classic Rock";
	case 2: return "Country";
	case 3: return "Dance";
	case 4: return "Disco";
	case 5: return "Funk";
	case 6: return "Grunge";
	case 7: return "Hip-Hop";
	case 8: return "Jazz";
	case 9: return "Metal";
	case 10: return "New Age";
	case 11: return "Oldies";
	case 12: return "Other";
	case 13: return "Pop";
	case 14: return "R&B";
	case 15: return "Rap";
	case 16: return "Reggae";
	case 17: return "Rock";
	case 18: return "Techno";
	case 19: return "Industrial";
	case 20: return "Alternative";
	case 21: return "Ska";
	case 22: return "Death Metal";
	case 23: return "Pranks";
	case 24: return "Soundtrack";
	case 25: return "Euro-Techno";
	case 26: return "Ambient";
	case 27: return "Trip-Hop";
	case 28: return "Vocal";
	case 29: return "Jazz+Funk";
	case 30: return "Fusion";
	case 31: return "Trance";
	case 32: return "Classical";
	case 33: return "Instrumental";
	case 34: return "Acid";
	case 35: return "House";
	case 36: return "Game";
	case 37: return "Sound Clip";
	case 38: return "Gospel";
	case 39: return "Noise";
	case 40: return "AlternRock";
	case 41: return "Bass";
	case 42: return "Soul";
	case 43: return "Punk";
	case 44: return "Space";
	case 45: return "Meditative";
	case 46: return "Instrumental Pop";
	case 47: return "Instrumental Rock";
	case 48: return "Ethnic";
	case 49: return "Gothic";
	case 50: return "Darkwave";
	case 51: return "Techno-Industrial";
	case 52: return "Electronic";
	case 53: return "Pop-Folk";
	case 54: return "Eurodance";
	case 55: return "Dream";
	case 56: return "Southern Rock";
	case 57: return "Comedy";
	case 58: return "Cult";
	case 59: return "Gangsta";
	case 60: return "Top 40";
	case 61: return "Christian Rap";
	case 62: return "Pop/Funk";
	case 63: return "Jungle";
	case 64: return "Native American";
	case 65: return "Cabaret";
	case 66: return "New Wave";
	case 67: return "Psychadelic";
	case 68: return "Rave";
	case 69: return "Showtunes";
	case 70: return "Trailer";
	case 71: return "Lo-Fi";
	case 72: return "Tribal";
	case 73: return "Acid Punk";
	case 74: return "Acid Jazz";
	case 75: return "Polka";
	case 76: return "Retro";
	case 77: return "Musical";
	case 78: return "Rock & Roll";
	case 79: return "Hard Rock";
	default: return NULL;
	}
}


void
import_button_pressed(GtkWidget * widget, gpointer gptr_data) {

	import_data_t * data = (import_data_t *)gptr_data;
	GtkTreeIter record_iter;
	GtkTreeIter artist_iter;
	GtkTreePath * path;
	char tmp[MAXLEN];
	char * ptmp;
	float ftmp;

	switch (data->dest_type) {
	case IMPORT_DEST_TITLE:
		gtk_tree_store_set(music_store, &(data->track_iter), 0, data->str, -1);
		music_store_mark_changed(&(data->track_iter));
		break;
	case IMPORT_DEST_RECORD:
		gtk_tree_model_iter_parent(data->model, &record_iter, &(data->track_iter));
		gtk_tree_store_set(music_store, &record_iter, 0, data->str, -1);
		music_store_mark_changed(&(data->track_iter));
		break;
	case IMPORT_DEST_ARTIST:
		gtk_tree_model_iter_parent(data->model, &record_iter, &(data->track_iter));
		gtk_tree_model_iter_parent(data->model, &artist_iter, &record_iter);
		gtk_tree_store_set(music_store, &artist_iter, 0, data->str, -1);
		gtk_tree_store_set(music_store, &artist_iter, 1, data->str, -1);
		path = gtk_tree_model_get_path(data->model, &(data->track_iter));
		gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(music_tree), path, NULL, TRUE, 0.5f, 0.0f);
		music_store_mark_changed(&(data->track_iter));