options.c

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

	set_option_from_entry(cddb_proxy_entry, options.cddb_proxy);
	set_option_from_spin(cddb_proxy_port_spinner, &options.cddb_proxy_port);
#endif /* HAVE_CDDB */


	/* Appearance */

        set_option_from_toggle(check_override_skin, &options.override_skin_settings);


        /* refresh GUI */

        for (i = 0; i < 3; i++) {

		GtkTreeIter iter;
		GtkTreeViewColumn * cols[4];
		char * pnumstr;

		cols[0] = track_column;
		cols[1] = rva_column;
		cols[2] = length_column;
		cols[3] = NULL;

		gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(plistcol_store), &iter, NULL, i);
		
		gtk_tree_model_get(GTK_TREE_MODEL(plistcol_store), &iter, 1, &pnumstr, -1);
		n = atoi(pnumstr);
		g_free(pnumstr);

		gtk_tree_view_move_column_after(GTK_TREE_VIEW(play_list),
						cols[n], cols[n_prev]);

		options.plcol_idx[i] = n;
		n_prev = n;
	}	

        if (!track_name_in_bold_shadow && options.show_active_track_name_in_bold == 1) {
		reskin_flag = 1;
                track_name_in_bold_shadow = 0;
        }

        if (options.override_skin_settings) {

                /* apply fonts */

                open_font_desc();

                gtk_widget_modify_font (music_tree, fd_browser);
                gtk_widget_modify_font (play_list, fd_playlist);

                gtk_widget_modify_font (bigtimer_label, fd_bigtimer);
                gtk_widget_modify_font (smalltimer_label_1, fd_smalltimer);
                gtk_widget_modify_font (smalltimer_label_2, fd_smalltimer);
                gtk_widget_modify_font (label_title, fd_songtitle);

                gtk_widget_modify_font (label_format, fd_songinfo);
                gtk_widget_modify_font (label_samplerate, fd_songinfo);
                gtk_widget_modify_font (label_bps, fd_songinfo);
                gtk_widget_modify_font (label_mono, fd_songinfo);
                gtk_widget_modify_font (label_output, fd_songinfo);
                gtk_widget_modify_font (label_src_type, fd_songinfo);

		if (options.enable_playlist_statusbar) {
			gtk_widget_modify_font (statusbar_total, fd_statusbar);
			gtk_widget_modify_font (statusbar_total_label, fd_statusbar);
			gtk_widget_modify_font (statusbar_selected, fd_statusbar);
			gtk_widget_modify_font (statusbar_selected_label, fd_statusbar);
		}
		if (options.enable_mstore_statusbar) {
			gtk_widget_modify_font (statusbar_ms, fd_statusbar);
		}

                /* apply colors */               

                if (gdk_color_parse(options.activesong_color, &color) == TRUE) {
 
                        /* sorry for this, but it's temporary workaround */
                        /* see playlist.c:1848 FIXME tag for details */

                        if (!color.red && !color.green && !color.blue)
                                color.red++;

                        play_list->style->fg[SELECTED].red = color.red;
                        play_list->style->fg[SELECTED].green = color.green;
                        play_list->style->fg[SELECTED].blue = color.blue;
                        set_playlist_color();
                }

                if (appearance_changed) {
			reskin_flag = 1;
		}

        } else if (override_shadow) {
		reskin_flag = 1;
                override_shadow = 0;
        } 
     


	i = 0;
	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
					     &iter, NULL, i++)) {
		char * p1;
		int j;
		int has;

		gtk_tree_model_get(GTK_TREE_MODEL(music_store), &iter, 2, &p1, -1);
		
		j = 0;
		has = 0;
		while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store),
						     &iter2, NULL, j++)) {
			char * p2;

			gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter2, 0, &p2, -1);
			if (strcmp(p1, p2) == 0) {

				if (access(p2, R_OK) == 0) {
					has = 1;
				}

				g_free(p2);
				break;
			}

			g_free(p2);
		}

		if (!has) {

			float dirty;
			char * name;

			gtk_tree_model_get(GTK_TREE_MODEL(music_store), &iter,
					   0, &name, 6, &dirty, -1);

			if (dirty < 0) {
				GtkWidget * dialog;

				dialog = gtk_message_dialog_new(GTK_WINDOW(options_window),
					GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
					GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, 
					_("Do you want to save store \"%s\" before removing from Music Store?"), name + 1);
				gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
				gtk_dialog_set_default_response(GTK_DIALOG(dialog),
								GTK_RESPONSE_YES);
				gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
		
				if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
					save_music_store(&iter);
				} else {
					music_store_mark_saved(&iter);
				}

				gtk_widget_destroy(dialog);
				g_free(name);
			}

			gtk_tree_store_remove(music_store, &iter);
			--i;
		}

		g_free(p1);
	}


	i = 0;
	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store),
					     &iter, NULL, i++)) {
		char * p1;
		int j;
		int has;
		char sort[4];

		snprintf(sort, 4, "%03d", i);

		gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter, 0, &p1, -1);

		j = 0;
		has = 0;
		while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
						     &iter2, NULL, j++)) {
			char * p2;

			gtk_tree_model_get(GTK_TREE_MODEL(music_store),
					   &iter2, 2, &p2, -1);

			if (strcmp(p1, p2) == 0) {

				gtk_tree_store_set(music_store, &iter2, 1, sort, -1);

				if (access(p2, W_OK) == 0) {
					gtk_tree_store_set(music_store, &iter2, 7, 1.0f, -1);
				} else {
					gtk_tree_store_set(music_store, &iter2, 7, -1.0f, -1);
				}

				g_free(p2);
				has = 1;

				break;
			}

			g_free(p2);
		}

		if (!has) {
			load_music_store(p1, sort);
		}

		g_free(p1);
	}

	set_buttons_relief();
	refresh_displays();
	gtk_window_set_keep_above(GTK_WINDOW(main_window), options.main_window_always_on_top);

        playlist_content_changed();
        playlist_selection_changed(NULL, NULL);
	music_store_set_status_bar_info();

        current_notebook_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));

	playlist_size_allocate(NULL, NULL);
        show_active_position_in_playlist();

	gtk_widget_destroy(options_window);

	save_config();
}


