src/gssmp_ui.c

   1 /*
   2  *  Gnome Simple Stateful Music Player
   3  *  Copyright (C) 2007 Andy Balaam
   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
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 **/
  19
  20 #include "gssmp_ui.h"
  21
  22 #include <stdio.h>
  23 #include <libgnomevfs/gnome-vfs.h>
  24 #include <sys/wait.h>
  25
  26 #include "interface.h"
  27 #include "support.h"
  28 #include "gssmp_config.h"
  29 #include "gssmp_files.h"
  30 #include "gssmp_gstreamer.h"
  31 #include "gssmp_util.h"
  32
  33 #define STATUS_TIMEOUT_LENGTH 5000
  34
  35 // Note: DOC_URI is passed in from the Makefile
  36 #define BIN_PKG_DOC_PATH "../share/doc/gssmp/html/use.html"
  37 #define SRC_DIR_DOC_PATH "../www/use.html"
  38 #define ONLINE_DOCS_URI  "http://gssmp.sourceforge.net/use.html"
  39
  40 GtkWindow *window1;
  41 GtkWindow *aboutdialog1;
  42 GtkWidget *hscale1;
  43 GtkLabel *label4;     // Artist and track name
  44 GtkLabel *label5;     // Album name etc.
  45 GtkLabel *label7;     // Current time
  46 GtkLabel *label8;     // Track length
  47 GtkWidget *button2;   // Play
  48 GtkWidget *button3;   // Pause
  49 GtkStatusbar *statusbar1;
  50 GtkMenuItem *recent1;
  51 GtkCheckMenuItem *no_repeat1;
  52 GtkCheckMenuItem *repeat_all1;
  53 GtkCheckMenuItem *repeat_one1;
  54 GtkCheckMenuItem *shuffle1;
  55
  56 // last.fm stuff
  57 GtkWindow *lastfmwindow;
  58 GtkCheckButton* checkbutton1;
  59 GtkEntry* entry1;
  60
  61 gchar* stored_title;
  62 gchar* stored_track_number;
  63 gchar* stored_track_length;
  64 gchar* stored_track_count;
  65 gchar* stored_album;
  66 gchar* stored_artist;
  67
  68 guint context_id_play_file;
  69 guint context_id_error_playing_file;
  70 guint context_id_status_callback;
  71 guint context_id_not_a_file;
  72
  73 gulong menu_number;
  74
  75 gboolean skip_errors;     // Don't pop up an error when reading an invalid file
  76 gboolean moving_forward;  // TRUE unless we have just clicked "Previous"
  77 guint status_timeout_source;
  78
  79 int new_tag;  // 0 = first time, 1 = info received, 2 = no info
  80
  81 void gssmp_ui_choose_bookmark_clicked (GtkMenuItem* unused, gpointer num);
  82
  83 void display_track_info (gboolean from_bookmark);
  84 void fork_lastfm_exe ();
  85 void choose_repeat_menu_item ();
  86
  87 void add_bookmark_here ();
  88 void redisplay_bookmarks ();
  89 void menu_bookmark_callback_create (GssmpBookmark* bmk, gpointer submenu);
  90
  91 void play_bookmark (guint num);
  92
  93 struct StatusDetails
  94 {
  95   guint context_id;
  96   const gchar* msg;
  97   const gchar* sub;
  98 };
  99
 100 gboolean status_callback (gpointer details);
 101
 102 void play_in_dir (const gchar* dirname);
 103
 104 void lastfm_enable_buttons ();
 105
 106 /**
 107  * Returns a newly-allocated string saying the time e.g. "1m 30s"
 108  */
 109 gchar* secs_to_time_str (gint secs);
 110
 111 void gssmp_ui_init (int argc, char *argv[])
 112 {
 113   window1 = GTK_WINDOW (create_window1 ());
 114   aboutdialog1 = NULL;
 115   hscale1 = lookup_widget (GTK_WIDGET (window1), "hscale1");
 116   label4 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label4"));
 117   label5 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label5"));
 118   label7 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label7"));
 119   label8 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label8"));
 120   button2 = lookup_widget (GTK_WIDGET (window1), "button2");
 121   button3 = lookup_widget (GTK_WIDGET (window1), "button3");
 122   statusbar1 = GTK_STATUSBAR (lookup_widget (GTK_WIDGET (window1),
 123     "statusbar1"));
 124   recent1     = GTK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1), "recent1"));
 125   no_repeat1  = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 126     "no_repeat1"));
 127   repeat_all1 = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 128     "repeat_all1"));
 129   repeat_one1 = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 130     "repeat_one1"));
 131   shuffle1    = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 132     "shuffle1"));
 133
 134   lastfmwindow = NULL;
 135   checkbutton1 = NULL;
 136   entry1 = NULL;
 137
 138   // NOTE: ICON_FILE is passed in via the make file
 139   gtk_window_set_icon_from_file (window1, ICON_FILE, NULL);
 140
 141   choose_repeat_menu_item ();
 142
 143   context_id_play_file = gtk_statusbar_get_context_id (statusbar1,
 144     "gssmp_ui_play_file");
 145   context_id_error_playing_file = gtk_statusbar_get_context_id (statusbar1,
 146     "gssmp_ui_error_callback");
 147   context_id_status_callback = gtk_statusbar_get_context_id (statusbar1,
 148     "status_callback");
 149   context_id_not_a_file = gtk_statusbar_get_context_id (statusbar1,
 150     "gssmp_ui_init");
 151
 152   skip_errors = TRUE;
 153   moving_forward = TRUE;
 154
 155   status_timeout_source = 0;
 156
 157
 158
 159   gtk_widget_show (GTK_WIDGET (window1));
 160
 161   if (argc < 2)
 162   {
 163     play_bookmark (0);
 164   }
 165   else
 166   {
 167     gchar* file_or_dir = gssmp_files_make_absolute (argv[1]);
 168
 169     if (g_file_test (file_or_dir, G_FILE_TEST_IS_DIR))
 170     {
 171       play_in_dir (file_or_dir);
 172       g_free (file_or_dir);
 173     }
 174     else if (g_file_test (file_or_dir, G_FILE_TEST_IS_REGULAR))
 175     {
 176       gssmp_ui_play_file (file_or_dir, TRUE, FALSE, 0, FALSE);
 177     }
 178     else
 179     {
 180       gssmp_ui_display_status_message ( context_id_not_a_file,
 181         _("Could not find file '%s'"), file_or_dir );
 182       g_free (file_or_dir);
 183     }
 184   }
 185
 186   redisplay_bookmarks ();
 187 }
 188
 189 void gssmp_ui_quit ()
 190 {
 191   add_bookmark_here ();
 192
 193   g_free (stored_title);
 194   g_free (stored_track_number);
 195   g_free (stored_track_count);
 196   g_free (stored_album);
 197   g_free (stored_artist);
 198
 199   gtk_main_quit ();
 200 }
 201
 202 void gssmp_ui_about ()
 203 {
 204   if (!aboutdialog1)
 205   {
 206     aboutdialog1 = GTK_WINDOW (create_aboutdialog1 ());
 207   }
 208
 209   gtk_widget_show (GTK_WIDGET (aboutdialog1));
 210 }
 211
 212 void update_buttons ()
 213 {
 214   gtk_widget_set_sensitive (button2, config_paused);
 215   gtk_widget_set_sensitive (button3, !config_paused);
 216 }
 217
 218 void gssmp_ui_choose_directory_clicked ()
 219 {
 220   GtkWidget *dialog;
 221
 222   dialog = gtk_file_chooser_dialog_new (_("Choose Directory"),
 223     window1, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
 224     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 225     GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 226     NULL);
 227
 228   if (current_directory && strlen (current_directory) > 0)
 229   {
 230     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 231       current_directory);
 232   }
 233   else
 234   {
 235     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 236       g_get_home_dir());
 237   }
 238
 239   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 240   {
 241     gchar *dirname;
 242
 243     gssmp_files_reset_shuffle ();
 244
 245     dirname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 246
 247     play_in_dir (dirname);
 248
 249     g_free (dirname);
 250   }
 251   gtk_widget_destroy (dialog);
 252 }
 253
 254 void gssmp_ui_choose_file_clicked ()
 255 {
 256   GtkWidget *dialog;
 257
 258   dialog = gtk_file_chooser_dialog_new (_("Choose File"),
 259     window1, GTK_FILE_CHOOSER_ACTION_OPEN,
 260     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 261     GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 262     NULL);
 263
 264   if (current_filename && strlen (current_filename) > 0)
 265   {
 266     gchar* dir;
 267     dir = g_path_get_dirname (current_filename);
 268     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dir);
 269     g_free (dir);
 270   }
 271   else if (current_directory && strlen (current_directory) > 0)
 272   {
 273     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 274       current_directory);
 275   }
 276   else
 277   {
 278     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 279       g_get_home_dir());
 280   }
 281
 282   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 283   {
 284     gchar *filename;
 285
 286     gssmp_files_reset_shuffle ();
 287
 288     filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 289     if (filename)
 290     {
 291       add_bookmark_here (); // Remember what we were playing
 292       gssmp_ui_play_file (filename, TRUE, TRUE, 0, FALSE);
 293     }
 294   }
 295   gtk_widget_destroy (dialog);
 296 }
 297
 298 void gssmp_ui_eos_callback ()
 299 {
 300   if (config_repeat_style == repeat_one)
 301   {
 302     gssmp_gstreamer_seek (0);
 303   }
 304   else
 305   {
 306     gssmp_ui_next_clicked ();
 307   }
 308 }
 309
 310 void gssmp_ui_next_clicked ()
 311 {
 312   gchar *filename;
 313
 314   moving_forward = TRUE;
 315
 316   if (config_repeat_style == shuffle)
 317   {
 318     filename = gssmp_files_find_next_shuffled_file ();
 319   }
 320   else
 321   {
 322     filename = gssmp_files_find_next_file_after (current_filename);
 323
 324     if (!filename && (config_repeat_style == repeat_all))
 325     {
 326       filename = gssmp_files_find_next_file_in_dir (current_directory, NULL);
 327     }
 328   }
 329
 330   if (filename)
 331   {
 332     gssmp_ui_play_file (filename, FALSE, TRUE, 0, TRUE);
 333   }
 334   else
 335   {
 336     gssmp_ui_pause_clicked ();
 337   }
 338 }
 339
 340 void gssmp_ui_previous_clicked ()
 341 {
 342   gchar *filename;
 343
 344   moving_forward = FALSE;
 345
 346   filename = gssmp_files_find_previous_file_before (current_filename);
 347
 348   if (filename)
 349   {
 350     gssmp_ui_play_file (filename, FALSE, TRUE, 0, TRUE);
 351   }
 352   else
 353   {
 354     gssmp_ui_pause_clicked ();
 355   }
 356 }
 357
 358 void gssmp_ui_display_status_message (guint context_id, const gchar* msg,
 359   const gchar* sub)
 360 {
 361   gchar* full_msg;
 362
 363   full_msg = g_strdup_printf (msg, sub);
 364
 365   gtk_statusbar_pop (statusbar1, context_id_status_callback);
 366   gtk_statusbar_push (statusbar1, context_id_status_callback, full_msg);
 367
 368   printf ("%s\n", full_msg);
 369
 370   g_free (full_msg);
 371 }
 372
 373 void gssmp_ui_display_2_status_messages (guint context_id, const gchar* msg1,
 374   const gchar* sub1, const gchar* msg2, const gchar* sub2)
 375 {
 376   struct StatusDetails* details;
 377
 378   gssmp_ui_display_status_message (context_id, msg1, sub1);
 379
 380   details = g_slice_new (struct StatusDetails);
 381   details->context_id = context_id;
 382   details->msg = msg2;
 383   details->sub = sub2;
 384
 385   if (status_timeout_source)
 386   {
 387     g_source_remove (status_timeout_source);
 388   }
 389   status_timeout_source = g_timeout_add (STATUS_TIMEOUT_LENGTH,
 390     status_callback, (gpointer)details);
 391 }
 392
 393 /**
 394  * Play the sound file supplied by calling into the gstreamer code and making
 395  * the UI ready where required.
 396  *
 397  * @arg filename             The full path to a file on disk
 398  * @arg change_dir           If this file is outside the user's chosen
 399  *                           directory, should we change that directory to
 400  *                           match the file?
 401  * @arg new_filename         Is the filename a newly-allocated string?  I.e.
 402  *                           should we free the old current_filename?
 403  * @arg start_offset         How many seconds through the file should we start?
 404  * @arg skip_to_next_if_fail If this file fails to load, automatically skip to
 405  *                           the next?  (If not, we display an error to the
 406  *                           user.)
 407  */
 408 void gssmp_ui_play_file (gchar* filename, gboolean change_dir,
 409   gboolean new_filename, gint start_offset, gboolean skip_to_next_if_fail)
 410 {
 411   skip_errors = skip_to_next_if_fail;
 412
 413   if (change_dir)
 414   {
 415     if (!current_directory ||
 416       strncmp (current_directory, filename, strlen (current_directory)) != 0)
 417     {
 418       current_directory = g_path_get_dirname (filename);
 419     }
 420   }
 421
 422   if (new_filename && current_filename)
 423   {
 424     g_free (current_filename);
 425   }
 426   current_filename = filename;
 427
 428   gssmp_ui_clear_track_info ();
 429
 430   new_tag = 0;
 431
 432   config_paused = FALSE;
 433   update_buttons ();
 434
 435   gssmp_ui_display_2_status_messages( context_id_play_file,
 436     _("Playing file %s"), current_filename,
 437     _("Playing in directory %s"), current_directory );
 438
 439   gssmp_gstreamer_play (current_filename, start_offset,
 440     gssmp_ui_duration_callback, gssmp_ui_progress_callback,
 441     gssmp_ui_tag_callback, gssmp_ui_eos_callback,
 442     gssmp_ui_error_callback);
 443 }
 444
 445 void gssmp_ui_play_clicked ()
 446 {
 447   config_paused = FALSE;
 448   update_buttons ();
 449   gssmp_gstreamer_unpause ();
 450 }
 451
 452 void gssmp_ui_pause_clicked ()
 453 {
 454   config_paused = TRUE;
 455   update_buttons ();
 456   gssmp_gstreamer_pause ();
 457 }
 458
 459 void gssmp_ui_slider_changed (gdouble value)
 460 {
 461   gchar* time_str;
 462   gint secs;
 463
 464   secs = (gint)value;
 465   if (current_length != -1 && secs >= current_length)
 466   {
 467     secs = current_length - 1;
 468   }
 469
 470   gssmp_gstreamer_seek (secs);
 471
 472   current_time = secs;
 473
 474   time_str = secs_to_time_str (secs);
 475   gtk_label_set_text (label7, time_str);
 476   gtk_widget_queue_draw(GTK_WIDGET(label7));
 477   g_free (time_str);
 478 }
 479
 480 void gssmp_ui_volume_change (gdouble value)
 481 {
 482   if (value < 0)
 483   {
 484     value = 0;
 485   }
 486   else if (value > 1)
 487   {
 488     value = 1;
 489   }
 490   gssmp_gstreamer_set_volume (value);
 491 }
 492
 493 void gssmp_ui_progress_callback (gint secs)
 494 {
 495   gchar* time_str;
 496
 497   current_time = secs;
 498   gtk_range_set_value (GTK_RANGE(hscale1), (gdouble)secs);
 499
 500   time_str = secs_to_time_str (secs);
 501   gtk_label_set_text (label7, time_str);
 502
 503   switch (new_tag)
 504   {
 505     case 1:
 506     {
 507       display_track_info (FALSE);
 508       new_tag = 2;
 509       break;
 510     }
 511     case 0:
 512     {
 513       new_tag = 1;
 514       break;
 515     }
 516     default:
 517     {
 518       break;
 519     }
 520   }
 521
 522   gtk_widget_queue_draw(GTK_WIDGET(hscale1));
 523   gtk_widget_queue_draw(GTK_WIDGET(label7));
 524   g_free (time_str);
 525 }
 526
 527 void gssmp_ui_duration_callback (gint secs)
 528 {
 529   gtk_range_set_range (GTK_RANGE(hscale1), (gdouble)0, (gdouble)secs);
 530
 531   stored_track_length = secs_to_time_str (secs);
 532   current_length = secs;
 533 }
 534
 535 void gssmp_ui_tag_callback (const gchar* tag, const gchar* value)
 536 {
 537   new_tag = 1;
 538   if (strcmp(tag, "title") == 0)
 539   {
 540     stored_title = g_strdup (value);
 541   }
 542   else if (strcmp(tag, "artist") == 0)
 543   {
 544     stored_artist = g_strdup (value);
 545   }
 546   else if (strcmp(tag, "album") == 0)
 547   {
 548     stored_album = g_strdup (value);
 549   }
 550   else if (strcmp(tag, "track-number") == 0)
 551   {
 552     stored_track_number = g_strdup (value);
 553   }
 554   else if (strcmp(tag, "track-count") == 0)
 555   {
 556     stored_track_count = g_strdup (value);
 557   }
 558   else
 559   {
 560     fprintf (stderr, _("Unknown tag: %s -> %s\n"), tag, value);
 561   }
 562 }
 563
 564 void gssmp_ui_error_callback (const gchar* msg)
 565 {
 566   gssmp_ui_display_status_message (context_id_error_playing_file,
 567     _("Unable to play file: %s"), current_filename );
 568
 569   if (skip_errors)
 570   {
 571     if (moving_forward)
 572     {
 573       gssmp_ui_next_clicked ();
 574     }
 575     else
 576     {
 577       gssmp_ui_previous_clicked ();
 578       moving_forward = FALSE;
 579     }
 580   }
 581   else
 582   {
 583     GtkMessageDialog* dialog;
 584     dialog = GTK_MESSAGE_DIALOG (gtk_message_dialog_new (window1,
 585                                     GTK_DIALOG_DESTROY_WITH_PARENT,
 586                                     GTK_MESSAGE_ERROR,
 587                                     GTK_BUTTONS_CLOSE,
 588                                     _("Error playing file '%s': %s"),
 589                                     current_filename, msg));
 590    gtk_dialog_run (GTK_DIALOG (dialog));
 591    gtk_widget_destroy (GTK_WIDGET (dialog));
 592   }
 593 }
 594
 595 void gssmp_ui_clear_track_info ()
 596 {
 597   if (stored_title)
 598   {
 599     g_free (stored_title);
 600   }
 601   if (stored_track_number)
 602   {
 603     g_free (stored_track_number);
 604   }
 605   if (stored_track_length)
 606   {
 607     g_free (stored_track_length);
 608   }
 609   if (stored_track_count)
 610   {
 611     g_free (stored_track_count);
 612   }
 613   if (stored_artist)
 614   {
 615     g_free (stored_artist);
 616   }
 617   if (stored_album)
 618   {
 619     g_free (stored_album);
 620   }
 621
 622   if (current_filename)
 623   {
 624     gchar* tmp1;
 625     gchar* tmp2;
 626
 627     stored_title = g_path_get_basename (current_filename);
 628     tmp1 = g_path_get_dirname (current_filename);
 629     stored_album = g_path_get_basename (tmp1);
 630     tmp2 = gssmp_files_get_parent_of_dir (tmp1);
 631     stored_artist = g_path_get_basename (tmp2);
 632
 633     g_free (tmp1);
 634     g_free (tmp2);
 635   }
 636   else
 637   {
 638     stored_title = NULL;
 639     stored_album = NULL;
 640     stored_artist = NULL;
 641   }
 642
 643   stored_track_number = NULL;
 644   stored_track_length = NULL;
 645   stored_track_count  = NULL;
 646 }
 647
 648 // --------------------------------
 649
 650 #define MAX_TITLE_LENGTH 2048
 651 void display_track_info (gboolean from_bookmark)
 652 {
 653   gchar title[MAX_TITLE_LENGTH];
 654   gchar tmp[MAX_TITLE_LENGTH];
 655
 656   g_strlcpy (title, "<span size=\"large\">", MAX_TITLE_LENGTH);
 657
 658   if (stored_artist)
 659   {
 660     if (stored_title)
 661     {
 662       if (stored_track_number)
 663       {
 664         if (stored_track_count)
 665         {
 666           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - %s (%s/%s)"),
 667             stored_artist, stored_title, stored_track_number,
 668             stored_track_count);
 669         }
 670         else
 671         {
 672           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - %s (%s)"),
 673             stored_artist, stored_title, stored_track_number);
 674         }
 675       }
 676       else
 677       {
 678         g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - %s"),
 679           stored_artist, stored_title);
 680       }
 681     }
 682     else
 683     {
 684       g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - unnamed"), stored_artist);
 685     }
 686   }
 687   else
 688   {
 689     if (stored_title)
 690     {
 691       if (stored_track_number)
 692       {
 693         if (stored_track_count)
 694         {
 695           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s (%s/%s)"),
 696             stored_title, stored_track_number, stored_track_count);
 697         }
 698         else
 699         {
 700           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s (%s)"),
 701             stored_title, stored_track_number);
 702         }
 703       }
 704       else
 705       {
 706         g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s"), stored_title);
 707       }
 708     }
 709     else
 710     {
 711       g_strlcpy (tmp, "", MAX_TITLE_LENGTH);
 712     }
 713   }
 714
 715   g_strlcat (title, tmp, MAX_TITLE_LENGTH);
 716
 717   g_strlcat (title, "</span>", MAX_TITLE_LENGTH);
 718
 719   gtk_label_set_markup (label4, title);
 720
 721   // Now the album name
 722   if (stored_album)
 723   {
 724     g_snprintf (tmp, MAX_TITLE_LENGTH, _("Album: %s"), stored_album);
 725   }
 726   else
 727   {
 728     g_strlcpy (tmp, "", MAX_TITLE_LENGTH);
 729   }
 730
 731   gtk_label_set_text (label5, tmp);
 732
 733   // and the track length
 734   if (stored_track_length)
 735   {
 736     g_snprintf (tmp, MAX_TITLE_LENGTH, _("Length: %s"), stored_track_length);
 737   }
 738   else
 739   {
 740     g_strlcpy (tmp, "", MAX_TITLE_LENGTH);
 741   }
 742   gtk_label_set_text (label8, tmp);
 743
 744   if( config_lastfm_active &&
 745     current_length > 0 && stored_title && stored_artist
 746     && !from_bookmark )
 747   {
 748     fork_lastfm_exe ();
 749   }
 750
 751   add_bookmark_here (); // Put this track to the top of the bookmarks list
 752 }
 753
 754 void fork_lastfm_exe ()
 755 {
 756   pid_t pid;
 757   char tmp[32];
 758
 759   pid = fork();
 760
 761   if (pid == -1)
 762   {
 763       fprintf (stderr, "fork() error before launching lastfm exe.\n");
 764   }
 765   else if( pid == 0 )
 766   {
 767     // We are the child, run lastfm exe
 768
 769     char *args[10];
 770
 771     args[0] = config_lastfm_exe;
 772     args[1] = "--length";
 773     g_snprintf (tmp, 32, "%d", current_length);
 774     args[2] = tmp;
 775     args[3] = "--title";
 776     args[4] = stored_title;
 777     args[5] = "--artist";
 778     args[6] = stored_artist;
 779
 780     if( stored_album )
 781     {
 782       args[7] = "--album";
 783       args[8] = stored_album;
 784       args[9] = NULL;
 785
 786       fprintf (stderr, "Running: %s %s %s %s \"%s\" %s \"%s\" %s \"%s\"\n",
 787         args[0], args[1], args[2], args[3], args[4],
 788         args[5], args[6], args[7], args[8]);
 789     }
 790     else
 791     {
 792       args[7] = NULL;
 793
 794       fprintf (stderr, "Running: %s %s %s %s \"%s\" %s \"%s\"\n",
 795         args[0], args[1], args[2], args[3], args[4],
 796         args[5], args[6]);
 797     }
 798
 799     execvp( args[0], args );
 800
 801     // Should never get here.
 802     fprintf (stderr, "execvp() error launching lastfm exe '%s'.\n",
 803       config_lastfm_exe);
 804   }
 805   else
 806   {
 807           int status;
 808           waitpid( pid, &status, 0 );
 809           // TODO report status anomalies
 810   }
 811 }
 812
 813 gchar* secs_to_time_str (gint secs)
 814 {
 815   if (secs < 0)
 816   {
 817     secs = 0;
 818   }
 819
 820   guint mins = secs / 60;
 821   guint remaining_secs = secs % 60;
 822
 823   return g_strdup_printf (_("%dm %02ds"), mins, remaining_secs);
 824 }
 825
 826 void gssmp_ui_choose_bookmark_clicked (GtkMenuItem* unused, gpointer num)
 827 {
 828   gssmp_files_reset_shuffle ();
 829   config_paused = FALSE;
 830   play_bookmark ((gulong)num);
 831 }
 832
 833 void gssmp_ui_launch_help ()
 834 {
 835   gchar* uri;
 836
 837   if (g_file_test (DOC_URI, G_FILE_TEST_IS_REGULAR))
 838   {
 839     uri = gnome_vfs_get_uri_from_local_path (DOC_URI);
 840   }
 841   else if (g_file_test (BIN_PKG_DOC_PATH, G_FILE_TEST_IS_REGULAR))
 842   {
 843     gchar* abs;
 844     abs = gssmp_files_make_absolute (BIN_PKG_DOC_PATH);
 845     uri = gnome_vfs_get_uri_from_local_path (abs);
 846     g_free (abs);
 847   }
 848   else if (g_file_test (SRC_DIR_DOC_PATH, G_FILE_TEST_IS_REGULAR))
 849   {
 850     gchar* abs;
 851     abs = gssmp_files_make_absolute (SRC_DIR_DOC_PATH);
 852     uri = gnome_vfs_get_uri_from_local_path (abs);
 853     g_free (abs);
 854   }
 855   else
 856   {
 857     uri = g_strdup (ONLINE_DOCS_URI);
 858   }
 859
 860   gnome_vfs_url_show (uri);
 861
 862   g_free (uri);
 863 }
 864
 865 void gssmp_ui_lastfm ()
 866 {
 867   if (!lastfmwindow)
 868   {
 869     lastfmwindow = GTK_WINDOW (create_lastfmwindow ());
 870     checkbutton1 = GTK_CHECK_BUTTON (
 871       lookup_widget (GTK_WIDGET (lastfmwindow), "checkbutton1"));
 872     entry1 = GTK_ENTRY (lookup_widget (GTK_WIDGET (lastfmwindow), "entry1"));
 873   }
 874
 875   gtk_toggle_button_set_active (
 876     GTK_TOGGLE_BUTTON (checkbutton1), config_lastfm_active);
 877   gtk_entry_set_text (entry1, config_lastfm_exe);
 878
 879   lastfm_enable_buttons ();
 880
 881   gtk_widget_show (GTK_WIDGET (lastfmwindow));
 882 }
 883
 884 void gssmp_ui_lastfm_close ()
 885 {
 886   gtk_widget_hide (GTK_WIDGET (lastfmwindow));
 887 }
 888
 889 void gssmp_ui_lastfm_statechange ()
 890 {
 891   config_lastfm_active = gtk_toggle_button_get_active (
 892     GTK_TOGGLE_BUTTON (checkbutton1));
 893 }
 894
 895 void gssmp_ui_lastfm_exechanged ()
 896 {
 897   lastfm_enable_buttons ();
 898
 899   if (config_lastfm_exe)
 900   {
 901     g_free (config_lastfm_exe);
 902   }
 903   config_lastfm_exe = g_strdup( gtk_entry_get_text (entry1) );
 904 }
 905
 906 // --------------------------------
 907
 908 void add_bookmark_here ()
 909 {
 910   if (current_filename && stored_title)
 911   {
 912     gssmp_config_add_bookmark (stored_title, stored_artist, stored_album,
 913       current_directory, current_filename, current_time, current_length);
 914     redisplay_bookmarks ();
 915   }
 916 }
 917
 918 void play_bookmark (guint num)
 919 {
 920   gboolean keep_paused;
 921   GssmpBookmark *bmk;
 922
 923   new_tag = 0;
 924   stored_track_number = NULL;
 925   stored_track_count  = NULL;
 926   stored_track_length = NULL;
 927
 928   bmk = gssmp_config_get_bookmark (num);
 929   if (bmk)
 930   {
 931     add_bookmark_here ();   // First remember what we were playing before
 932
 933     gssmp_ui_duration_callback (bmk->length);
 934     gssmp_ui_progress_callback (bmk->time);
 935
 936     if (stored_title)
 937     {
 938       g_free (stored_title);
 939     }
 940     stored_title  = g_strdup (bmk->track);
 941
 942     if (stored_album)
 943     {
 944       g_free (stored_album);
 945     }
 946     stored_album  = g_strdup (bmk->album);
 947
 948     if (stored_artist)
 949     {
 950       g_free (stored_artist);
 951     }
 952     stored_artist = g_strdup (bmk->artist);
 953
 954     if (current_filename)
 955     {
 956       g_free (current_filename);
 957     }
 958     current_filename     = g_strdup (bmk->filename);
 959
 960     if (current_directory)
 961     {
 962       g_free (current_directory);
 963     }
 964     current_directory    = g_strdup (bmk->directory);
 965
 966     display_track_info (TRUE);
 967   }
 968   else
 969   {
 970     stored_title        = NULL;
 971     stored_album        = NULL;
 972     stored_artist       = NULL;
 973   }
 974
 975   if (current_filename)
 976   {
 977     keep_paused = config_paused;
 978     gssmp_ui_play_file (current_filename, TRUE, FALSE, current_time, TRUE);
 979     if (keep_paused)
 980     {
 981       gssmp_ui_pause_clicked ();
 982     }
 983   }
 984
 985   redisplay_bookmarks ();
 986 }
 987
 988 void choose_repeat_menu_item ()
 989 {
 990   switch (config_repeat_style)
 991   {
 992     case no_repeat:
 993     {
 994       gtk_check_menu_item_set_active (no_repeat1,  TRUE);
 995       gtk_check_menu_item_set_active (repeat_all1, FALSE);
 996       gtk_check_menu_item_set_active (repeat_one1, FALSE);
 997       gtk_check_menu_item_set_active (shuffle1,    FALSE);
 998       break;
 999     }
1000     case repeat_all:
1001     {
1002       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1003       gtk_check_menu_item_set_active (repeat_all1, TRUE);
1004       gtk_check_menu_item_set_active (repeat_one1, FALSE);
1005       gtk_check_menu_item_set_active (shuffle1,    FALSE);
1006       break;
1007     }
1008     case repeat_one:
1009     {
1010       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1011       gtk_check_menu_item_set_active (repeat_all1, FALSE);
1012       gtk_check_menu_item_set_active (repeat_one1, TRUE);
1013       gtk_check_menu_item_set_active (shuffle1,    FALSE);
1014       break;
1015     }
1016     case shuffle:
1017     {
1018       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1019       gtk_check_menu_item_set_active (repeat_all1, FALSE);
1020       gtk_check_menu_item_set_active (repeat_one1, FALSE);
1021       gtk_check_menu_item_set_active (shuffle1,    TRUE);
1022       break;
1023     }
1024   }
1025 }
1026
1027 void redisplay_bookmarks ()
1028 {
1029   GtkMenu *submenu;
1030
1031   gtk_widget_set_sensitive (GTK_WIDGET (recent1), FALSE);
1032
1033   gtk_menu_item_deselect (GTK_MENU_ITEM (recent1));
1034
1035   submenu = GTK_MENU (gtk_menu_new ());
1036
1037   menu_number = 0;
1038   gssmp_config_bookmarks_foreach (menu_bookmark_callback_create, submenu);
1039
1040   gtk_widget_show (GTK_WIDGET (submenu));
1041
1042   gtk_menu_item_set_submenu (GTK_MENU_ITEM (recent1), GTK_WIDGET (submenu));
1043
1044   gtk_widget_set_sensitive (GTK_WIDGET (recent1), TRUE);
1045 }
1046
1047 void menu_bookmark_callback_create (GssmpBookmark* bmk, gpointer submenu)
1048 {
1049   GtkWidget *item;
1050   gchar* item_name;
1051   gchar* time_str;
1052
1053   time_str = secs_to_time_str (bmk->time);
1054
1055   item_name =  g_strdup_printf (_("%s - %s (%s)"), bmk->artist, bmk->track,
1056     time_str);
1057   item = gtk_menu_item_new_with_label (item_name);
1058   gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
1059   gtk_widget_show (GTK_WIDGET (item));
1060
1061   g_signal_connect ((gpointer) item, "activate",
1062                     G_CALLBACK (gssmp_ui_choose_bookmark_clicked),
1063                     (gpointer)menu_number);
1064
1065   ++menu_number;
1066
1067   g_free (item_name);
1068   g_free (time_str);
1069 }
1070
1071 gboolean status_callback (gpointer detailsptr)
1072 {
1073   struct StatusDetails* details;
1074
1075   status_timeout_source = 0;
1076
1077   details = (struct StatusDetails*)detailsptr;
1078
1079   gssmp_ui_display_status_message (details->context_id, details->msg,
1080     details->sub);
1081
1082   g_slice_free (struct StatusDetails, details);
1083
1084   return FALSE;
1085 }
1086
1087 void play_in_dir (const gchar* dirname)
1088 {
1089   gchar* first_file_name;
1090
1091   gssmp_config_set_directory (dirname);
1092
1093   if (config_repeat_style == shuffle)
1094   {
1095     first_file_name = gssmp_files_find_next_shuffled_file ();
1096   }
1097   else
1098   {
1099     first_file_name = gssmp_files_find_next_file_in_dir (
1100       current_directory, NULL);
1101   }
1102
1103   if (first_file_name)
1104   {
1105     add_bookmark_here (); // Remember what we were playing
1106     gssmp_ui_play_file (first_file_name, FALSE, TRUE, 0, TRUE);
1107   }
1108 }
1109
1110 void lastfm_enable_buttons ()
1111 {
1112   const gchar* exe;
1113   gchar* fullexe;
1114
1115   exe = gtk_entry_get_text (entry1);
1116
1117   fullexe = g_find_program_in_path (exe);
1118
1119   if (fullexe)
1120   {
1121     gtk_widget_set_sensitive (GTK_WIDGET (checkbutton1), TRUE);
1122     g_free (fullexe);
1123   }
1124   else
1125   {
1126     config_lastfm_active = FALSE;
1127     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), FALSE);
1128     gtk_widget_set_sensitive (GTK_WIDGET (checkbutton1), FALSE);
1129   }
1130 }
1131