file_info.cpp

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

		break;
	case IMPORT_DEST_NUMBER:
		if (data->str[0] != '0') {
			tmp[0] = '0';
			tmp[1] = '\0';
		} else {
			tmp[0] = '\0';
		}
		strncat(tmp, data->str, MAXLEN-1);
		gtk_tree_store_set(music_store, &(data->track_iter), 1, tmp, -1);
		music_store_mark_changed(&(data->track_iter));
		break;
	case IMPORT_DEST_COMMENT:
		gtk_tree_model_get(data->model, &(data->track_iter), 3, &ptmp, -1);
		tmp[0] = '\0';
		if (ptmp != NULL) {
			strncat(tmp, ptmp, MAXLEN-1);
		}
		if ((tmp[strlen(tmp)-1] != '\n') && (tmp[0] != '\0')) {
			strncat(tmp, "\n", MAXLEN-1);
		}
		strncat(tmp, data->str, MAXLEN-1);
		gtk_tree_store_set(music_store, &(data->track_iter), 3, tmp, -1);
		tree_selection_changed_cb(music_select, NULL);
		music_store_mark_changed(&(data->track_iter));
		break;
	case IMPORT_DEST_RVA:
		ftmp = 1.0f;
		gtk_tree_store_set(music_store, &(data->track_iter), 6, data->fval, -1);
		gtk_tree_store_set(music_store, &(data->track_iter), 7, ftmp, -1);
		music_store_mark_changed(&(data->track_iter));
		break;
	}
}


/* returns the text entry widget */
GtkWidget *
append_table(GtkWidget * table, int * cnt, int edit_mode, char * field, char * value,
	     char * importbtn_text, import_data_t * data) {

	GtkWidget * hbox;
	GtkWidget * entry = NULL;
	GtkWidget * label;

	GtkWidget * button;

	gtk_table_resize(GTK_TABLE(table), *cnt + 1, 3);

	hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(field);
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, *cnt, *cnt+1, GTK_FILL, GTK_FILL, 5, 3);

#ifdef HAVE_TAGLIB
	if (edit_mode == EDITABLE_GENRE) {
		entry = gtk_combo_box_new_text();
		int selected = 0;
		int i = 0;
		gtk_combo_box_append_text(GTK_COMBO_BOX(entry), _("(not set)"));
		while (lookup_id3v1_genre(i) != NULL) {
			gtk_combo_box_append_text(GTK_COMBO_BOX(entry), lookup_id3v1_genre(i));
			if (strcmp(lookup_id3v1_genre(i), value) == 0) {
				selected = i+1;
			}
			++i;
		}
		gtk_combo_box_set_active(GTK_COMBO_BOX(entry), selected);
	} else {
		entry = gtk_entry_new();
		gtk_entry_set_text(GTK_ENTRY(entry), value);
	}

	if (edit_mode == EDITABLE_NO) {
		GTK_WIDGET_UNSET_FLAGS(entry, GTK_CAN_FOCUS);
		gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	}
#endif /* HAVE_TAG_LIB */

	if (importbtn_text == NULL) {
		gtk_table_attach(GTK_TABLE(table), entry, 1, 3, *cnt, *cnt+1,
				 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);
	} else if (data != NULL) {
		button = gtk_button_new_with_label(importbtn_text);
		g_signal_connect(G_OBJECT(button), "clicked",
				 G_CALLBACK(import_button_pressed), (gpointer)data);
		gtk_table_attach(GTK_TABLE(table), entry, 1, 2, *cnt, *cnt+1,
				 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);
		gtk_table_attach(GTK_TABLE(table), button, 2, 3, *cnt, *cnt+1,
				 GTK_FILL, GTK_FILL, 5, 3);
	} else { /* we have no data -> dummy button, no signal attached */
		button = gtk_button_new_with_label(importbtn_text);
		gtk_table_attach(GTK_TABLE(table), entry, 1, 2, *cnt, *cnt+1,
				 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);
		gtk_table_attach(GTK_TABLE(table), button, 2, 3, *cnt, *cnt+1,
				 GTK_FILL, GTK_FILL, 5, 3);
	}
	
	(*cnt)++;
	return entry;
}


void
save_pic_button_pressed(GtkWidget * widget, gpointer data) {

	save_pic_t * save_pic = (save_pic_t *)data;
        GtkWidget * dialog;
        gchar * selected_filename;
	char filename[MAXLEN];

        dialog = gtk_file_chooser_dialog_new(_("Please specify the file to save the image to."), 
                                             GTK_WINDOW(info_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), save_pic->savefile);

        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);
                g_free(selected_filename);

		FILE * f = fopen(filename, "wb");
		if (f == NULL) {
			printf("error: fopen() failed\n");
			gtk_widget_destroy(dialog);
			return;
		}
		if (fwrite(save_pic->image_data, 1, save_pic->image_size, f) != save_pic->image_size) {
			printf("fwrite() error\n");
			gtk_widget_destroy(dialog);
			return;
		}
		fclose(f);

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


