/* vim: set ai et ts=4 sw=4: */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gnome.h>

#include "liteamp.h"
#include "prefs.h"
#include "playlist.h"
#include "util.h"

Prefs prefs;

/*-----------------------------------------------------------------*/

void prefs_read()
{
    memset(&prefs, 0, sizeof(prefs));

    gnome_config_push_prefix("/liteamp/Preferences/");
    prefs.play_shuffle = gnome_config_get_bool("PlayShuffle=false");
    prefs.play_loop = gnome_config_get_bool("PlayLoop=false");
    prefs.play_mute = gnome_config_get_bool("PlayMute=false");
    prefs.play_effect = gnome_config_get_bool("PlayEffect=false");
    prefs.view_toolbar = gnome_config_get_bool("ViewToolbar=true");
    prefs.view_statusbar = gnome_config_get_bool("ViewStatusbar=true");
    prefs.view_sidebar = gnome_config_get_bool("ViewSidebar=true");
    prefs.view_play_info = gnome_config_get_bool("ViewPlayInfo=true");
    prefs.view_play_pos = gnome_config_get_bool("ViewPlayPos=true");
    prefs.playlist_columns = gnome_config_get_string("PlaylistColumns=ICON,CHECK,NUMBER,TITLE,TIME");
    prefs.sidebar_icon_width = gnome_config_get_int("SidebarIconWidth=16");
    prefs.sidebar_icon_height = gnome_config_get_int("SidebarIconHeight=16");
    prefs.sidebar_text_beside_icon = gnome_config_get_bool("SidebarTextBesideIcon=true");
    prefs.save_geometry = gnome_config_get_bool("SaveGeometry=true");
    prefs.geometry_x = gnome_config_get_int("GeometryX=0");
    prefs.geometry_y = gnome_config_get_int("GeometryY=0");
    prefs.geometry_width = gnome_config_get_int("GeometryWidth=400");
    prefs.geometry_height = gnome_config_get_int("GeometryHeight=300");
    prefs.divider_position = gnome_config_get_int("DividerPosition=100");
    prefs.parse_tag = gnome_config_get_bool("ParseTag=true");
    prefs.parse_tag_all = gnome_config_get_bool("ParseTagAll=false");
    prefs.playback_device = gnome_config_get_string("PlaybackDevice=esd");
    prefs.decoder_select_by_contents = gnome_config_get_bool("DecoderSelectByContents=false");
    prefs.playback_volume = gnome_config_get_bool("PlaybackVolume=false");
    prefs.tag_codesets = gnome_config_get_string("TagCodesets=cp949,cp932,latin-1");
    gnome_config_pop_prefix();
}


void prefs_write()
{
    gnome_config_push_prefix("/liteamp/Preferences/");
    gnome_config_set_bool("PlayShuffle", prefs.play_shuffle);
    gnome_config_set_bool("PlayLoop", prefs.play_loop);
    gnome_config_set_bool("PlayMute", prefs.play_mute);
    gnome_config_set_bool("PlayEffect", prefs.play_effect);
    gnome_config_set_bool("ViewToolbar", prefs.view_toolbar);
    gnome_config_set_bool("ViewStatusbar", prefs.view_statusbar);
    gnome_config_set_bool("ViewSidebar", prefs.view_sidebar);
    gnome_config_set_bool("ViewPlayInfo", prefs.view_play_info);
    gnome_config_set_bool("ViewPlayPos", prefs.view_play_pos);
    gnome_config_set_string("PlaylistColumns", prefs.playlist_columns);
    gnome_config_set_int("SidebarIconWidth", prefs.sidebar_icon_width);
    gnome_config_set_int("SidebarIconHeight", prefs.sidebar_icon_height);
    gnome_config_set_bool("SidebarTextBesideIcon", prefs.sidebar_text_beside_icon);
    gnome_config_set_bool("SaveGeometry", prefs.save_geometry);
    gnome_config_set_int("GeometryX", prefs.geometry_x);
    gnome_config_set_int("GeometryY", prefs.geometry_y);
    gnome_config_set_int("GeometryWidth", prefs.geometry_width);
    gnome_config_set_int("GeometryHeight", prefs.geometry_height);
    gnome_config_set_int("DividerPosition", prefs.divider_position);
    gnome_config_set_bool("ParseTag", prefs.parse_tag);
    gnome_config_set_bool("ParseTagAll", prefs.parse_tag_all);
    gnome_config_set_string("PlaybackDevice", prefs.playback_device);
    gnome_config_set_bool("DecoderSelectByContents",prefs.decoder_select_by_contents);
    gnome_config_set_bool("PlaybackVolume", prefs.playback_volume);
    gnome_config_set_string("TagCodesets", prefs.tag_codesets);
    gnome_config_pop_prefix();
    gnome_config_sync();
}


