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
  25 #include "interface.h"
  26 #include "support.h"
  27 #include "gssmp_config.h"
  28 #include "gssmp_files.h"
  29 #include "gssmp_gstreamer.h"
  30 #include "gssmp_util.h"
  31
  32 #define STATUS_TIMEOUT_LENGTH 5000
  33
  34 // Note: DOC_URI is passed in from the Makefile
  35 #define BIN_PKG_DOC_PATH "../share/doc/gssmp/html/use.html"
  36 #define SRC_DIR_DOC_PATH "../www/use.html"
  37 #define ONLINE_DOCS_URI  "http://gssmp.sourceforge.net/use.html"
  38
  39 GtkWindow *window1;
  40 GtkWindow *aboutdialog1;
  41 GtkWidget *hscale1;
  42 GtkLabel *label4;     // Artist and track name
  43 GtkLabel *label5;     // Album name etc.
  44 GtkLabel *label7;     // Current time
  45 GtkLabel *label8;     // Track length
  46 GtkWidget *button2;   // Play
  47 GtkWidget *button3;   // Pause
  48 GtkStatusbar *statusbar1;
  49 GtkMenuItem *recent1;
  50 GtkCheckMenuItem *no_repeat1;
  51 GtkCheckMenuItem *repeat_all1;
  52 GtkCheckMenuItem *repeat_one1;
  53 GtkCheckMenuItem *shuffle1;
  54
  55 // last.fm stuff
  56 GtkWindow *lastfmwindow;
  57 GtkCheckButton* checkbutton1;
  58 GtkEntry* entry1;
  59
  60 gchar* stored_title;
  61 gchar* stored_track_number;
  62 gchar* stored_track_length;
  63 gchar* stored_track_count;
  64 gchar* stored_album;
  65 gchar* stored_artist;
  66
  67 guint context_id_play_file;
  68 guint context_id_error_playing_file;
  69 guint context_id_status_callback;
  70 guint context_id_not_a_file;
  71
  72 gulong menu_number;
  73
  74 gboolean skip_errors;     // Don't pop up an error when reading an invalid file
  75 gboolean moving_forward;  // TRUE unless we have just clicked "Previous"
  76 guint status_timeout_source;
  77
  78 int new_tag;  // 0 = first time, 1 = info received, 2 = no info
  79
  80 void gssmp_ui_choose_bookmark_clicked (GtkMenuItem* unused, gpointer num);
  81
  82 void display_track_info ();
  83 void fork_lastfm_exe ();
  84 void choose_repeat_menu_item ();
  85
  86 void add_bookmark_here ();
  87 void redisplay_bookmarks ();
  88 void menu_bookmark_callback_create (GssmpBookmark* bmk, gpointer submenu);
  89
  90 void play_bookmark (guint num);
  91
  92 struct StatusDetails
  93 {
  94   guint context_id;
  95   const gchar* msg;
  96   const gchar* sub;
  97 };
  98
  99 gboolean status_callback (gpointer details);
 100
 101 void play_in_dir (const gchar* dirname);
 102
 103 void lastfm_enable_buttons ();
 104
 105 /**
 106  * Returns a newly-allocated string saying the time e.g. "1m 30s"
 107  */
 108 gchar* secs_to_time_str (gint secs);
 109
 110 void gssmp_ui_init (int argc, char *argv[])
 111 {
 112   window1 = GTK_WINDOW (create_window1 ());
 113   aboutdialog1 = NULL;
 114   hscale1 = lookup_widget (GTK_WIDGET (window1), "hscale1");
 115   label4 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label4"));
 116   label5 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label5"));
 117   label7 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label7"));
 118   label8 = GTK_LABEL (lookup_widget (GTK_WIDGET (window1), "label8"));
 119   button2 = lookup_widget (GTK_WIDGET (window1), "button2");
 120   button3 = lookup_widget (GTK_WIDGET (window1), "button3");
 121   statusbar1 = GTK_STATUSBAR (lookup_widget (GTK_WIDGET (window1),
 122     "statusbar1"));
 123   recent1     = GTK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1), "recent1"));
 124   no_repeat1  = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 125     "no_repeat1"));
 126   repeat_all1 = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 127     "repeat_all1"));
 128   repeat_one1 = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 129     "repeat_one1"));
 130   shuffle1    = GTK_CHECK_MENU_ITEM (lookup_widget (GTK_WIDGET (window1),
 131     "shuffle1"));
 132
 133   lastfmwindow = NULL;
 134   checkbutton1 = NULL;
 135   entry1 = NULL;
 136
 137   // NOTE: ICON_FILE is passed in via the make file
 138   gtk_window_set_icon_from_file (window1, ICON_FILE, NULL);
 139
 140   choose_repeat_menu_item ();
 141
 142   context_id_play_file = gtk_statusbar_get_context_id (statusbar1,
 143     "gssmp_ui_play_file");
 144   context_id_error_playing_file = gtk_statusbar_get_context_id (statusbar1,
 145     "gssmp_ui_error_callback");
 146   context_id_status_callback = gtk_statusbar_get_context_id (statusbar1,
 147     "status_callback");
 148   context_id_not_a_file = gtk_statusbar_get_context_id (statusbar1,
 149     "gssmp_ui_init");
 150
 151   skip_errors = TRUE;
 152   moving_forward = TRUE;
 153
 154   status_timeout_source = 0;
 155
 156
 157
 158   gtk_widget_show (GTK_WIDGET (window1));
 159
 160   if (argc < 2)
 161   {
 162     play_bookmark (0);
 163   }
 164   else
 165   {
 166     gchar* file_or_dir = gssmp_files_make_absolute (argv[1]);
 167
 168     if (g_file_test (file_or_dir, G_FILE_TEST_IS_DIR))
 169     {
 170       play_in_dir (file_or_dir);
 171       g_free (file_or_dir);
 172     }
 173     else if (g_file_test (file_or_dir, G_FILE_TEST_IS_REGULAR))
 174     {
 175       gssmp_ui_play_file (file_or_dir, TRUE, FALSE, 0, FALSE);
 176     }
 177     else
 178     {
 179       gssmp_ui_display_status_message ( context_id_not_a_file,
 180         _("Could not find file '%s'"), file_or_dir );
 181       g_free (file_or_dir);
 182     }
 183   }
 184
 185   redisplay_bookmarks ();
 186 }
 187
 188 void gssmp_ui_quit ()
 189 {
 190   add_bookmark_here ();
 191
 192   g_free (stored_title);
 193   g_free (stored_track_number);
 194   g_free (stored_track_count);
 195   g_free (stored_album);
 196   g_free (stored_artist);
 197
 198   gtk_main_quit ();
 199 }
 200
 201 void gssmp_ui_about ()
 202 {
 203   if (!aboutdialog1)
 204   {
 205     aboutdialog1 = GTK_WINDOW (create_aboutdialog1 ());
 206   }
 207
 208   gtk_widget_show (GTK_WIDGET (aboutdialog1));
 209 }
 210
 211 void update_buttons ()
 212 {
 213   gtk_widget_set_sensitive (button2, config_paused);
 214   gtk_widget_set_sensitive (button3, !config_paused);
 215 }
 216
 217 void gssmp_ui_choose_directory_clicked ()
 218 {
 219   GtkWidget *dialog;
 220
 221   dialog = gtk_file_chooser_dialog_new (_("Choose Directory"),
 222     window1, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
 223     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 224     GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 225     NULL);
 226
 227   if (current_directory && strlen (current_directory) > 0)
 228   {
 229     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 230       current_directory);
 231   }
 232   else
 233   {
 234     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 235       g_get_home_dir());
 236   }
 237
 238   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 239   {
 240     gchar *dirname;
 241
 242     gssmp_files_reset_shuffle ();
 243
 244     dirname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 245
 246     play_in_dir (dirname);
 247
 248     g_free (dirname);
 249   }
 250   gtk_widget_destroy (dialog);
 251 }
 252
 253 void gssmp_ui_choose_file_clicked ()
 254 {
 255   GtkWidget *dialog;
 256
 257   dialog = gtk_file_chooser_dialog_new (_("Choose File"),
 258     window1, GTK_FILE_CHOOSER_ACTION_OPEN,
 259     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 260     GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 261     NULL);
 262
 263   if (current_filename && strlen (current_filename) > 0)
 264   {
 265     gchar* dir;
 266     dir = g_path_get_dirname (current_filename);
 267     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dir);
 268     g_free (dir);
 269   }
 270   else if (current_directory && strlen (current_directory) > 0)
 271   {
 272     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 273       current_directory);
 274   }
 275   else
 276   {
 277     gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 278       g_get_home_dir());
 279   }
 280
 281   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 282   {
 283     gchar *filename;
 284
 285     gssmp_files_reset_shuffle ();
 286
 287     filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 288     if (filename)
 289     {
 290       add_bookmark_here (); // Remember what we were playing
 291       gssmp_ui_play_file (filename, TRUE, TRUE, 0, FALSE);
 292     }
 293   }
 294   gtk_widget_destroy (dialog);
 295 }
 296
 297 void gssmp_ui_eos_callback ()
 298 {
 299   if (config_repeat_style == repeat_one)
 300   {
 301     gssmp_gstreamer_seek (0);
 302   }
 303   else
 304   {
 305     gssmp_ui_next_clicked ();
 306   }
 307 }
 308
 309 void gssmp_ui_next_clicked ()
 310 {
 311   gchar *filename;
 312
 313   moving_forward = TRUE;
 314
 315   if (config_repeat_style == shuffle)
 316   {
 317     filename = gssmp_files_find_next_shuffled_file ();
 318   }
 319   else
 320   {
 321     filename = gssmp_files_find_next_file_after (current_filename);
 322
 323     if (!filename && (config_repeat_style == repeat_all))
 324     {
 325       filename = gssmp_files_find_next_file_in_dir (current_directory, NULL);
 326     }
 327   }
 328
 329   if (filename)
 330   {
 331     gssmp_ui_play_file (filename, FALSE, TRUE, 0, TRUE);
 332   }
 333   else
 334   {
 335     gssmp_ui_pause_clicked ();
 336   }
 337 }
 338
 339 void gssmp_ui_previous_clicked ()
 340 {
 341   gchar *filename;
 342
 343   moving_forward = FALSE;
 344
 345   filename = gssmp_files_find_previous_file_before (current_filename);
 346
 347   if (filename)
 348   {
 349     gssmp_ui_play_file (filename, FALSE, TRUE, 0, TRUE);
 350   }
 351   else
 352   {
 353     gssmp_ui_pause_clicked ();
 354   }
 355 }
 356
 357 void gssmp_ui_display_status_message (guint context_id, const gchar* msg,
 358   const gchar* sub)
 359 {
 360   gchar* full_msg;
 361
 362   full_msg = g_strdup_printf (msg, sub);
 363
 364   gtk_statusbar_pop (statusbar1, context_id_status_callback);
 365   gtk_statusbar_push (statusbar1, context_id_status_callback, full_msg);
 366
 367   printf (full_msg);
 368   printf ("\n");
 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 ();
 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 ()
 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   {
 747     fork_lastfm_exe ();
 748   }
 749
 750   add_bookmark_here (); // Put this track to the top of the bookmarks list
 751 }
 752
 753 void fork_lastfm_exe ()
 754 {
 755   pid_t pid;
 756   char tmp[32];
 757
 758   pid = fork();
 759
 760   if (pid == -1)
 761   {
 762       fprintf (stderr, "fork() error before launching lastfm exe.");
 763   }
 764   else if( pid == 0 )
 765   {
 766     // We are the child, run lastfm exe
 767
 768     char *args[10];
 769
 770     args[0] = config_lastfm_exe;
 771     args[1] = "--lengtsdsh";
 772     g_snprintf (tmp, 32, "%d", current_length);
 773     args[2] = tmp;
 774     args[3] = "--title";
 775     args[4] = stored_title;
 776     args[5] = "--artist";
 777     args[6] = stored_artist;
 778
 779     if( stored_album )
 780     {
 781       args[7] = "--album";
 782       args[8] = stored_album;
 783       args[9] = NULL;
 784     }
 785     else
 786     {
 787       args[7] = NULL;
 788     }
 789
 790     execvp( args[0], args );
 791
 792     // Should never get here.
 793     fprintf (stderr, "execvp() error launching lastfm exe '%s'.\n",
 794       config_lastfm_exe);
 795   }
 796 }
 797
 798 gchar* secs_to_time_str (gint secs)
 799 {
 800   if (secs < 0)
 801   {
 802     secs = 0;
 803   }
 804
 805   guint mins = secs / 60;
 806   guint remaining_secs = secs % 60;
 807
 808   return g_strdup_printf (_("%dm %02ds"), mins, remaining_secs);
 809 }
 810
 811 void gssmp_ui_choose_bookmark_clicked (GtkMenuItem* unused, gpointer num)
 812 {
 813   gssmp_files_reset_shuffle ();
 814   config_paused = FALSE;
 815   play_bookmark ((gulong)num);
 816 }
 817
 818 void gssmp_ui_launch_help ()
 819 {
 820   gchar* uri;
 821
 822   if (g_file_test (DOC_URI, G_FILE_TEST_IS_REGULAR))
 823   {
 824     uri = gnome_vfs_get_uri_from_local_path (DOC_URI);
 825   }
 826   else if (g_file_test (BIN_PKG_DOC_PATH, G_FILE_TEST_IS_REGULAR))
 827   {
 828     gchar* abs;
 829     abs = gssmp_files_make_absolute (BIN_PKG_DOC_PATH);
 830     uri = gnome_vfs_get_uri_from_local_path (abs);
 831     g_free (abs);
 832   }
 833   else if (g_file_test (SRC_DIR_DOC_PATH, G_FILE_TEST_IS_REGULAR))
 834   {
 835     gchar* abs;
 836     abs = gssmp_files_make_absolute (SRC_DIR_DOC_PATH);
 837     uri = gnome_vfs_get_uri_from_local_path (abs);
 838     g_free (abs);
 839   }
 840   else
 841   {
 842     uri = g_strdup (ONLINE_DOCS_URI);
 843   }
 844
 845   gnome_vfs_url_show (uri);
 846
 847   g_free (uri);
 848 }
 849
 850 void gssmp_ui_lastfm ()
 851 {
 852   if (!lastfmwindow)
 853   {
 854     lastfmwindow = GTK_WINDOW (create_lastfmwindow ());
 855     checkbutton1 = GTK_CHECK_BUTTON (
 856       lookup_widget (GTK_WIDGET (lastfmwindow), "checkbutton1"));
 857     entry1 = GTK_ENTRY (lookup_widget (GTK_WIDGET (lastfmwindow), "entry1"));
 858   }
 859
 860   gtk_toggle_button_set_active (
 861     GTK_TOGGLE_BUTTON (checkbutton1), config_lastfm_active);
 862   gtk_entry_set_text (entry1, config_lastfm_exe);
 863
 864   lastfm_enable_buttons ();
 865
 866   gtk_widget_show (GTK_WIDGET (lastfmwindow));
 867 }
 868
 869 void gssmp_ui_lastfm_close ()
 870 {
 871   gtk_widget_hide (GTK_WIDGET (lastfmwindow));
 872 }
 873
 874 void gssmp_ui_lastfm_statechange ()
 875 {
 876   config_lastfm_active = gtk_toggle_button_get_active (
 877     GTK_TOGGLE_BUTTON (checkbutton1));
 878 }
 879
 880 void gssmp_ui_lastfm_exechanged ()
 881 {
 882   lastfm_enable_buttons ();
 883
 884   if (config_lastfm_exe)
 885   {
 886     g_free (config_lastfm_exe);
 887   }
 888   config_lastfm_exe = g_strdup( gtk_entry_get_text (entry1) );
 889 }
 890
 891 // --------------------------------
 892
 893 void add_bookmark_here ()
 894 {
 895   if (current_filename && stored_title)
 896   {
 897     gssmp_config_add_bookmark (stored_title, stored_artist, stored_album,
 898       current_directory, current_filename, current_time, current_length);
 899     redisplay_bookmarks ();
 900   }
 901 }
 902
 903 void play_bookmark (guint num)
 904 {
 905   gboolean keep_paused;
 906   GssmpBookmark *bmk;
 907
 908   new_tag = 0;
 909   stored_track_number = NULL;
 910   stored_track_count  = NULL;
 911   stored_track_length = NULL;
 912
 913   bmk = gssmp_config_get_bookmark (num);
 914   if (bmk)
 915   {
 916     add_bookmark_here ();   // First remember what we were playing before
 917
 918     gssmp_ui_duration_callback (bmk->length);
 919     gssmp_ui_progress_callback (bmk->time);
 920
 921     if (stored_title)
 922     {
 923       g_free (stored_title);
 924     }
 925     stored_title  = g_strdup (bmk->track);
 926
 927     if (stored_album)
 928     {
 929       g_free (stored_album);
 930     }
 931     stored_album  = g_strdup (bmk->album);
 932
 933     if (stored_artist)
 934     {
 935       g_free (stored_artist);
 936     }
 937     stored_artist = g_strdup (bmk->artist);
 938
 939     if (current_filename)
 940     {
 941       g_free (current_filename);
 942     }
 943     current_filename     = g_strdup (bmk->filename);
 944
 945     if (current_directory)
 946     {
 947       g_free (current_directory);
 948     }
 949     current_directory    = g_strdup (bmk->directory);
 950
 951     display_track_info ();
 952   }
 953   else
 954   {
 955     stored_title        = NULL;
 956     stored_album        = NULL;
 957     stored_artist       = NULL;
 958   }
 959
 960   if (current_filename)
 961   {
 962     keep_paused = config_paused;
 963     gssmp_ui_play_file (current_filename, TRUE, FALSE, current_time, TRUE);
 964     if (keep_paused)
 965     {
 966       gssmp_ui_pause_clicked ();
 967     }
 968   }
 969
 970   redisplay_bookmarks ();
 971 }
 972
 973 void choose_repeat_menu_item ()
 974 {
 975   switch (config_repeat_style)
 976   {
 977     case no_repeat:
 978     {
 979       gtk_check_menu_item_set_active (no_repeat1,  TRUE);
 980       gtk_check_menu_item_set_active (repeat_all1, FALSE);
 981       gtk_check_menu_item_set_active (repeat_one1, FALSE);
 982       gtk_check_menu_item_set_active (shuffle1,    FALSE);
 983       break;
 984     }
 985     case repeat_all:
 986     {
 987       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
 988       gtk_check_menu_item_set_active (repeat_all1, TRUE);
 989       gtk_check_menu_item_set_active (repeat_one1, FALSE);
 990       gtk_check_menu_item_set_active (shuffle1,    FALSE);
 991       break;
 992     }
 993     case repeat_one:
 994     {
 995       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
 996       gtk_check_menu_item_set_active (repeat_all1, FALSE);
 997       gtk_check_menu_item_set_active (repeat_one1, TRUE);
 998       gtk_check_menu_item_set_active (shuffle1,    FALSE);
 999       break;
1000     }
1001     case shuffle:
1002     {
1003       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1004       gtk_check_menu_item_set_active (repeat_all1, FALSE);
1005       gtk_check_menu_item_set_active (repeat_one1, FALSE);
1006       gtk_check_menu_item_set_active (shuffle1,    TRUE);
1007       break;
1008     }
1009   }
1010 }
1011
1012 void redisplay_bookmarks ()
1013 {
1014   GtkMenu *submenu;
1015
1016   gtk_widget_set_sensitive (GTK_WIDGET (recent1), FALSE);
1017
1018   gtk_menu_item_deselect (GTK_MENU_ITEM (recent1));
1019
1020   submenu = GTK_MENU (gtk_menu_new ());
1021
1022   menu_number = 0;
1023   gssmp_config_bookmarks_foreach (menu_bookmark_callback_create, submenu);
1024
1025   gtk_widget_show (GTK_WIDGET (submenu));
1026
1027   gtk_menu_item_set_submenu (GTK_MENU_ITEM (recent1), GTK_WIDGET (submenu));
1028
1029   gtk_widget_set_sensitive (GTK_WIDGET (recent1), TRUE);
1030 }
1031
1032 void menu_bookmark_callback_create (GssmpBookmark* bmk, gpointer submenu)
1033 {
1034   GtkWidget *item;
1035   gchar* item_name;
1036   gchar* time_str;
1037
1038   time_str = secs_to_time_str (bmk->time);
1039
1040   item_name =  g_strdup_printf (_("%s - %s (%s)"), bmk->artist, bmk->track,
1041     time_str);
1042   item = gtk_menu_item_new_with_label (item_name);
1043   gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
1044   gtk_widget_show (GTK_WIDGET (item));
1045
1046   g_signal_connect ((gpointer) item, "activate",
1047                     G_CALLBACK (gssmp_ui_choose_bookmark_clicked),
1048                     (gpointer)menu_number);
1049
1050   ++menu_number;
1051
1052   g_free (item_name);
1053   g_free (time_str);
1054 }
1055
1056 gboolean status_callback (gpointer detailsptr)
1057 {
1058   struct StatusDetails* details;
1059
1060   status_timeout_source = 0;
1061
1062   details = (struct StatusDetails*)detailsptr;
1063
1064   gssmp_ui_display_status_message (details->context_id, details->msg,
1065     details->sub);
1066
1067   g_slice_free (struct StatusDetails, details);
1068
1069   return FALSE;
1070 }
1071
1072 void play_in_dir (const gchar* dirname)
1073 {
1074   gchar* first_file_name;
1075
1076   gssmp_config_set_directory (dirname);
1077
1078   if (config_repeat_style == shuffle)
1079   {
1080     first_file_name = gssmp_files_find_next_shuffled_file ();
1081   }
1082   else
1083   {
1084     first_file_name = gssmp_files_find_next_file_in_dir (
1085       current_directory, NULL);
1086   }
1087
1088   if (first_file_name)
1089   {
1090     add_bookmark_here (); // Remember what we were playing
1091     gssmp_ui_play_file (first_file_name, FALSE, TRUE, 0, TRUE);
1092   }
1093 }
1094
1095 void lastfm_enable_buttons ()
1096 {
1097   const gchar* exe;
1098   gchar* fullexe;
1099
1100   exe = gtk_entry_get_text (entry1);
1101
1102   fullexe = g_find_program_in_path (exe);
1103
1104   if (fullexe)
1105   {
1106     gtk_widget_set_sensitive (GTK_WIDGET (checkbutton1), TRUE);
1107     g_free (fullexe);
1108   }
1109   else
1110   {
1111     config_lastfm_active = FALSE;
1112     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), FALSE);
1113     gtk_widget_set_sensitive (GTK_WIDGET (checkbutton1), FALSE);
1114   }
1115 }
1116