void
append_table_pic(GtkWidget * table, int * cnt, GtkWidget * image,
		 char * type, char * descr, char * savefilename,
		 void * image_data, int image_size) {

	char type_str[MAXLEN];
	char descr_str[MAXLEN];

	save_pic_t * save_pic = (save_pic_t *)malloc(sizeof(save_pic_t));
	if (save_pic == NULL)
		return;

	trashlist_add(fileinfo_trash, save_pic);
	strncpy(save_pic->savefile, savefilename, MAXLEN-1);
	save_pic->image_size = image_size;
	save_pic->image_data = image_data;

	snprintf(type_str, MAXLEN-1, "%s: %s", _("Type"), type);
	if (descr != NULL) {
		snprintf(descr_str, MAXLEN-1, "%s: %s", _("Description"), descr);
	} else {
		strcpy(descr_str, _("No description"));
	}

	GtkWidget * frame = gtk_frame_new(_("Embedded picture"));
	GtkWidget * hbox = gtk_hbox_new(FALSE, 0);
	GtkWidget * hbox_i;
	GtkWidget * vbox = gtk_vbox_new(FALSE, 0);
	GtkWidget * label;
	gtk_container_add(GTK_CONTAINER(frame), hbox);
	gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);

	hbox_i = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(type_str);
	gtk_box_pack_start(GTK_BOX(hbox_i), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox_i, FALSE, FALSE, 3);
	hbox_i = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(descr_str);
	gtk_box_pack_start(GTK_BOX(hbox_i), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox_i, FALSE, FALSE, 3);

        GtkWidget * hbuttonbox = gtk_hbutton_box_new();
        gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox), GTK_BUTTONBOX_END);
        GtkWidget * button = gui_stock_label_button(_("Save to file..."), GTK_STOCK_SAVE);
  	gtk_container_add(GTK_CONTAINER(hbuttonbox), button);   
	g_signal_connect(G_OBJECT(button), "clicked",
			 G_CALLBACK(save_pic_button_pressed), (gpointer)save_pic);
	gtk_box_pack_end(GTK_BOX(vbox), hbuttonbox, FALSE, FALSE, 3);  

	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 3);
	gtk_box_pack_end(GTK_BOX(hbox), image, FALSE, FALSE, 3);
	gtk_table_attach(GTK_TABLE(table), frame, 0, 3, *cnt, *cnt+1,
			 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 5, 3);

	(*cnt)++;
}