void prefs_apply(void)
{
	tag_init();
	sidebar_refresh(liteamp_get_sidebar());
	playlist_refresh(liteamp_get_playlist());
    playback_set_playdevice(prefs.playback_device);
    playback_volume_set_active(prefs.playback_volume);
}


gboolean prefs_show_dialog(void)
{
	GtkWidget* prefs_dlg;
	gint response;

	prefs_dlg = prefs_dialog_new();
	prefs_dialog_update_ui(PREFS_DIALOG(prefs_dlg));

	gtk_widget_show_all(prefs_dlg);

	// FIXME: make non-modal dialog
	response = gtk_dialog_run(GTK_DIALOG(prefs_dlg));
	if(response == GTK_RESPONSE_OK) {
		prefs_dialog_update_prefs(PREFS_DIALOG(prefs_dlg));
		prefs_apply();
		prefs_write();
	}
	gtk_widget_destroy(prefs_dlg);

	return response == GTK_RESPONSE_OK;
}

/*-----------------------------------------------------------------*/

// available playlist columns
static const gchar* plc_columns[] = {
    N_("ICON"),
	N_("CHECK"),
    N_("NUMBER"),
    N_("TITLE"),
    N_("ARTIST"),
    N_("ALBUM"),
    N_("TRACK"),
    N_("YEAR"),
    N_("GENRE"),
    N_("TIME"),
    N_("QUALITY"),
    N_("RATING"),
    N_("COMMENT"),
    //N_("FILENAME"),
    //N_("BYTES"),
    //N_("SECONDS"),
    NULL
};

gint prefs_get_playlist_column_index(const gchar* id)
{
    return strfindv_nocase(id, plc_columns);
}

const gchar* prefs_get_playlist_column_id(gint index)
{
    g_return_val_if_fail(index >= 0 && index < G_N_ELEMENTS(plc_columns), NULL);
    return plc_columns[index];
}

/*-----------------------------------------------------------------*/

// available playback devices
static const gchar* playback_devices[] = {
	"esd",
	"oss",
	"alsa",
	"arts",
	"alsa09",
	"sun",
	NULL,
};

/*-----------------------------------------------------------------*/

// column list for playlist columns treeview
typedef enum {
	PLC_COLUMN_COLUMN,
	PLC_INDEX_COLUMN,//invisible
	PLC_N_COLUMNS,
} PlaylistColumnsIndex;
	
/*-----------------------------------------------------------------*/

//
// dialog callbacks
//

static void plc_up_btn_clicked_cb(GtkButton* button, PrefsDialog* prefs_dlg);
static void plc_down_btn_clicked_cb(GtkButton* button, PrefsDialog* prefs_dlg);
static void plc_add_btn_clicked_cb(GtkButton* button, PrefsDialog* prefs_dlg);
static void plc_remove_btn_clicked_cb(GtkButton* button, PrefsDialog* prefs_dlg);

/*-----------------------------------------------------------------*/

//
// boiler plate
//

static void prefs_dialog_class_init(PrefsDialogClass* klass);
static void prefs_dialog_init(PrefsDialog* item);

static GtkWidgetClass *parent_class = NULL;

