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