#ifdef HAVE_TAGLIB
void
save_basic_fields(GtkWidget * widget, gpointer data) {

	savepage_data_t * sdata = (savepage_data_t *)data;
	save_basic_t * save_basic = sdata->save_basic;
	char buf[MAXLEN];
	int i;
	TagLib::String str;
	TagLib::Tag * tag = NULL;

	if (sdata->save_page_no == save_basic->id3v1_page_no) {
		tag = dynamic_cast<TagLib::Tag *>(save_basic->id3v1_tag);
	} else if (sdata->save_page_no == save_basic->id3v2_page_no) {
		tag = dynamic_cast<TagLib::Tag *>(save_basic->id3v2_tag);
	} else if (sdata->save_page_no == save_basic->ape_page_no) {
		tag = dynamic_cast<TagLib::Tag *>(save_basic->ape_tag);
	} else if (sdata->save_page_no == save_basic->oxc_page_no) {
		tag = dynamic_cast<TagLib::Tag *>(save_basic->oxc);
	} else {
		fprintf(stderr, "save_basic_fields(): error looking up metadata type\n");
		return;
	}

	strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_title)), MAXLEN-1);
	cut_trailing_whitespace(buf);
	/* hack to work around TagLib not saving the tag if it's empty */
	if (buf[0] == '\0') {
		buf[0] = ' ';
		buf[1] = '\0';
	}
	str = TagLib::String(buf, TagLib::String::UTF8);	
	tag->setTitle(str);

	strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_artist)), MAXLEN-1);
	cut_trailing_whitespace(buf);
	str = TagLib::String(buf, TagLib::String::UTF8);
	tag->setArtist(str);

	strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_album)), MAXLEN-1);
	cut_trailing_whitespace(buf);
	str = TagLib::String(buf, TagLib::String::UTF8);
	tag->setAlbum(str);

	strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_comment)), MAXLEN-1);
	cut_trailing_whitespace(buf);
	/* workaround silly TagLib when writing an empty comment to an id3v2 tag */
	if (save_basic->taglib_mpeg_file != NULL) {
		if (buf[0] == '\0') {
			buf[0] = ' ';
			buf[1] = '\0';
		}
	}
	str = TagLib::String(buf, TagLib::String::UTF8);
	tag->setComment(str);

	if (GTK_IS_ENTRY(save_basic->entry_genre)) {
		strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_genre)), MAXLEN-1);
		cut_trailing_whitespace(buf);
	} else {
		int selected = gtk_combo_box_get_active(GTK_COMBO_BOX(save_basic->entry_genre));
		if (selected > 0) {
			strncpy(buf, lookup_id3v1_genre(selected-1), MAXLEN-1);
		} else {
			buf[0] = '\0';
		}
	}
	str = TagLib::String(buf, TagLib::String::UTF8);
	tag->setGenre(str);

	strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_year)), MAXLEN-1);
	cut_trailing_whitespace(buf);
	if (sscanf(buf, "%d", &i) < 1) {
		i = 0;
	}
	if ((i < 0) || (i > 9999)) {
		i = 0;
	}
	tag->setYear(i);

	strncpy(buf, gtk_entry_get_text(GTK_ENTRY(save_basic->entry_track)), MAXLEN-1);
	cut_trailing_whitespace(buf);
	if (sscanf(buf, "%d", &i) < 1) {
		i = 0;
	}
	if ((i < 0) || (i > 9999)) {
		i = 0;
	}
	tag->setTrack(i);

	/* save the file */
	if (save_basic->taglib_flac_file != NULL)
		save_basic->taglib_flac_file->save();
	if (save_basic->taglib_oggv_file != NULL)
		save_basic->taglib_oggv_file->save();
	if (save_basic->taglib_mpeg_file != NULL) {
		int tags = 0;
		if (save_basic->id3v1_tag != NULL)
			tags |= TagLib::MPEG::File::ID3v1;
		if (save_basic->id3v2_tag != NULL)
			tags |= TagLib::MPEG::File::ID3v2;
		if (save_basic->ape_tag != NULL)
			tags |= TagLib::MPEG::File::APE;
		save_basic->taglib_mpeg_file->save(tags, false);
	}
	if (save_basic->taglib_mpc_file != NULL)
		save_basic->taglib_mpc_file->save();
}


/* simple mode for fields that don't require anything fancy */
int
build_simple_page(save_basic_t * save_basic, TagLib::Tag * tag, int * cnt, GtkWidget ** ptable,
		  int edit_mode, char * nb_label) {

	GtkWidget * vbox = gtk_vbox_new(FALSE, 4);
	GtkWidget * table = gtk_table_new(0, 3, FALSE);
	GtkWidget * label = gtk_label_new(nb_label);
	GtkWidget * scrwin = gtk_scrolled_window_new(NULL, NULL);
	GtkWidget * viewp = gtk_viewport_new(NULL, NULL);
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewp), GTK_SHADOW_NONE);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwin),
				       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 10);
	gtk_container_add(GTK_CONTAINER(scrwin), viewp);
	gtk_container_add(GTK_CONTAINER(viewp), vbox);
	int page_id = gtk_notebook_append_page(GTK_NOTEBOOK(save_basic->nb), scrwin, label);

	char str[MAXLEN];

	if (save_basic->mode.is_called_from_browser) {
		import_data_t * data;

		strncpy(str, (char *)tag->title().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		if (is_all_wspace(str)) {
			data = NULL;
		} else {
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_TITLE;
			strncpy(data->str, str, MAXLEN-1);
		}
		save_basic->entry_title = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						       _("Title:"), str, _("Import as Title"), data);

		strncpy(str, (char *)tag->artist().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		if (is_all_wspace(str)) {
			data = NULL;
		} else {
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_ARTIST;
			strncpy(data->str, str, MAXLEN-1);
		}
		save_basic->entry_artist = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
							_("Artist:"), str, _("Import as Artist"), data);

		strncpy(str, (char *)tag->album().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		if (is_all_wspace(str)) {
			data = NULL;
		} else {
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_RECORD;
			strncpy(data->str, str, MAXLEN-1);
		}
		save_basic->entry_album = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						       _("Album:"), str, _("Import as Record"), data);

		if (tag->track() != 0) {
			sprintf(str, "%d", tag->track());
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_NUMBER;
			strncpy(data->str, str, MAXLEN-1);
		} else {
			str[0] = '\0';
			data = NULL;
		}
		save_basic->entry_track = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						       _("Track:"), str, _("Import as Track number"), data);

		if (tag->year() != 0) {
			sprintf(str, "%d", tag->year());
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_COMMENT;
			snprintf(data->str, MAXLEN-1, "%s %s", _("Year:"), str);
		} else {
			str[0] = '\0';
			data = NULL;
		}
		save_basic->entry_year = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						      _("Year:"), str, _("Add to Comments"), data);