src/Tools/mpdinteraction.c

   1 /* Gnome Music Player Client (GMPC)
   2  * Copyright (C) 2004-2012 Qball Cow <qball@gmpclient.org>
   3  * Project homepage: http://gmpclient.org/
   4
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <stdio.h>
  21 #include <gtk/gtk.h>
  22 #include <string.h>
  23 #include "main.h"
  24 #include "config1.h"
  25 #include "playlist3.h"
  26 #include "mpdinteraction.h"
  27 #include "advanced-search.h"
  28 #include "gmpc-extras.h"
  29
  30 //G_LOCK_DEFINE (connecting_lock);
  31
  32 int current_volume = 0;
  33
  34 static GMutex *connecting_lock = NULL;    //g_mutex_new();//G_STATIC_MUTEX_INIT;
  35
  36 /* Server Settings plugin */
  37 static void server_pref_construct(GtkWidget *);
  38 static void server_pref_destroy(GtkWidget *);
  39
  40 /* Connection settings plugin */
  41 static void connection_pref_construct(GtkWidget * container);
  42 static void connection_pref_destroy(GtkWidget * container);
  43
  44 void server_pref_replaygain_changed(GtkComboBox * combo, gpointer data);
  45 static void ServerStatusChangedCallback(MpdObj * mi, ChangedStatusType what, void *userdata);
  46
  47 static GtkBuilder *server_pref_xml = NULL;
  48 static GtkBuilder *connection_pref_xml = NULL;
  49
  50 gmpcPrefPlugin server_gpp = {
  51     server_pref_construct,
  52     server_pref_destroy
  53 };
  54
  55 /* Glade prototypes, would be static without glade */
  56 void xfade_enable_toggled(GtkToggleButton * but);
  57 void xfade_time_changed(GtkSpinButton * but);
  58 void entry_auth_changed(GtkEntry * entry);
  59
  60 void select_directory_dialog(GtkWidget *button);
  61 void auth_enable_toggled(GtkToggleButton * but);
  62
  63 void preferences_window_autoconnect(GtkToggleButton * tog);
  64 void preferences_window_connect(GtkWidget * but);
  65 void preferences_window_disconnect(GtkWidget * but);
  66 void update_preferences_name(GtkWidget * entry);
  67 void update_preferences_hostname(GtkWidget * entry);
  68 void update_preferences_portnumber(GtkWidget * wid);
  69 void update_preferences_information(GtkWidget * wid);
  70 void connection_profiles_changed(GtkComboBox * combo, gpointer data);
  71 void connection_add_profile(GtkWidget * but);
  72 void connection_remove_profile(GtkWidget * but);
  73 void submenu_artist_clicked(GtkWidget * item);
  74 void submenu_album_clicked(GtkWidget * item);
  75 void submenu_genre_clicked(GtkWidget * item);
  76 void submenu_dir_clicked(GtkWidget * item);
  77
  78 static void mpd_interaction_init(void)
  79 {
  80 }
  81
  82 gmpcPlugin server_plug = {
  83     .name = N_("Server Settings"),    /** name */
  84     .version = {1, 1, 1},        /** Version */
  85     .plugin_type = GMPC_INTERNALL,        /** Plugin Type */
  86     .init = mpd_interaction_init,/** init */
  87     .mpd_status_changed = ServerStatusChangedCallback,    /** status changed */
  88     .pref = &server_gpp            /** preferences */
  89 };
  90
  91 enum
  92 {
  93     ENABLED_COL,
  94     NAME_COL,
  95     ID_COL,
  96     N_COLUMNS
  97 };
  98
  99 gmpcPrefPlugin connection_gpp = {
 100     connection_pref_construct,
 101     connection_pref_destroy
 102 };
 103
 104 gmpcPlugin connection_plug = {
 105     .name = N_("Connection"),    /* name */
 106     .version = {1, 1, 1},    /* version */
 107     .plugin_type = GMPC_INTERNALL,    /* type */
 108     .pref = &connection_gpp    /* preferences */
 109 };
 110
 111 guint connecting_pulse = 0;
 112 gboolean connecting_pulse_callback(void);
 113 gboolean connecting_pulse_callback(void)
 114 {
 115     if (pl3_xml)
 116     {
 117         GtkProgressBar *pb = GTK_PROGRESS_BAR(gtk_builder_get_object(pl3_xml, "pl3_progressbar"));
 118         gtk_progress_bar_pulse(pb);
 119     }
 120     return TRUE;
 121 }
 122
 123 /* this function doesnt use the start/stop_mpd_action because it the user doesnt want to see that */
 124
 125 int update_mpd_status(void)
 126 {
 127     if (!mpd_check_connected(connection))
 128         return TRUE;
 129     mpd_status_update(connection);
 130
 131     return TRUE;
 132 }
 133
 134 static int connected_to_mpd(mpd_Connection * mpd_conn)
 135 {
 136     gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "pl3_progressbar")));
 137     g_source_remove(connecting_pulse);
 138     connecting_pulse = 0;
 139     g_mutex_unlock(connecting_lock);
 140     if (connection)
 141     {
 142         mpd_connect_real(connection, mpd_conn);
 143     }
 144
 145     return FALSE;
 146 }
 147
 148 static void connection_thread(void)
 149 {
 150     gchar * hostname = connection_get_hostname();
 151     mpd_Connection *conn = mpd_newConnection(hostname, connection_get_port(), cfg_get_single_value_as_float_with_default(config, "connection", "timeout", DEFAULT_TIMEOUT));
 152     g_free(hostname);
 153
 154     g_idle_add((GSourceFunc) connected_to_mpd, conn);
 155     return;
 156 }
 157
 158 /* the functiont that connects to mpd */
 159 int connect_to_mpd(void)
 160 {
 161     char *string = NULL;
 162     if (connecting_lock == NULL)
 163     {
 164         connecting_lock = g_mutex_new();
 165     }
 166     if (! /*G_TRYLOCK */ g_mutex_trylock(connecting_lock))
 167     {
 168         return FALSE;
 169     }
 170     /**
 171      * Set Hostname
 172      */
 173     string = connection_get_hostname();
 174     mpd_set_hostname(connection, string);
 175     g_free(string);
 176     /**
 177      * Set port
 178      */
 179     mpd_set_port(connection, connection_get_port());
 180     /**
 181      * Timeout
 182      */
 183     mpd_set_connection_timeout(connection,
 184                                cfg_get_single_value_as_float_with_default(config, "connection", "timeout",
 185                                                                           DEFAULT_TIMEOUT));
 186
 187     if (connection_use_auth())
 188     {
 189         string = connection_get_password();
 190         mpd_set_password(connection, string);
 191         g_free(string);
 192     } else
 193     {
 194         mpd_set_password(connection, "");
 195     }
 196     g_thread_create((GThreadFunc) connection_thread, NULL, FALSE, NULL);
 197     connecting_pulse = g_timeout_add(200, (GSourceFunc) (connecting_pulse_callback), NULL);
 198     gtk_progress_bar_set_text(GTK_PROGRESS_BAR(gtk_builder_get_object(pl3_xml, "pl3_progressbar")), _("Connecting"));
 199     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "pl3_progressbar")));
 200
 201     /* Set the title
 202        update_mpd_status();
 203        mpd_stats_update(connection);
 204      */
 205     /* set that user wants to connect */
 206     gmpc_connected = TRUE;
 207
 208     return FALSE;
 209 }
 210
 211 /******************************************************
 212  * PLAYER FUNCTIONS
 213  */
 214
 215 /* the normal play functions, stop, play, next, prev */
 216 /* returns FALSE when everything went ok */
 217 int next_song(void)
 218 {
 219     if (mpd_server_check_command_allowed(connection, "next") == MPD_SERVER_COMMAND_ALLOWED)
 220     {
 221         mpd_player_next(connection);
 222     }
 223     return FALSE;
 224 }
 225
 226 int prev_song(void)
 227 {
 228     if (mpd_server_check_command_allowed(connection, "previous") == MPD_SERVER_COMMAND_ALLOWED)
 229         mpd_player_prev(connection);
 230     return FALSE;
 231 }
 232
 233 int stop_song(void)
 234 {
 235     if (mpd_server_check_command_allowed(connection, "stop") == MPD_SERVER_COMMAND_ALLOWED)
 236         mpd_player_stop(connection);
 237     return FALSE;
 238 }
 239
 240 int
 241 pause_song(void)
 242 {
 243     if (
 244         mpd_check_connected(connection) &&
 245         mpd_server_check_command_allowed(connection, "pause") == MPD_SERVER_COMMAND_ALLOWED)
 246         mpd_player_pause(connection);
 247     return FALSE;
 248 }
 249
 250 int real_play_song(void)
 251 {
 252     if (mpd_server_check_command_allowed(connection, "play") == MPD_SERVER_COMMAND_ALLOWED)
 253         mpd_player_play(connection);
 254     return FALSE;
 255 }
 256
 257 int real_pause_song(void)
 258 {
 259     int state = mpd_player_get_state(connection);
 260     if (state == MPD_PLAYER_PLAY)
 261     {
 262         if (mpd_server_check_command_allowed(connection, "pause") == MPD_SERVER_COMMAND_ALLOWED)
 263             mpd_player_pause(connection);
 264     }
 265     return FALSE;
 266 }
 267 int play_song(void)
 268 {
 269     int state = mpd_player_get_state(connection);
 270     if (state == MPD_PLAYER_STOP)
 271     {
 272         if (mpd_server_check_command_allowed(connection, "play") == MPD_SERVER_COMMAND_ALLOWED)
 273             mpd_player_play(connection);
 274     } else if (state == MPD_PLAYER_PAUSE || state == MPD_PLAYER_PLAY)
 275     {
 276         if (mpd_server_check_command_allowed(connection, "pause") == MPD_SERVER_COMMAND_ALLOWED)
 277             mpd_player_pause(connection);
 278     }
 279     return FALSE;
 280 }
 281
 282 void random_pl(GtkToggleButton * tb)
 283 {
 284     if (gtk_toggle_button_get_active(tb) != mpd_player_get_random(connection))
 285         mpd_player_set_random(connection, !mpd_player_get_random(connection));
 286 }
 287
 288 void repeat_pl(GtkToggleButton * tb)
 289 {
 290     if (gtk_toggle_button_get_active(tb) != mpd_player_get_repeat(connection))
 291         mpd_player_set_repeat(connection, !mpd_player_get_repeat(connection));
 292 }
 293
 294 int seek_ps(int n)
 295 {
 296     if (mpd_server_check_command_allowed(connection, "seek") == MPD_SERVER_COMMAND_ALLOWED)
 297         mpd_player_seek(connection, mpd_status_get_elapsed_song_time(connection) + n);
 298     return FALSE;
 299 }
 300
 301 int seek_ns(int n)
 302 {
 303     return seek_ps(-n);
 304 }
 305
 306 void song_fastforward(void)
 307 {
 308     seek_ps(1);
 309 }
 310
 311 void song_fastbackward(void)
 312 {
 313     seek_ps(-1);
 314 }
 315
 316 void repeat_toggle(void)
 317 {
 318     mpd_player_set_repeat(connection, !mpd_player_get_repeat(connection));
 319 }
 320
 321 void repeat_single_toggle(void)
 322 {
 323     mpd_player_set_single(connection, !mpd_player_get_single(connection));
 324 }
 325
 326 void consume_toggle(void)
 327 {
 328     mpd_player_set_consume(connection, !mpd_player_get_consume(connection));
 329 }
 330
 331 void random_toggle(void)
 332 {
 333     mpd_player_set_random(connection, !mpd_player_get_random(connection));
 334 }
 335
 336 void volume_up(void)
 337 {
 338     mpd_status_set_volume(connection, mpd_status_get_volume(connection) + 5);
 339 }
 340
 341 void volume_down(void)
 342 {
 343     mpd_status_set_volume(connection, mpd_status_get_volume(connection) - 5);
 344 }
 345
 346 void volume_mute(void)
 347 {
 348     mpd_status_set_volume(connection, 0);
 349 }
 350
 351 void volume_unmute(void)
 352 {
 353     if (mpd_status_get_volume(connection) == 0)
 354         mpd_status_set_volume(connection, current_volume);
 355 }
 356
 357 void volume_toggle_mute(void)
 358 {
 359     if (current_volume > 0 && mpd_status_get_volume(connection) == 0)
 360     {
 361         mpd_status_set_volume(connection, current_volume);
 362     } else
 363     {
 364         mpd_status_set_volume(connection, 0);
 365     }
 366 }
 367
 368 /*****************************************************************
 369  * Preferences
 370  */
 371 static void outputs_toggled(GtkCellRendererToggle * cell, gchar * path_str, GtkTreeView * view)
 372 {
 373     gboolean state;
 374     gint id;
 375     GtkTreeIter iter;
 376     GtkTreeModel *model = gtk_tree_view_get_model(view);
 377     GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
 378
 379     if (gtk_tree_model_get_iter(model, &iter, path))
 380     {
 381         gtk_tree_model_get(model, &iter, ENABLED_COL, &state, ID_COL, &id, -1);
 382         state = !state;
 383         mpd_server_set_output_device(connection, id, state);
 384
 385         gtk_list_store_set(GTK_LIST_STORE(model), &iter, ENABLED_COL, state, -1);
 386     }
 387     gtk_tree_path_free(path);
 388 }
 389
 390 static void create_outputs_tree(void)
 391 {
 392     GtkListStore *model;
 393     GtkCellRenderer *cell;
 394     GtkTreeViewColumn *col;
 395     GtkTreeView *tree;
 396
 397     tree = GTK_TREE_VIEW(gtk_builder_get_object(server_pref_xml, "tv_outputs"));
 398     model = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT);
 399     gtk_tree_view_set_model(tree, GTK_TREE_MODEL(model));
 400     g_object_unref(G_OBJECT(model));
 401
 402     cell = gtk_cell_renderer_toggle_new();
 403     col = gtk_tree_view_column_new();
 404     gtk_tree_view_column_pack_start(col, cell, TRUE);
 405     gtk_tree_view_column_add_attribute(col, cell, "active", 0);
 406     gtk_tree_view_column_set_title(col, "Enabled");
 407     gtk_tree_view_append_column(tree, col);
 408     g_signal_connect(G_OBJECT(cell), "toggled", G_CALLBACK(outputs_toggled), tree);
 409
 410     cell = gtk_cell_renderer_text_new();
 411     col = gtk_tree_view_column_new();
 412     gtk_tree_view_column_pack_start(col, cell, TRUE);
 413     gtk_tree_view_column_add_attribute(col, cell, "text", 1);
 414     gtk_tree_view_column_set_title(col, "Name");
 415     gtk_tree_view_append_column(tree, col);
 416
 417     col = gtk_tree_view_column_new();
 418     gtk_tree_view_column_set_visible(col, FALSE);
 419     gtk_tree_view_append_column(tree, col);
 420 }
 421
 422 static void update_outputs_settings(void)
 423 {
 424     GtkTreeIter iter;
 425     GtkListStore *store;
 426     GtkFrame *frame;
 427
 428     frame = GTK_FRAME(gtk_builder_get_object(server_pref_xml, "frm_outputs"));
 429     store =
 430         GTK_LIST_STORE(gtk_tree_view_get_model
 431                        (GTK_TREE_VIEW(gtk_builder_get_object(server_pref_xml, "tv_outputs"))));
 432     gtk_list_store_clear(store);
 433     if (mpd_check_connected(connection) && mpd_server_check_version(connection, 0, 12, 0))
 434     {
 435         MpdData *data = mpd_server_get_output_devices(connection);
 436         while (data != NULL && data->output_dev->id != -10)
 437         {
 438             gtk_list_store_append(store, &iter);
 439             gtk_list_store_set(store, &iter,
 440                                0, data->output_dev->enabled ? TRUE : FALSE,
 441                                1, data->output_dev->name, 2, data->output_dev->id, -1);
 442             data = mpd_data_get_next(data);
 443         }
 444         gtk_widget_set_sensitive(GTK_WIDGET(frame), TRUE);
 445         gtk_widget_show_all(GTK_WIDGET(frame));
 446     } else
 447     {
 448         gtk_widget_set_sensitive(GTK_WIDGET(frame), FALSE);
 449     }
 450 }
 451
 452 void xfade_enable_toggled(GtkToggleButton * but)
 453 {
 454
 455     int bool1 = gtk_toggle_button_get_active(but);
 456     gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "sb_fade_time")), bool1);
 457     if (bool1)
 458     {
 459         int fade_time =
 460             gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
 461                                              (gtk_builder_get_object(server_pref_xml, "sb_fade_time")));
 462         mpd_status_set_crossfade(connection, fade_time);
 463     } else
 464     {
 465         mpd_status_set_crossfade(connection, 0);
 466     }
 467 }
 468
 469 void xfade_time_changed(GtkSpinButton * but)
 470 {
 471     int fade_time =
 472         gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
 473                                          (gtk_builder_get_object(server_pref_xml, "sb_fade_time")));
 474     if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(server_pref_xml, "cb_fading"))))
 475     {
 476         return;
 477     }
 478     mpd_status_set_crossfade(connection, fade_time);
 479 }
 480
 481 static void xfade_update(void)
 482 {
 483     if (mpd_status_get_crossfade(connection) > 0)
 484     {
 485         gtk_spin_button_set_value(GTK_SPIN_BUTTON(gtk_builder_get_object(server_pref_xml, "sb_fade_time")),
 486                                   mpd_status_get_crossfade(connection));
 487     }
 488     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(server_pref_xml, "cb_fading")),
 489                                  mpd_status_get_crossfade(connection) ? TRUE : FALSE);
 490
 491     gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "sb_fade_time")),
 492                              (mpd_status_get_crossfade(connection)) ? TRUE : FALSE);
 493
 494 }
 495
 496 /**
 497  * Helper functions
 498  */
 499 void play_path(const gchar * path)
 500 {
 501     if (path)
 502     {
 503         if (mpd_server_check_command_allowed(connection, "playlistfind") == MPD_SERVER_COMMAND_ALLOWED)
 504         {
 505             MpdData *data = NULL;
 506             mpd_playlist_search_start(connection, TRUE);
 507             mpd_playlist_search_add_constraint(connection, MPD_TAG_ITEM_FILENAME, path);
 508             data = mpd_playlist_search_commit(connection);
 509             if (data)
 510             {
 511                 mpd_player_play_id(connection, data->song->id);
 512                 mpd_data_free(data);
 513                 return;
 514             }
 515         }
 516         if (mpd_server_check_command_allowed(connection, "addid") == MPD_SERVER_COMMAND_ALLOWED)
 517         {
 518             int songid = mpd_playlist_add_get_id(connection, (gchar *) path);
 519             if (songid >= 0)
 520             {
 521                 mpd_player_play_id(connection, songid);
 522             }
 523         }
 524     }
 525 }
 526
 527 void add_artist(const gchar * artist)
 528 {
 529     MpdData *data = NULL;
 530     /* Check artist */
 531     g_return_if_fail(artist != NULL);
 532
 533     mpd_database_search_start(connection, TRUE);
 534     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ARTIST, artist);
 535     data = mpd_database_search_commit(connection);
 536     if (data)
 537     {
 538         data = misc_sort_mpddata_by_album_disc_track(data);
 539         for (; data; data = mpd_data_get_next(data))
 540         {
 541             mpd_playlist_queue_add(connection, data->song->file);
 542         }
 543         mpd_playlist_queue_commit(connection);
 544     }
 545 }
 546
 547 void add_album(const gchar * artist, const gchar * album)
 548 {
 549     MpdData *data = NULL;
 550     /* Check artist */
 551     g_return_if_fail(artist != NULL);
 552     g_return_if_fail(album != NULL);
 553
 554     mpd_database_search_start(connection, TRUE);
 555     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ARTIST, artist);
 556     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, album);
 557     data = mpd_database_search_commit(connection);
 558     if (data)
 559     {
 560         data = misc_sort_mpddata_by_album_disc_track(data);
 561         for (; data; data = mpd_data_get_next(data))
 562         {
 563             mpd_playlist_queue_add(connection, data->song->file);
 564         }
 565         mpd_playlist_queue_commit(connection);
 566     }
 567 }
 568
 569 void add_genre(const gchar * genre)
 570 {
 571     MpdData *data = NULL;
 572     /* Check artist */
 573     g_return_if_fail(genre != NULL);
 574
 575     mpd_database_search_start(connection, TRUE);
 576     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_GENRE, genre);
 577     data = mpd_database_search_commit(connection);
 578     if (data)
 579     {
 580         data = misc_sort_mpddata_by_album_disc_track(data);
 581         for (; data; data = mpd_data_get_next(data))
 582         {
 583             mpd_playlist_queue_add(connection, data->song->file);
 584         }
 585         mpd_playlist_queue_commit(connection);
 586     }
 587 }
 588
 589 void add_directory(const gchar * path)
 590 {
 591     gchar *dirpath = g_path_get_dirname(path);
 592     MpdData *data = mpd_database_get_directory(connection, dirpath);
 593     if(data)
 594     {
 595         data = misc_sort_mpddata_by_album_disc_track(data);
 596         for (; data; data = mpd_data_get_next(data))
 597         {
 598             if (data->type == MPD_DATA_TYPE_SONG)
 599             {
 600                 mpd_playlist_queue_add(connection, data->song->file);
 601             }
 602         }
 603         mpd_playlist_queue_commit(connection);
 604     }
 605     g_free(dirpath);
 606 }
 607
 608 void ServerStatusChangedCallback(MpdObj * mi, ChangedStatusType what, void *userdata)
 609 {
 610     if (what & MPD_CST_VOLUME)
 611     {
 612         int volume = mpd_status_get_volume(connection);
 613         if (volume)
 614             current_volume = volume;
 615     }
 616
 617     if (!server_pref_xml)
 618         return;
 619     if (what & MPD_CST_CROSSFADE)
 620     {
 621         xfade_update();
 622     }
 623     if (what & MPD_CST_OUTPUT)
 624     {
 625         update_outputs_settings();
 626     }
 627     if (what & MPD_CST_REPLAYGAIN)
 628     {
 629         if (server_pref_xml)
 630         {
 631             gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_builder_get_object(server_pref_xml, "replay_gain_combo")),
 632                                      mpd_server_get_replaygain_mode(connection));
 633         }
 634     }
 635 }
 636
 637 static void server_pref_destroy(GtkWidget * container)
 638 {
 639     if (server_pref_xml)
 640     {
 641         GtkWidget *vbox = GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "server-vbox"));
 642         gtk_container_remove(GTK_CONTAINER(container), vbox);
 643         g_object_unref(server_pref_xml);
 644         server_pref_xml = NULL;
 645     }
 646 }
 647
 648 void server_pref_replaygain_changed(GtkComboBox * combo, gpointer data)
 649 {
 650     unsigned int cur = gtk_combo_box_get_active(combo);
 651     if (cur != mpd_server_get_replaygain_mode(connection))
 652     {
 653         if (mpd_server_check_command_allowed(connection, "replay_gain_mode") == MPD_SERVER_COMMAND_ALLOWED)
 654         {
 655             mpd_server_set_replaygain_mode(connection, cur);
 656         }
 657     }
 658
 659 }
 660
 661 static void server_pref_construct(GtkWidget * container)
 662 {
 663     gchar *path = gmpc_get_full_glade_path("preferences-server.ui");
 664     server_pref_xml = gtk_builder_new();
 665     gtk_builder_add_from_file(server_pref_xml, path, NULL);
 666     q_free(path);
 667
 668     if (server_pref_xml)
 669     {
 670         GtkWidget *vbox = GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "server-vbox"));
 671         GtkWidget *frame = GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "replay_gain_frame"));
 672         create_outputs_tree();
 673         update_outputs_settings();
 674         if (!mpd_check_connected(connection))
 675         {
 676             gtk_widget_set_sensitive(vbox, FALSE);
 677             gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "hb_warning_mesg")));
 678         } else
 679         {
 680             gtk_widget_set_sensitive(vbox, TRUE);
 681             gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "hb_warning_mesg")));
 682         }
 683         switch (mpd_server_check_command_allowed(connection, "replay_gain_status"))
 684         {
 685         case MPD_SERVER_COMMAND_ALLOWED:
 686             {
 687                 gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_builder_get_object(server_pref_xml, "replay_gain_combo")),
 688                                          mpd_server_get_replaygain_mode(connection));
 689                 switch (mpd_server_check_command_allowed(connection, "replay_gain_mode"))
 690                 {
 691                 case MPD_SERVER_COMMAND_ALLOWED:
 692                     break;
 693                 default:
 694                     gtk_widget_set_sensitive(frame, FALSE);
 695                     break;
 696                 }
 697                 break;
 698             }
 699         case MPD_SERVER_COMMAND_NOT_ALLOWED:
 700             gtk_widget_set_sensitive(frame, FALSE);
 701             break;
 702         case MPD_SERVER_COMMAND_NOT_SUPPORTED:
 703         default:
 704             gtk_widget_hide(frame);
 705         }
 706
 707         if (mpd_status_get_crossfade(connection) == 0)
 708         {
 709             gtk_toggle_button_set_active(
 710                                          GTK_TOGGLE_BUTTON(gtk_builder_get_object(server_pref_xml, "cb_fading")), FALSE);
 711             gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "sb_fade_time")), FALSE);
 712         } else
 713         {
 714             gtk_toggle_button_set_active(
 715                                         GTK_TOGGLE_BUTTON(gtk_builder_get_object(server_pref_xml, "cb_fading")), TRUE);
 716             gtk_spin_button_set_value(GTK_SPIN_BUTTON(gtk_builder_get_object(server_pref_xml, "sb_fade_time")),
 717                                       mpd_status_get_crossfade(connection));
 718             gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(server_pref_xml, "sb_fade_time")), TRUE);
 719
 720         }
 721         gtk_container_add(GTK_CONTAINER(container), vbox);
 722         //      glade_xml_signal_autoconnect(server_pref_xml);
 723         gtk_builder_connect_signals(server_pref_xml, NULL);
 724     }
 725 }
 726
 727 /**************************************************
 728  * Connection Preferences *
 729  */
 730 static void gmpc_profiles_changed_pref_win(GmpcProfiles * prof, GmpcProfilesAction changed, GmpcProfilesColumn col, const char *id,
 731                                            GtkBuilder * xml)
 732 {
 733     switch (changed)
 734     {
 735         case GMPC_PROFILES_ACTION_ADDED:
 736         {
 737             GtkComboBox *combo = GTK_COMBO_BOX(gtk_builder_get_object(xml, "cb_profiles"));
 738             GtkTreeIter iter;
 739             const char *name = gmpc_profiles_get_name(prof, id);
 740             GtkTreeModel *store = gtk_combo_box_get_model(combo);
 741             gtk_list_store_append(GTK_LIST_STORE(store), &iter);
 742             gtk_list_store_set(GTK_LIST_STORE(store), &iter, 0, id, 1, name, -1);
 743             break;
 744         }
 745         case GMPC_PROFILES_ACTION_REMOVED:
 746             /* TODO: */
 747             break;
 748         case GMPC_PROFILES_ACTION_COL_CHANGED:
 749         {
 750             GtkTreeIter iter;
 751             GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(xml, "cb_profiles");
 752             GtkListStore *store = (GtkListStore *) gtk_combo_box_get_model(combo);
 753             /* tell it to update all the information in the view.
 754              * might be to much work, so check id*/
 755             gchar *uid;
 756             if (gtk_combo_box_get_active_iter(combo, &iter) && id)
 757             {
 758
 759                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, -1);
 760                 if (strcmp(uid, id) == 0)
 761                 {
 762                     connection_profiles_changed(combo, NULL);
 763                 }
 764                 g_free(uid);
 765             }
 766             break;
 767         }
 768         default:
 769             break;
 770     }
 771 }
 772
 773 static void gmpc_connection_changed_pref_win(GmpcConnection * object, MpdObj * mi, int connected, GtkBuilder * xml)
 774 {
 775     if (connected != mpd_check_connected(mi))
 776         return;
 777     if (!connected)
 778     {
 779         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "bt_con"), TRUE);
 780         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "bt_dis"), FALSE);
 781     } else
 782     {
 783         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "bt_con"), FALSE);
 784         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "bt_dis"), TRUE);
 785     }
 786 }
 787
 788 void entry_auth_changed(GtkEntry * entry)
 789 {
 790     GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(connection_pref_xml, "connection-vbox");
 791     gulong *a = g_object_get_data(G_OBJECT(vbox), "profile-signal-handler");
 792     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 793     GtkTreeIter iter;
 794     GtkListStore *store = (GtkListStore *) gtk_combo_box_get_model(combo);
 795     if (gtk_combo_box_get_active_iter(combo, &iter))
 796     {
 797         gchar *value = NULL, *uid = NULL;
 798         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
 799         g_signal_handler_block(G_OBJECT(gmpc_profiles), *a);
 800         gmpc_profiles_set_password(gmpc_profiles, uid,
 801                                    (char *)
 802                                    gtk_entry_get_text(GTK_ENTRY
 803                                                       ((GtkWidget *)
 804                                                        gtk_builder_get_object(connection_pref_xml, "entry_auth"))));
 805         g_signal_handler_unblock(G_OBJECT(gmpc_profiles), *a);
 806         q_free(uid);
 807         q_free(value);
 808     }
 809 }
 810
 811 void auth_enable_toggled(GtkToggleButton * but)
 812 {
 813     GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(connection_pref_xml, "connection-vbox");
 814     gulong *a = g_object_get_data(G_OBJECT(vbox), "profile-signal-handler");
 815     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 816     GtkTreeIter iter;
 817     GtkTreeModel *store = gtk_combo_box_get_model(combo);
 818     if (gtk_combo_box_get_active_iter(combo, &iter))
 819     {
 820         char *value = NULL, *uid = NULL;
 821         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
 822         g_signal_handler_block(G_OBJECT(gmpc_profiles), *a);
 823
 824         gmpc_profiles_set_do_auth(gmpc_profiles, uid, gtk_toggle_button_get_active(but));
 825         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "entry_auth"),
 826                                  gmpc_profiles_get_do_auth(gmpc_profiles, uid));
 827
 828         g_signal_handler_unblock(G_OBJECT(gmpc_profiles), *a);
 829         q_free(uid);
 830         q_free(value);
 831     }
 832 }
 833
 834 void update_preferences_name(GtkWidget * entry)
 835 {
 836     GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(connection_pref_xml, "connection-vbox");
 837     gulong *a = g_object_get_data(G_OBJECT(vbox), "profile-signal-handler");
 838     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 839     GtkTreeIter iter;
 840     GtkTreeModel *store = gtk_combo_box_get_model(combo);
 841     if (gtk_combo_box_get_active_iter(combo, &iter))
 842     {
 843         char *value = NULL, *uid = NULL;
 844         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
 845         g_signal_handler_block(G_OBJECT(gmpc_profiles), *a);
 846
 847         gmpc_profiles_set_name(gmpc_profiles, uid,
 848                                (char *)
 849                                gtk_entry_get_text(GTK_ENTRY
 850                                                   ((GtkWidget *)
 851                                                    gtk_builder_get_object(connection_pref_xml, "name_entry"))));
 852         g_signal_handler_unblock(G_OBJECT(gmpc_profiles), *a);
 853
 854         q_free(uid);
 855         q_free(value);
 856         value =
 857             (char *)
 858             gtk_entry_get_text(GTK_ENTRY((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "name_entry")));
 859         gtk_list_store_set(GTK_LIST_STORE(store), &iter, 1, value, -1);
 860     }
 861 }
 862
 863 G_MODULE_EXPORT void select_directory_dialog(GtkWidget *button)
 864 {
 865
 866     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 867     GtkTreeIter iter;
 868     GtkTreeModel *store = gtk_combo_box_get_model(combo);
 869
 870     if (gtk_combo_box_get_active_iter(combo, &iter))
 871     {
 872         GtkWidget *d = gtk_file_chooser_dialog_new(_("Select the music directory"),
 873                 GTK_WINDOW(gtk_widget_get_toplevel(button)),
 874                 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
 875                 GTK_STOCK_CANCEL,
 876                 GTK_RESPONSE_CANCEL,
 877                 GTK_STOCK_CLEAR,
 878                 GTK_RESPONSE_REJECT,
 879                 GTK_STOCK_OPEN,
 880                 GTK_RESPONSE_OK,NULL);
 881         const char *value = NULL; char *uid = NULL;
 882         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, -1);
 883         value = gmpc_profiles_get_music_directory(gmpc_profiles, uid);
 884         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(d), value);
 885         switch(gtk_dialog_run(GTK_DIALOG(d)))
 886         {
 887             case GTK_RESPONSE_REJECT:
 888                 gmpc_profiles_set_music_directory(gmpc_profiles, uid,(char *)"");
 889                 break;
 890             case GTK_RESPONSE_OK:
 891                 gmpc_profiles_set_music_directory(gmpc_profiles, uid,
 892                         gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(d)));
 893                         break;
 894             default:
 895                 break;
 896         }
 897         gtk_widget_destroy(d);
 898         g_free(uid);
 899     }
 900 }
 901
 902 void update_preferences_hostname(GtkWidget * entry)
 903 {
 904     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 905     GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(connection_pref_xml, "connection-vbox");
 906     gulong *a = g_object_get_data(G_OBJECT(vbox), "profile-signal-handler");
 907     GtkTreeIter iter;
 908     GtkTreeModel *store = gtk_combo_box_get_model(combo);
 909
 910     if (gtk_combo_box_get_active_iter(combo, &iter))
 911     {
 912         char *value = NULL, *uid = NULL;
 913         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
 914         g_signal_handler_block(G_OBJECT(gmpc_profiles), *a);
 915
 916         gmpc_profiles_set_hostname(gmpc_profiles, uid,
 917                                    (char *)
 918                                    gtk_entry_get_text(GTK_ENTRY
 919                                                       ((GtkWidget *)
 920                                                        gtk_builder_get_object(connection_pref_xml, "hostname_entry"))));
 921         g_signal_handler_unblock(G_OBJECT(gmpc_profiles), *a);
 922
 923         q_free(uid);
 924         q_free(value);
 925     }
 926 }
 927
 928 void update_preferences_portnumber(GtkWidget * wid)
 929 {
 930     GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(connection_pref_xml, "connection-vbox");
 931     gulong *a = g_object_get_data(G_OBJECT(vbox), "profile-signal-handler");
 932     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 933     GtkTreeIter iter;
 934     GtkTreeModel *store = gtk_combo_box_get_model(combo);
 935     if (gtk_combo_box_get_active_iter(combo, &iter))
 936     {
 937         char *value = NULL, *uid = NULL;
 938         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
 939         g_signal_handler_block(G_OBJECT(gmpc_profiles), *a);
 940         gmpc_profiles_set_port(gmpc_profiles, uid,
 941                                gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
 942                                                                 ((GtkWidget *)
 943                                                                  gtk_builder_get_object(connection_pref_xml,
 944                                                                                         "port_spin"))));
 945         g_signal_handler_unblock(G_OBJECT(gmpc_profiles), *a);
 946         q_free(uid);
 947         q_free(value);
 948     }
 949 }
 950
 951 void update_preferences_information(GtkWidget * wid)
 952 {
 953     cfg_set_single_value_as_float(config, "connection", "timeout",
 954                                   (float)
 955                                   gtk_spin_button_get_value(GTK_SPIN_BUTTON
 956                                                             ((GtkWidget *)
 957                                                              gtk_builder_get_object(connection_pref_xml,
 958                                                                                     "timeout_spin"))));
 959
 960     /* update timeout live */
 961     if (mpd_check_connected(connection))
 962     {
 963         mpd_set_connection_timeout(connection,
 964                                    (float)
 965                                    gtk_spin_button_get_value(GTK_SPIN_BUTTON
 966                                                              ((GtkWidget *)
 967                                                               gtk_builder_get_object(connection_pref_xml,
 968                                                                                      "timeout_spin"))));
 969     }
 970 }
 971
 972 void preferences_window_autoconnect(GtkToggleButton * tog)
 973 {
 974     cfg_set_single_value_as_int(config, "connection", "autoconnect", gtk_toggle_button_get_active(tog));
 975 }
 976
 977 void preferences_window_connect(GtkWidget * but)
 978 {
 979     if (connection_pref_xml)
 980     {
 981         GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(connection_pref_xml, "cb_profiles");
 982         GtkTreeIter iter;
 983         GtkTreeModel *store = gtk_combo_box_get_model(combo);
 984         if (gtk_combo_box_get_active_iter(combo, &iter))
 985         {
 986             char *uid = NULL;
 987             gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, -1);
 988             if (uid)
 989             {
 990                 connection_set_current_profile(uid);
 991                 if (!mpd_check_connected(connection))
 992                 {
 993                     connect_to_mpd();
 994                 }
 995                 q_free(uid);
 996             }
 997         }
 998     } else
 999     {
1000         if (!mpd_check_connected(connection))
1001         {
1002             connect_to_mpd();
1003         }
1004     }
1005 }
1006 void disconnect_from_mpd(void)
1007 {
1008     /* set that user doesn't want to connect */
1009     gmpc_connected = FALSE;
1010     mpd_disconnect(connection);
1011 }
1012 void preferences_window_disconnect(GtkWidget * but)
1013 {
1014     disconnect_from_mpd();
1015 }
1016
1017 static void connection_pref_destroy(GtkWidget * container)
1018 {
1019     GtkWidget *widget = gtk_bin_get_child(GTK_BIN(container));
1020     if (widget)
1021     {
1022         if (connection_pref_xml)
1023         {
1024             gtk_container_remove(GTK_CONTAINER(container), widget);
1025             g_object_unref(connection_pref_xml);
1026             connection_pref_xml = NULL;
1027         }
1028     }
1029 }
1030
1031 void connection_profiles_changed(GtkComboBox * combo, gpointer data)
1032 {
1033     GtkBuilder *xml = connection_pref_xml;
1034     GtkTreeIter iter;
1035     GtkTreeModel *store = gtk_combo_box_get_model(combo);
1036     if (gtk_combo_box_get_active_iter(combo, &iter))
1037     {
1038         char *value = NULL, *uid = NULL, *string;
1039         const gchar *md;
1040         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
1041
1042         /**
1043          * Set name
1044          */
1045         gtk_entry_set_text(GTK_ENTRY((GtkWidget *) gtk_builder_get_object(xml, "name_entry")), value);
1046         /**
1047          * Set hostname
1048          */
1049         string = g_strdup(gmpc_profiles_get_hostname(gmpc_profiles, uid));
1050         gtk_entry_set_text(GTK_ENTRY((GtkWidget *) gtk_builder_get_object(xml, "hostname_entry")), string);
1051         g_free(string);
1052         /**
1053          * Set port number
1054          */
1055         gtk_spin_button_set_value(GTK_SPIN_BUTTON((GtkWidget *) gtk_builder_get_object(xml, "port_spin")),
1056                                   gmpc_profiles_get_port(gmpc_profiles, uid));
1057
1058         /**
1059          * Set password check, and entry
1060          */
1061         string = gmpc_profiles_get_password(gmpc_profiles, uid);
1062         gtk_toggle_button_set_active((GtkToggleButton *)
1063                                      gtk_builder_get_object(xml, "ck_auth"),
1064                                      gmpc_profiles_get_do_auth(gmpc_profiles, uid));
1065         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "entry_auth"),
1066                                  gmpc_profiles_get_do_auth(gmpc_profiles, uid));
1067
1068         gtk_entry_set_text(GTK_ENTRY((GtkWidget *) gtk_builder_get_object(xml, "entry_auth")),
1069                            string);
1070         g_free(string);
1071
1072         /**
1073          * Set music directory
1074          */
1075         md = gmpc_profiles_get_music_directory(gmpc_profiles, uid);
1076         gtk_label_set_text(GTK_LABEL(gtk_builder_get_object(xml,"music_directory_label")), (md && md[0] != 0)?md:_("(None)"));
1077         /**
1078          * Only enable the rmeove button when there is more then 1 profile
1079          */
1080         if (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL) > 1)
1081         {
1082             gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "remove_butt"), TRUE);
1083         } else
1084         {
1085             gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(xml, "remove_butt"), FALSE);
1086         }
1087         q_free(value);
1088         q_free(uid);
1089     }
1090
1091 }
1092
1093 void connection_add_profile(GtkWidget * but)
1094 {
1095     gchar *value = NULL;
1096     GtkBuilder *xml = connection_pref_xml;
1097     GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(xml, "connection-vbox");
1098     gulong *a = g_object_get_data(G_OBJECT(vbox), "profile-signal-handler");
1099     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(xml, "cb_profiles");
1100     GtkTreeIter iter;
1101     GtkTreeModel *store = gtk_combo_box_get_model(combo);
1102
1103     g_signal_handler_block(G_OBJECT(gmpc_profiles), *a);
1104     value = gmpc_profiles_create_new_item(gmpc_profiles, NULL);    /*g_strdup_printf("%u", g_random_int()); */
1105     gtk_list_store_append(GTK_LIST_STORE(store), &iter);
1106     gtk_list_store_set(GTK_LIST_STORE(store), &iter, 0, value, 1, "Name", -1);
1107     gtk_combo_box_set_active_iter(GTK_COMBO_BOX((GtkWidget *) gtk_builder_get_object(xml, "cb_profiles")), &iter);
1108     g_signal_handler_unblock(G_OBJECT(gmpc_profiles), *a);
1109 }
1110
1111 void connection_remove_profile(GtkWidget * but)
1112 {
1113     GtkBuilder *xml = connection_pref_xml;
1114     GtkComboBox *combo = (GtkComboBox *) gtk_builder_get_object(xml, "cb_profiles");
1115     GtkTreeIter iter;
1116     GtkTreeModel *store = gtk_combo_box_get_model(combo);
1117     if (gtk_combo_box_get_active_iter(combo, &iter))
1118     {
1119         char *value = NULL, *uid = NULL;
1120         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &uid, 1, &value, -1);
1121         gmpc_profiles_remove_item(gmpc_profiles, uid);
1122         gtk_list_store_remove(GTK_LIST_STORE(store), &iter);
1123         q_free(uid);
1124         q_free(value);
1125         gtk_combo_box_set_active(GTK_COMBO_BOX((GtkWidget *) gtk_builder_get_object(xml, "cb_profiles")), 0);
1126     }
1127 }
1128
1129 static void destroy_profile_signal_handler(gpointer box)
1130 {
1131     gulong *a = box;
1132     g_signal_handler_disconnect(G_OBJECT(gmpc_profiles), *a);
1133     g_free(a);
1134 }
1135
1136 static void destroy_connection_signal_handler(gpointer box)
1137 {
1138     gulong *a = box;
1139     g_signal_handler_disconnect(G_OBJECT(gmpcconn), *a);
1140     g_free(a);
1141 }
1142
1143 static void connection_pref_construct(GtkWidget * container)
1144 {
1145     gulong *a;
1146     gchar *def_profile = NULL;
1147     GList *mult, *iter;
1148     GtkWidget *vbox = NULL;
1149     GtkCellRenderer *renderer = NULL;
1150     GtkListStore *store = NULL;
1151     gchar *path = gmpc_get_full_glade_path("preferences-connection.ui");
1152     connection_pref_xml = gtk_builder_new();    //glade_xml_new(path, "connection-vbox",NULL);
1153     gtk_builder_add_from_file(connection_pref_xml, path, NULL);
1154     q_free(path);
1155
1156     vbox = (GtkWidget *) gtk_builder_get_object(connection_pref_xml, "connection-vbox");
1157     /**
1158      * Profile selector
1159      * uid, name
1160      */
1161     def_profile = gmpc_profiles_get_current(gmpc_profiles);
1162     store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
1163     gtk_combo_box_set_model(GTK_COMBO_BOX((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "cb_profiles")),
1164                             GTK_TREE_MODEL(store));
1165     renderer = gtk_cell_renderer_text_new();
1166     gtk_cell_layout_pack_start(GTK_CELL_LAYOUT
1167                                ((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "cb_profiles")), renderer,
1168                                TRUE);
1169     gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT
1170                                    ((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "cb_profiles")), renderer,
1171                                    "text", 1, NULL);
1172
1173     mult = gmpc_profiles_get_profiles_ids(gmpc_profiles);
1174     if (mult)
1175     {
1176         int i = 0;
1177         iter = mult;
1178         do
1179         {
1180             GtkTreeIter piter;
1181             const gchar *value = gmpc_profiles_get_name(gmpc_profiles, (char *)iter->data);
1182             gtk_list_store_append(store, &piter);
1183             gtk_list_store_set(store, &piter, 0, iter->data, 1, value, -1);
1184             if (!strcmp((char *)(iter->data), def_profile))
1185             {
1186                 gtk_combo_box_set_active(GTK_COMBO_BOX
1187                                          ((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "cb_profiles")), i);
1188             }
1189             i++;
1190         } while ((iter = g_list_next(iter)));
1191         g_list_free(mult);
1192     } else
1193     {
1194         /*  GtkTreeIter piter;
1195            gchar *value = cfg_get_single_value_as_string_with_default(profiles, "Default", "name", "Default");
1196            gtk_list_store_append(store, &piter);
1197            gtk_list_store_set(store, &piter, 0,"Default", 1,value,-1);
1198            q_free(value);
1199            gtk_combo_box_set_active(GTK_COMBO_BOX((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "cb_profiles")),0);
1200          */
1201     }
1202     q_free(def_profile);
1203
1204     connection_profiles_changed(GTK_COMBO_BOX((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "cb_profiles")),
1205                                 NULL);
1206
1207     gtk_spin_button_set_value(GTK_SPIN_BUTTON
1208                               ((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "timeout_spin")),
1209                               (gdouble) cfg_get_single_value_as_float_with_default(config, "connection", "timeout",
1210                                                                                    DEFAULT_TIMEOUT));
1211     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1212                                  ((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "ck_autocon")),
1213                                  cfg_get_single_value_as_int_with_default(config, "connection", "autoconnect", DEFAULT_AUTOCONNECT));
1214
1215     /* set the right sensitive stuff */
1216     if (!mpd_check_connected(connection))
1217     {
1218         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "bt_con"), TRUE);
1219         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "bt_dis"), FALSE);
1220     } else
1221     {
1222         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "bt_con"), FALSE);
1223         gtk_widget_set_sensitive((GtkWidget *) gtk_builder_get_object(connection_pref_xml, "bt_dis"), TRUE);
1224     }
1225     gtk_container_add(GTK_CONTAINER(container), vbox);
1226     //glade_xml_signal_autoconnect(connection_pref_xml);
1227     gtk_builder_connect_signals(connection_pref_xml, NULL);
1228
1229     a = g_malloc0(sizeof(*a));
1230     *a = g_signal_connect(G_OBJECT(gmpc_profiles), "changed",
1231                           G_CALLBACK(gmpc_profiles_changed_pref_win), connection_pref_xml);
1232     g_object_set_data_full(G_OBJECT(vbox), "profile-signal-handler", a, destroy_profile_signal_handler);
1233
1234     a = g_malloc0(sizeof(*a));
1235     *a = g_signal_connect(G_OBJECT(gmpcconn), "connection-changed",
1236                           G_CALLBACK(gmpc_connection_changed_pref_win), connection_pref_xml);
1237     g_object_set_data_full(G_OBJECT(vbox), "conn-signal-handler", a, destroy_connection_signal_handler);
1238
1239 }
1240
1241 void connection_set_current_profile(const char *uid)
1242 {
1243     gmpc_profiles_set_current(gmpc_profiles, uid);
1244 }
1245
1246 void connection_set_password(char *password)
1247 {
1248     gchar *profile = gmpc_profiles_get_current(gmpc_profiles);
1249     /**
1250      * if NULL, or length 0, then disable, else set
1251      */
1252     if (password && password[0] != '\0')
1253     {
1254         gmpc_profiles_set_password(gmpc_profiles, profile, password);
1255         gmpc_profiles_set_do_auth(gmpc_profiles, profile, TRUE);
1256
1257     } else
1258     {
1259         gmpc_profiles_set_password(gmpc_profiles, profile, NULL);
1260         gmpc_profiles_set_do_auth(gmpc_profiles, profile, FALSE);
1261     }
1262     q_free(profile);
1263 }
1264
1265 int connection_use_auth(void)
1266 {
1267     int retv;
1268     gchar *profile = gmpc_profiles_get_current(gmpc_profiles);
1269     retv = gmpc_profiles_get_do_auth(gmpc_profiles, profile);
1270     q_free(profile);
1271     return retv;
1272 }
1273
1274 char *connection_get_hostname(void)
1275 {
1276     gchar *profile = gmpc_profiles_get_current(gmpc_profiles);
1277     gchar *retv = gmpc_profiles_get_hostname(gmpc_profiles, profile);
1278     g_free(profile);
1279
1280     return retv;
1281 }
1282
1283 int connection_get_port(void)
1284 {
1285     int retv;
1286     gchar *profile = gmpc_profiles_get_current(gmpc_profiles);
1287     retv = gmpc_profiles_get_port(gmpc_profiles, profile);
1288     q_free(profile);
1289     return retv;
1290 }
1291
1292 char *connection_get_password(void)
1293 {
1294     gchar *profile = gmpc_profiles_get_current(gmpc_profiles);
1295     gchar *retv = gmpc_profiles_get_password(gmpc_profiles, profile);
1296     g_free(profile);
1297     return retv;
1298 }
1299
1300 const char *connection_get_music_directory(void)
1301 {
1302     gchar *profile = gmpc_profiles_get_current(gmpc_profiles);
1303     const gchar *retv = gmpc_profiles_get_music_directory(gmpc_profiles, profile);
1304     g_free(profile);
1305     return retv;
1306 }
1307
1308 /**
1309  * Helper menu functions *
1310  */
1311 void submenu_artist_clicked(GtkWidget * item)
1312 {
1313     gchar *artist = g_object_get_data(G_OBJECT(item), "artist");
1314     add_artist(artist);
1315 }
1316
1317 void submenu_album_clicked(GtkWidget * item)
1318 {
1319     gchar *artist = g_object_get_data(G_OBJECT(item), "artist");
1320     gchar *album = g_object_get_data(G_OBJECT(item), "album");
1321     add_album(artist, album);
1322 }
1323
1324 void submenu_genre_clicked(GtkWidget * item)
1325 {
1326     gchar *genre = g_object_get_data(G_OBJECT(item), "genre");
1327     add_genre(genre);
1328 }
1329
1330 void submenu_dir_clicked(GtkWidget * item)
1331 {
1332     gchar *dir = g_object_get_data(G_OBJECT(item), "path");
1333     add_directory(dir);
1334 }
1335
1336 void submenu_for_song(GtkWidget * menu, mpd_Song * song)
1337 {
1338     GtkWidget *sitem;
1339     GtkWidget *item;
1340     GtkWidget *smenu;
1341     smenu = gtk_menu_new();
1342     if (song->file)
1343     {
1344         gchar *schema = g_uri_parse_scheme(song->file);
1345         /* If it has a schame, it isn't an mpd url */
1346         if (schema)
1347         {
1348             g_object_ref_sink(smenu);
1349             g_object_unref(smenu);
1350             g_free(schema);
1351             return;
1352         }
1353     }
1354     if (song->artist && song->album)
1355     {
1356         /* Add all from album */
1357         sitem = gtk_image_menu_item_new_with_label(_("All from album"));
1358         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(sitem),
1359                                       gtk_image_new_from_icon_name("media-album", GTK_ICON_SIZE_MENU));
1360         g_object_set_data_full(G_OBJECT(sitem), "artist", g_strdup(song->artist), g_free);
1361         g_object_set_data_full(G_OBJECT(sitem), "album", g_strdup(song->album), g_free);
1362         g_signal_connect(G_OBJECT(sitem), "activate", G_CALLBACK(submenu_album_clicked), NULL);
1363         gtk_menu_shell_append(GTK_MENU_SHELL(smenu), sitem);
1364         gtk_widget_show(sitem);
1365
1366     }
1367     if (song->artist)
1368     {
1369         /* Add all from artist */
1370         sitem = gtk_image_menu_item_new_with_label(_("All from artist"));
1371         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(sitem),
1372                                       gtk_image_new_from_icon_name("media-artist", GTK_ICON_SIZE_MENU));
1373         g_object_set_data_full(G_OBJECT(sitem), "artist", g_strdup(song->artist), g_free);
1374         g_signal_connect(G_OBJECT(sitem), "activate", G_CALLBACK(submenu_artist_clicked), NULL);
1375         gtk_menu_shell_append(GTK_MENU_SHELL(smenu), sitem);
1376         gtk_widget_show(sitem);
1377     }
1378     if (song->genre)
1379     {
1380         /* Add all from genre */
1381         sitem = gtk_menu_item_new_with_label(_("All from genre"));
1382         g_object_set_data_full(G_OBJECT(sitem), "genre", g_strdup(song->genre), g_free);
1383         g_signal_connect(G_OBJECT(sitem), "activate", G_CALLBACK(submenu_genre_clicked), NULL);
1384         gtk_menu_shell_append(GTK_MENU_SHELL(smenu), sitem);
1385         gtk_widget_show(sitem);
1386
1387     }
1388     /* Add all from file */
1389     sitem = gtk_image_menu_item_new_with_label(_("All from same directory"));
1390     gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(sitem),
1391                                   gtk_image_new_from_icon_name("gtk-directory", GTK_ICON_SIZE_MENU));
1392     g_object_set_data_full(G_OBJECT(sitem), "path", g_strdup(song->file), g_free);
1393     g_signal_connect(G_OBJECT(sitem), "activate", G_CALLBACK(submenu_dir_clicked), NULL);
1394     gtk_menu_shell_append(GTK_MENU_SHELL(smenu), sitem);
1395     gtk_widget_show(sitem);
1396     /* Create sub menu */
1397     /* Add */
1398     item = gtk_menu_item_new_with_label(_("Add more"));
1399     gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), smenu);
1400     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1401     gtk_widget_show(item);
1402
1403     gtk_widget_show(smenu);
1404
1405 }
1406
1407 /* vim: set noexpandtab ts=4 sw=4 sts=4 tw=120: */