GType prefs_dialog_get_type() 
{ 
    static GType prefs_dialog_type = 0; 

    if(!prefs_dialog_type) { 
        GTypeInfo prefs_dialog_info = { 
            sizeof(PrefsDialogClass), 
            NULL,
            NULL,
            (GClassInitFunc) prefs_dialog_class_init, 
            NULL,
            NULL,
            sizeof(PrefsDialog), 
            0,
            (GInstanceInitFunc) prefs_dialog_init
        }; 

        prefs_dialog_type = g_type_register_static(GTK_TYPE_DIALOG, "PrefsDialog", &prefs_dialog_info, 0); 
    } 
    return prefs_dialog_type; 
}


static void prefs_dialog_class_init(PrefsDialogClass* klass)
{ 
    // nothing to do
    GtkObjectClass* object_class;
    GtkWidgetClass* widget_class;

    object_class = (GtkObjectClass*)klass;
    widget_class = (GtkWidgetClass*)klass;

    parent_class = gtk_type_class(gtk_dialog_get_type());
}


static void prefs_dialog_init(PrefsDialog* item)
{ 
    // nothing to do
}

/*-----------------------------------------------------------------*/

GtkWidget* prefs_dialog_new()
{
	PrefsDialog* self;

    self = g_object_new(prefs_dialog_get_type(), NULL);

	gtk_window_set_title(GTK_WINDOW(self), _("Preferences"));
	gtk_dialog_add_buttons(GTK_DIALOG(self),
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_OK, GTK_RESPONSE_OK,
			NULL);

    gtk_window_set_default_size(GTK_WINDOW(self), 400, -1);
	gtk_dialog_set_default_response(GTK_DIALOG(self), GTK_RESPONSE_OK);

	// general tab

	self->general_table = gtk_table_new(2, 2, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(self->general_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->general_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->general_table), 3);

	self->plc_frame = gtk_frame_new(_("Playlist Columns"));
	gtk_table_attach(GTK_TABLE(self->general_table),
			self->plc_frame, 0, 1, 0, 1,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->plc_frame), 3);

	self->plc_hbox = gtk_hbox_new(FALSE, 3);
	gtk_container_add(GTK_CONTAINER(self->plc_frame), self->plc_hbox);
	gtk_container_set_border_width(GTK_CONTAINER(self->plc_hbox), 3);

	self->plc_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_box_pack_start(GTK_BOX(self->plc_hbox), self->plc_scrollwin, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->plc_scrollwin), 3);

	self->plc_treeview = gtk_tree_view_new();
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->plc_treeview), FALSE);
	gtk_container_add(GTK_CONTAINER(self->plc_scrollwin), self->plc_treeview);

	self->plc_vbox = gtk_vbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(self->plc_hbox), self->plc_vbox, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->plc_vbox), 3);

	self->plc_up_btn = gtk_button_new_from_stock("gtk-go-up");
	gtk_box_pack_start(GTK_BOX(self->plc_vbox), self->plc_up_btn, FALSE, FALSE, 0);

	self->plc_down_btn = gtk_button_new_from_stock("gtk-go-down");
	gtk_box_pack_start(GTK_BOX(self->plc_vbox), self->plc_down_btn, FALSE, FALSE, 0);

	self->plc_remove_btn = gtk_button_new_from_stock("gtk-remove");
	gtk_box_pack_end(GTK_BOX(self->plc_vbox), self->plc_remove_btn, FALSE, FALSE, 0);

	self->plc_add_btn = gtk_button_new_from_stock("gtk-add");
	gtk_box_pack_end(GTK_BOX(self->plc_vbox), self->plc_add_btn, FALSE, FALSE, 0);


	self->sb_frame = gtk_frame_new(_("Sidebar"));
	gtk_table_attach(GTK_TABLE(self->general_table),
			self->sb_frame, 1, 2, 0, 1,
			GTK_FILL, GTK_FILL, 0, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->sb_frame), 3);

	self->sb_table = gtk_table_new(3, 2, FALSE);
	gtk_container_add(GTK_CONTAINER(self->sb_frame), self->sb_table);
	gtk_container_set_border_width(GTK_CONTAINER(self->sb_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->sb_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->sb_table), 3);

	self->sb_icon_width_label = gtk_label_new(_("Icon Width"));
	gtk_table_attach(GTK_TABLE(self->sb_table),
			self->sb_icon_width_label, 0, 1, 0, 1,
			GTK_FILL, 0, 0, 0);

	self->sb_icon_width_spin = gtk_spin_button_new_with_range(0, 100, 1);
	gtk_table_attach(GTK_TABLE(self->sb_table),
			self->sb_icon_width_spin, 1, 2, 0, 1,
			GTK_EXPAND | GTK_FILL, 0, 0, 0);

	self->sb_icon_height_label = gtk_label_new(_("Icon Height"));
	gtk_table_attach(GTK_TABLE(self->sb_table),
			self->sb_icon_height_label, 0, 1, 1, 2,
			GTK_FILL, 0, 0, 0);

	self->sb_icon_height_spin = gtk_spin_button_new_with_range(0, 100, 1);
	gtk_table_attach(GTK_TABLE(self->sb_table),
			self->sb_icon_height_spin, 1, 2, 1, 2,
			GTK_EXPAND | GTK_FILL, 0, 0, 0);

	self->sb_text_beside_icon_check = gtk_check_button_new_with_mnemonic(_("Text Besides Icon"));
	gtk_table_attach(GTK_TABLE(self->sb_table),
			self->sb_text_beside_icon_check, 0, 2, 2, 3,
			GTK_FILL, 0, 0, 0);

	self->others_frame = gtk_frame_new(_("Others"));
	gtk_table_attach(GTK_TABLE(self->general_table),
			self->others_frame, 0, 2, 1, 2,
			GTK_FILL, GTK_FILL, 0, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->others_frame), 3);

	self->others_table = gtk_table_new(3, 1, FALSE);
	gtk_container_add(GTK_CONTAINER(self->others_frame), self->others_table);
	gtk_container_set_border_width(GTK_CONTAINER(self->others_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->others_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->others_table), 3);

	self->save_geometry_check = gtk_check_button_new_with_mnemonic(_("Save Window Geometry on Exit"));
	gtk_table_attach(GTK_TABLE(self->others_table),
			self->save_geometry_check, 0, 1, 0, 1,
			GTK_FILL, 0, 0, 0);

	self->parse_tag_check = gtk_check_button_new_with_mnemonic(_("Enable Tag Parsing"));
	gtk_table_attach(GTK_TABLE(self->others_table),
			self->parse_tag_check, 0, 1, 1, 2,
			GTK_FILL, 0, 0, 0);

	self->parse_tag_all_check = gtk_check_button_new_with_mnemonic(_("Enable Tag Parsing for \"All\" Playlist(Slow!)"));
	gtk_table_attach(GTK_TABLE(self->others_table),
			self->parse_tag_all_check, 0, 1, 2, 3,
			GTK_FILL, 0, 0, 0);

	// input tab

	self->input_table = gtk_table_new(1, 1, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(self->input_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->input_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->input_table), 3);

	self->decoder_frame = gtk_frame_new(_("Decoder"));
	gtk_table_attach(GTK_TABLE(self->input_table),
			self->decoder_frame, 0, 1, 0, 1,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->decoder_frame), 3);

	self->decoder_table = gtk_table_new(1, 1, FALSE);
	gtk_container_add(GTK_CONTAINER(self->decoder_frame), self->decoder_table);
	gtk_container_set_border_width(GTK_CONTAINER(self->decoder_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->decoder_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->decoder_table), 3);

	self->decoder_select_by_contents_check = gtk_check_button_new_with_mnemonic(_("Decoder Select by Contents"));
	gtk_table_attach(GTK_TABLE(self->decoder_table),
			self->decoder_select_by_contents_check, 0, 1, 0, 1,
			GTK_FILL, 0, 0, 0);

	// output tab

	self->output_table = gtk_table_new(1, 1, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(self->output_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->output_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->output_table), 3);

	self->playback_frame = gtk_frame_new(_("Playback"));
	gtk_table_attach(GTK_TABLE(self->output_table),
			self->playback_frame, 0, 1, 0, 1,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
	gtk_container_set_border_width(GTK_CONTAINER(self->playback_frame), 3);

	self->playback_table = gtk_table_new(1, 2, FALSE);
	gtk_container_add(GTK_CONTAINER(self->playback_frame), self->playback_table);
	gtk_container_set_border_width(GTK_CONTAINER(self->playback_table), 3);
	gtk_table_set_row_spacings(GTK_TABLE(self->playback_table), 3);
	gtk_table_set_col_spacings(GTK_TABLE(self->playback_table), 3);

	self->playback_device_label = gtk_label_new(_("Playback Device"));
	gtk_table_attach(GTK_TABLE(self->playback_table),
			self->playback_device_label, 0, 1, 0, 1,
			GTK_FILL, 0, 0, 0);

	self->playback_device_combo = gtk_combo_new();
	gtk_combo_set_value_in_list(GTK_COMBO(self->playback_device_combo),
			TRUE, FALSE);
	gtk_combo_set_popdown_strings(GTK_COMBO(self->playback_device_combo),
			array_to_list((gpointer*)playback_devices));
	gtk_editable_set_editable(
			GTK_EDITABLE(GTK_COMBO(self->playback_device_combo)->entry),
			FALSE);

	gtk_table_attach(GTK_TABLE(self->playback_table),
			self->playback_device_combo, 1, 2, 0, 1,
			GTK_EXPAND | GTK_FILL, 0, 0, 0);

	self->playback_volume_check = gtk_check_button_new_with_mnemonic(_("Enable Software Volume Control"));
	gtk_table_attach(GTK_TABLE(self->playback_table),
			self->playback_volume_check, 0, 2, 1, 2,
			GTK_FILL, 0, 0, 0);

	// notebook

    self->nb = gtk_notebook_new();

	gtk_notebook_append_page(
			GTK_NOTEBOOK(self->nb),
			self->general_table,
			gtk_label_new(_("General")));

	gtk_notebook_append_page(
			GTK_NOTEBOOK(self->nb),
			self->input_table,
			gtk_label_new(_("Input")));

	gtk_notebook_append_page(
			GTK_NOTEBOOK(self->nb),
			self->output_table,
			gtk_label_new(_("Output")));

    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(self)->vbox),
		self->nb, TRUE, TRUE, 0);

	// playlist columns tree model

	self->plc_model = GTK_TREE_MODEL(gtk_list_store_new(PLC_N_COLUMNS,
			G_TYPE_STRING, G_TYPE_INT));
	gtk_tree_view_set_model(GTK_TREE_VIEW(self->plc_treeview),
			self->plc_model);
	self->plc_selection = gtk_tree_view_get_selection(
			GTK_TREE_VIEW(self->plc_treeview));
	gtk_tree_selection_set_mode(self->plc_selection,
			GTK_SELECTION_SINGLE);
	gtk_tree_view_append_column(
			GTK_TREE_VIEW(self->plc_treeview),
			gtk_tree_view_column_new_with_attributes(
					_("Column"), gtk_cell_renderer_text_new(),
					"text", PLC_COLUMN_COLUMN, NULL));

	// signals

	g_signal_connect(
			G_OBJECT(self->plc_up_btn),
			"clicked",
			G_CALLBACK(plc_up_btn_clicked_cb),
			self);

	g_signal_connect(
			G_OBJECT(self->plc_down_btn),
			"clicked",
			G_CALLBACK(plc_down_btn_clicked_cb),
			self);

	g_signal_connect(
			G_OBJECT(self->plc_remove_btn),
			"clicked",
			G_CALLBACK(plc_remove_btn_clicked_cb),
			self);

	g_signal_connect(
			G_OBJECT(self->plc_add_btn),
			"clicked",
			G_CALLBACK(plc_add_btn_clicked_cb),
			self);

	return GTK_WIDGET(self);
}