#ifdef HAVE_LADSPA
void
changed_ladspa_prepost(GtkWidget * widget, gpointer * data) {

	int status = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_ladspa));
	options.ladspa_is_postfader = status;
}
#endif /* HAVE_LADSPA */


#ifdef HAVE_SRC
void
changed_src_type(GtkWidget * widget, gpointer * data) {

	src_type = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_src));
	gtk_label_set_text(GTK_LABEL(label_src), src_get_description(src_type));
	set_src_type_label(src_type);
}
#endif /* HAVE_SRC */


void
check_rva_is_enabled_toggled(GtkWidget * widget, gpointer * data) {

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_rva_is_enabled))) {
		rva_is_enabled_shadow = 1;
		gtk_widget_set_sensitive(combo_listening_env, TRUE);
		gtk_widget_set_sensitive(label_listening_env, TRUE);
		gtk_widget_set_sensitive(spin_refvol, TRUE);
		gtk_widget_set_sensitive(label_refvol, TRUE);
		gtk_widget_set_sensitive(spin_steepness, TRUE);
		gtk_widget_set_sensitive(label_steepness, TRUE);

		gtk_widget_set_sensitive(check_rva_use_averaging, TRUE);

		if (rva_use_averaging_shadow) {
			gtk_widget_set_sensitive(combo_threshold, TRUE);
			gtk_widget_set_sensitive(label_threshold, TRUE);
			gtk_widget_set_sensitive(spin_linthresh, TRUE);
			gtk_widget_set_sensitive(label_linthresh, TRUE);
			gtk_widget_set_sensitive(spin_stdthresh, TRUE);
			gtk_widget_set_sensitive(label_stdthresh, TRUE);
		}
	} else {
		rva_is_enabled_shadow = 0;
		gtk_widget_set_sensitive(combo_listening_env, FALSE);
		gtk_widget_set_sensitive(label_listening_env, FALSE);
		gtk_widget_set_sensitive(spin_refvol, FALSE);
		gtk_widget_set_sensitive(label_refvol, FALSE);
		gtk_widget_set_sensitive(spin_steepness, FALSE);
		gtk_widget_set_sensitive(label_steepness, FALSE);

		gtk_widget_set_sensitive(check_rva_use_averaging, FALSE);
		gtk_widget_set_sensitive(combo_threshold, FALSE);
		gtk_widget_set_sensitive(label_threshold, FALSE);
		gtk_widget_set_sensitive(spin_linthresh, FALSE);
		gtk_widget_set_sensitive(label_linthresh, FALSE);
		gtk_widget_set_sensitive(spin_stdthresh, FALSE);
		gtk_widget_set_sensitive(label_stdthresh, FALSE);
	}

	draw_rva_diagram();
}


