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 (full_msg);
 369   printf ("\n");
 370
 371   g_free (full_msg);
 372 }
 373
 374 void gssmp_ui_display_2_status_messages (guint context_id, const gchar* msg1,
 375   const gchar* sub1, const gchar* msg2, const gchar* sub2)
 376 {
 377   struct StatusDetails* details;
 378
 379   gssmp_ui_display_status_message (context_id, msg1, sub1);
 380
 381   details = g_slice_new (struct StatusDetails);
 382   details->context_id = context_id;
 383   details->msg = msg2;
 384   details->sub = sub2;
 385
 386   if (status_timeout_source)
 387   {
 388     g_source_remove (status_timeout_source);
 389   }
 390   status_timeout_source = g_timeout_add (STATUS_TIMEOUT_LENGTH,
 391     status_callback, (gpointer)details);
 392 }
 393
 394 /**
 395  * Play the sound file supplied by calling into the gstreamer code and making
 396  * the UI ready where required.
 397  *
 398  * @arg filename             The full path to a file on disk
 399  * @arg change_dir           If this file is outside the user's chosen
 400  *                           directory, should we change that directory to
 401  *                           match the file?
 402  * @arg new_filename         Is the filename a newly-allocated string?  I.e.
 403  *                           should we free the old current_filename?
 404  * @arg start_offset         How many seconds through the file should we start?
 405  * @arg skip_to_next_if_fail If this file fails to load, automatically skip to
 406  *                           the next?  (If not, we display an error to the
 407  *                           user.)
 408  */
 409 void gssmp_ui_play_file (gchar* filename, gboolean change_dir,
 410   gboolean new_filename, gint start_offset, gboolean skip_to_next_if_fail)
 411 {
 412   skip_errors = skip_to_next_if_fail;
 413
 414   if (change_dir)
 415   {
 416     if (!current_directory ||
 417       strncmp (current_directory, filename, strlen (current_directory)) != 0)
 418     {
 419       current_directory = g_path_get_dirname (filename);
 420     }
 421   }
 422
 423   if (new_filename && current_filename)
 424   {
 425     g_free (current_filename);
 426   }
 427   current_filename = filename;
 428
 429   gssmp_ui_clear_track_info ();
 430
 431   new_tag = 0;
 432
 433   config_paused = FALSE;
 434   update_buttons ();
 435
 436   gssmp_ui_display_2_status_messages( context_id_play_file,
 437     _("Playing file %s"), current_filename,
 438     _("Playing in directory %s"), current_directory );
 439
 440   gssmp_gstreamer_play (current_filename, start_offset,
 441     gssmp_ui_duration_callback, gssmp_ui_progress_callback,
 442     gssmp_ui_tag_callback, gssmp_ui_eos_callback,
 443     gssmp_ui_error_callback);
 444 }
 445
 446 void gssmp_ui_play_clicked ()
 447 {
 448   config_paused = FALSE;
 449   update_buttons ();
 450   gssmp_gstreamer_unpause ();
 451 }
 452
 453 void gssmp_ui_pause_clicked ()
 454 {
 455   config_paused = TRUE;
 456   update_buttons ();
 457   gssmp_gstreamer_pause ();
 458 }
 459
 460 void gssmp_ui_slider_changed (gdouble value)
 461 {
 462   gchar* time_str;
 463   gint secs;
 464
 465   secs = (gint)value;
 466   if (current_length != -1 && secs >= current_length)
 467   {
 468     secs = current_length - 1;
 469   }
 470
 471   gssmp_gstreamer_seek (secs);
 472
 473   current_time = secs;
 474
 475   time_str = secs_to_time_str (secs);
 476   gtk_label_set_text (label7, time_str);
 477   gtk_widget_queue_draw(GTK_WIDGET(label7));
 478   g_free (time_str);
 479 }
 480
 481 void gssmp_ui_volume_change (gdouble value)
 482 {
 483   if (value < 0)
 484   {
 485     value = 0;
 486   }
 487   else if (value > 1)
 488   {
 489     value = 1;
 490   }
 491   gssmp_gstreamer_set_volume (value);
 492 }
 493
 494 void gssmp_ui_progress_callback (gint secs)
 495 {
 496   gchar* time_str;
 497
 498   current_time = secs;
 499   gtk_range_set_value (GTK_RANGE(hscale1), (gdouble)secs);
 500
 501   time_str = secs_to_time_str (secs);
 502   gtk_label_set_text (label7, time_str);
 503
 504   switch (new_tag)
 505   {
 506     case 1:
 507     {
 508       display_track_info (FALSE);
 509       new_tag = 2;
 510       break;
 511     }
 512     case 0:
 513     {
 514       new_tag = 1;
 515       break;
 516     }
 517     default:
 518     {
 519       break;
 520     }
 521   }
 522
 523   gtk_widget_queue_draw(GTK_WIDGET(hscale1));
 524   gtk_widget_queue_draw(GTK_WIDGET(label7));
 525   g_free (time_str);
 526 }
 527
 528 void gssmp_ui_duration_callback (gint secs)
 529 {
 530   gtk_range_set_range (GTK_RANGE(hscale1), (gdouble)0, (gdouble)secs);
 531
 532   stored_track_length = secs_to_time_str (secs);
 533   current_length = secs;
 534 }
 535
 536 void gssmp_ui_tag_callback (const gchar* tag, const gchar* value)
 537 {
 538   new_tag = 1;
 539   if (strcmp(tag, "title") == 0)
 540   {
 541     stored_title = g_strdup (value);
 542   }
 543   else if (strcmp(tag, "artist") == 0)
 544   {
 545     stored_artist = g_strdup (value);
 546   }
 547   else if (strcmp(tag, "album") == 0)
 548   {
 549     stored_album = g_strdup (value);
 550   }
 551   else if (strcmp(tag, "track-number") == 0)
 552   {
 553     stored_track_number = g_strdup (value);
 554   }
 555   else if (strcmp(tag, "track-count") == 0)
 556   {
 557     stored_track_count = g_strdup (value);
 558   }
 559   else
 560   {
 561     fprintf (stderr, _("Unknown tag: %s -> %s\n"), tag, value);
 562   }
 563 }
 564
 565 void gssmp_ui_error_callback (const gchar* msg)
 566 {
 567   gssmp_ui_display_status_message (context_id_error_playing_file,
 568     _("Unable to play file: %s"), current_filename );
 569
 570   if (skip_errors)
 571   {
 572     if (moving_forward)
 573     {
 574       gssmp_ui_next_clicked ();
 575     }
 576     else
 577     {
 578       gssmp_ui_previous_clicked ();
 579       moving_forward = FALSE;
 580     }
 581   }
 582   else
 583   {
 584     GtkMessageDialog* dialog;
 585     dialog = GTK_MESSAGE_DIALOG (gtk_message_dialog_new (window1,
 586                                     GTK_DIALOG_DESTROY_WITH_PARENT,
 587                                     GTK_MESSAGE_ERROR,
 588                                     GTK_BUTTONS_CLOSE,
 589                                     _("Error playing file '%s': %s"),
 590                                     current_filename, msg));
 591    gtk_dialog_run (GTK_DIALOG (dialog));
 592    gtk_widget_destroy (GTK_WIDGET (dialog));
 593   }
 594 }
 595
 596 void gssmp_ui_clear_track_info ()
 597 {
 598   if (stored_title)
 599   {
 600     g_free (stored_title);
 601   }
 602   if (stored_track_number)
 603   {
 604     g_free (stored_track_number);
 605   }
 606   if (stored_track_length)
 607   {
 608     g_free (stored_track_length);
 609   }
 610   if (stored_track_count)
 611   {
 612     g_free (stored_track_count);
 613   }
 614   if (stored_artist)
 615   {
 616     g_free (stored_artist);
 617   }
 618   if (stored_album)
 619   {
 620     g_free (stored_album);
 621   }
 622
 623   if (current_filename)
 624   {
 625     gchar* tmp1;
 626     gchar* tmp2;
 627
 628     stored_title = g_path_get_basename (current_filename);
 629     tmp1 = g_path_get_dirname (current_filename);
 630     stored_album = g_path_get_basename (tmp1);
 631     tmp2 = gssmp_files_get_parent_of_dir (tmp1);
 632     stored_artist = g_path_get_basename (tmp2);
 633
 634     g_free (tmp1);
 635     g_free (tmp2);
 636   }
 637   else
 638   {
 639     stored_title = NULL;
 640     stored_album = NULL;
 641     stored_artist = NULL;
 642   }
 643
 644   stored_track_number = NULL;
 645   stored_track_length = NULL;
 646   stored_track_count  = NULL;
 647 }
 648
 649 // --------------------------------
 650
 651 #define MAX_TITLE_LENGTH 2048
 652 void display_track_info (gboolean from_bookmark)
 653 {
 654   gchar title[MAX_TITLE_LENGTH];
 655   gchar tmp[MAX_TITLE_LENGTH];
 656
 657   g_strlcpy (title, "<span size=\"large\">", MAX_TITLE_LENGTH);
 658
 659   if (stored_artist)
 660   {
 661     if (stored_title)
 662     {
 663       if (stored_track_number)
 664       {
 665         if (stored_track_count)
 666         {
 667           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - %s (%s/%s)"),
 668             stored_artist, stored_title, stored_track_number,
 669             stored_track_count);
 670         }
 671         else
 672         {
 673           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - %s (%s)"),
 674             stored_artist, stored_title, stored_track_number);
 675         }
 676       }
 677       else
 678       {
 679         g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - %s"),
 680           stored_artist, stored_title);
 681       }
 682     }
 683     else
 684     {
 685       g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s - unnamed"), stored_artist);
 686     }
 687   }
 688   else
 689   {
 690     if (stored_title)
 691     {
 692       if (stored_track_number)
 693       {
 694         if (stored_track_count)
 695         {
 696           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s (%s/%s)"),
 697             stored_title, stored_track_number, stored_track_count);
 698         }
 699         else
 700         {
 701           g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s (%s)"),
 702             stored_title, stored_track_number);
 703         }
 704       }
 705       else
 706       {
 707         g_snprintf (tmp, MAX_TITLE_LENGTH, _("%s"), stored_title);
 708       }
 709     }
 710     else
 711     {
 712       g_strlcpy (tmp, "", MAX_TITLE_LENGTH);
 713     }
 714   }
 715
 716   g_strlcat (title, tmp, MAX_TITLE_LENGTH);
 717
 718   g_strlcat (title, "</span>", MAX_TITLE_LENGTH);
 719
 720   gtk_label_set_markup (label4, title);
 721
 722   // Now the album name
 723   if (stored_album)
 724   {
 725     g_snprintf (tmp, MAX_TITLE_LENGTH, _("Album: %s"), stored_album);
 726   }
 727   else
 728   {
 729     g_strlcpy (tmp, "", MAX_TITLE_LENGTH);
 730   }
 731
 732   gtk_label_set_text (label5, tmp);
 733
 734   // and the track length
 735   if (stored_track_length)
 736   {
 737     g_snprintf (tmp, MAX_TITLE_LENGTH, _("Length: %s"), stored_track_length);
 738   }
 739   else
 740   {
 741     g_strlcpy (tmp, "", MAX_TITLE_LENGTH);
 742   }
 743   gtk_label_set_text (label8, tmp);
 744
 745   if( config_lastfm_active &&
 746     current_length > 0 && stored_title && stored_artist
 747     && !from_bookmark )
 748   {
 749     fork_lastfm_exe ();
 750   }
 751
 752   add_bookmark_here (); // Put this track to the top of the bookmarks list
 753 }
 754
 755 void fork_lastfm_exe ()
 756 {
 757   pid_t pid;
 758   char tmp[32];
 759
 760   pid = fork();
 761
 762   if (pid == -1)
 763   {
 764       fprintf (stderr, "fork() error before launching lastfm exe.\n");
 765   }
 766   else if( pid == 0 )
 767   {
 768     // We are the child, run lastfm exe
 769
 770     char *args[10];
 771
 772     args[0] = config_lastfm_exe;
 773     args[1] = "--length";
 774     g_snprintf (tmp, 32, "%d", current_length);
 775     args[2] = tmp;
 776     args[3] = "--title";
 777     args[4] = stored_title;
 778     args[5] = "--artist";
 779     args[6] = stored_artist;
 780
 781     if( stored_album )
 782     {
 783       args[7] = "--album";
 784       args[8] = stored_album;
 785       args[9] = NULL;
 786
 787       fprintf (stderr, "Running: %s %s %s %s \"%s\" %s \"%s\" %s \"%s\"\n",
 788         args[0], args[1], args[2], args[3], args[4],
 789         args[5], args[6], args[7], args[8]);
 790     }
 791     else
 792     {
 793       args[7] = NULL;
 794
 795       fprintf (stderr, "Running: %s %s %s %s \"%s\" %s \"%s\"\n",
 796         args[0], args[1], args[2], args[3], args[4],
 797         args[5], args[6]);
 798     }
 799
 800     execvp( args[0], args );
 801
 802     // Should never get here.
 803     fprintf (stderr, "execvp() error launching lastfm exe '%s'.\n",
 804       config_lastfm_exe);
 805   }
 806   else
 807   {
 808           int status;
 809           waitpid( pid, &status, 0 );
 810           // TODO report status anomalies
 811   }
 812 }
 813
 814 gchar* secs_to_time_str (gint secs)
 815 {
 816   if (secs < 0)
 817   {
 818     secs = 0;
 819   }
 820
 821   guint mins = secs / 60;
 822   guint remaining_secs = secs % 60;
 823
 824   return g_strdup_printf (_("%dm %02ds"), mins, remaining_secs);
 825 }
 826
 827 void gssmp_ui_choose_bookmark_clicked (GtkMenuItem* unused, gpointer num)
 828 {
 829   gssmp_files_reset_shuffle ();
 830   config_paused = FALSE;
 831   play_bookmark ((gulong)num);
 832 }
 833
 834 void gssmp_ui_launch_help ()
 835 {
 836   gchar* uri;
 837
 838   if (g_file_test (DOC_URI, G_FILE_TEST_IS_REGULAR))
 839   {
 840     uri = gnome_vfs_get_uri_from_local_path (DOC_URI);
 841   }
 842   else if (g_file_test (BIN_PKG_DOC_PATH, G_FILE_TEST_IS_REGULAR))
 843   {
 844     gchar* abs;
 845     abs = gssmp_files_make_absolute (BIN_PKG_DOC_PATH);
 846     uri = gnome_vfs_get_uri_from_local_path (abs);
 847     g_free (abs);
 848   }
 849   else if (g_file_test (SRC_DIR_DOC_PATH, G_FILE_TEST_IS_REGULAR))
 850   {
 851     gchar* abs;
 852     abs = gssmp_files_make_absolute (SRC_DIR_DOC_PATH);
 853     uri = gnome_vfs_get_uri_from_local_path (abs);
 854     g_free (abs);
 855   }
 856   else
 857   {
 858     uri = g_strdup (ONLINE_DOCS_URI);
 859   }
 860
 861   gnome_vfs_url_show (uri);
 862
 863   g_free (uri);
 864 }
 865
 866 void gssmp_ui_lastfm ()
 867 {
 868   if (!lastfmwindow)
 869   {
 870     lastfmwindow = GTK_WINDOW (create_lastfmwindow ());
 871     checkbutton1 = GTK_CHECK_BUTTON (
 872       lookup_widget (GTK_WIDGET (lastfmwindow), "checkbutton1"));
 873     entry1 = GTK_ENTRY (lookup_widget (GTK_WIDGET (lastfmwindow), "entry1"));
 874   }
 875
 876   gtk_toggle_button_set_active (
 877     GTK_TOGGLE_BUTTON (checkbutton1), config_lastfm_active);
 878   gtk_entry_set_text (entry1, config_lastfm_exe);
 879
 880   lastfm_enable_buttons ();
 881
 882   gtk_widget_show (GTK_WIDGET (lastfmwindow));
 883 }
 884
 885 void gssmp_ui_lastfm_close ()
 886 {
 887   gtk_widget_hide (GTK_WIDGET (lastfmwindow));
 888 }
 889
 890 void gssmp_ui_lastfm_statechange ()
 891 {
 892   config_lastfm_active = gtk_toggle_button_get_active (
 893     GTK_TOGGLE_BUTTON (checkbutton1));
 894 }
 895
 896 void gssmp_ui_lastfm_exechanged ()
 897 {
 898   lastfm_enable_buttons ();
 899
 900   if (config_lastfm_exe)
 901   {
 902     g_free (config_lastfm_exe);
 903   }
 904   config_lastfm_exe = g_strdup( gtk_entry_get_text (entry1) );
 905 }
 906
 907 // --------------------------------
 908
 909 void add_bookmark_here ()
 910 {
 911   if (current_filename && stored_title)
 912   {
 913     gssmp_config_add_bookmark (stored_title, stored_artist, stored_album,
 914       current_directory, current_filename, current_time, current_length);
 915     redisplay_bookmarks ();
 916   }
 917 }
 918
 919 void play_bookmark (guint num)
 920 {
 921   gboolean keep_paused;
 922   GssmpBookmark *bmk;
 923
 924   new_tag = 0;
 925   stored_track_number = NULL;
 926   stored_track_count  = NULL;
 927   stored_track_length = NULL;
 928
 929   bmk = gssmp_config_get_bookmark (num);
 930   if (bmk)
 931   {
 932     add_bookmark_here ();   // First remember what we were playing before
 933
 934     gssmp_ui_duration_callback (bmk->length);
 935     gssmp_ui_progress_callback (bmk->time);
 936
 937     if (stored_title)
 938     {
 939       g_free (stored_title);
 940     }
 941     stored_title  = g_strdup (bmk->track);
 942
 943     if (stored_album)
 944     {
 945       g_free (stored_album);
 946     }
 947     stored_album  = g_strdup (bmk->album);
 948
 949     if (stored_artist)
 950     {
 951       g_free (stored_artist);
 952     }
 953     stored_artist = g_strdup (bmk->artist);
 954
 955     if (current_filename)
 956     {
 957       g_free (current_filename);
 958     }
 959     current_filename     = g_strdup (bmk->filename);
 960
 961     if (current_directory)
 962     {
 963       g_free (current_directory);
 964     }
 965     current_directory    = g_strdup (bmk->directory);
 966
 967     display_track_info (TRUE);
 968   }
 969   else
 970   {
 971     stored_title        = NULL;
 972     stored_album        = NULL;
 973     stored_artist       = NULL;
 974   }
 975
 976   if (current_filename)
 977   {
 978     keep_paused = config_paused;
 979     gssmp_ui_play_file (current_filename, TRUE, FALSE, current_time, TRUE);
 980     if (keep_paused)
 981     {
 982       gssmp_ui_pause_clicked ();
 983     }
 984   }
 985
 986   redisplay_bookmarks ();
 987 }
 988
 989 void choose_repeat_menu_item ()
 990 {
 991   switch (config_repeat_style)
 992   {
 993     case no_repeat:
 994     {
 995       gtk_check_menu_item_set_active (no_repeat1,  TRUE);
 996       gtk_check_menu_item_set_active (repeat_all1, FALSE);
 997       gtk_check_menu_item_set_active (repeat_one1, FALSE);
 998       gtk_check_menu_item_set_active (shuffle1,    FALSE);
 999       break;
1000     }
1001     case repeat_all:
1002     {
1003       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1004       gtk_check_menu_item_set_active (repeat_all1, TRUE);
1005       gtk_check_menu_item_set_active (repeat_one1, FALSE);
1006       gtk_check_menu_item_set_active (shuffle1,    FALSE);
1007       break;
1008     }
1009     case repeat_one:
1010     {
1011       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1012       gtk_check_menu_item_set_active (repeat_all1, FALSE);
1013       gtk_check_menu_item_set_active (repeat_one1, TRUE);
1014       gtk_check_menu_item_set_active (shuffle1,    FALSE);
1015       break;
1016     }
1017     case shuffle:
1018     {
1019       gtk_check_menu_item_set_active (no_repeat1,  FALSE);
1020       gtk_check_menu_item_set_active (repeat_all1, FALSE);
1021       gtk_check_menu_item_set_active (repeat_one1, FALSE);
1022       gtk_check_menu_item_set_active (shuffle1,    TRUE);
1023       break;
1024     }
1025   }
1026 }
1027
1028 void redisplay_bookmarks ()
1029 {
1030   GtkMenu *submenu;
1031
1032   gtk_widget_set_sensitive (GTK_WIDGET (recent1), FALSE);
1033
1034   gtk_menu_item_deselect (GTK_MENU_ITEM (recent1));
1035
1036   submenu = GTK_MENU (gtk_menu_new ());
1037
1038   menu_number = 0;
1039   gssmp_config_bookmarks_foreach (menu_bookmark_callback_create, submenu);
1040
1041   gtk_widget_show (GTK_WIDGET (submenu));
1042
1043   gtk_menu_item_set_submenu (GTK_MENU_ITEM (recent1), GTK_WIDGET (submenu));
1044
1045   gtk_widget_set_sensitive (GTK_WIDGET (recent1), TRUE);
1046 }
1047
1048 void menu_bookmark_callback_create (GssmpBookmark* bmk, gpointer submenu)
1049 {
1050   GtkWidget *item;
1051   gchar* item_name;
1052   gchar* time_str;
1053
1054   time_str = secs_to_time_str (bmk->time);
1055
1056   item_name =  g_strdup_printf (_("%s - %s (%s)"), bmk->artist, bmk->track,
1057     time_str);
1058   item = gtk_menu_item_new_with_label (item_name);
1059   gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
1060   gtk_widget_show (GTK_WIDGET (item));
1061
1062   g_signal_connect ((gpointer) item, "activate",
1063                     G_CALLBACK (gssmp_ui_choose_bookmark_clicked),
1064                     (gpointer)menu_number);
1065
1066   ++menu_number;
1067
1068   g_free (item_name);
1069   g_free (time_str);
1070 }
1071
1072 gboolean status_callback (gpointer detailsptr)
1073 {
1074   struct StatusDetails* details;
1075
1076   status_timeout_source = 0;
1077
1078   details = (struct StatusDetails*)detailsptr;
1079
1080   gssmp_ui_display_status_message (details->context_id, details->msg,
1081     details->sub);
1082
1083   g_slice_free (struct StatusDetails, details);
1084
1085   return FALSE;
1086 }
1087
1088 void play_in_dir (const gchar* dirname)
1089 {
1090   gchar* first_file_name;
1091
1092   gssmp_config_set_directory (dirname);
1093
1094   if (config_repeat_style == shuffle)
1095   {
1096     first_file_name = gssmp_files_find_next_shuffled_file ();
1097   }
1098   else
1099   {
1100     first_file_name = gssmp_files_find_next_file_in_dir (
1101       current_directory, NULL);
1102   }
1103
1104   if (first_file_name)
1105   {
1106     add_bookmark_here (); // Remember what we were playing
1107     gssmp_ui_play_file (first_file_name, FALSE, TRUE, 0, TRUE);
1108   }
1109 }
1110
1111 void lastfm_enable_buttons ()
1112 {
1113   const gchar* exe;
1114   gchar* fullexe;
1115
1116   exe = gtk_entry_get_text (entry1);
1117
1118   fullexe = g_find_program_in_path (exe);
1119
1120   if (fullexe)
1121   {
1122     gtk_widget_set_sensitive (GTK_WIDGET (checkbutton1), TRUE);
1123     g_free (fullexe);
1124   }
1125   else
1126   {
1127     config_lastfm_active = FALSE;
1128     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), FALSE);
1129     gtk_widget_set_sensitive (GTK_WIDGET (checkbutton1), FALSE);
1130   }
1131 }
1132