void prefs_dialog_update_ui(PrefsDialog* self)
{
	GtkTreeIter iter;
    gchar** prefs_columns;
	gint i;
	gint plc_index;

	g_assert(IS_PREFS_DIALOG(self));

	gtk_spin_button_set_value(
			GTK_SPIN_BUTTON(self->sb_icon_width_spin),
			(gdouble)prefs.sidebar_icon_width);
	gtk_spin_button_set_value(
			GTK_SPIN_BUTTON(self->sb_icon_height_spin),
			(gdouble)prefs.sidebar_icon_height);
	gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(self->sb_text_beside_icon_check),
			prefs.sidebar_text_beside_icon);
	gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(self->save_geometry_check),
			prefs.save_geometry);
	gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(self->parse_tag_check),
			prefs.parse_tag);
	gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(self->parse_tag_all_check),
			prefs.parse_tag_all);
	gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(self->decoder_select_by_contents_check),
			prefs.decoder_select_by_contents);
	gtk_entry_set_text(
			GTK_ENTRY(GTK_COMBO(self->playback_device_combo)->entry), 
			prefs.playback_device);
	gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(self->playback_volume_check),
			prefs.playback_volume);

	gtk_list_store_clear(GTK_LIST_STORE(self->plc_model));
    prefs_columns = g_strsplit(prefs.playlist_columns, ",", 0);
    for(i = 0; prefs_columns[i] != NULL; i++) {
		plc_index = prefs_get_playlist_column_index(prefs_columns[i]);
		if(plc_index >= 0) {
			gtk_list_store_append(
					GTK_LIST_STORE(self->plc_model),
					&iter);
			gtk_list_store_set(
					GTK_LIST_STORE(self->plc_model),
					&iter,
					PLC_COLUMN_COLUMN, _(plc_columns[plc_index]),
					PLC_INDEX_COLUMN, plc_index,
					-1);
		}
	}
}


