src/playlist3.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 <gtk/gtk.h>
  21 #include <gdk/gdkkeysyms.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <config.h>
  25 #include "main.h"
  26 #include "plugin.h"
  27 #include "misc.h"
  28 #include "playlist3.h"
  29 #include "preferences.h"
  30 #include "revision.h"
  31 #include "gmpc-metaimage.h"
  32 #include "gmpc-extras.h"
  33 #include "GUI/cmd.h"
  34 #include "GUI/status_icon.h"
  35 #include "GUI/title_header.h"
  36 #include "GUI/control_window.h"
  37
  38 #define ALBUM_SIZE 42
  39
  40 #define LOG_DOMAIN "Playlist"
  41
  42 /* Drag and drop Target table */
  43 static GtkTargetEntry target_table[] =
  44 {
  45     {(gchar *) "x-url/http", 0, 0},
  46     {(gchar *) "_NETSCAPE_URL", 0, 1},
  47     {(gchar *) "text/uri-list", 0, 2},
  48     {(gchar *) "audio/*", 0, 3},
  49     {(gchar *) "audio/x-scpls", 0, 4},
  50     {(gchar *) "internal-drop", 0, 99}
  51 };
  52
  53 GtkWidget *metaimage_album_art = NULL;
  54 GtkWidget *metaimage_artist_art = NULL;
  55 GmpcFavoritesButton *favorites_button = NULL;
  56
  57 GtkCellRenderer *sidebar_text = NULL;
  58 /**
  59  * Widgets used in the header.
  60  * and the new progresbar
  61  */
  62 static GtkWidget *new_pb = NULL;
  63
  64 /**
  65  * Indicates the zoom level and the previous zoom level.
  66  */
  67 int pl3_zoom = PLAYLIST_NO_ZOOM;
  68 int pl3_old_zoom = PLAYLIST_NO_ZOOM;
  69
  70 static void playlist_zoom_level_changed(void);
  71 void playlist_zoom_in(void);
  72 void playlist_zoom_out(void);
  73
  74
  75 void pl3_pb_seek_event(GtkWidget * pb, guint seek_time, gpointer user_data);
  76
  77 void set_browser_format(void);
  78 void set_playlist_format(void);
  79
  80 gboolean playlist_player_volume_changed(GtkWidget * vol_but, double new_vol);
  81
  82 /* Glade declarations, otherwise these would be static */
  83 void about_window(void);
  84 int pl3_cat_tree_button_press_event(GtkTreeView *, GdkEventButton *);
  85 int pl3_cat_tree_button_release_event(GtkTreeView *, GdkEventButton *);
  86 int pl3_window_key_release_event(GtkWidget * mw, GdkEventKey * event);
  87
  88 void cur_song_center_enable_tb(GtkToggleButton *);
  89 void show_cover_case_tb(GtkToggleButton * but);
  90 void save_possize_enable_tb(GtkToggleButton *);
  91 void playlist_menu_repeat_changed(GtkToggleAction *);
  92 void playlist_menu_single_mode_changed(GtkToggleAction * );
  93 void playlist_menu_consume_changed(GtkToggleAction * );
  94
  95 void playlist_menu_random_changed(GtkToggleAction *);
  96 void playlist_menu_artist_image_changed(GtkToggleAction *);
  97 void hide_on_close_enable_tb(GtkToggleButton * but);
  98 gboolean pl3_close(void);
  99 static void pl3_update_profiles_menu(GmpcProfiles * prof, const int changed, const int col, const gchar * id);
 100 gboolean playlist3_enter_notify_event(GtkWidget * wid, GdkEventCrossing * event, gpointer data);
 101 gboolean playlist3_leave_notify_event(GtkWidget * wid, GdkEventCrossing * event, gpointer data);
 102 gboolean pl3_window_focus_out_event(GtkWidget *window, GdkEventFocus *event, gpointer data);
 103
 104 static void pl3_profiles_changed(GmpcProfiles * prof, const int changed, const int col, const gchar * id);
 105 static void playlist3_server_output_changed(GtkWidget * item, gpointer data);
 106 static void playlist3_fill_server_menu(void);
 107 void playlist3_server_update_db(void);
 108
 109 void easy_command_help_window(void);
 110
 111 void pl3_style_set_event(GtkWidget *widget, GtkStyle *previous_style, gpointer user_data);
 112
 113 void pl3_sidebar_plugins_init(void);
 114 static gboolean pl3_cat_select_function(GtkTreeSelection *select, GtkTreeModel *model, GtkTreePath *path, gboolean cur_select, gpointer data);
 115
 116 /* Old category browser style */
 117 static int old_type = -1;
 118
 119 /* interface description */
 120 GtkBuilder *pl3_xml = NULL;
 121 /* category treeview-store */
 122 GtkTreeModel *pl3_tree = NULL;
 123
 124 /* size */
 125 static GtkAllocation pl3_wsize = { 0, 0, 0, 0 };
 126
 127 static int pl3_hidden = TRUE;
 128
 129 static void playlist_status_changed(MpdObj * mi, ChangedStatusType what, void *userdata);
 130
 131 /* Playlist "Plugin" */
 132 static void playlist_pref_construct(GtkWidget * container);
 133 static void playlist_pref_destroy(GtkWidget * container);
 134
 135 static GtkBuilder *playlist_pref_xml = NULL;
 136
 137 void ck_search_as_you_type(GtkToggleButton * but);
 138
 139
 140 /* Get the type of the selected row..
 141  * -1 means no row selected
 142  */
 143 int pl3_cat_get_selected_browser(void)
 144 {
 145     return old_type;
 146 }
 147
 148
 149
 150
 151 /**
 152  * Extras for better integration
 153  */
 154
 155 void init_extra_playlist_state(void);
 156 void enable_extra_playlist(GtkToggleAction *action);
 157
 158 /**************************************************
 159  * Category Tree
 160  */
 161 static void pl3_initialize_tree(void)
 162 {
 163     int i;
 164     GtkTreePath *path;
 165     GtkTreeSelection *sel;
 166     GtkWidget *cat_tree = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "cat_tree"));
 167
 168     INIT_TIC_TAC()
 169
 170     path = gtk_tree_path_new_from_string("0");
 171     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtk_builder_get_object(pl3_xml, "cat_tree")));
 172     TEC("Get selection");
 173     for (i = 0; i < num_plugins; i++)
 174     {
 175         if (gmpc_plugin_is_browser(plugins[i]))
 176         {
 177             if (gmpc_plugin_get_enabled(plugins[i]))
 178             {
 179                 gmpc_plugin_browser_add(plugins[i], cat_tree);
 180             }
 181         }
 182         TEC("setup %s", gmpc_plugin_get_name(plugins[i]))
 183     }
 184
 185     gtk_tree_view_set_cursor(GTK_TREE_VIEW(gtk_builder_get_object(pl3_xml, "cat_tree")), path, NULL, FALSE);
 186     TEC("set cursor");
 187     gtk_tree_path_free(path);
 188     TEC("finish set");
 189 }
 190
 191
 192 /**
 193  * Function to handle a change in category.
 194  */
 195 static void pl3_cat_sel_changed(GtkTreeSelection * selec, gpointer * userdata)
 196 {
 197     GtkTreeView *tree = (GtkTreeView *) gtk_builder_get_object(pl3_xml, "cat_tree");
 198     GtkTreeModel *model = gtk_tree_view_get_model(tree);
 199     GtkTreeIter iter;
 200     GtkWidget *container = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "browser_container"));
 201     if (!model)
 202         return;
 203     if (gtk_tree_selection_get_selected(selec, &model, &iter))
 204     {
 205         gint type;
 206
 207         gtk_tree_model_get(model, &iter, PL3_CAT_TYPE, &type, -1);
 208
 209
 210         /**
 211          * Start switching side view (if type changed )
 212          */
 213         if (old_type != -1)
 214         {
 215             gmpc_plugin_browser_unselected(plugins[plugin_get_pos(old_type)], container);
 216         }
 217         old_type = -1;
 218         if(type > -1)
 219         {
 220             /** if type changed give a selected signal */
 221             if ((old_type != type))
 222             {
 223                 gmpc_plugin_browser_selected(plugins[plugin_get_pos(type)], container);
 224
 225             }
 226         }
 227         /**
 228          * update old value, so get_selected_category is correct before calling selection_changed
 229          */
 230         old_type = type;
 231
 232     } else
 233     {
 234         if (old_type != -1)
 235         {
 236             gmpc_plugin_browser_unselected(plugins[plugin_get_pos(old_type)], container);
 237         }
 238         old_type = -1;
 239         gtk_tree_model_get_iter_first(model, &iter);
 240         gtk_tree_selection_select_iter(selec, &iter);
 241     }
 242     pl3_option_menu_activate();
 243 }
 244
 245
 246 /* handle right mouse clicks on the cat tree view */
 247 /* gonna be a big function*/
 248 int pl3_cat_tree_button_press_event(GtkTreeView * tree, GdkEventButton * event)
 249 {
 250     GtkTreeSelection *sel = gtk_tree_view_get_selection(tree);
 251     if (event->button != 3 || gtk_tree_selection_count_selected_rows(sel) < 2 || !mpd_check_connected(connection))
 252     {
 253         return FALSE;
 254     }
 255     return TRUE;
 256
 257 }
 258
 259
 260 void pl3_option_menu_activate(void)
 261 {
 262
 263     GtkWidget *tree = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "cat_tree"));
 264     int i;
 265     gint type = pl3_cat_get_selected_browser();
 266     int menu_items = 0;
 267     GdkEventButton *event = NULL;
 268     GtkWidget *menu = NULL;
 269     GtkUIManager *ui = GTK_UI_MANAGER(gtk_builder_get_object(pl3_xml, "uimanager1"));
 270     GtkMenuItem *m_item = GTK_MENU_ITEM(gtk_ui_manager_get_widget(ui, "/menubartest/menu_option"));
 271
 272     //gtk_menu_item_set_submenu(m_item, NULL);
 273
 274     if (!mpd_check_connected(connection) || type == -1)
 275         return;
 276
 277     menu = gtk_menu_new();
 278
 279     for (i = 0; i < num_plugins; i++)
 280     {
 281         if (gmpc_plugin_is_browser(plugins[i]))
 282         {
 283             menu_items += gmpc_plugin_browser_cat_right_mouse_menu(plugins[i], menu, type, tree, event);
 284         }
 285     }
 286     if (menu_items)
 287     {
 288         gtk_widget_show_all(menu);
 289         gtk_menu_item_set_submenu(m_item, menu);
 290         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_option")), TRUE);
 291     } else
 292     {
 293         g_object_ref_sink(menu);
 294         g_object_unref(menu);
 295         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_option")), FALSE);
 296     }
 297
 298 }
 299
 300
 301 int pl3_cat_tree_button_release_event(GtkTreeView * tree, GdkEventButton * event)
 302 {
 303     int i;
 304     gint type = pl3_cat_get_selected_browser();
 305     int menu_items = 0;
 306     GtkWidget *menu = NULL;
 307
 308     if (type == -1 || !mpd_check_connected(connection) || event->button != 3)
 309     {
 310         /* no selections, or no usefull one.. so propagate the signal */
 311         return FALSE;
 312     }
 313
 314     menu = gtk_menu_new();
 315
 316     for (i = 0; i < num_plugins; i++)
 317     {
 318         if (gmpc_plugin_is_browser(plugins[i]))
 319         {
 320             menu_items += gmpc_plugin_browser_cat_right_mouse_menu(plugins[i], menu, type, GTK_WIDGET(tree), event);
 321         }
 322     }
 323
 324     if (menu_items)
 325     {
 326         gtk_widget_show_all(menu);
 327         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
 328             /*event->button */ 0, event->time);
 329     } else
 330     {
 331         g_object_ref_sink(menu);
 332         g_object_unref(menu);
 333     }
 334     return TRUE;
 335 }
 336
 337 void pl3_sidebar_plugins_init(void)
 338 {
 339     int i;
 340     for (i = 0; i < num_plugins; i++)
 341     {
 342         // This is implicitely done inside sidebar_init
 343 //        if (gmpc_plugin_is_sidebar(plugins[i]))
 344         {
 345             gmpc_plugin_sidebar_init(plugins[i]);
 346         }
 347     }
 348 }
 349
 350 /**********************************************************
 351  * MISC
 352  */
 353 static GtkWidget *control_window = NULL;
 354 static gboolean pl3_win_state_event(GtkWidget * window, GdkEventWindowState * event, gpointer data)
 355 {
 356     GtkWidget *vbox1 =  GTK_WIDGET(gtk_builder_get_object(pl3_xml, "vbox1"));
 357     GtkWidget *p = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "alignment1"));
 358     GtkWidget *h = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox1"));
 359     GtkWidget *b = (GTK_WIDGET(gtk_builder_get_object(pl3_xml, "menubartest")));
 360     if (((event->new_window_state) & GDK_WINDOW_STATE_FULLSCREEN))
 361     {
 362         if(control_window == NULL) {
 363             control_window = create_control_window(window);
 364             gtk_box_pack_start(GTK_BOX(vbox1), control_window, FALSE, FALSE, 0);
 365         }
 366         gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "sidebar")));
 367         gtk_widget_hide(p);
 368         gtk_widget_hide(h);
 369         gtk_widget_hide(b);
 370     } else if ((event->changed_mask) & GDK_WINDOW_STATE_FULLSCREEN)
 371     {
 372         control_window_destroy(control_window);
 373         control_window = NULL;
 374            playlist_zoom_level_changed();
 375         gtk_widget_show(p);
 376         gtk_widget_show(h);
 377         gtk_widget_show(b);
 378     }
 379     return FALSE;
 380 }
 381
 382 /**
 383  * This avoids the 'keybinding help' to become sticky when moving the window, or chainging
 384  * focus to other window.
 385  */
 386 gboolean pl3_window_focus_out_event(GtkWidget *window, GdkEventFocus *event, gpointer data)
 387 {
 388     return FALSE;
 389 }
 390
 391
 392 gboolean pl3_window_is_fullscreen(void)
 393 {
 394     GtkWidget *win = playlist3_get_window();
 395     GdkWindowState state = 0;
 396     if (gtk_widget_get_window(win))
 397         state = gdk_window_get_state(gtk_widget_get_window(win));
 398     return (state & GDK_WINDOW_STATE_FULLSCREEN) ? TRUE : FALSE;
 399 }
 400
 401
 402 gboolean pl3_window_fullscreen(void)
 403 {
 404     GtkWidget *win = playlist3_get_window();
 405
 406     if (pl3_zoom < PLAYLIST_MINI)
 407     {
 408         if (pl3_window_is_fullscreen())
 409         {
 410             gtk_window_unfullscreen(GTK_WINDOW(win));
 411         } else
 412         {
 413             gtk_window_fullscreen(GTK_WINDOW(win));
 414         }
 415     }
 416     return FALSE;
 417 }
 418
 419
 420 int pl3_window_key_release_event(GtkWidget * mw, GdkEventKey * event)
 421 {
 422     return FALSE;
 423 }
 424 static int  pl3_window_browser_cycle_backwards()
 425 {
 426     GtkWidget *cat_tree = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "cat_tree"));
 427     GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(cat_tree));
 428     GtkTreeIter iter;
 429     GtkTreeModel *model;
 430     if(gtk_tree_selection_get_selected(select, &model, &iter))
 431     {
 432         while(gtk_tree_model_iter_previous(model, &iter)) {
 433             GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 434             if(pl3_cat_select_function(select, model, path, FALSE,NULL)) {
 435                 gtk_tree_selection_select_iter(select, &iter);
 436                 gtk_tree_path_free(path);
 437                 return TRUE;
 438             }
 439             gtk_tree_path_free(path);
 440         }
 441         // Get last one
 442         gtk_tree_model_iter_nth_child(model, &iter, NULL,
 443                 gtk_tree_model_iter_n_children(model, NULL)-1);
 444         gtk_tree_selection_select_iter(select, &iter);
 445         return FALSE;
 446     }
 447 }
 448 static int  pl3_window_browser_cycle_forward()
 449 {
 450     GtkWidget *cat_tree = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "cat_tree"));
 451     GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(cat_tree));
 452     GtkTreeIter iter;
 453     GtkTreeModel *model;
 454     if(gtk_tree_selection_get_selected(select, &model, &iter))
 455     {
 456         while(gtk_tree_model_iter_next(model, &iter)) {
 457             GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 458             if(pl3_cat_select_function(select, model, path, FALSE,NULL)) {
 459                 gtk_tree_selection_select_iter(select, &iter);
 460                 gtk_tree_path_free(path);
 461                 return TRUE;
 462             }
 463             gtk_tree_path_free(path);
 464         }
 465         // Cycle to front.
 466         gtk_tree_model_get_iter_first(model, &iter);
 467         gtk_tree_selection_select_iter(select, &iter);
 468         return FALSE;
 469     }
 470     return FALSE;
 471 }
 472 int pl3_window_key_press_event(GtkWidget * mw, GdkEventKey * event)
 473 {
 474     int i = 0;
 475     gint type = pl3_cat_get_selected_browser();
 476     /**
 477      * Following key's are only valid when connected
 478      */
 479     if (!mpd_check_connected(connection))
 480     {
 481         return FALSE;
 482     }
 483     for (i = 0; i < num_plugins; i++)
 484     {
 485         if (gmpc_plugin_is_browser(plugins[i]))
 486         {
 487             gmpc_plugin_browser_key_press_event(plugins[i], mw, event, type);
 488         }
 489     }
 490     if(event->keyval == GDK_KEY_colon)
 491     {
 492         show_command_line();
 493         return TRUE;
 494     }
 495     else if (event->keyval == GDK_KEY_less &&
 496             (event->state&GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
 497         song_fastbackward();
 498     }
 499     else if (event->keyval == GDK_KEY_greater &&
 500             (event->state&GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
 501         song_fastforward();
 502     }
 503     else if(event->keyval == GDK_KEY_Tab && (event->state&GDK_CONTROL_MASK) > 0)
 504     {
 505         return pl3_window_browser_cycle_forward();
 506     }
 507     else if(event->keyval == GDK_KEY_ISO_Left_Tab && (event->state&GDK_CONTROL_MASK) > 0)
 508     {
 509         return pl3_window_browser_cycle_backwards();
 510     }
 511     if((event->state&GDK_MOD1_MASK) > 0)
 512     {
 513         guint kev = event->keyval;
 514         if(kev >= GDK_KEY_0 && kev <= GDK_KEY_9)
 515         {
 516             guint i_index = 0;
 517             GtkTreeIter iter;
 518             kev-=GDK_KEY_0;
 519             if (gtk_tree_model_get_iter_first(pl3_tree, &iter))
 520             {
 521                 if(kev == 0) kev+=10;
 522                 do{
 523                     gint new_type =0 ;
 524                     gtk_tree_model_get(pl3_tree, &iter, PL3_CAT_TYPE, &new_type, -1);
 525                     if(new_type >= 0) i_index++;
 526                     if(i_index == kev && new_type >= 0)
 527                     {
 528                         GtkWidget *cat_tree = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "cat_tree"));
 529                         GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(cat_tree));
 530
 531                         // if this is allready selected, do +10. this allows us to go up to 20 browsers.
 532                         if(new_type == old_type  && gtk_tree_selection_iter_is_selected(select, &iter)) {
 533                             kev+=10;
 534                         }else{
 535                             gtk_tree_selection_select_iter(select, &iter);
 536                             return TRUE;
 537                         }
 538                     }
 539                 }while(gtk_tree_model_iter_next(pl3_tree, &iter));
 540             }
 541         }
 542     }
 543
 544     /* don't propagate */
 545     return FALSE;
 546 }
 547
 548 /**
 549  * Close the playlist and save position/size
 550  */
 551 gboolean pl3_close(void)
 552 {
 553     /* only save when window is PLAYLIST_SMALL or NO ZOOM */
 554     if (pl3_xml != NULL)
 555     {
 556         GtkWidget *window = playlist3_get_window();
 557         int maximized = FALSE;
 558         if (gtk_widget_get_window(window))
 559         {
 560             GdkWindowState state = gdk_window_get_state(gtk_widget_get_window(window));
 561             maximized = ((state & GDK_WINDOW_STATE_MAXIMIZED) > 0);
 562         }
 563         cfg_set_single_value_as_int(config, "playlist", "maximized", maximized);
 564
 565         gtk_window_get_position(GTK_WINDOW(window), &pl3_wsize.x, &pl3_wsize.y);
 566
 567         cfg_set_single_value_as_int(config, "playlist", "xpos", pl3_wsize.x);
 568         cfg_set_single_value_as_int(config, "playlist", "ypos", pl3_wsize.y);
 569
 570         if (pl3_zoom <= PLAYLIST_SMALL)
 571         {
 572             gtk_window_get_size(GTK_WINDOW(window), &pl3_wsize.width, &pl3_wsize.height);
 573             g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "pl3_close: save size: %i %i\n", pl3_wsize.width, pl3_wsize.height);
 574             cfg_set_single_value_as_int(config, "playlist", "width", pl3_wsize.width);
 575             cfg_set_single_value_as_int(config, "playlist", "height", pl3_wsize.height);
 576         }
 577     }
 578
 579     if (cfg_get_single_value_as_int_with_default(config, "playlist", "hide-on-close", FALSE))
 580     {
 581         if (tray_icon2_get_available())
 582         {
 583             pl3_toggle_hidden();
 584             return TRUE;
 585         }
 586         gtk_window_iconify(GTK_WINDOW(playlist3_get_window()));
 587         return TRUE;
 588
 589     }
 590     /**
 591      * Quit the program
 592      */
 593     main_quit();
 594     return TRUE;
 595 }
 596
 597
 598 /**
 599  * Hide the playlist.
 600  * Before hiding save current size and position
 601 */
 602 int pl3_hide(void)
 603 {
 604     GtkWidget *pl3_win = playlist3_get_window();
 605     if (!tray_icon2_get_available())
 606     {
 607         gtk_window_iconify(GTK_WINDOW(pl3_win));
 608         return 1;
 609     }
 610     if (pl3_xml != NULL && !pl3_hidden)
 611     {
 612         GtkWidget *window = playlist3_get_window();
 613         int maximized = FALSE;
 614         if (gtk_widget_get_window(window))
 615         {
 616             GdkWindowState state = gdk_window_get_state(gtk_widget_get_window(window));
 617             maximized = ((state & GDK_WINDOW_STATE_MAXIMIZED) > 0);
 618         }
 619         cfg_set_single_value_as_int(config, "playlist", "maximized", maximized);
 620         /** Save position
 621          */
 622         gtk_window_get_position(GTK_WINDOW(pl3_win), &pl3_wsize.x, &pl3_wsize.y);
 623         cfg_set_single_value_as_int(config, "playlist", "xpos", pl3_wsize.x);
 624         cfg_set_single_value_as_int(config, "playlist", "ypos", pl3_wsize.y);
 625         /* save size, only when in SMALL or no zoom mode
 626          */
 627         if (pl3_zoom <= PLAYLIST_SMALL)
 628         {
 629             gtk_window_get_size(GTK_WINDOW(pl3_win), &pl3_wsize.width, &pl3_wsize.height);
 630             g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "pl3_hide: save size: %i %i\n", pl3_wsize.width, pl3_wsize.height);
 631             cfg_set_single_value_as_int(config, "playlist", "width", pl3_wsize.width);
 632             cfg_set_single_value_as_int(config, "playlist", "height", pl3_wsize.height);
 633         }
 634         gtk_widget_hide(pl3_win);
 635         pl3_hidden = TRUE;
 636     }
 637     #ifdef HAVE_APP_INDICATOR
 638         tray_icon2_update_menu();
 639     #endif
 640     return TRUE;
 641 }
 642
 643
 644 /* create the playlist view
 645  * This is done only once, for the rest its hidden, but still there
 646  */
 647 void pl3_show_and_position_window(void)
 648 {
 649     GtkWidget *pl3_win;
 650     if (!pl3_xml)
 651         return;
 652     pl3_win = playlist3_get_window();
 653     if (pl3_wsize.x > 0 || pl3_wsize.y > 0)
 654     {
 655         gtk_window_move(GTK_WINDOW(pl3_win), pl3_wsize.x, pl3_wsize.y);
 656     }
 657     if (pl3_wsize.height > 0 && pl3_wsize.width > 0)
 658     {
 659         g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "restore size %i %i\n", pl3_wsize.width, pl3_wsize.height);
 660         gtk_window_resize(GTK_WINDOW(pl3_win), pl3_wsize.width, pl3_wsize.height);
 661     }
 662     gtk_widget_show(pl3_win);
 663     gtk_window_present(GTK_WINDOW(pl3_win));
 664
 665 }
 666
 667
 668 gboolean playlist3_window_is_hidden(void)
 669 {
 670     return pl3_hidden;
 671 }
 672
 673
 674 void pl3_toggle_hidden(void)
 675 {
 676     if (pl3_hidden)
 677     {
 678         create_playlist3();
 679     } else
 680     {
 681         pl3_hide();
 682     }
 683 }
 684
 685
 686 static void playlist3_source_drag_data_recieved(GtkWidget * widget,
 687 GdkDragContext * context,
 688 gint x,
 689 gint y, GtkSelectionData * data, guint info, guint time_recieved)
 690 {
 691     if (info != 99)
 692     {
 693         int found = 0;
 694         const guchar *url_data = gtk_selection_data_get_data(data);
 695         int i;
 696         if (url_data)
 697         {
 698
 699             gchar **url = g_uri_list_extract_uris(url_data);
 700             for (i = 0; url && url[i]; i++)
 701             {
 702                 gchar *scheme = g_uri_parse_scheme(url[i]);
 703                 /* Don't add lines withouth an actual scheme. */
 704                 if (scheme)
 705                 {
 706                     gchar *fu = g_uri_unescape_string(url[i], NULL);
 707                     url_start_real(fu);
 708                     g_free(fu);
 709                     g_free(scheme);
 710                 }
 711             }
 712             if (url)
 713                 g_strfreev(url);
 714         }
 715
 716         gtk_drag_finish(context, found, FALSE, time_recieved);
 717     } else
 718     {
 719         MpdData *mdata;
 720         gchar **stripped;
 721         int i;
 722         guchar *odata = gtk_selection_data_get_text(data);
 723         stripped = g_strsplit((gchar *) odata, "\n", 0);
 724         g_free(odata);
 725         if (gdk_drag_context_get_actions(context)== GDK_ACTION_MOVE)
 726         {
 727             mpd_playlist_clear(connection);
 728         }
 729         mpd_database_search_start(connection, TRUE);
 730         for (i = 0; stripped && stripped[i]; i++)
 731         {
 732             gchar **request = g_strsplit(stripped[i], ":", 2);
 733             mpd_database_search_add_constraint(connection, mpd_misc_get_tag_by_name(request[0]), request[1]);
 734             g_strfreev(request);
 735         }
 736         mdata = mpd_database_search_commit(connection);
 737         for (; mdata; mdata = mpd_data_get_next(mdata))
 738         {
 739             mpd_playlist_queue_add(connection, mdata->song->file);
 740         }
 741         mpd_playlist_queue_commit(connection);
 742         if (gdk_drag_context_get_actions(context)== GDK_ACTION_MOVE)
 743         {
 744             mpd_player_play(connection);
 745         }
 746
 747         g_strfreev(stripped);
 748         gtk_drag_finish(context, TRUE, FALSE, time_recieved);
 749     }
 750 }
 751
 752
 753 /**
 754  * Progresbar
 755  */
 756 void pl3_pb_seek_event(GtkWidget * pb, guint seek_time, gpointer user_data)
 757 {
 758     mpd_player_seek(connection, (int)seek_time);
 759 }
 760
 761
 762
 763 static void about_dialog_activate(GtkWidget * dialog, const gchar * uri, gpointer data)
 764 {
 765     open_uri(uri);
 766 }
 767
 768
 769 /***
 770  * Handle a connect/Disconnect
 771  */
 772 static void playlist_connection_changed(MpdObj * mi, int connect, gpointer data)
 773 {
 774     GtkWidget *pl3_win = playlist3_get_window();
 775     /* Set menu items */
 776     if (connect)
 777     {
 778         char **handlers;
 779         gboolean found = FALSE;
 780         gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "vbox_playlist_player")), TRUE);
 781         gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hpaned1-hbox")), TRUE);
 782
 783         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDConnect")), FALSE);
 784         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDDisconnect")), TRUE);
 785         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPassword")), TRUE);
 786         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_view")), TRUE);
 787         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_option")), TRUE);
 788
 789         /* Check if MPD supports 'file://' (so local files). */
 790         /* TODO: make this a separate function */
 791         handlers = mpd_server_get_url_handlers(connection);
 792         if (handlers)
 793         {
 794             int i=0;
 795             for(; !found && handlers != NULL && handlers[i] != NULL; i++) {
 796                 if(g_utf8_collate(handlers[i], "file://") == 0) {
 797                     found = TRUE;
 798                 }
 799             }
 800             g_strfreev(handlers);
 801         }
 802         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "open_local_file")), found);
 803     } else
 804     {
 805         gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "vbox_playlist_player")), FALSE);
 806         gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hpaned1-hbox")), FALSE);
 807
 808         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDConnect")), TRUE);
 809         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDDisconnect")), FALSE);
 810         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPassword")), FALSE);
 811         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_view")), FALSE);
 812         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_option")), FALSE);
 813         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "open_local_file")), FALSE);
 814     }
 815     /** Set back to the current borwser, and update window title */
 816     if (connect)
 817     {
 818         gchar *string = NULL;
 819         GtkTreeIter iter;
 820         GtkTreeSelection *selec = gtk_tree_view_get_selection((GtkTreeView *) gtk_builder_get_object(pl3_xml,
 821             "cat_tree"));
 822         GtkTreeModel *model = GTK_TREE_MODEL(pl3_tree);
 823         if (gtk_tree_model_get_iter_first(model, &iter))
 824         {
 825             gtk_tree_selection_select_iter(selec, &iter);
 826         }
 827         if (gmpc_profiles_get_number_of_profiles(gmpc_profiles) > 1)
 828         {
 829             gchar *id = gmpc_profiles_get_current(gmpc_profiles);
 830             if (id)
 831             {
 832                 string =
 833                     g_strdup_printf("[%s] %s - %s %s", gmpc_profiles_get_name(gmpc_profiles, id), _("GMPC"),
 834                     _("Connected to"), mpd_get_hostname(mi));
 835                 g_free(id);
 836             }
 837         }
 838         if (!string)
 839             string = g_strdup_printf("%s - %s %s", _("GMPC"), _("Connected to"), mpd_get_hostname(mi));
 840         gtk_window_set_title(GTK_WINDOW(pl3_win), string);
 841         g_free(string);
 842     } else
 843     {
 844         gchar *string = NULL;
 845
 846         if (gmpc_profiles_get_number_of_profiles(gmpc_profiles) > 1)
 847         {
 848             gchar *id = gmpc_profiles_get_current(gmpc_profiles);
 849             if (id)
 850             {
 851                 string =
 852                     g_strdup_printf("[%s] %s - %s", gmpc_profiles_get_name(gmpc_profiles, id), _("GMPC"),
 853                     _("Disconnected"));
 854                 g_free(id);
 855             }
 856         }
 857         if (!string)
 858             string = g_strdup_printf("%s - %s", _("GMPC"), _("Disconnected"));
 859         gtk_window_set_title(GTK_WINDOW(pl3_win), string);
 860         g_free(string);
 861     }
 862
 863     /*
 864      * make the playlist update itself
 865      */
 866     playlist_status_changed(connection,
 867         MPD_CST_STATE | MPD_CST_SONGID | MPD_CST_NEXTSONG |
 868         MPD_CST_ELAPSED_TIME | MPD_CST_VOLUME |
 869         MPD_CST_REPEAT | MPD_CST_RANDOM | MPD_CST_PERMISSION
 870         | MPD_CST_SINGLE_MODE | MPD_CST_CONSUME_MODE | MPD_CST_UPDATING, NULL);
 871
 872     /**
 873      * Also need updating
 874      */
 875     pl3_option_menu_activate();
 876     pl3_tool_menu_update();
 877
 878     playlist3_fill_server_menu();
 879
 880     /**
 881      * update interface
 882      * items that are caused by the plugin.
 883      */
 884     pl3_update_go_menu();
 885
 886 }
 887
 888 void pl3_style_set_event( GtkWidget *widget,
 889                           GtkStyle  *previous_style,
 890                           gpointer   user_data)
 891 {
 892     if (cfg_get_single_value_as_int_with_default(config, "Default", "use-dark-style-header", TRUE))
 893     {
 894         gtk_rc_parse_string("widget \"*header*\" style \"dark\"");
 895     }
 896 }
 897 static gboolean pl3_cat_select_function(GtkTreeSelection *select, GtkTreeModel *model, GtkTreePath *path, gboolean cur_select, gpointer data)
 898 {
 899     GtkTreeIter iter;
 900     if(gtk_tree_model_get_iter(model, &iter, path))
 901     {
 902         gint type =0 ;
 903         gtk_tree_model_get(model, &iter, PL3_CAT_TYPE, &type, -1);
 904         if(type >= 0) return TRUE;
 905     }
 906     return FALSE;
 907 }
 908
 909 void create_playlist3(void)
 910 {
 911     GtkWidget *pb,*ali;
 912     GtkCellRenderer *renderer;
 913     GtkWidget *tree;
 914     GtkTreeSelection *sel;
 915     GtkTreeViewColumn *column = NULL;
 916     gchar *path = NULL;
 917     GtkTreeIter iter;
 918     GError *error = NULL;
 919     INIT_TIC_TAC();
 920     /* indicate that the playlist is not hidden */
 921     pl3_hidden = FALSE;
 922
 923     /**
 924      * If the playlist already exists,
 925      * It is probably coming from a hidden state,
 926      * so re-position the window
 927      */
 928     if (pl3_xml != NULL)
 929     {
 930         pl3_show_and_position_window();
 931         return;
 932     }
 933
 934
 935
 936
 937
 938     /** Ambiance / Radiance theme "dark" header */
 939     if (cfg_get_single_value_as_int_with_default(config, "Default", "use-dark-style-header", TRUE))
 940     {
 941         gtk_rc_parse_string("widget \"*header*\" style \"dark\"");
 942     }
 943
 944     /** use background color for the sidebar treeview cells */
 945     gtk_rc_parse_string (
 946         "style \"sidebar-treeview\"\n"
 947         "{\n"
 948         "   GtkTreeView::odd-row-color = @bg_color\n"
 949         "   GtkTreeView::even-row-color = @bg_color\n"
 950         "}\n"
 951         "widget \"*.sidebar.*\" style \"sidebar-treeview\"");
 952
 953     /** menubar */
 954     gtk_rc_parse_string (
 955         "style \"menubar-style\"\n"
 956         "{\n"
 957         "   GtkMenuBar::shadow-type = none\n"
 958         "}\n"
 959         "widget \"*.menubar\" style \"menubar-style\"\n");
 960
 961     /* initial, setting the url hook */
 962     // TODO
 963 //    gtk_about_dialog_set_url_hook((GtkAboutDialogActivateLinkFunc) about_dialog_activate, NULL, NULL);
 964     TEC("Setup dialog url hook")
 965     /* load gui desciption */
 966     path = gmpc_get_full_glade_path("playlist3.ui");
 967     TEC("get path")
 968     pl3_xml = gtk_builder_new();
 969     TEC("create builder")
 970     if(gtk_builder_add_from_file(pl3_xml, path,&error) == 0)
 971     {
 972         /*
 973          * Check if the file is loaded, if not then show an error message and abort the program
 974         if (pl3_xml == NULL)
 975         {
 976         */
 977         g_log(LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Failed to open playlist3.glade: %s\n", error->message);
 978         abort();
 979     }
 980     g_free(path);
 981
 982
 983     {
 984         // update style.
 985         GtkWidget *widget = (GtkWidget *)gtk_builder_get_object(pl3_xml, "cat_tree");
 986         GtkStyleContext *ct = gtk_widget_get_style_context(widget);
 987         gtk_style_context_add_class(ct, GTK_STYLE_CLASS_SIDEBAR);
 988     }
 989     TEC("Load builder file")
 990
 991     /* create tree store for the "category" view */
 992     if (pl3_tree == NULL)
 993     {
 994         GType types[] =
 995         {
 996             G_TYPE_INT,          /* row type, see free_type struct */
 997             G_TYPE_STRING,       /* display name */
 998             G_TYPE_STRING,       /* full path and stuff for backend */
 999             G_TYPE_STRING,       /* icon id */
1000             G_TYPE_INT,          /* ordering */
1001             G_TYPE_INT,             /* Bold */
1002             G_TYPE_STRING,       /* stock id */
1003             G_TYPE_BOOLEAN          /* Show text */
1004         };
1005         /* song id, song title */
1006         pl3_tree = (GtkTreeModel *) gmpc_tools_liststore_sort_new();
1007         gtk_list_store_set_column_types(GTK_LIST_STORE(pl3_tree), PL3_CAT_NROWS, types);
1008     }
1009     TEC("Setup pl3_tree")
1010
1011     tree = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "cat_tree"));
1012     gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)),
1013             pl3_cat_select_function, pl3_tree, NULL);
1014
1015     gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(pl3_tree));
1016     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
1017     gtk_tree_selection_set_mode(GTK_TREE_SELECTION(sel), GTK_SELECTION_BROWSE);
1018     gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree), TRUE);
1019     // Enable tooltip on the treeview.
1020     gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(tree), PL3_CAT_TITLE);
1021
1022     sidebar_text = renderer = GTK_CELL_RENDERER(my_cell_renderer_new());
1023     g_object_set(G_OBJECT(renderer), "xalign", 0.5,NULL);
1024     column = gtk_tree_view_column_new();
1025     gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(column),GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1026
1027     gtk_tree_view_column_pack_start(column, renderer, TRUE);
1028     g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_MENU, NULL);
1029     {
1030         int w, h;
1031         if (gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &w, &h))
1032         {
1033             g_object_set(G_OBJECT(renderer), "height", h+10, NULL);
1034             g_object_set(G_OBJECT(renderer), "image-width", w,NULL);
1035         }
1036     }
1037     gtk_tree_view_column_set_attributes(column, renderer,
1038             "icon-name", PL3_CAT_ICON_ID,
1039             "stock-id", PL3_CAT_STOCK_ID,
1040             "text", PL3_CAT_TITLE,
1041             "weight", PL3_CAT_BOLD,
1042             "show_text", PL3_CAT_SHOW_TEXT, NULL);
1043     g_object_set(renderer, "weight-set", TRUE, NULL);
1044
1045     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
1046     gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree), PL3_CAT_TITLE);
1047     g_signal_connect_after(G_OBJECT(sel), "changed", G_CALLBACK(pl3_cat_sel_changed), NULL);
1048
1049     TEC("setup cat_tree");
1050
1051     /* initialize the category view */
1052     pl3_initialize_tree();
1053
1054     TEC("Init category tree")
1055     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "vbox_playlist_player")));
1056
1057     /**
1058      * The new progress bar
1059      */
1060     pb = (GtkWidget *) gtk_builder_get_object(pl3_xml, "hbox_progress");
1061     gtk_widget_show(pb);
1062     g_signal_connect(G_OBJECT(pb), "seek-event", G_CALLBACK(pl3_pb_seek_event), NULL);
1063
1064     new_pb = pb;
1065
1066     TEC("Init progress bar")
1067     /* Make sure change is applied */
1068
1069     playlist3_new_header();
1070
1071     pl3_sidebar_plugins_init();
1072
1073     TEC("Init header")
1074     if (!cfg_get_single_value_as_int_with_default(config, "Interface", "hide-favorites-icon", FALSE))
1075     {
1076         favorites_button = gmpc_favorites_button_new();
1077         ali = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
1078         gtk_container_add(GTK_CONTAINER(ali), GTK_WIDGET(favorites_button));
1079         gtk_box_pack_start(GTK_BOX(gtk_builder_get_object(pl3_xml, "hbox10")), GTK_WIDGET(ali), FALSE, FALSE, 0);
1080         gtk_widget_show_all(GTK_WIDGET(ali));
1081         TEC("Init fav icon")
1082     }
1083     playlist_status_changed(connection,
1084         MPD_CST_STATE | MPD_CST_SONGID | MPD_CST_NEXTSONG |
1085         MPD_CST_ELAPSED_TIME | MPD_CST_VOLUME |
1086         MPD_CST_REPEAT | MPD_CST_RANDOM | MPD_CST_PERMISSION
1087         | MPD_CST_SINGLE_MODE | MPD_CST_CONSUME_MODE, NULL);
1088     g_signal_connect(G_OBJECT(gtk_builder_get_object(pl3_xml, "volume_button")),
1089         "value_changed", G_CALLBACK(playlist_player_volume_changed), NULL);
1090
1091     TEC("Signal setup")
1092
1093     /* Restore values from config */
1094     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION
1095         (gtk_builder_get_object
1096         (pl3_xml, "ViewShowArtistImage")),
1097         cfg_get_single_value_as_int_with_default
1098         (config, "playlist", "cover-image-enable", 0));
1099
1100     /* connect signals that are defined in the gui description */
1101     gtk_builder_connect_signals(pl3_xml,NULL);
1102
1103     TEC("connect signals")
1104
1105     /* select the current playlist */
1106     if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pl3_tree), &iter))
1107     {
1108         gtk_tree_selection_select_iter(sel, &iter);
1109     }
1110
1111     TEC("Select view")
1112     /*
1113      * Insert new custom widget
1114      */
1115     metaimage_album_art = gmpc_metaimage_new(META_ALBUM_ART);
1116
1117     /* Hide when requested. */
1118     if (cfg_get_single_value_as_int_with_default(config, "Interface", "hide-album-art", FALSE))
1119     {
1120         gmpc_metaimage_set_is_visible(GMPC_METAIMAGE(metaimage_album_art), FALSE);
1121     }
1122     gtk_box_pack_start(GTK_BOX
1123         (gtk_builder_get_object(pl3_xml, "hbox_playlist_player")), metaimage_album_art, FALSE, TRUE, 0);
1124
1125     gtk_box_reorder_child(GTK_BOX
1126         (gtk_builder_get_object(pl3_xml, "hbox_playlist_player")), metaimage_album_art, 0);
1127     gmpc_metaimage_set_size(GMPC_METAIMAGE(metaimage_album_art), ALBUM_SIZE);
1128     gmpc_metaimage_set_no_cover_icon(GMPC_METAIMAGE(metaimage_album_art), (char *)"gmpc");
1129     gmpc_metaimage_set_connection(GMPC_METAIMAGE(metaimage_album_art), connection);
1130     /** make sure size is updated */
1131     gmpc_metaimage_set_cover_na(GMPC_METAIMAGE(metaimage_album_art));
1132
1133     metaimage_artist_art = gmpc_metaimage_new(META_ARTIST_ART);
1134     gtk_container_add(GTK_CONTAINER(gtk_builder_get_object(pl3_xml, "sidebar_artist_image_alignment")), metaimage_artist_art);
1135
1136     gmpc_metaimage_set_no_cover_icon(GMPC_METAIMAGE(metaimage_artist_art), (char *)"no-artist");
1137     gmpc_metaimage_set_loading_cover_icon(GMPC_METAIMAGE(metaimage_artist_art), (char *)"fetching-artist");
1138     gmpc_metaimage_set_connection(GMPC_METAIMAGE(metaimage_artist_art), connection);
1139     if (!cfg_get_single_value_as_int_with_default(config, "playlist", "cover-image-enable", FALSE))
1140     {
1141         gmpc_metaimage_set_is_visible(GMPC_METAIMAGE(metaimage_artist_art), FALSE);
1142     }
1143     gmpc_metaimage_set_squared(GMPC_METAIMAGE(metaimage_artist_art), FALSE);
1144     gmpc_metaimage_set_size(GMPC_METAIMAGE(metaimage_artist_art), 145);
1145
1146     TEC("Setup metaimages")
1147     /* restore the window's position and size, if the user wants this. */
1148     if (cfg_get_single_value_as_int_with_default(config, "playlist", "savepossize", 1))
1149     {
1150         int maximized = cfg_get_single_value_as_int_with_default(config, "playlist", "maximized", 0);
1151         /* Load values from config file */
1152         pl3_wsize.x = cfg_get_single_value_as_int_with_default(config, "playlist", "xpos", 0);
1153         pl3_wsize.y = cfg_get_single_value_as_int_with_default(config, "playlist", "ypos", 0);
1154         pl3_wsize.width = cfg_get_single_value_as_int_with_default(config, "playlist", "width", 0);
1155         pl3_wsize.height = cfg_get_single_value_as_int_with_default(config, "playlist", "height", 0);
1156         TEC("get settings")
1157         /* restore location + position */
1158         /*pl3_show_and_position_window(); */
1159
1160         if (pl3_wsize.x > 0 || pl3_wsize.y > 0)
1161         {
1162             gtk_window_move(GTK_WINDOW(playlist3_get_window()), pl3_wsize.x, pl3_wsize.y);
1163         }
1164         TEC("move window settings")
1165         if (pl3_wsize.height > 0 && pl3_wsize.width > 0)
1166         {
1167             g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "restore size %i %i\n", pl3_wsize.width, pl3_wsize.height);
1168             gtk_window_resize(GTK_WINDOW(playlist3_get_window()), pl3_wsize.width, pl3_wsize.height);
1169         }
1170         TEC("set pane window settings")
1171         if (maximized)
1172             gtk_window_maximize(GTK_WINDOW(playlist3_get_window()));
1173         TEC("maximize pane window settings")
1174         /**
1175          * restore zoom level
1176          */
1177     }
1178     gtk_widget_show(playlist3_get_window());
1179     TEC("Show window")
1180     pl3_zoom = cfg_get_single_value_as_int_with_default(config, "playlist", "zoomlevel", PLAYLIST_NO_ZOOM);
1181     playlist_zoom_level_changed();
1182     TEC("zoom level")
1183
1184     #ifdef HAVE_APP_INDICATOR
1185         tray_icon2_update_menu();
1186     #endif
1187
1188     TEC("Restore state")
1189     pl3_update_go_menu();
1190     TEC("Go menu")
1191     /* make it update itself */
1192     pl3_update_profiles_menu(gmpc_profiles, GMPC_PROFILES_ACTION_ADDED, -1, NULL);
1193     g_signal_connect(G_OBJECT(gmpc_profiles), "changed", G_CALLBACK(pl3_update_profiles_menu), NULL);
1194     g_signal_connect(G_OBJECT(gmpc_profiles), "changed", G_CALLBACK(pl3_profiles_changed), NULL);
1195
1196     TEC("Update profiles")
1197     /**
1198      * Set as drag destination
1199      */
1200     gtk_drag_dest_set(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox_playlist_player")),
1201         GTK_DEST_DEFAULT_ALL,
1202         target_table, 6, GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_DEFAULT | GDK_ACTION_MOVE);
1203     g_signal_connect(G_OBJECT
1204         (gtk_builder_get_object(pl3_xml, "hbox_playlist_player")),
1205         "drag_data_received", G_CALLBACK (playlist3_source_drag_data_recieved), NULL);
1206
1207     TEC("setup drag")
1208     /**
1209      *
1210      */
1211     playlist_connection_changed(connection, FALSE, NULL);
1212
1213     g_signal_connect(G_OBJECT(playlist3_get_window()), "window-state-event", G_CALLBACK(pl3_win_state_event), NULL);
1214
1215     TEC("signal connn changed")
1216
1217     g_signal_connect(G_OBJECT(playlist3_get_window()), "style-set", G_CALLBACK(pl3_style_set_event), NULL);
1218
1219     /**
1220      * Add status icons
1221      */
1222     main_window_init_default_status_icons();
1223     main_window_update_status_icons();
1224
1225     TEC("Update status icon")
1226     /* Update extra */
1227     init_extra_playlist_state();
1228     TEC("Setup extra playlist")
1229
1230     // Add window to GtkApplication.
1231     gtk_application_add_window(gmpc_application, playlist3_get_window());
1232 }
1233
1234
1235 /**
1236  * Helper functions
1237  */
1238 GtkListStore *playlist3_get_category_tree_store(void)
1239 {
1240     if (pl3_xml == NULL)
1241         return NULL;
1242     return GTK_LIST_STORE(pl3_tree);
1243 }
1244
1245
1246 GtkTreeView *playlist3_get_category_tree_view(void)
1247 {
1248     if (pl3_xml == NULL)
1249         return NULL;
1250     return (GtkTreeView *) gtk_builder_get_object(pl3_xml, "cat_tree");
1251 }
1252
1253 GtkWidget* playlist3_get_widget_by_id(const char *id) {
1254     return (GtkWidget *) gtk_builder_get_object(pl3_xml, id);
1255 }
1256
1257
1258 /****************************************************************************************
1259  *  PREFERENCES                                        *
1260  ****************************************************************************************/
1261 /* prototyping for glade */
1262 void ck_stop_on_exit_toggled_cb(GtkToggleButton * but, gpointer data);
1263 void ck_show_tooltip_enable_tb(GtkToggleButton * but);
1264
1265 G_MODULE_EXPORT void show_cover_case_tb(GtkToggleButton * but)
1266 {
1267     int bool1 = gtk_toggle_button_get_active(but);
1268     cfg_set_single_value_as_int(config, "metaimage", "addcase", bool1);
1269     pixbuf_cache_clear();
1270     gmpc_meta_watcher_force_reload_cb(gmw);
1271 }
1272
1273
1274 G_MODULE_EXPORT void ck_stop_on_exit_toggled_cb(GtkToggleButton * but, gpointer data)
1275 {
1276     int bool1 = gtk_toggle_button_get_active(but);
1277     cfg_set_single_value_as_int(config, "connection", "stop-on-exit", bool1);
1278 }
1279
1280
1281 G_MODULE_EXPORT void hide_on_close_enable_tb(GtkToggleButton * but)
1282 {
1283     int bool1 = gtk_toggle_button_get_active(but);
1284     cfg_set_single_value_as_int(config, "playlist", "hide-on-close", bool1);
1285 }
1286
1287
1288 G_MODULE_EXPORT void cur_song_center_enable_tb(GtkToggleButton * but)
1289 {
1290     int bool1 = gtk_toggle_button_get_active(but);
1291     cfg_set_single_value_as_int(config, "playlist", "st_cur_song", bool1);
1292 }
1293
1294
1295 G_MODULE_EXPORT void save_possize_enable_tb(GtkToggleButton * but)
1296 {
1297     int bool1 = gtk_toggle_button_get_active(but);
1298     cfg_set_single_value_as_int(config, "playlist", "savepossize", bool1);
1299 }
1300
1301
1302 G_MODULE_EXPORT void ck_show_tooltip_enable_tb(GtkToggleButton * but)
1303 {
1304     int bool1 = gtk_toggle_button_get_active(but);
1305     cfg_set_single_value_as_int(config, "GmpcTreeView", "show-tooltip", bool1);
1306 }
1307
1308
1309 G_MODULE_EXPORT void ck_search_as_you_type(GtkToggleButton * but)
1310 {
1311     int bool1 = gtk_toggle_button_get_active(but);
1312     cfg_set_single_value_as_int(config, "general", "search-as-you-type", bool1);
1313 }
1314
1315
1316 static void playlist_pref_destroy(GtkWidget * container)
1317 {
1318     if (playlist_pref_xml)
1319     {
1320         GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(playlist_pref_xml,
1321             "playlist-vbox");
1322         gtk_container_remove(GTK_CONTAINER(container), vbox);
1323         g_object_unref(playlist_pref_xml);
1324         playlist_pref_xml = NULL;
1325     }
1326 }
1327
1328
1329 void playlist_pref_construct(GtkWidget * container)
1330 {
1331     GError *error = NULL;
1332     gchar *path = gmpc_get_full_glade_path("preferences-playlist.ui");
1333     playlist_pref_xml = gtk_builder_new();
1334
1335     gtk_builder_add_from_file(playlist_pref_xml, path, &error);
1336     if(error) {
1337         g_warning("Failed to open builder file: %s", error->message);
1338         g_error_free(error);
1339         return;
1340     }
1341     if (playlist_pref_xml)
1342     {
1343         GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(playlist_pref_xml,
1344             "playlist-vbox");
1345         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1346             (gtk_builder_get_object
1347             (playlist_pref_xml, "ck_ps")),
1348             cfg_get_single_value_as_int_with_default(config, "playlist", "st_cur_song", 0));
1349         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1350             (gtk_builder_get_object
1351             (playlist_pref_xml, "ck_possize")),
1352             cfg_get_single_value_as_int_with_default(config, "playlist", "savepossize", 1));
1353         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1354             (gtk_builder_get_object
1355             (playlist_pref_xml, "ck_hide_on_close")),
1356             cfg_get_single_value_as_int_with_default(config, "playlist", "hide-on-close", 0));
1357
1358         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1359             (gtk_builder_get_object
1360             (playlist_pref_xml, "ck_stop_on_exit")),
1361             cfg_get_single_value_as_int_with_default(config, "connection", "stop-on-exit", 0));
1362
1363         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1364             (gtk_builder_get_object
1365             (playlist_pref_xml, "ck_cover_case")),
1366             cfg_get_single_value_as_int_with_default(config, "metaimage", "addcase", TRUE));
1367
1368         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1369             (gtk_builder_get_object
1370             (playlist_pref_xml, "ck_show_tooltip")),
1371             cfg_get_single_value_as_int_with_default
1372             (config, "GmpcTreeView", "show-tooltip", TRUE));
1373
1374         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
1375             (gtk_builder_get_object
1376             (playlist_pref_xml, "ck_search_as_you_type")),
1377             cfg_get_single_value_as_int_with_default(config, "general", "search-as-you-type",
1378             0));
1379         gtk_container_add(GTK_CONTAINER(container), vbox);
1380         gtk_widget_show_all(vbox);
1381         gtk_builder_connect_signals(playlist_pref_xml, NULL);
1382     }
1383     g_free(path);
1384 }
1385
1386
1387 /**
1388  * Menu Callback functions
1389  */
1390
1391 void playlist_menu_repeat_changed(GtkToggleAction * action)
1392 {
1393     int active = gtk_toggle_action_get_active(action);
1394     if (active != mpd_player_get_repeat(connection))
1395     {
1396         mpd_player_set_repeat(connection, active);
1397     }
1398 }
1399
1400
1401 void playlist_menu_random_changed(GtkToggleAction *action)
1402 {
1403     int active = gtk_toggle_action_get_active(action);
1404     if (active != mpd_player_get_random(connection))
1405     {
1406         mpd_player_set_random(connection, active);
1407     }
1408 }
1409
1410
1411 void playlist_menu_single_mode_changed(GtkToggleAction * action)
1412 {
1413     int active = gtk_toggle_action_get_active(action);
1414     if (active != mpd_player_get_single(connection))
1415     {
1416         mpd_player_set_single(connection, active);
1417     }
1418 }
1419
1420
1421 void playlist_menu_consume_changed(GtkToggleAction * action)
1422 {
1423     int active = gtk_toggle_action_get_active(action);
1424     if (active != mpd_player_get_consume(connection))
1425     {
1426         mpd_player_set_consume(connection, active);
1427     }
1428 }
1429
1430
1431 /**
1432  * This is artist image
1433  * FIXME: Rename
1434  */
1435 void playlist_menu_artist_image_changed(GtkToggleAction *ta)
1436 {
1437     int active = gtk_toggle_action_get_active(ta);
1438     cfg_set_single_value_as_int(config, "playlist", "cover-image-enable", active);
1439     if(pl3_zoom < PLAYLIST_SMALL)
1440     {
1441         gmpc_metaimage_set_is_visible(GMPC_METAIMAGE(metaimage_artist_art), active);
1442         if (active)
1443             gtk_widget_show(metaimage_artist_art);
1444     }
1445 }
1446
1447
1448 /***
1449  * Zooming functions
1450  */
1451 void playlist_zoom_out(void)
1452 {
1453     /* Do not change zoom level when fullscreen */
1454     if(pl3_window_is_fullscreen())
1455         return;
1456     if ((pl3_zoom + 1) >= PLAYLIST_ZOOM_LEVELS)
1457         return;
1458     pl3_old_zoom = pl3_zoom;
1459     pl3_zoom++;
1460     playlist_zoom_level_changed();
1461 }
1462
1463
1464 void playlist_zoom_in(void)
1465 {
1466     /* Do not change zoom level when fullscreen */
1467     if(pl3_window_is_fullscreen())
1468         return;
1469     if (pl3_zoom <= PLAYLIST_NO_ZOOM)
1470         return;
1471     pl3_old_zoom = pl3_zoom;
1472     pl3_zoom--;
1473     playlist_zoom_level_changed();
1474 }
1475 static void update_show_text(gboolean state)
1476 {
1477     GtkTreeView *tree = (GtkTreeView *) gtk_builder_get_object(pl3_xml, "cat_tree");
1478     GtkTreeModel *model = gtk_tree_view_get_model(tree);
1479     GtkTreeIter iter;
1480     if(gtk_tree_model_get_iter_first(model, &iter))
1481     {
1482         do{
1483             gtk_list_store_set(GTK_LIST_STORE(model), &iter, PL3_CAT_SHOW_TEXT, state, -1);
1484         }while(gtk_tree_model_iter_next(model, &iter));
1485     }
1486 }
1487
1488 /**
1489  * FIXME: Needs propper grouping and cleaning up
1490  */
1491 static void playlist_zoom_level_changed(void)
1492 {
1493     gboolean st_shown;
1494     GtkWidget *pl3_win = playlist3_get_window();
1495     printf("playlist3 zoom level changed\n");
1496
1497     if (pl3_old_zoom <= PLAYLIST_SMALL)
1498     {
1499         gtk_window_get_size(GTK_WINDOW(pl3_win), &pl3_wsize.width, &pl3_wsize.height);
1500         cfg_set_single_value_as_int(config, "playlist", "width", pl3_wsize.width);
1501         cfg_set_single_value_as_int(config, "playlist", "height", pl3_wsize.height);
1502         g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "save size: %i %i\n", pl3_wsize.width, pl3_wsize.height);
1503     }
1504
1505     if (pl3_old_zoom == PLAYLIST_MINI && pl3_zoom != PLAYLIST_MINI)
1506     {
1507         GtkWidget *box =GTK_WIDGET(gtk_builder_get_object(pl3_xml, "pl3_button_control_box"));
1508         GtkWidget *top = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox10"));
1509         GtkWidget *vtop = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "vbox_playlist_player"));
1510         /* add my own reference */
1511         g_object_ref(box);
1512         gtk_container_remove(GTK_CONTAINER(vtop), box);
1513         gtk_box_pack_end(GTK_BOX(top), box, FALSE, TRUE, 0);
1514         gtk_box_reorder_child(GTK_BOX(top), box, 0);
1515         /* release my reference */
1516         g_object_unref(box);
1517         gtk_widget_show(box);
1518         gmpc_progress_set_hide_text(GMPC_PROGRESS(new_pb), FALSE);
1519     }
1520     if (pl3_old_zoom != PLAYLIST_MINI && pl3_zoom == PLAYLIST_MINI)
1521     {
1522         GtkWidget *box = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "pl3_button_control_box"));
1523         GtkWidget *top = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox10"));
1524         GtkWidget *vtop = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "vbox_playlist_player"));
1525         /* add my own reference */
1526         g_object_ref(box);
1527         gtk_container_remove(GTK_CONTAINER(top), box);
1528         gtk_box_pack_end(GTK_BOX(vtop), box, FALSE, TRUE, 3);
1529         /* release my reference */
1530         g_object_unref(box);
1531         gtk_widget_show(box);
1532
1533         gmpc_progress_set_hide_text(GMPC_PROGRESS(new_pb), TRUE);
1534     }
1535
1536     /* Show full view */
1537     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hpaned1-hbox")));
1538     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox1")));
1539     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox10")));
1540     /** Menu Bar */
1541     /** BUTTON BOX */
1542     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "pl3_button_control_box")));
1543
1544     gtk_window_set_resizable(GTK_WINDOW(pl3_win), TRUE);
1545     if (pl3_wsize.width > 0 && pl3_wsize.height > 0 && pl3_old_zoom == PLAYLIST_MINI)
1546     {
1547         g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "restore size %i %i\n", pl3_wsize.width, pl3_wsize.height);
1548         gtk_window_resize(GTK_WINDOW(pl3_win), pl3_wsize.width, pl3_wsize.height);
1549     }
1550     gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "sidebar")));
1551
1552     if (cfg_get_single_value_as_int_with_default(config, "playlist", "cover-image-enable", FALSE))
1553     {
1554         gmpc_metaimage_set_is_visible(GMPC_METAIMAGE(metaimage_artist_art), TRUE);
1555         gtk_widget_show(metaimage_artist_art);
1556     }
1557     gtk_action_set_visible(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_go")),TRUE);
1558     gtk_action_set_visible(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_option")),TRUE);
1559
1560     update_show_text(TRUE);
1561     gmpc_sidebar_plugins_update_state(GMPC_PLUGIN_SIDEBAR_STATE_FULL);
1562
1563     /* Now start hiding */
1564     switch (pl3_zoom)
1565     {
1566         case PLAYLIST_NO_ZOOM:
1567             break;
1568         case PLAYLIST_MINI:
1569             gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hpaned1-hbox")));
1570             gtk_action_set_visible(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_option")),FALSE);
1571             gtk_action_set_visible(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_go")),FALSE);
1572             if (pl3_win)
1573             {
1574                 if (gdk_window_get_state(gtk_widget_get_window(pl3_win)) & GDK_WINDOW_STATE_MAXIMIZED)
1575                 {
1576                     gtk_window_unmaximize(GTK_WINDOW(pl3_win));
1577                 }
1578
1579                 if (gdk_window_get_state(gtk_widget_get_window(pl3_win)) & GDK_WINDOW_STATE_FULLSCREEN)
1580                 {
1581                     gtk_window_unfullscreen(GTK_WINDOW(pl3_win));
1582                 }
1583             }
1584             gtk_window_set_resizable(GTK_WINDOW(pl3_win), FALSE);
1585
1586             gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(pl3_xml, "sidebar")));
1587             break;
1588         case PLAYLIST_SMALL:
1589             gmpc_metaimage_set_is_visible(GMPC_METAIMAGE(metaimage_artist_art), FALSE);
1590             update_show_text(FALSE);
1591             gmpc_sidebar_plugins_update_state(GMPC_PLUGIN_SIDEBAR_STATE_COLLAPSED);
1592             gtk_widget_grab_focus(pl3_win);
1593         default:
1594             break;
1595     }
1596     /** Save zoom level
1597      */
1598     cfg_set_single_value_as_int(config, "playlist", "zoomlevel", pl3_zoom);
1599 }
1600
1601
1602 /**
1603  * Update the window to status changes in mpd
1604  */
1605 static void playlist_status_changed(MpdObj * mi, ChangedStatusType what, void *userdata)
1606 {
1607     char buffer[1024];
1608     GtkWidget *pl3_win = playlist3_get_window();
1609     /**
1610      * if the window isn't there yet, return
1611      */
1612     if (!pl3_xml)
1613         return;
1614     control_window_status_update(mi, what, control_window);
1615     /**
1616      * Player state changed
1617      */
1618     if (what & MPD_CST_STATE)
1619     {
1620         mpd_Song *song = mpd_playlist_get_current_song(connection);
1621         int state = mpd_player_get_state(mi);
1622         switch (state)
1623         {
1624             case MPD_PLAYER_PLAY:
1625             {
1626                 gchar *markup = cfg_get_single_value_as_string_with_default(config,
1627                     "playlist",  /* Category */
1628                     "window-markup",/* Key */
1629                                  /* default value */
1630                     "[%title% - &[%artist%]]|%name%|%shortfile%"
1631                     );
1632                 /**
1633                  * Update the image in the menu
1634                  */
1635                 gtk_action_set_stock_id(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")), "gtk-media-pause");
1636                 gtk_image_set_from_stock(GTK_IMAGE
1637                     (gtk_builder_get_object
1638                     (pl3_xml, "play_button_image")), "gtk-media-pause",
1639                     GTK_ICON_SIZE_MENU);
1640
1641                 /**
1642                  * Update window title
1643                  */
1644                 mpd_song_markup(buffer, 1024, markup, mpd_playlist_get_current_song(connection));
1645
1646                 if (gmpc_profiles_get_number_of_profiles(gmpc_profiles) > 1)
1647                 {
1648                     gchar *id = gmpc_profiles_get_current(gmpc_profiles);
1649                     if (id)
1650                     {
1651                         gchar *string = g_strdup_printf("[%s] %s", gmpc_profiles_get_name(gmpc_profiles,
1652                             id), buffer);
1653                         gtk_window_set_title(GTK_WINDOW(pl3_win), string);
1654                         g_free(id);
1655                         g_free(string);
1656                     }
1657                 } else
1658                 gtk_window_set_title(GTK_WINDOW(pl3_win), buffer);
1659
1660                 g_free(markup);
1661                 break;
1662             }
1663             case MPD_PLAYER_PAUSE:
1664             {
1665                 gchar *markup = cfg_get_single_value_as_string_with_default(config,
1666                     "playlist",  /* Category */
1667                     "window-markup",/* Key */
1668                                  /* default value */
1669                     "[%title% - &[%artist%]]|%name%|%shortfile%"
1670                     );
1671                 /** Update menu and button images */
1672
1673                 gtk_action_set_stock_id(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")), "gtk-media-play");
1674                 gtk_image_set_from_stock(GTK_IMAGE
1675                     (gtk_builder_get_object
1676                     (pl3_xml, "play_button_image")), "gtk-media-play",
1677                     GTK_ICON_SIZE_MENU);
1678                 /**
1679                  * Set paused in Window string
1680                  */
1681                 mpd_song_markup(buffer, 1024 - strlen(_("paused") - 4),
1682                     markup, mpd_playlist_get_current_song(connection));
1683                 /* Append translated paused */
1684                 strcat(buffer, " (");
1685                 strcat(buffer, _("paused"));
1686                 strcat(buffer, ")");
1687
1688                 if (gmpc_profiles_get_number_of_profiles(gmpc_profiles) > 1)
1689                 {
1690                     gchar *id = gmpc_profiles_get_current(gmpc_profiles);
1691                     if (id)
1692                     {
1693                         gchar *string = g_strdup_printf("[%s] %s", gmpc_profiles_get_name(gmpc_profiles,
1694                             id), buffer);
1695                         gtk_window_set_title(GTK_WINDOW(pl3_win), string);
1696                         g_free(id);
1697                         g_free(string);
1698                     }
1699                 } else
1700                 gtk_window_set_title(GTK_WINDOW(pl3_win), buffer);
1701                 g_free(markup);
1702                 break;
1703             }
1704             default:
1705                 gtk_action_set_stock_id(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")), "gtk-media-play");
1706                 /* Make sure it's reset correctly */
1707                 gmpc_progress_set_time(GMPC_PROGRESS(new_pb), 0, 0);
1708
1709                 gtk_image_set_from_stock(GTK_IMAGE
1710                     (gtk_builder_get_object
1711                     (pl3_xml, "play_button_image")), "gtk-media-play",
1712                     GTK_ICON_SIZE_MENU);
1713                 if (gmpc_profiles_get_number_of_profiles(gmpc_profiles) > 1)
1714                 {
1715                     gchar *id = gmpc_profiles_get_current(gmpc_profiles);
1716                     if (id)
1717                     {
1718                         gchar *string = g_strdup_printf("[%s] %s", gmpc_profiles_get_name(gmpc_profiles,
1719                             id), _("GMPC"));
1720                         gtk_window_set_title(GTK_WINDOW(pl3_win), string);
1721                         g_free(id);
1722                         g_free(string);
1723                     }
1724                 } else
1725                 gtk_window_set_title(GTK_WINDOW(pl3_win), _("GMPC"));
1726         }
1727         playlist3_update_header();
1728
1729         if(favorites_button != NULL)
1730         {
1731             if (state == MPD_PLAYER_PLAY || state == MPD_PLAYER_PAUSE)
1732             {
1733                 gmpc_favorites_button_set_song(favorites_button, song);
1734             } else
1735             {
1736                 gmpc_favorites_button_set_song(favorites_button, NULL);
1737             }
1738         }
1739     }
1740     /**
1741      * Handle song change or Playlist change
1742      * Anything that can change metadta
1743      */
1744     if (what & MPD_CST_SONGID || what & MPD_CST_SONGPOS || what & MPD_CST_PLAYLIST)
1745     {
1746         playlist3_update_header();
1747         /* make is update markups and stuff */
1748         playlist_status_changed(mi, MPD_CST_STATE, NULL);
1749     }
1750     /**
1751      * set repeat buttons in menu correct
1752      */
1753     if (what & MPD_CST_REPEAT)
1754     {
1755         if (mpd_check_connected(connection))
1756         {
1757             gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_builder_get_object(pl3_xml, "MPDRepeat")),
1758                 mpd_player_get_repeat(connection));
1759         }
1760
1761     }
1762     if (what & MPD_CST_RANDOM)
1763     {
1764         if (mpd_check_connected(connection))
1765         {
1766             gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_builder_get_object(pl3_xml, "MPDRandom")),
1767                 mpd_player_get_random(connection));
1768         }
1769     }
1770     if (what & (MPD_CST_RANDOM | MPD_CST_REPEAT | MPD_CST_SINGLE_MODE | MPD_CST_CONSUME_MODE))
1771     {
1772         main_window_update_status_icons();
1773     }
1774     if (what & MPD_CST_SINGLE_MODE)
1775     {
1776         if (mpd_check_connected(connection))
1777         {
1778             gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_builder_get_object(pl3_xml, "MPDSingleMode")),
1779                 mpd_player_get_single(connection));
1780         }
1781     }
1782
1783     if (what & MPD_CST_CONSUME_MODE)
1784     {
1785         if (mpd_check_connected(connection))
1786         {
1787             gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_builder_get_object(pl3_xml, "MPDConsumeMode")),
1788                 mpd_player_get_consume(connection));
1789         }
1790     }
1791     if (what & MPD_CST_ELAPSED_TIME)
1792     {
1793         if (mpd_check_connected(connection))
1794         {
1795             int totalTime = mpd_status_get_total_song_time(connection);
1796             int elapsedTime = mpd_status_get_elapsed_song_time(connection);
1797             gmpc_progress_set_time(GMPC_PROGRESS(new_pb), totalTime, elapsedTime);
1798         } else
1799         {
1800
1801             gmpc_progress_set_time(GMPC_PROGRESS(new_pb), 0, 0);
1802         }
1803     }
1804     if (what & MPD_CST_PERMISSION)
1805     {
1806         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDSingleMode")),
1807             (
1808             mpd_check_connected(connection) &&
1809             mpd_server_check_command_allowed(connection, "single") == MPD_SERVER_COMMAND_ALLOWED
1810             )
1811             );
1812         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDConsumeMode")),
1813             (
1814             mpd_check_connected(connection) &&
1815             mpd_server_check_command_allowed(connection, "consume") == MPD_SERVER_COMMAND_ALLOWED
1816             )
1817             );
1818         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")),
1819             (
1820             mpd_check_connected(connection) &&
1821             mpd_server_check_command_allowed(connection, "play") == MPD_SERVER_COMMAND_ALLOWED
1822             )
1823             );
1824         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext")),
1825             (
1826             mpd_check_connected(connection) &&
1827             mpd_server_check_command_allowed(connection, "next") == MPD_SERVER_COMMAND_ALLOWED
1828             )
1829             );
1830         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious")),
1831             (
1832             mpd_check_connected(connection) &&
1833             mpd_server_check_command_allowed(connection, "previous") == MPD_SERVER_COMMAND_ALLOWED
1834             )
1835             );
1836         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDStop")),
1837             (
1838             mpd_check_connected(connection) &&
1839             mpd_server_check_command_allowed(connection, "stop") == MPD_SERVER_COMMAND_ALLOWED
1840             )
1841             );
1842         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDRepeat")),
1843             (
1844             mpd_check_connected(connection) &&
1845             mpd_server_check_command_allowed(connection, "repeat") == MPD_SERVER_COMMAND_ALLOWED
1846             )
1847             );
1848         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDRandom")),
1849             (
1850             mpd_check_connected(connection)&&
1851             mpd_server_check_command_allowed(connection, "random") == MPD_SERVER_COMMAND_ALLOWED
1852             )
1853             );
1854         /* Also update volume stuff */
1855         what = what|MPD_CST_VOLUME;
1856     }
1857
1858     if (what & MPD_CST_VOLUME)
1859     {
1860         GtkWidget *volume_button = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "volume_button"));
1861         int new_volume = mpd_status_get_volume(connection);
1862         if (new_volume >= 0 &&
1863             mpd_server_check_command_allowed(connection, "setvol") == MPD_SERVER_COMMAND_ALLOWED
1864             )
1865         {
1866             int volume = gtk_scale_button_get_value(GTK_SCALE_BUTTON(volume_button))/100.0;
1867             gtk_widget_show(GTK_WIDGET(volume_button));
1868             gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDMuted")),
1869                 TRUE
1870                 );
1871             /* don't do anything if nothing is changed */
1872             if (new_volume != volume)
1873             {
1874                 gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_button),new_volume/100.0f);
1875             }
1876         } else
1877         {
1878             gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_button),0);
1879             gtk_widget_hide(GTK_WIDGET(volume_button));
1880             gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDMuted")),
1881                 FALSE
1882                 );
1883         }
1884     }
1885     if (what & MPD_CST_SERVER_ERROR)
1886     {
1887         gchar *error = mpd_status_get_mpd_error(mi);
1888         if (error)
1889         {
1890             gchar *mes = g_markup_printf_escaped("%s: '%s'",
1891                 _("MPD Reported the following error"),
1892                 error);
1893             playlist3_show_error_message(mes, ERROR_WARNING);
1894             g_free(mes);
1895             g_free(error);
1896         }
1897     }
1898     if (what & MPD_CST_OUTPUT)
1899     {
1900         playlist3_fill_server_menu();
1901     }
1902     if (what & MPD_CST_NEXTSONG)
1903     {
1904
1905         GtkWidget *next_button = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "next_button"));
1906         if (next_button)
1907         {
1908             int i = mpd_player_get_next_song_id(mi);
1909             if (i >= 0)
1910             {
1911                 mpd_Song *song = mpd_playlist_get_song(mi, i);
1912                 if (song)
1913                 {
1914                     mpd_song_markup(buffer, 1024, "[%title% - &[%artist%]]|%shortfile%", song);
1915                     gtk_widget_set_tooltip_text(next_button, buffer);
1916                     mpd_freeSong(song);
1917                 } else
1918                 gtk_widget_set_tooltip_text(next_button, "");
1919             } else
1920             gtk_widget_set_tooltip_text(next_button, "");
1921         }
1922     }
1923 }
1924
1925 gboolean playlist_player_volume_changed(GtkWidget * vol_but, double new_vol)
1926 {
1927     int volume = new_vol*100;        //gtk_scale_button_get_value(GTK_SCALE_BUTTON(vol_but)) * 100;
1928     int new_volume = mpd_status_get_volume(connection);
1929     if (new_volume >= 0 && new_volume != volume)
1930     {
1931         mpd_status_set_volume(connection, volume);
1932         return FALSE;
1933     }
1934     return FALSE;
1935 }
1936
1937
1938 void about_window(void)
1939 {
1940     gchar *path = gmpc_get_full_glade_path("aboutdialog.ui");
1941     GtkBuilder *xml = gtk_builder_new();
1942     GtkWidget *dialog = NULL;
1943     gtk_builder_add_from_file(xml, path, NULL);
1944     dialog = (GtkWidget *) gtk_builder_get_object(xml, "aboutdialog");
1945
1946     gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(playlist3_get_window()));
1947     gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
1948     g_free(path);
1949
1950     if (strlen(revision))
1951     {
1952         path = g_strdup_printf("%s\nRevision: %s", VERSION, revision);
1953     } else
1954     {
1955         path = g_strdup_printf("%s\n%s\n", VERSION, GMPC_TAGLINE);
1956     }
1957     gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog), GMPC_COPYRIGHT);
1958     gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(dialog), _("Gnome Music Player Client"));
1959     gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog), GMPC_WEBSITE);
1960     gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), path);
1961
1962     g_free(path);
1963     gtk_widget_show(dialog);
1964     gtk_dialog_run(GTK_DIALOG(dialog));
1965     gtk_widget_destroy(dialog);
1966     g_object_unref(xml);
1967 }
1968
1969
1970 /****************************************************
1971  * Interface stuff
1972  */
1973 void pl3_update_go_menu(void)
1974 {
1975     int i = 0;
1976     int items = 0;
1977     GtkWidget *menu = NULL;
1978     GtkAccelGroup *group = playlist3_get_accel_group();
1979     GtkUIManager *ui = GTK_UI_MANAGER(gtk_builder_get_object(pl3_xml, "uimanager1"));
1980     GtkMenuItem *m_item = GTK_MENU_ITEM(gtk_ui_manager_get_widget(ui, "/menubartest/menu_go"));
1981     /***
1982      * Remove any old menu
1983      */
1984     gtk_menu_item_set_submenu(m_item, NULL);
1985     /**
1986      * Create a new menu
1987      */
1988     menu = gtk_menu_new();
1989     gtk_menu_set_accel_group(GTK_MENU(menu), group);
1990     if (mpd_check_connected(connection))
1991     {
1992         for (i = 0; i < num_plugins; i++)
1993         {
1994             if (gmpc_plugin_is_browser(plugins[i]))
1995             {
1996                 items += gmpc_plugin_browser_add_go_menu(plugins[i], menu);
1997             }
1998         }
1999     }
2000
2001     /**
2002      * Attach menu
2003      */
2004     if (items)
2005     {
2006         gtk_widget_show_all(menu);
2007         gtk_menu_item_set_submenu(m_item, menu);
2008         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_go")), TRUE);
2009     } else
2010     {
2011         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_go")), FALSE);
2012         g_object_ref_sink(menu);
2013         g_object_unref(menu);
2014     }
2015 }
2016
2017
2018 static void pl3_profile_selected(GtkRadioMenuItem * radio, gpointer data)
2019 {
2020     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(radio)))
2021     {
2022         gchar *uid = g_object_get_data(G_OBJECT(radio), "uid");
2023         if (!uid)
2024         {
2025             return;
2026         }
2027         connection_set_current_profile(uid);
2028         if (mpd_check_connected(connection))
2029         {
2030             mpd_disconnect(connection);
2031             connect_to_mpd();
2032         }
2033     }
2034 }
2035
2036
2037 static void pl3_profiles_changed(GmpcProfiles * prof, const int changed, const int col, const gchar * id)
2038 {
2039     if (!mpd_check_connected(connection))
2040     {
2041         playlist_connection_changed(connection, 0, NULL);
2042     }
2043 }
2044
2045
2046 static void pl3_update_profiles_menu(GmpcProfiles * prof, const int changed, const int col, const gchar * id)
2047 {
2048     int items = 0;
2049     GtkWidget *menu = NULL;
2050     gchar *current = gmpc_profiles_get_current(gmpc_profiles);
2051     GList *iter, *mult;
2052     GtkUIManager *ui = GTK_UI_MANAGER(gtk_builder_get_object(pl3_xml, "uimanager1"));
2053     GtkMenuItem *m_item = GTK_MENU_ITEM(gtk_ui_manager_get_widget(ui, "/menubartest/menu_music/menu_profiles"));
2054     /* check if there is anything changed that is important for us. */
2055
2056     if (changed == GMPC_PROFILES_ACTION_COL_CHANGED && col != GMPC_PROFILES_COLUMN_NAME)
2057     {
2058         g_free(current);
2059         return;
2060     }
2061     /***
2062      * Remove any old menu
2063      */
2064     gtk_menu_item_set_submenu(m_item, NULL);
2065     /**
2066      * Create a new menu
2067      */
2068     menu = gtk_menu_new();
2069
2070     mult = gmpc_profiles_get_profiles_ids(gmpc_profiles);
2071     if (mult)
2072     {
2073         GSList *group = NULL;
2074         iter = mult;
2075         do
2076         {
2077             /** Get profile name */
2078             const gchar *value = gmpc_profiles_get_name(gmpc_profiles, (char *)iter->data);
2079             GtkWidget *item = gtk_radio_menu_item_new_with_label(group, value);
2080             /* get new group */
2081             group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
2082             /* add to the menu */
2083             gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
2084
2085             /* check the current profile */
2086             if (!strcmp((char *)(iter->data), current))
2087             {
2088                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2089             }
2090
2091             /**
2092              * Attach click handler
2093              */
2094             g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(pl3_profile_selected), NULL);
2095
2096             /** Attach the uid to the handler */
2097             value = g_strdup((char *)(iter->data));
2098             g_object_set_data_full(G_OBJECT(item), "uid", (gpointer) value, g_free);
2099
2100             items++;
2101         } while ((iter = g_list_next(iter)));
2102         g_list_free(mult);
2103
2104     }
2105
2106     /**
2107      * Attach menu
2108      */
2109     if (items)
2110     {
2111         gtk_widget_show_all(menu);
2112         gtk_menu_item_set_submenu(m_item , menu);
2113         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_profiles")), TRUE);
2114     } else
2115     {
2116         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_profiles")), FALSE);
2117         g_object_ref_sink(menu);
2118         g_object_unref(menu);
2119     }
2120     g_free(current);
2121 }
2122
2123
2124 static void playlist3_server_output_changed(GtkWidget * item, gpointer data)
2125 {
2126     int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item), "id"));
2127     int state = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item));
2128     mpd_server_set_output_device(connection, id, state);
2129
2130 }
2131
2132
2133 void playlist3_server_update_db(void)
2134 {
2135     mpd_database_update_dir(connection, "/");
2136 }
2137
2138
2139 static GList *server_menu_items = NULL;
2140 static void playlist3_fill_server_menu(void)
2141 {
2142     GtkUIManager *ui = GTK_UI_MANAGER(gtk_builder_get_object(pl3_xml, "uimanager1"));
2143     GtkMenuItem *m_item = GTK_MENU_ITEM(gtk_ui_manager_get_widget(ui, "/menubartest/menu_server"));
2144     /** Clear old items */
2145     if(server_menu_items != NULL)
2146     {
2147         g_list_foreach(server_menu_items, (GFunc)gtk_widget_destroy, NULL);
2148         g_list_free(server_menu_items);
2149         server_menu_items = NULL;
2150     }
2151
2152     /* if connected fill with items */
2153     if (mpd_check_connected(connection))
2154     {
2155         GtkWidget *menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(m_item));
2156         GtkWidget *menu_item = NULL;
2157         int i = 0;
2158         MpdData *data = NULL;
2159
2160         data = mpd_server_get_output_devices(connection);
2161         if(data)
2162         {
2163             menu_item = gtk_separator_menu_item_new();
2164             server_menu_items = g_list_append(server_menu_items, menu_item);
2165             gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
2166         }
2167         for (; data; data = mpd_data_get_next(data))
2168         {
2169             menu_item = gtk_check_menu_item_new_with_label(data->output_dev->name);
2170             server_menu_items = g_list_append(server_menu_items, menu_item);
2171             gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), data->output_dev->enabled ? TRUE : FALSE);
2172             gtk_widget_add_accelerator(menu_item, "activate",
2173                 gtk_ui_manager_get_accel_group(GTK_UI_MANAGER(ui)),
2174                 GDK_KEY_1 + i, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
2175
2176             g_signal_connect(G_OBJECT(menu_item), "toggled", G_CALLBACK(playlist3_server_output_changed), NULL);
2177             g_object_set_data(G_OBJECT(menu_item), "id", GINT_TO_POINTER(data->output_dev->id));
2178             gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
2179             i++;
2180         }
2181         gtk_widget_show_all(menu);
2182         /* Server Menu Item */
2183         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_server")), TRUE);
2184     } else
2185     {
2186         /* Server Menu Item */
2187         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_server")), FALSE);
2188     }
2189 }
2190
2191
2192 /**
2193  * new header
2194  */
2195 /* glue code */
2196
2197
2198 void info2_activate(void)
2199 {
2200     GtkTreeView *tree = (GtkTreeView *) gtk_builder_get_object(pl3_xml, "cat_tree");
2201     gmpc_browsers_metadata_select_browser(browsers_metadata, tree);
2202 }
2203
2204
2205 void info2_fill_song_view(mpd_Song * song)
2206 {
2207     info2_activate();
2208     gmpc_browsers_metadata_set_song(browsers_metadata, song);
2209 }
2210
2211
2212 void info2_fill_artist_view(const gchar * artist)
2213 {
2214     info2_activate();
2215     gmpc_browsers_metadata_set_artist(browsers_metadata, artist);
2216 }
2217
2218
2219 void info2_fill_album_view(const gchar * artist, const gchar * album)
2220 {
2221     info2_activate();
2222     gmpc_browsers_metadata_set_album(browsers_metadata, artist, album);
2223 }
2224
2225
2226 void playlist3_insert_browser(GtkTreeIter * iter, gint position)
2227 {
2228     GtkTreeIter it, *sib = NULL;
2229     gint pos = 0;
2230     GtkTreeModel *model = GTK_TREE_MODEL(pl3_tree);
2231     if (gtk_tree_model_get_iter_first(model, &it))
2232     {
2233         do
2234         {
2235             gtk_tree_model_get(model, &it, PL3_CAT_ORDER, &pos, -1);
2236             if (position <= pos)
2237                 sib = &it;
2238         } while (sib == NULL && gtk_tree_model_iter_next(model, &it));
2239     }
2240
2241     // first check breaks recursion. Do not check for header when adding a header.
2242     // Next check checks if the header is allready there.
2243     if(position%1000 != 0 && (pos-pos%1000) != (position-position%1000))
2244     {
2245         // insert category
2246         pos = position-position%1000;
2247
2248         if(pos == PL3_CAT_BROWSER_LIBRARY)
2249         {
2250             playlist3_insert_browser(&it, PL3_CAT_BROWSER_LIBRARY);
2251             gtk_list_store_set(GTK_LIST_STORE(pl3_tree), &it,
2252                 PL3_CAT_TYPE,-1, PL3_CAT_TITLE, _("Library"),PL3_CAT_BOLD, PANGO_WEIGHT_ULTRABOLD,-1);
2253             sib = &it;
2254             gtk_list_store_insert_after(GTK_LIST_STORE(pl3_tree), iter, sib);
2255         }
2256         else if (pos == PL3_CAT_BROWSER_ONLINE_MEDIA)
2257         {
2258             playlist3_insert_browser(&it, PL3_CAT_BROWSER_ONLINE_MEDIA);
2259             gtk_list_store_set(GTK_LIST_STORE(pl3_tree), &it,
2260                 PL3_CAT_TYPE,-1, PL3_CAT_TITLE, _("Online Media"),PL3_CAT_BOLD, PANGO_WEIGHT_ULTRABOLD,-1);
2261             sib = &it;
2262             gtk_list_store_insert_after(GTK_LIST_STORE(pl3_tree), iter, sib);
2263         }
2264         else if  (pos == PL3_CAT_BROWSER_MISC)
2265         {
2266             playlist3_insert_browser(&it, PL3_CAT_BROWSER_MISC);
2267             gtk_list_store_set(GTK_LIST_STORE(pl3_tree), &it,
2268                     PL3_CAT_TYPE,-1, PL3_CAT_TITLE, _("Misc."),PL3_CAT_BOLD, PANGO_WEIGHT_ULTRABOLD,-1);
2269             sib = &it;
2270             gtk_list_store_insert_after(GTK_LIST_STORE(pl3_tree), iter, sib);
2271         }
2272         else
2273         {
2274             // Insert item.
2275             gtk_list_store_insert_before(GTK_LIST_STORE(pl3_tree), iter, sib);
2276         }
2277     }
2278     else
2279     {
2280         gtk_list_store_insert_before(GTK_LIST_STORE(pl3_tree), iter, sib);
2281     }
2282     gtk_list_store_set(GTK_LIST_STORE(pl3_tree), iter, PL3_CAT_ORDER, position, PL3_CAT_BOLD, PANGO_WEIGHT_NORMAL, -1);
2283 }
2284
2285
2286 /**
2287  * Category editing
2288  */
2289
2290 void playlist3_destroy(void)
2291 {
2292     GtkWidget *win = playlist3_get_window();
2293     if(server_menu_items) g_list_free(server_menu_items);
2294     gtk_widget_destroy(win);
2295     g_object_unref(pl3_xml);
2296 }
2297
2298 GtkWidget *playlist3_get_window(void)
2299 {
2300     return GTK_WIDGET(gtk_builder_get_object(pl3_xml, "pl3_win"));
2301 }
2302
2303
2304 /***
2305  * Help menu
2306  */
2307 /* Make glade happy */
2308 void url_visit_website(void);
2309 void url_getting_help(void);
2310
2311 void url_visit_website(void)
2312 {
2313     open_uri(GMPC_WEBSITE);
2314 }
2315
2316
2317 void url_getting_help(void)
2318 {
2319     open_uri(GMPC_BUGTRACKER);
2320 }
2321
2322
2323 gmpcPrefPlugin playlist_gpp =
2324 {
2325     .construct = playlist_pref_construct,
2326     .destroy = playlist_pref_destroy
2327 };
2328
2329 gmpcPlugin playlist_plug =
2330 {
2331     .name = N_("Interface"),
2332     .version = {1, 1, 1},
2333     .plugin_type = GMPC_INTERNALL,
2334     .mpd_status_changed = &playlist_status_changed,
2335     .mpd_connection_changed = &playlist_connection_changed,
2336     .pref = &playlist_gpp,
2337 };
2338
2339
2340 /**
2341  * Tool menu
2342  */
2343
2344 void pl3_tool_menu_update(void)
2345 {
2346     int i;
2347     int menu_items = 0;
2348     GtkWidget *menu = NULL;
2349     GtkAccelGroup *group = gtk_accel_group_new();
2350     GtkUIManager *ui = GTK_UI_MANAGER(gtk_builder_get_object(pl3_xml, "uimanager1"));
2351     GtkMenuItem *m_item = GTK_MENU_ITEM(gtk_ui_manager_get_widget(ui, "/menubartest/menu_tool"));
2352     gtk_menu_item_set_submenu(m_item, NULL);
2353     gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_tool")), FALSE);
2354     if (!mpd_check_connected(connection))
2355         return;
2356
2357     menu = gtk_menu_new();
2358     gtk_menu_set_accel_group(GTK_MENU(menu), group);
2359     g_object_unref(group);
2360     gtk_window_add_accel_group(GTK_WINDOW(playlist3_get_window()), group);
2361     for (i = 0; i < num_plugins; i++)
2362     {
2363         menu_items += gmpc_plugin_tool_menu_integration(plugins[i], GTK_MENU(menu));
2364     }
2365     if (menu_items)
2366     {
2367         gtk_widget_show_all(menu);
2368         gtk_menu_item_set_submenu(m_item, menu);
2369         gtk_action_set_sensitive(GTK_ACTION(gtk_builder_get_object(pl3_xml, "menu_tool")), TRUE);
2370     } else
2371     {
2372         g_object_ref_sink(menu);
2373         g_object_unref(menu);
2374     }
2375 }
2376
2377
2378 void easy_command_help_window(void)
2379 {
2380     if (gmpc_easy_command)
2381         gmpc_easy_command_help_window(gmpc_easy_command, NULL);
2382 }
2383
2384
2385
2386 /**
2387  * Extra wrappings for menu
2388  */
2389 extern gmpcPlugin extraplaylist_plugin;
2390 void enable_extra_playlist(GtkToggleAction *action)
2391 {
2392     gboolean state = gtk_toggle_action_get_active(action);
2393     if(extraplaylist_plugin.set_enabled)
2394     {
2395         if(extraplaylist_plugin.get_enabled() != state)
2396         {
2397             extraplaylist_plugin.set_enabled(state);
2398         }
2399     }
2400     preferences_window_update();
2401 }
2402
2403
2404 void init_extra_playlist_state(void)
2405 {
2406     GtkToggleAction *action = GTK_TOGGLE_ACTION(gtk_builder_get_object(pl3_xml, "ViewExtraPlaylist"));
2407     if(extraplaylist_plugin.get_enabled)
2408     {
2409         gtk_toggle_action_set_active(action, extraplaylist_plugin.get_enabled());
2410     }
2411 }
2412
2413 GtkAccelGroup *playlist3_get_accel_group(void)
2414 {
2415     static GtkAccelGroup *group = NULL;
2416     if(group == NULL) {
2417         group = gtk_accel_group_new();
2418         gtk_window_add_accel_group(GTK_WINDOW(playlist3_get_window()), group);
2419     }
2420     return group;
2421 }
2422
2423 void open_local_file(void)
2424 {
2425     char **handlers;
2426     gboolean found = FALSE;
2427     if(!mpd_check_connected(connection))
2428         return;
2429
2430     /* Check if MPD supports 'file://' (so local files). */
2431     handlers = mpd_server_get_url_handlers(connection);
2432     if (handlers)
2433     {
2434         int i=0;
2435         for(; !found && handlers != NULL && handlers[i] != NULL; i++) {
2436             if(g_utf8_collate(handlers[i], "file://") == 0) {
2437                 found = TRUE;
2438             }
2439         }
2440         g_strfreev(handlers);
2441     }
2442     /* error message or file open */
2443     if(!found) {
2444         /* Message not found */
2445         GtkWidget *gmd = gtk_message_dialog_new(
2446                     (GtkWindow*)playlist3_get_window(),
2447                     GTK_DIALOG_MODAL,
2448                     GTK_MESSAGE_ERROR,
2449                     GTK_BUTTONS_CLOSE,
2450                     _(
2451                         "To playback local files, you need to be connected "
2452                         "using unix socket.\n"
2453                         "See the MPD website for more information."
2454                     )
2455                 );
2456         gtk_dialog_run(GTK_DIALOG(gmd));
2457         gtk_widget_destroy(GTK_WIDGET(gmd));
2458     }else {
2459         GtkWidget *fmd = gtk_file_chooser_dialog_new(
2460                         "Select a local file",
2461                         (GtkWindow*)playlist3_get_window(),
2462                         GTK_FILE_CHOOSER_ACTION_OPEN,
2463                         GTK_STOCK_CLOSE,
2464                         GTK_RESPONSE_CLOSE,
2465                         GTK_STOCK_OPEN,
2466                         GTK_RESPONSE_OK,
2467                         NULL);
2468         gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fmd), TRUE);
2469         switch(gtk_dialog_run(GTK_DIALOG(fmd)))
2470         {
2471             case GTK_RESPONSE_OK:
2472             {
2473                 GSList *iter;
2474                 GSList *uris = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(fmd));
2475                 for(iter = uris;
2476                     iter != NULL;
2477                     iter = g_slist_next(iter))
2478                 {
2479                     char *uri = g_uri_unescape_string(iter->data,NULL);
2480                     url_start_real(uri);
2481                     g_free(uri);
2482                 }
2483                 g_slist_foreach (uris, (GFunc) g_free, NULL);
2484                 g_slist_free (uris);
2485                 break;
2486             }
2487             default:
2488                 break;
2489         }
2490         gtk_widget_destroy(GTK_WIDGET(fmd));
2491     }
2492 }
2493
2494 void show_user_manual(void);
2495 void show_user_manual(void)
2496 {
2497     open_help("ghelp:gmpc");
2498 }
2499
2500 GmpcPluginSidebarState playlist3_get_sidebar_state(void)
2501 {
2502     return  pl3_zoom == PLAYLIST_NO_ZOOM ? GMPC_PLUGIN_SIDEBAR_STATE_FULL:GMPC_PLUGIN_SIDEBAR_STATE_COLLAPSED;
2503 }
2504 /* vim: set noexpandtab ts=4 sw=4 sts=4 tw=80: */