void
check_rva_use_averaging_toggled(GtkWidget * widget, gpointer * data) {

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_rva_use_averaging))) {
		rva_use_averaging_shadow = 1;
		gtk_widget_set_sensitive(combo_threshold, TRUE);
		gtk_widget_set_sensitive(label_threshold, TRUE);
		gtk_widget_set_sensitive(spin_linthresh, TRUE);
		gtk_widget_set_sensitive(label_linthresh, TRUE);
		gtk_widget_set_sensitive(spin_stdthresh, TRUE);
		gtk_widget_set_sensitive(label_stdthresh, TRUE);
	} else {
		rva_use_averaging_shadow = 0;
		gtk_widget_set_sensitive(combo_threshold, FALSE);
		gtk_widget_set_sensitive(label_threshold, FALSE);
		gtk_widget_set_sensitive(spin_linthresh, FALSE);
		gtk_widget_set_sensitive(label_linthresh, FALSE);
		gtk_widget_set_sensitive(spin_stdthresh, FALSE);
		gtk_widget_set_sensitive(label_stdthresh, FALSE);
	}
}


void
changed_listening_env(GtkWidget * widget, gpointer * data) {

	rva_env_shadow = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_listening_env));

	switch (rva_env_shadow) {
	case 0: /* Audiophile */
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 1.0f);
		break;
	case 1: /* Living room */
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 0.7f);
		break;
	case 2: /* Office */
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 0.4f);
		break;
	case 3: /* Noisy workshop */
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 0.1f);
		break;
	default:
		fprintf(stderr, "programmer error: options.c/changed_listening_env(): "
			"invalid rva_env_shadow value.\nPlease report this to the programmers!\n");
		break;
	}
}


void
draw_rva_diagram(void) {

	GdkGC * gc;
	GdkColor fg_color;
	int i;
	int width = rva_viewport->allocation.width - 4;
	int height = rva_viewport->allocation.height - 4;
	int dw = width / 24;
	int dh = height / 24;
	int xoffs = (width - 24*dw) / 2 - 1;
	int yoffs = (height - 24*dh) / 2 - 1;
	float volx, voly;
	int px1, py1, px2, py2;


	gdk_draw_rectangle(rva_pixmap,
			   rva_drawing_area->style->black_gc,
			   TRUE,
			   0, 0,
			   rva_drawing_area->allocation.width,
			   rva_drawing_area->allocation.height);
	
	gc = gdk_gc_new(rva_pixmap);
	if (rva_is_enabled_shadow) {
		fg_color.red = 10000;
		fg_color.green = 10000;
		fg_color.blue = 10000;
	} else {
		fg_color.red = 5000;
		fg_color.green = 5000;
		fg_color.blue = 5000;
	}
	gdk_gc_set_rgb_fg_color(gc, &fg_color);

	for (i = 0; i <= 24; i++) {
		gdk_draw_line(rva_pixmap, gc,
			      xoffs + i * dw, yoffs,
			      xoffs + i * dw, yoffs + 24 * dh);
	}

	for (i = 0; i <= 24; i++) {
		gdk_draw_line(rva_pixmap, gc,
			      xoffs, yoffs + i * dh,
			      xoffs + 24 * dw, yoffs + i * dh);
	}