void prefs_dialog_update_prefs(PrefsDialog* self)
{
	GtkTreeIter iter;
	gboolean valid;
	gint plc_index;
	gchar* temp_str;

	prefs.sidebar_icon_width = (gint)gtk_spin_button_get_value(
			GTK_SPIN_BUTTON(self->sb_icon_width_spin));
	prefs.sidebar_icon_height = (gint)gtk_spin_button_get_value(
			GTK_SPIN_BUTTON(self->sb_icon_height_spin));
	prefs.sidebar_text_beside_icon = gtk_toggle_button_get_active(
			GTK_TOGGLE_BUTTON(self->sb_text_beside_icon_check));
	prefs.save_geometry = gtk_toggle_button_get_active(
			GTK_TOGGLE_BUTTON(self->save_geometry_check));
	prefs.parse_tag = gtk_toggle_button_get_active(
			GTK_TOGGLE_BUTTON(self->parse_tag_check));
	prefs.parse_tag_all = gtk_toggle_button_get_active(
			GTK_TOGGLE_BUTTON(self->parse_tag_all_check));
	prefs.decoder_select_by_contents = gtk_toggle_button_get_active(
			GTK_TOGGLE_BUTTON(self->decoder_select_by_contents_check));
	prefs.playback_device = g_strdup(gtk_entry_get_text(
			GTK_ENTRY(GTK_COMBO(self->playback_device_combo)->entry)));
	prefs.playback_volume = gtk_toggle_button_get_active(
			GTK_TOGGLE_BUTTON(self->playback_volume_check));

	prefs.playlist_columns = NULL;
	valid = gtk_tree_model_get_iter_first(self->plc_model, &iter);
	while(valid) {
		gtk_tree_model_get(
				self->plc_model,
				&iter,
				PLC_INDEX_COLUMN, &plc_index,
				-1);
		if(prefs.playlist_columns) {
			temp_str = prefs.playlist_columns;
			prefs.playlist_columns = g_strconcat(prefs.playlist_columns, ",", plc_columns[plc_index], NULL);
			g_free(temp_str);
		} else {
			prefs.playlist_columns = g_strdup(plc_columns[plc_index]);
		}
		valid = gtk_tree_model_iter_next(self->plc_model, &iter);
	}
}

