src/main.c

   1 /* Gnome Music Player Client (GMPC)
   2  * Copyright (C) 2004-2012 Qball Cow <qball@gmpclient.org>
   3  * Project homepage: http://gmpclient.org/
   4
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <strings.h>
  24
  25 #include <libxml/parser.h>
  26
  27 /** Gtk/glib glade stuff */
  28 #include <gtk/gtk.h>
  29
  30 #include <libmpd/debug_printf.h>
  31 /* header files */
  32 #include "main.h"
  33 #include "playlist3.h"
  34
  35 #include "misc.h"
  36 #include "advanced-search.h"
  37 #include "gmpc_easy_download.h"
  38
  39 #include "setup-assistant.h"
  40
  41 #include "gmpc-mpddata-model-playlist.h"
  42 #include "bug-information.h"
  43
  44 #include "pixbuf-cache.h"
  45 #include "options.h"
  46 #include "preferences.h"
  47
  48 #include "plugin-man.h"
  49 #include "browsers/playlist3-playlist-editor.h"
  50
  51 #ifdef ENABLE_MMKEYS
  52 #include "mm-keys.h"
  53 #endif
  54
  55 #define LOG_DOMAIN "Gmpc"
  56 /**
  57  * Get revision
  58  */
  59 #include "revision.h"
  60
  61 #include "internal-plugins.h"
  62 #include "log.h"
  63 #include "mpd-easy-commands.h"
  64
  65 /**
  66  * Global objects that give signals
  67  */
  68
  69 GtkApplication *gmpc_application = NULL;
  70
  71
  72 /* gives signal on connection changes, and state changes of mpd.*/
  73 GmpcConnection *gmpcconn = NULL;
  74 /* Implements, and gives signals on profiles */
  75 GmpcProfiles *gmpc_profiles = NULL;
  76 /* Implements, and gives signals on meta_data*/
  77 GmpcMetaWatcher *gmw = NULL;
  78 /* Easy command */
  79 GmpcEasyCommand *gmpc_easy_command = NULL;
  80 /* Playlist3 messages */
  81 Playlist3MessagePlugin *pl3_messages = NULL;
  82
  83 /* The playlist backend */
  84 GtkTreeModel *playlist = NULL;
  85
  86 GObject *paned_size_group = NULL;
  87 /**
  88  * This flag indicate the requested connection state by the user.
  89  * If the user presses disconnect,  you don't want to auto-connect anymore.
  90  **/
  91 int gmpc_connected = FALSE;
  92
  93 static void connection_changed_real(
  94     GmpcConnection * gmpcconn,
  95     MpdObj * mi,
  96     int connect,
  97     gpointer data);
  98
  99 static void gmpc_status_changed_callback_real(
 100     GmpcConnection * gmpcconn,
 101     MpdObj * mi,
 102     ChangedStatusType what,
 103     gpointer data);
 104
 105 /**
 106  * Define some local functions
 107  */
 108
 109 static void gmpc_easy_command_set_default_entries(void);
 110 static void  gmpc_mmkeys_connect_signals(GObject *keys);
 111 /** handle connection changed */
 112 static void connection_changed(MpdObj * mi, int connect, gpointer data);
 113
 114 /** Error callback */
 115 static int error_callback(MpdObj * mi,
 116     int error_id,
 117     char *error_msg,
 118     gpointer data);
 119
 120 /** init stock icons */
 121 static void init_stock_icons(void);
 122
 123 /*
 124  * the xml fle pointer to the player window
 125  */
 126 static GtkBuilder *xml_password_window = NULL;
 127 static int autoconnect_callback(void);
 128
 129 /*
 130  * the ID of the autoconnect timeout callback
 131  */
 132 static guint autoconnect_timeout = 0;
 133
 134 /*
 135  * The Config object
 136  */
 137 config_obj *config = NULL;
 138
 139 /*
 140  * The Connection object
 141  */
 142 MpdObj *connection = NULL;
 143
 144 /* Glade prototypes, these would be static otherwise */
 145 void send_password(void);
 146
 147 static void print_version(void);
 148
 149
 150 /**
 151  * Forward libxml errors into GLib.log errors with LibXML error domain
 152  */
 153 static void xml_error_func(void *ctx, const char *msg, ...)
 154 {
 155     va_list ap;
 156     va_start(ap, msg);
 157     g_logv("LibXML", G_LOG_LEVEL_DEBUG, msg, ap);
 158     va_end(ap);
 159 }
 160 /* \todo why is this here? */
 161 static xmlGenericErrorFunc handler = (xmlGenericErrorFunc) xml_error_func;
 162
 163
 164 static gboolean hide_on_start(void)
 165 {
 166     pl3_hide();
 167     return FALSE;
 168 }
 169 static int handle_commandline(GApplication *app, GApplicationCommandLine *cmd, gpointer data)
 170 {
 171     gchar **argv;
 172     gint argc;
 173
 174     argv = g_application_command_line_get_arguments(cmd, &argc);
 175     printf("Commandline handler: %i\n", argc);
 176     if(argc > 1) {
 177         int i;
 178         for ( i = 1; i < argc; i++) {
 179             printf("executing: %s\n" , argv[i]);
 180             gmpc_easy_command_do_query(gmpc_easy_command, argv[i]);
 181         }
 182     }else {
 183         printf("activate\n");
 184         g_application_activate(gmpc_application);
 185     }
 186
 187     return EXIT_SUCCESS;
 188 }
 189
 190
 191 int main(int argc, char **argv)
 192 {
 193     #ifdef WIN32
 194     gchar *packagedir = NULL;
 195     #endif
 196     #ifdef ENABLE_MMKEYS
 197     MmKeys *keys = NULL;
 198     #endif
 199
 200     /* A string used severall times to create a path  */
 201     gchar *url = NULL;
 202
 203     INIT_TIC_TAC();
 204
 205     log_init();
 206
 207     /**
 208      * Setup NLS
 209      */
 210     #ifdef ENABLE_NLS
 211     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Setting NLS");
 212     bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
 213     bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
 214     textdomain(GETTEXT_PACKAGE);
 215     #endif
 216
 217     //gtk_set_locale();
 218 //    setlocale();
 219
 220     TEC("Setting up locale");
 221
 222     parse_options(&argc, &argv);
 223
 224     /* Show the version, if requested */
 225     if (settings.show_version)
 226     {
 227         print_version();
 228         return EXIT_SUCCESS;
 229     }
 230     TEC("Parsing command line options");
 231
 232     log_set_debug_level(settings.debug_level);
 233     TEC("Set debug level")
 234     /* Show the bug-information dialog */
 235     if (settings.show_bug_information)
 236     {
 237         bug_information_file_new(stdout);
 238         return EXIT_SUCCESS;
 239     }
 240
 241
 242     /**
 243      * Init libxml.
 244      * Libxml is not used (directly) by gmpc.
 245      * But via glade and several plugins use it.
 246      * I need to initialize it before the threading is started.
 247      * So moved to gmpc.
 248      *
 249      * This fixes the plugin crasher bug on windows.
 250      */
 251     xmlInitParser();
 252     initGenericErrorDefaultFunc(&handler);
 253
 254     /**
 255      * Check if threading is supported, if so, start it.
 256      * Don't fail here, stuff like can cause that it is allready initialized.
 257      */
 258     if (!g_thread_supported())
 259         g_thread_init(NULL);
 260
 261     TEC("Initializing threading");
 262     /*
 263      * initialize gtk
 264      */
 265     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Initializing gtk ");
 266
 267     #ifdef WIN32
 268     /**
 269      * This loads an extra gtk rc file on windows.
 270      * This is used to re-enable rule-hint in the treeview.
 271      * (this is forced off on windows).
 272      */
 273     packagedir = g_win32_get_package_installation_directory_of_module(NULL);
 274     url = g_build_filename(packagedir,
 275             "share", "gmpc",
 276             "gmpc-gtk-win32.rc", NULL);
 277     q_free(packagedir);
 278     gtk_rc_add_default_file(url);
 279     g_free(url);
 280     #endif
 281
 282     /* initialize gtk */
 283     gmpc_application = gtk_application_new("org.gmpclient.gmpc",  G_APPLICATION_HANDLES_COMMAND_LINE);
 284     {
 285         GError *error = NULL;
 286
 287
 288         if(!g_application_register(G_APPLICATION(gmpc_application),NULL, &error))
 289         {
 290             g_error("Failed to register instance: %s", error->message);
 291             return EXIT_FAILURE;
 292         }
 293
 294         // Check if we are already running.
 295         if(g_application_get_is_remote(G_APPLICATION(gmpc_application)))
 296         {
 297             g_debug("Already running....");
 298             return g_application_run(G_APPLICATION(gmpc_application), argc, argv);
 299         }
 300
 301         g_signal_connect(G_OBJECT(gmpc_application), "command-line", G_CALLBACK(handle_commandline), NULL);
 302         g_signal_connect(G_OBJECT(gmpc_application), "activate", G_CALLBACK(pl3_show_and_position_window), NULL);
 303     }
 304     TEC("Gtk init");
 305
 306
 307     {
 308         GError          *error = NULL;
 309         GtkCssProvider  *provider = gtk_css_provider_new ();
 310         gchar           *path = g_build_filename(PACKAGE_DATA_DIR, "gmpc", "gmpc.css", NULL);
 311
 312         gtk_css_provider_load_from_path(provider, path, &error);
 313
 314         printf("Loading: %s\n", path);
 315
 316
 317         if(error != NULL) {
 318             g_error("Failed to load css file: %s:%s",path, error->message);
 319             g_free(path);
 320             g_error_free(error);
 321         }
 322         GdkDisplay *display = gdk_display_get_default ();
 323         GdkScreen *screen = gdk_display_get_default_screen (display);
 324
 325         gtk_style_context_add_provider_for_screen (
 326                 screen, GTK_STYLE_PROVIDER (provider),
 327                 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 328
 329         g_object_unref (provider);
 330         g_free(path);
 331     }
 332
 333
 334     /* Hack to override the icon theme, on recursive zeltak request */
 335     if(settings.icon_theme != NULL) {
 336         gtk_settings_set_string_property(gtk_settings_get_default(),
 337                 "gtk-icon-theme-name" , settings.icon_theme,NULL);
 338     }
 339
 340     /**
 341      * Call create_gmpc_paths();
 342      * This function checks if the path needed path are available
 343      * and creates them if needed.
 344      */
 345     create_gmpc_paths();
 346     TEC("Check version and create paths");
 347
 348
 349     /**
 350      * Open the config file
 351      */
 352     /**
 353      * Check if the user has forced a different config file location.
 354      * else set to ~/.gmpc/gmpc.cfg
 355      */
 356     if (!settings.config_path)
 357     {
 358         url = gmpc_get_user_path("gmpc.cfg");
 359     } else
 360     {
 361         url = g_strdup(settings.config_path);
 362     }
 363
 364     /**
 365      * Open it
 366      */
 367     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
 368             "Trying to open the config file: %s", url);
 369     config = cfg_open(url);
 370
 371    /**
 372     * Show gtk error message and quit if config failed to open.
 373     */
 374     if (config == NULL)
 375     {
 376         g_log(LOG_DOMAIN, G_LOG_LEVEL_ERROR,
 377             "Failed to save/load configuration:\n%s\n", url);
 378         show_error_message(_("Failed to load the configuration system."));
 379         return EXIT_FAILURE;
 380     }
 381     TEC("Opening config file: %s", url);
 382     q_free(url);
 383
 384     /**
 385      * \TODO, Check if version changed, then say something about it
 386      *
 387      * Enable this function if we need todo some upgrading on version change.
 388      * Removal of this current content destroys config conversion from 0.17 and
 389      * up
 390      */
 391     url = cfg_get_single_value_as_string(config, "Default", "version");
 392     if (url == NULL || strcmp(url, VERSION))
 393     {
 394         cfg_set_single_value_as_string(config, "Default", "version", VERSION);
 395     }
 396     if (url) q_free(url);
 397     TEC("New version check");
 398
 399
 400     if (settings.quit)
 401     {
 402         cfg_close(config);
 403         return EXIT_SUCCESS;
 404     }
 405
 406     /* Easy command */
 407     gmpc_easy_command = gmpc_easy_command_new();
 408     TEC("Init easy command")
 409     gmpc_easy_command_set_default_entries();
 410     TEC("Set easy commands")
 411     mpd_easy_commands_init();
 412     TEC("Set MPD Easy commands");
 413     /* Advanced search */
 414     advanced_search_init();
 415     TEC("Init advanced search");
 416
 417     /* PanedSizeGroup */
 418     paned_size_group = (GObject *) gmpc_paned_size_group_new();
 419
 420     gmpc_profiles = gmpc_profiles_new();
 421     /* If user requested a profile, look it up and set it active */
 422     if (settings.profile_name)
 423     {
 424        gmpc_profiles_set_profile_from_name(gmpc_profiles,
 425                                                settings.profile_name);
 426     }
 427     TEC("Setting up gmpc idle,signals and profiles");
 428     /**
 429      * Initialize the new metadata subsystem.
 430      */
 431     meta_data_init();
 432
 433     TEC("Initializing metadata system");
 434     pixbuf_cache_create();
 435     TEC("Pixbuf cache create()");
 436
 437     /**
 438      * stock icons
 439      */
 440     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading stock icons");
 441     init_stock_icons();
 442     TEC("Init stock icons");
 443     /**
 444      * Create connection object
 445      */
 446     connection = mpd_new_default();
 447     if (connection == NULL)
 448     {
 449         /**
 450          * if failed, print error message
 451          */
 452         g_log(LOG_DOMAIN,
 453              G_LOG_LEVEL_ERROR,
 454              "Failed to create connection object\n");
 455         show_error_message(_("Failed to setup libmpd"));
 456         abort();
 457     }
 458     TEC("Setting up mpd connection object");
 459     /**
 460      * Connect signals to the connection object
 461      */
 462     mpd_signal_connect_status_changed(connection,
 463             GmpcStatusChangedCallback, NULL);
 464     mpd_signal_connect_error(connection,
 465             error_callback, NULL);
 466     mpd_signal_connect_connection_changed(connection,
 467             connection_changed, NULL);
 468     /**
 469      * Just some trick to provide glib signals
 470      */
 471     gmpcconn = (GmpcConnection *) gmpc_connection_new();
 472     g_signal_connect(G_OBJECT(gmpcconn),
 473             "connection_changed",
 474             G_CALLBACK(connection_changed_real), NULL);
 475     g_signal_connect(G_OBJECT(gmpcconn),
 476             "status_changed",
 477             G_CALLBACK(gmpc_status_changed_callback_real), NULL);
 478
 479     TEC("Setting up mpd object signal system");
 480     /**
 481      * New Metadata object
 482      */
 483     gmw = gmpc_meta_watcher_new();
 484     TEC("Initializing metadata watcher");
 485
 486
 487
 488     /** init the error messages */
 489     pl3_messages = playlist3_message_plugin_new();
 490
 491     playlist = (GtkTreeModel*)gmpc_mpddata_model_playlist_new(
 492                                                 gmpcconn,
 493                                                 connection);
 494     gmpc_mpddata_model_disable_image(GMPC_MPDDATA_MODEL(playlist));
 495
 496     /**
 497      * Add the internall plugins
 498      */
 499      plugin_manager_load_internal_plugins();
 500
 501
 502     /**
 503      *  load dynamic plugins
 504      */
 505     if (!settings.disable_plugins)
 506     {
 507         plugin_manager_load_plugins();
 508     }
 509
 510     /**
 511      * Create the main window
 512      */
 513     create_playlist3();
 514     TEC("Creating playlist window");
 515
 516     /* time todo some initialisation of plugins */
 517     plugin_manager_initialize_plugins();
 518
 519     /**
 520      * First run dialog
 521      *
 522      * If gmpc is ran for the first time, we want to show a wizard that helps
 523      * the user getting started.
 524      */
 525     if (cfg_get_single_value_as_int_with_default(config,
 526             "Default",
 527             "first-run",
 528             1))
 529     {
 530         setup_assistant();
 531         cfg_set_single_value_as_int(config, "Default", "first-run", 0);
 532         TEC("Setup first run assistant");
 533     }
 534
 535     /**
 536      * If autoconnect is enabled, tell gmpc that it's in state it should connect
 537      */
 538     if (cfg_get_single_value_as_int_with_default(config,
 539             "connection",
 540             "autoconnect",
 541             DEFAULT_AUTOCONNECT))
 542     {
 543         gmpc_connected = TRUE;
 544     }
 545     /*
 546      * create timeouts
 547      * get the status every 1/2 second should be enough, but it's configurable.
 548      */
 549     g_timeout_add(cfg_get_single_value_as_int_with_default(config,
 550         "connection",
 551         "mpd-update-speed",
 552         500), (GSourceFunc) update_mpd_status, NULL);
 553     /**
 554      * create the autoconnect timeout,
 555      * if autoconnect enable, it will check every 5 seconds
 556      * if you are still connected, and reconnects you if not.
 557      */
 558     autoconnect_timeout = g_timeout_add_seconds(5,
 559             (GSourceFunc) autoconnect_callback, NULL);
 560
 561     /**
 562      * Call this when entering the main loop,
 563      *  so you are connected on startup, not 5 seconds later
 564      */
 565     g_idle_add((GSourceFunc) autoconnect_callback, NULL);
 566     if (settings.fullscreen)
 567     {
 568         g_idle_add((GSourceFunc) pl3_window_fullscreen, NULL);
 569     }
 570
 571     /**
 572      * If the user wants gmpc to be started hidden,
 573      * call pl3_hide after the mainloop started running
 574      */
 575     if (cfg_get_single_value_as_int_with_default(config,
 576             "Default",
 577             "start-hidden",
 578             FALSE) ||
 579             settings.start_hidden)
 580     {
 581         g_timeout_add(250, (GSourceFunc) hide_on_start, NULL);
 582     }
 583     TEC("Setting up timers");
 584
 585     #ifdef ENABLE_MMKEYS
 586     /**
 587      * Setup Multimedia Keys
 588      */
 589     keys = mmkeys_new();
 590     gmpc_mmkeys_connect_signals(G_OBJECT(keys));
 591     TEC("Setting up multimedia keys");
 592     #endif
 593
 594     url = gmpc_get_user_path("gmpc.key");
 595     gtk_accel_map_load(url);
 596     q_free(url);
 597
 598
 599     /*
 600      * run the main loop
 601      */
 602     //gtk_main();
 603     int retv = g_application_run(G_APPLICATION(gmpc_application), argc, argv);
 604
 605     /**
 606      * Shutting Down
 607      *  cleaning up.
 608      */
 609     url = gmpc_get_user_path("gmpc.key");
 610     gtk_accel_map_save(url);
 611     q_free(url);
 612
 613     /* Quit _all_ downloads */
 614     gmpc_easy_async_quit();
 615
 616     /* tell the plugins to save themself. */
 617     plugin_manager_save_state();
 618
 619     /* Should fix some possible crashes */
 620     gtk_tree_view_set_model(playlist3_get_category_tree_view(), NULL);
 621
 622     /**
 623      * Clear metadata struct
 624      */
 625     meta_data_destroy();
 626
 627     /* time todo some destruction of plugins */
 628     plugin_manager_destroy_plugins();
 629
 630     playlist3_destroy();
 631
 632     g_object_unref(playlist);
 633     g_object_unref(G_OBJECT(gmw));
 634
 635     /* Destroy PanedSizeGroup */
 636     g_object_unref(paned_size_group);
 637     /**
 638      * Close the config file
 639      */
 640     TOC("Starting save config");
 641     cfg_close(config);
 642     TOC("Saved config");
 643     g_object_unref(gmpc_profiles);
 644     g_object_unref(gmpcconn);
 645
 646     pixbuf_cache_destroy();
 647     /**
 648      * This now gets destroyed with the plugins
 649      */
 650     advanced_search_destroy();
 651     /**
 652      * Destroy the connection object
 653      */
 654     mpd_free(connection);
 655
 656     /* Reset xml error function and cleanup */
 657     initGenericErrorDefaultFunc((xmlGenericErrorFunc *) NULL);
 658     xmlCleanupParser();
 659     /* cleanup */
 660     gmpc_mpddata_treeview_cleanup();
 661
 662     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Quit....\n");
 663     return retv;
 664 }
 665
 666
 667 /**
 668  * Function to quiet the program
 669  */
 670 void main_quit(void)
 671 {
 672     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Quiting gmpc....");
 673     /**
 674      * close playlist and store size
 675      */
 676     pl3_hide();
 677     /**
 678      * Remove the autoconnect timeout,
 679      */
 680     if (autoconnect_timeout)
 681         g_source_remove(autoconnect_timeout);
 682
 683     /**
 684      * Call the connection changed.
 685      * so it saves the playlist pos
 686      */
 687     mpd_signal_connect_connection_changed(connection, NULL, NULL);
 688
 689     /**
 690      * Disconnect when connected
 691      */
 692     if (mpd_check_connected(connection))
 693     {
 694         if (cfg_get_single_value_as_int_with_default(config,
 695                     "connection", "stop-on-exit", FALSE))
 696         {
 697             mpd_player_stop(connection);
 698         }
 699         mpd_disconnect(connection);
 700     }
 701     /**
 702      * Exit main loop
 703      */
 704     gtk_widget_destroy(playlist3_get_window());
 705 }
 706
 707
 708 /**
 709  * Callback that get's called every 5 seconds,
 710  * and tries to autoconnect
 711  * (when enabled)
 712  */
 713
 714 static int autoconnect_backoff = 0;
 715 static int autoconnect_callback(void)
 716 {
 717     /* Don't autoconnect while showing the first start assistant */
 718     if (setup_assistant_is_running())
 719         return FALSE;
 720
 721     /* check if there is an connection. */
 722     if (!mpd_check_connected(connection))
 723     {
 724         /* connect when autoconnect is enabled, the user wants to be connected
 725          */
 726         if (gmpc_connected
 727             && cfg_get_single_value_as_int_with_default(config,
 728                     "connection", "autoconnect", DEFAULT_AUTOCONNECT))
 729         {
 730             connect_to_mpd();
 731         }
 732     }
 733     if (autoconnect_backoff < 60)
 734         autoconnect_backoff += 1;
 735     /* keep the timeout running */
 736     if (autoconnect_timeout)
 737         g_source_remove(autoconnect_timeout);
 738     autoconnect_timeout = g_timeout_add_seconds(5 + autoconnect_backoff,
 739             (GSourceFunc) autoconnect_callback, NULL);
 740     return FALSE;
 741 }
 742
 743
 744 static void init_stock_icons(void)
 745 {
 746     char *path;
 747
 748     path = gmpc_get_full_image_path();
 749     gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), path);
 750     q_free(path);
 751
 752     gtk_window_set_default_icon_name("gmpc");
 753
 754     #ifdef WIN32
 755     /* The Windows gtkrc sets this to 0, so images don't work on buttons */
 756     gtk_settings_set_long_property(gtk_settings_get_default(),
 757                 "gtk-button-images", TRUE, "main");
 758     #endif
 759
 760     return;
 761 }
 762
 763
 764 /**
 765  * Handle status changed callback from the libmpd object
 766  * This involves propegating the signal
 767  */
 768 void GmpcStatusChangedCallback(MpdObj * mi,
 769                                 ChangedStatusType what,
 770                                 void *userdata)
 771 {
 772     g_signal_emit_by_name(gmpcconn, "status-changed", mi, what);
 773 }
 774
 775
 776 /* The actual handling of the status changed signal */
 777 static void gmpc_status_changed_callback_real(GmpcConnection * conn,
 778                                             MpdObj * mi,
 779                                             ChangedStatusType what,
 780                                             gpointer data)
 781 {
 782     /* When permission changes, update the advanced search regex */
 783     if (what & MPD_CST_PERMISSION)
 784     {
 785         advanced_search_update_taglist();
 786     }
 787     /**
 788      * Make the plugins recieve the signals
 789      */
 790      plugin_manager_status_changed(mi, what);
 791 }
 792
 793
 794 /*******************************
 795  * Error handling
 796  * TODO: Needs to be redone/rethought
 797  */
 798
 799 static void password_dialog_response(
 800                 GtkWidget * dialog,
 801                 gint response,
 802                 gpointer data)
 803 {
 804     gchar *path;
 805     switch (response)
 806     {
 807         case 0:
 808             return;
 809         case GTK_RESPONSE_OK:
 810         {
 811             path = (char *)gtk_entry_get_text(
 812                         GTK_ENTRY(gtk_builder_get_object(xml_password_window,
 813                         "pass_entry")));
 814             mpd_set_password(connection, path);
 815             if (gtk_toggle_button_get_active
 816                 (GTK_TOGGLE_BUTTON(gtk_builder_get_object(
 817                     xml_password_window,
 818                     "ck_save_pass"))))
 819             {
 820                 connection_set_password(path);
 821             }
 822             mpd_send_password(connection);
 823         }
 824         break;
 825         default:
 826             if (mpd_server_check_command_allowed(connection, "status") !=
 827                              MPD_SERVER_COMMAND_ALLOWED)
 828             {
 829                 playlist3_show_error_message(
 830                     _("GMPC has insufficient permissions on the mpd server."),
 831                     ERROR_CRITICAL);
 832                 mpd_disconnect(connection);
 833             }
 834             break;
 835     }
 836     gtk_widget_destroy(
 837         (GtkWidget *) gtk_builder_get_object(xml_password_window,
 838         "password-dialog"));
 839     g_object_unref(xml_password_window);
 840     xml_password_window = NULL;
 841 }
 842
 843
 844 static void password_dialog(int failed)
 845 {
 846     GtkWidget *pl3_win = playlist3_get_window();
 847     gchar *path = NULL;
 848     if (xml_password_window)
 849         return;
 850     path = gmpc_get_full_glade_path("password-dialog.ui");
 851     xml_password_window = gtk_builder_new();
 852     gtk_builder_add_from_file(xml_password_window, path, NULL);
 853     gtk_window_set_transient_for(GTK_WINDOW
 854         (gtk_builder_get_object(xml_password_window, "password-dialog")),
 855         GTK_WINDOW(pl3_win));
 856     q_free(path);
 857     if (!xml_password_window)
 858         return;
 859     if (failed)
 860     {
 861         path = g_strdup_printf(
 862             _("Failed to set password on: '%s'\nPlease try again"),
 863             mpd_get_hostname(connection));
 864     } else
 865     {
 866         path = g_strdup_printf(
 867             _("Please enter your password for: '%s'"),
 868             mpd_get_hostname(connection));
 869     }
 870     gtk_label_set_text(
 871         GTK_LABEL(gtk_builder_get_object(xml_password_window, "pass_label")),
 872         path);
 873     q_free(path);
 874
 875     g_signal_connect(G_OBJECT
 876         (gtk_builder_get_object
 877         (xml_password_window, "password-dialog")), "response",
 878         G_CALLBACK(password_dialog_response), xml_password_window);
 879 }
 880
 881
 882 void send_password(void)
 883 {
 884     password_dialog(FALSE);
 885 }
 886
 887 static void playlist_support_help_button_clicked(GObject *a)
 888 {
 889     open_help("ghelp:gmpc?ProblemSolving");
 890
 891 }
 892
 893 static int error_callback(MpdObj * mi,
 894                 int error_id,
 895                 char *error_msg,
 896                 gpointer data)
 897 {
 898     int autoconnect = cfg_get_single_value_as_int_with_default(config,
 899             "connection",
 900             "autoconnect",
 901             DEFAULT_AUTOCONNECT);
 902
 903     /* if we are not connected we show a reconnect */
 904     if (!mpd_check_connected(mi))
 905     {
 906         GtkWidget *button;
 907         char *str;
 908         /* no response? then we just ignore it when autoconnecting. */
 909         if (error_id == 15 && autoconnect)
 910             return FALSE;
 911
 912         str = g_markup_printf_escaped("<b>%s %i: %s</b>",
 913                 _("error code"),
 914                 error_id,
 915                 error_msg);
 916         playlist3_show_error_message(str, ERROR_CRITICAL);
 917         button = gtk_button_new_from_stock(GTK_STOCK_CONNECT);
 918         g_signal_connect(G_OBJECT(button),
 919                 "clicked",
 920                 G_CALLBACK(connect_to_mpd), NULL);
 921         playlist3_error_add_widget(button);
 922         g_free(str);
 923     } else
 924     {
 925         if (setup_assistant_is_running()
 926                 && (error_id == MPD_ACK_ERROR_PERMISSION ||
 927                     error_id == MPD_ACK_ERROR_PASSWORD))
 928         {
 929             gchar *str = g_markup_printf_escaped("<b>%s</b>",
 930                     _("Insufficient permission to connect to mpd. Check password"));
 931             setup_assistant_set_error(str);
 932             q_free(str);
 933             return TRUE;
 934         }
 935         if(error_id == MPD_ACK_ERROR_SYSTEM || error_id == MPD_ACK_ERROR_NO_EXIST) {
 936             if(g_regex_match_simple(".*{.*playlist.*}.*", error_msg,
 937                         0,G_REGEX_MATCH_NOTEMPTY))
 938             {
 939                 GtkWidget *button = NULL;
 940                 if(favorites != NULL) {
 941                     gmpc_favorites_list_set_disable(favorites,TRUE);
 942                 }
 943                 playlist_editor_set_disabled();
 944                 playlist3_show_error_message(
 945                         _("Playlist support in MPD is not working. See the "
 946                         "manual on possible fixes.\n"
 947                         "Playlist editor and favorites are now disabled."
 948                         )
 949                         , ERROR_WARNING);
 950
 951                 button = gtk_button_new_from_stock(GTK_STOCK_HELP);
 952                 g_signal_connect(G_OBJECT(button), "clicked",
 953                         G_CALLBACK(playlist_support_help_button_clicked), NULL);
 954                 playlist3_error_add_widget(button);
 955                 return FALSE;
 956             }
 957         }
 958         if (error_id == MPD_ACK_ERROR_PASSWORD)
 959         {
 960             password_dialog(TRUE);
 961         } else if (error_id == MPD_ACK_ERROR_PERMISSION)
 962         {
 963             password_dialog(FALSE);
 964         } else
 965         {
 966             gchar *str = g_markup_printf_escaped("<b>%s %i: %s</b>",
 967                     _("error code"), error_id,
 968                     error_msg);
 969             playlist3_show_error_message(str, ERROR_CRITICAL);
 970             g_free(str);
 971         }
 972     }
 973     return FALSE;
 974 }
 975
 976
 977 /**
 978  * handle a connection changed
 979  */
 980 static void connection_changed(MpdObj * mi, int connected, gpointer data)
 981 {
 982     /* propagate the signal to the connection object */
 983     if (mpd_check_connected(mi) != connected)
 984     {
 985         g_log(LOG_DOMAIN,
 986                 G_LOG_LEVEL_ERROR,
 987                 "Connection state differs from actual state: act: %i\n",
 988                 !connected);
 989     }
 990     /**
 991      * Check version
 992      */
 993     if (connected && !mpd_server_check_version(mi, 0, 13, 0))
 994     {
 995         gchar *value = g_markup_printf_escaped("<b>%s</b>",
 996             _("MPD versions before 0.13.0 are not supported"));
 997         /* disable user connect ! */
 998         gmpc_connected = FALSE;
 999         mpd_disconnect(mi);
1000         /* Give error */
1001         playlist3_show_error_message(value, ERROR_CRITICAL);
1002         g_free(value);
1003     }
1004     /* Remove timeout */
1005     if (connected)
1006     {
1007         if (autoconnect_timeout)
1008             g_source_remove(autoconnect_timeout);
1009         autoconnect_timeout = 0;
1010         autoconnect_backoff = 0;
1011     }
1012     if (connected)
1013     {
1014         advanced_search_update_taglist();
1015     }
1016     /**
1017      * force an update of status, to check password
1018      */
1019     if (connected)
1020     {
1021         mpd_status_update(mi);
1022         if (connected != mpd_check_connected(mi))
1023         {
1024             g_log(LOG_DOMAIN, G_LOG_LEVEL_WARNING, "State differs, exit");
1025             /* Probly disconnected when getting status..   exiting */
1026             return;
1027         }
1028     }
1029
1030     /* remove this when it does not fix it */
1031     g_signal_emit_by_name(gmpcconn,
1032                 "connection-changed",
1033                 mi,
1034                 mpd_check_connected(mi));
1035 }
1036
1037
1038 static void connection_changed_real(
1039                         GmpcConnection * obj,
1040                         MpdObj * mi,
1041                         int connected,
1042                         gpointer data)
1043 {
1044     /**
1045      * propegate signals
1046      */
1047     g_log(LOG_DOMAIN,
1048             G_LOG_LEVEL_DEBUG,
1049             "Connection changed %i-%i \n",
1050             connected,
1051             mpd_check_connected(mi));
1052     plugin_manager_connection_changed(mi, connected);
1053
1054     /**
1055      * force an update of status
1056      */
1057     if (connected)
1058         mpd_status_update(mi);
1059
1060     if (connected)
1061     {
1062         playlist3_show_error_message(_("Connected to mpd"), ERROR_INFO);
1063     } else
1064     {
1065         playlist3_show_error_message(_("Disconnected from mpd"), ERROR_INFO);
1066     }
1067
1068     if (!connected)
1069     {
1070         if (autoconnect_timeout)
1071             g_source_remove(autoconnect_timeout);
1072         autoconnect_timeout = g_timeout_add_seconds(5,
1073                 (GSourceFunc) autoconnect_callback, NULL);
1074         autoconnect_backoff = 0;
1075     }
1076 }
1077
1078
1079 /**
1080  * Shows an error message.
1081  */
1082 void show_error_message(const gchar * string)
1083 {
1084     GtkWidget *dialog = gtk_message_dialog_new_with_markup(NULL,
1085         GTK_DIALOG_MODAL,
1086         GTK_MESSAGE_ERROR,
1087         GTK_BUTTONS_CLOSE,
1088         "%s", string);
1089     gtk_widget_show(dialog);
1090     gtk_dialog_run(GTK_DIALOG(dialog));
1091 }
1092
1093 static void print_version(void)
1094 {
1095     printf("%s\n", _("Gnome Music Player Client"));
1096     printf(GMPC_COPYRIGHT "\n\n");
1097     printf("%-25s: %s\n", _("Tagline"), GMPC_TAGLINE);
1098     printf("%-25s: %i.%i.%i\n", _("Version"),
1099             GMPC_MAJOR_VERSION,
1100             GMPC_MINOR_VERSION,
1101             GMPC_MICRO_VERSION);
1102     if (revision && revision[0] != '\0')
1103     {
1104         printf("%-25s: %s\n", _("Revision"), revision);
1105     }
1106 }
1107
1108 /**
1109  * Set a basic set of easycommand handlers.
1110  */
1111 static void gmpc_easy_command_set_default_entries(void)
1112 {
1113     gmpc_easy_command_add_entry_stock_id(gmpc_easy_command,
1114             _("quit"), "",
1115             _("Quit gmpc"),
1116             (GmpcEasyCommandCallback *) main_quit,
1117             NULL,GTK_STOCK_QUIT);
1118
1119     gmpc_easy_command_add_entry(gmpc_easy_command,
1120             _("hide"), "",
1121             _("Hide gmpc"),
1122             (GmpcEasyCommandCallback *) pl3_hide,
1123             NULL);
1124
1125     gmpc_easy_command_add_entry(gmpc_easy_command,
1126             _("show"), "",
1127             _("Show gmpc"),
1128             (GmpcEasyCommandCallback *) create_playlist3,
1129             NULL);
1130
1131     gmpc_easy_command_add_entry(gmpc_easy_command,
1132             _("toggle"), "",
1133             _("Toggle gmpc visibility"),
1134             (GmpcEasyCommandCallback *) pl3_toggle_hidden,
1135             NULL);
1136
1137     gmpc_easy_command_add_entry(gmpc_easy_command,
1138             _("show notification"), "",
1139             _("Show trayicon notification"),
1140             (GmpcEasyCommandCallback *) tray_icon2_create_tooltip,
1141             NULL);
1142     gmpc_easy_command_add_entry_stock_id(gmpc_easy_command,
1143             _("preferences"), "",
1144             _("Show preferences window"),
1145             (GmpcEasyCommandCallback *) create_preferences_window,
1146             NULL, GTK_STOCK_PREFERENCES);
1147
1148     gmpc_easy_command_add_entry(gmpc_easy_command,
1149             _("bug information"), "",
1150             _("Show bug information"),
1151             (GmpcEasyCommandCallback *) bug_information_window_new,
1152             NULL);
1153
1154     gmpc_easy_command_add_entry_icon_name(gmpc_easy_command,
1155             _("url"), "",
1156             _("Show add url window"),
1157             (GmpcEasyCommandCallback *) url_start,
1158             NULL,"add-url");
1159
1160     gmpc_easy_command_add_entry_icon_name(gmpc_easy_command,
1161             _("url"), ".*://.*",
1162             _("Add url <scheme>://<path>"),
1163             (GmpcEasyCommandCallback *) url_start_easy_command,
1164             NULL,"add-url");
1165 }
1166
1167 static void  gmpc_mmkeys_connect_signals(GObject *keys)
1168 {
1169     g_signal_connect(keys,
1170             "mm_playpause",
1171             G_CALLBACK(play_song), NULL);
1172
1173     g_signal_connect(keys,
1174             "mm_play",
1175             G_CALLBACK(real_play_song), NULL);
1176
1177     g_signal_connect(keys,
1178             "mm_pause",
1179             G_CALLBACK(real_pause_song), NULL);
1180
1181     g_signal_connect(keys,
1182             "mm_next",
1183             G_CALLBACK(next_song), NULL);
1184
1185     g_signal_connect(keys,
1186             "mm_prev",
1187             G_CALLBACK(prev_song), NULL);
1188
1189     g_signal_connect(keys,
1190             "mm_stop",
1191             G_CALLBACK(stop_song), NULL);
1192
1193     g_signal_connect(keys,
1194             "mm_fastforward",
1195             G_CALLBACK(song_fastforward), NULL);
1196
1197     g_signal_connect(keys,
1198             "mm_fastbackward",
1199             G_CALLBACK(song_fastbackward), NULL);
1200
1201     g_signal_connect(keys,
1202             "mm_repeat",
1203             G_CALLBACK(repeat_toggle), NULL);
1204
1205     g_signal_connect(keys,
1206             "mm_random",
1207             G_CALLBACK(random_toggle), NULL);
1208
1209     g_signal_connect(keys,
1210             "mm_raise",
1211             G_CALLBACK(create_playlist3), NULL);
1212
1213     g_signal_connect(keys,
1214             "mm_hide",
1215             G_CALLBACK(pl3_hide), NULL);
1216
1217     g_signal_connect(keys,
1218             "mm_toggle_hidden",
1219             G_CALLBACK(pl3_toggle_hidden), NULL);
1220
1221     g_signal_connect(keys,
1222             "mm_volume_up",
1223             G_CALLBACK(volume_up), NULL);
1224
1225     g_signal_connect(keys,
1226             "mm_volume_down",
1227             G_CALLBACK(volume_down), NULL);
1228
1229     g_signal_connect(keys,
1230             "mm_toggle_mute",
1231             G_CALLBACK(volume_toggle_mute), NULL);
1232
1233     g_signal_connect(keys,
1234             "mm_show_notification",
1235             G_CALLBACK(tray_icon2_create_tooltip), NULL);
1236
1237     g_signal_connect_swapped(keys,
1238             "mm_show_easy_command",
1239             G_CALLBACK(gmpc_easy_command_popup),
1240             gmpc_easy_command);
1241 }
1242
1243 /* vim: set noexpandtab ts=4 sw=4 sts=4 tw=80: */