/*-----------------------------------------------------------------*/

//
// callbacks
//

static void plc_up_btn_clicked_cb(
        GtkButton* button, PrefsDialog* prefs_dlg)
{
	GtkTreeIter iter;
	GtkTreeIter iter2;
	GtkTreePath* path;
	gint plc_index, plc_index2;

	if(gtk_tree_selection_get_selected(
			prefs_dlg->plc_selection, NULL, &iter)) {
		path = gtk_tree_model_get_path(prefs_dlg->plc_model, &iter);
		if(path) {
			if(gtk_tree_path_prev(path)) {
				gtk_tree_model_get_iter(prefs_dlg->plc_model, &iter2, path);

#if GTK_CHECK_VERSION(2,2,0)
				gtk_list_store_swap(
						GTK_LIST_STORE(prefs_dlg->plc_model), &iter, &iter2);
#else
				gtk_tree_model_get(
						prefs_dlg->plc_model,
						&iter,
						PLC_INDEX_COLUMN, &plc_index,
						-1);
				gtk_tree_model_get(
						prefs_dlg->plc_model,
						&iter2,
						PLC_INDEX_COLUMN, &plc_index2,
						-1);
				gtk_list_store_set(
						GTK_LIST_STORE(prefs_dlg->plc_model),
						&iter,
						PLC_COLUMN_COLUMN, _(plc_columns[plc_index2]),
						PLC_INDEX_COLUMN, plc_index2,
						-1);
				gtk_list_store_set(
						GTK_LIST_STORE(prefs_dlg->plc_model),
						&iter2,
						PLC_COLUMN_COLUMN, _(plc_columns[plc_index]),
						PLC_INDEX_COLUMN, plc_index,
						-1);
				gtk_tree_selection_select_iter(prefs_dlg->plc_selection, &iter2);
#endif
			}
			gtk_tree_path_free(path);
		}
	}
}


static void plc_down_btn_clicked_cb(
        GtkButton* button, PrefsDialog* prefs_dlg)
{
	GtkTreeIter iter;
	GtkTreeIter iter2;
	gint plc_index, plc_index2;

	if(gtk_tree_selection_get_selected(
			prefs_dlg->plc_selection, NULL, &iter)) {
		iter2 = iter;
		if(gtk_tree_model_iter_next(prefs_dlg->plc_model, &iter2)) {
#if GTK_CHECK_VERSION(2,2,0)
			gtk_list_store_swap(
					GTK_LIST_STORE(prefs_dlg->plc_model), &iter, &iter2);
#else
			gtk_tree_model_get(
					prefs_dlg->plc_model,
					&iter,
					PLC_INDEX_COLUMN, &plc_index,
					-1);
			gtk_tree_model_get(
					prefs_dlg->plc_model,
					&iter2,
					PLC_INDEX_COLUMN, &plc_index2,
					-1);
			gtk_list_store_set(
					GTK_LIST_STORE(prefs_dlg->plc_model),
					&iter,
					PLC_COLUMN_COLUMN, _(plc_columns[plc_index2]),
					PLC_INDEX_COLUMN, plc_index2,
					-1);
			gtk_list_store_set(
					GTK_LIST_STORE(prefs_dlg->plc_model),
					&iter2,
					PLC_COLUMN_COLUMN, _(plc_columns[plc_index]),
					PLC_INDEX_COLUMN, plc_index,
					-1);
			gtk_tree_selection_select_iter(prefs_dlg->plc_selection, &iter2);
#endif
		}
	}
}


static void plc_add_btn_clicked_cb(
		GtkButton* button, PrefsDialog* prefs_dlg)
{
	GtkWidget* plc_add_dlg;
	GtkWidget* plc_scrollwin;
	GtkWidget* plc_treeview;
	GtkTreeModel* plc_model;
	GtkTreeSelection* plc_selection;
	int i;
	GtkTreeIter iter;
	gint plc_index;
	gchar* plc_column;
	gboolean valid;

    plc_add_dlg = gtk_dialog_new_with_buttons(_("Add Columns"),
            GTK_WINDOW(prefs_dlg),
            GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
            GTK_STOCK_OK, GTK_RESPONSE_OK,
            NULL);

    gtk_window_set_default_size(GTK_WINDOW(plc_add_dlg), -1, 300);
    gtk_dialog_set_default_response(GTK_DIALOG(plc_add_dlg), GTK_RESPONSE_OK);

	plc_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(plc_add_dlg)->vbox), plc_scrollwin, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(plc_scrollwin), 3);

	plc_treeview = gtk_tree_view_new();
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(plc_treeview), FALSE);
	gtk_container_add(GTK_CONTAINER(plc_scrollwin), plc_treeview);

	plc_model = GTK_TREE_MODEL(gtk_list_store_new(PLC_N_COLUMNS,
			G_TYPE_STRING, G_TYPE_INT));
	gtk_tree_view_set_model(GTK_TREE_VIEW(plc_treeview),
			plc_model);
	plc_selection = gtk_tree_view_get_selection(
			GTK_TREE_VIEW(plc_treeview));
	gtk_tree_selection_set_mode(plc_selection,
			GTK_SELECTION_SINGLE);
	gtk_tree_view_append_column(
			GTK_TREE_VIEW(plc_treeview),
			gtk_tree_view_column_new_with_attributes(
					_("Column"), gtk_cell_renderer_text_new(),
					"text", PLC_COLUMN_COLUMN, NULL));

    for(i = 0; plc_columns[i] != NULL; i++) {
		// skip existing columns
		// FIXME: somewhat ugly :(
		valid = gtk_tree_model_get_iter_first(prefs_dlg->plc_model, &iter);
		while(valid) {
			gtk_tree_model_get(
					prefs_dlg->plc_model,
					&iter,
					PLC_INDEX_COLUMN, &plc_index,
					-1);
			if(i == plc_index) {
				valid = TRUE;
				break;
			}

			valid = gtk_tree_model_iter_next(prefs_dlg->plc_model, &iter);
		}
		if(valid) continue;

		gtk_list_store_append(
				GTK_LIST_STORE(plc_model),
				&iter);
		gtk_list_store_set(
				GTK_LIST_STORE(plc_model),
				&iter,
				PLC_COLUMN_COLUMN, _(plc_columns[i]),
				PLC_INDEX_COLUMN, i,
				-1);
	}

	gtk_widget_show_all(plc_add_dlg);

	// FIXME: make non-modal dialog
	if(gtk_dialog_run(GTK_DIALOG(plc_add_dlg)) == GTK_RESPONSE_OK) {

		if(gtk_tree_selection_get_selected(
				plc_selection, NULL, &iter)) {

			gtk_tree_model_get(plc_model, &iter,
					PLC_COLUMN_COLUMN, &plc_column,
					PLC_INDEX_COLUMN, &plc_index,
					-1);

			gtk_list_store_append(
					GTK_LIST_STORE(prefs_dlg->plc_model),
					&iter);
			gtk_list_store_set(
					GTK_LIST_STORE(prefs_dlg->plc_model),
					&iter,
					PLC_COLUMN_COLUMN, plc_column,
					PLC_INDEX_COLUMN, plc_index,
					-1);
			gtk_tree_selection_select_iter(prefs_dlg->plc_selection, &iter);

			g_free(plc_column);
		}
	}

	gtk_widget_destroy(plc_add_dlg);
}


static void plc_remove_btn_clicked_cb(
		GtkButton* button, PrefsDialog* prefs_dlg)
{
	GtkTreeIter iter;

	if(gtk_tree_selection_get_selected(
			prefs_dlg->plc_selection, NULL, &iter)) {

		gtk_list_store_remove(
				GTK_LIST_STORE(prefs_dlg->plc_model), &iter);
	}
}

/*prefs.c*/