src/demo-gui.c

   1 /* demo-gui.c
   2  * Copyright (C) 2008 Rov Juvano <rovjuvano@users.sourceforge.net>
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <gtk/gtk.h>
  19 #include <glib/gprintf.h>
  20 #include <math.h>
  21 #include "demo-gui.h"
  22
  23 #undef G_LOG_DOMAIN
  24 #define G_LOG_DOMAIN "demo-gui"
  25
  26 enum
  27 {
  28   SIGNAL_ERROR,
  29   SIGNAL_QUITING,
  30   LAST_SIGNAL
  31 };
  32 static guint demo_gui_signals[LAST_SIGNAL] = { 0 };
  33
  34 enum
  35 {
  36   PROP_0,
  37 };
  38
  39 typedef struct _DemoGuiPrivate
  40 {
  41   DemoPlayer     *player;
  42   GList          *uris;
  43   GList          *now_playing;
  44   gboolean        is_playing;
  45   GtkWidget      *window;
  46   GtkEntry       *rate_entry;
  47   GtkStatusbar   *status_bar;
  48   gint            position_updater_id;
  49   GtkRange       *seek_range;
  50   GtkLabel       *amount_played;
  51   GtkLabel       *amount_to_play;
  52   GtkAction      *play_action;
  53   GtkAction      *pause_action;
  54   GtkAction      *open_file;
  55   GtkAction      *playlist_next;
  56 } DemoGuiPrivate;
  57
  58 #define DEMO_GUI_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DEMO_TYPE_GUI, DemoGuiPrivate))
  59
  60 /* forward declarations */
  61 static GValueArray * build_gvalue_array (guint n_values, ...);
  62
  63 /* Handlers for status bar and seek bar */
  64 static int
  65 pop_status_bar (gpointer data) {
  66   GValueArray *gvalues = (GValueArray *)data;
  67   GtkStatusbar *sb = GTK_STATUSBAR (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
  68   guint msg_id = g_value_get_uint (g_value_array_get_nth (gvalues, 1));
  69
  70   gtk_statusbar_remove (sb, 0, msg_id);
  71   return FALSE;
  72 }
  73
  74 #define DEFAULT_STATUS_BAR_TIMEOUT 2
  75 static void
  76 status_bar_printf (GtkStatusbar *sb,
  77                    guint seconds,
  78                    gchar const *format,
  79                    ...)
  80 {
  81   va_list args;
  82   gchar msg[80];
  83   va_start (args, format);
  84   g_vsnprintf (msg, 80, format, args);
  85   va_end (args);
  86   guint msg_id = gtk_statusbar_push (sb, 0, msg);
  87   g_timeout_add (2000, pop_status_bar,
  88     build_gvalue_array (2, G_TYPE_OBJECT, sb, G_TYPE_UINT, msg_id));
  89 }
  90
  91 #define PRINTF_TIME_FORMAT "u:%02u:%02u"
  92 #define PRINTF_TIME_ARGS(t)                       \
  93     (t >= 0) ? (guint) ((t) / (60 * 60)) : 99,    \
  94     (t >= 0) ? (guint) (((t) / (60)) % 60) : 99,  \
  95     (t >= 0) ? (guint) ((t) % 60) : 99
  96
  97 static gchar*
  98 demo_gui_seek_bar_format (GtkScale   *scale,
  99                           gdouble     value,
 100                           gpointer    data)
 101 {
 102   return g_strdup_printf ("%" PRINTF_TIME_FORMAT, PRINTF_TIME_ARGS ((gint64)value));
 103 }
 104
 105 gboolean update_position (gpointer data) {
 106   DemoGui *gui = DEMO_GUI (data);
 107   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 108   gchar pos_str[16], dur_str[16];
 109
 110   gint pos = demo_player_get_position (priv->player);
 111   if (pos > 0) {
 112     g_snprintf (pos_str, 16, "%" PRINTF_TIME_FORMAT, PRINTF_TIME_ARGS (pos));
 113     gint dur = demo_player_get_duration (priv->player);
 114     if (dur > 0) {
 115       g_snprintf (dur_str, 16, "-%" PRINTF_TIME_FORMAT, PRINTF_TIME_ARGS (dur - pos));
 116     } else {
 117       dur = pos;
 118       g_sprintf (dur_str, "-??:??:??");
 119     }
 120     if (dur > 0)
 121       gtk_range_set_range (GTK_RANGE (priv->seek_range), 0, (gdouble)dur);
 122     gtk_range_set_value (GTK_RANGE (priv->seek_range), (gdouble)pos);
 123   } else {
 124     g_sprintf (pos_str, "??:??:??");
 125     g_sprintf (dur_str, "-??:??:??");
 126   }
 127   gtk_label_set_text (GTK_LABEL (priv->amount_played), pos_str);
 128   gtk_label_set_text (GTK_LABEL (priv->amount_to_play), dur_str);
 129
 130   return priv->is_playing;
 131 }
 132
 133
 134 gboolean
 135 demo_gui_seek_bar_change (GtkRange        *range,
 136                           GtkScrollType    scroll,
 137                           gdouble          value,
 138                           gpointer         data)
 139 {
 140   DemoGui *gui = DEMO_GUI (data);
 141   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 142   gint new_second = (gint)value;
 143
 144   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Seeking to %i second", new_second);
 145   demo_player_seek_to (priv->player, new_second);
 146
 147   return FALSE;
 148 }
 149
 150
 151 /* Callbacks for actions */
 152 static void
 153 demo_gui_do_change_rate (GtkAction   *action,
 154                          gpointer     data)
 155 {
 156   GValueArray *gvalues = (GValueArray *)data;
 157   DemoGui *gui = g_value_get_object (g_value_array_get_nth (gvalues, 0));
 158   gdouble scale_amount = g_value_get_double (g_value_array_get_nth (gvalues, 1));
 159   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 160
 161   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Changing rate by %3.2lf", scale_amount);
 162
 163   demo_player_scale_rate (priv->player, scale_amount);
 164 }
 165
 166 static void
 167 demo_gui_do_set_rate (GtkAction   *action,
 168                       gpointer     data)
 169 {
 170   GValueArray *gvalues = (GValueArray *)data;
 171   DemoGui *gui = g_value_get_object (g_value_array_get_nth (gvalues, 0));
 172   gdouble new_rate = g_value_get_double (g_value_array_get_nth (gvalues, 1));
 173   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 174
 175   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Setting rate to %3.2lf", new_rate);
 176
 177   demo_player_set_rate (priv->player, new_rate);
 178 }
 179
 180 static gboolean
 181 demo_gui_do_rate_entered (GtkWidget   *widget,
 182                           gpointer     data)
 183 {
 184   DemoGui *gui = DEMO_GUI (data);
 185   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 186   gchar *err = NULL;
 187   const gchar *text = gtk_entry_get_text (GTK_ENTRY (widget));
 188   double new_rate = g_strtod (text, &err);
 189   if (*err) {
 190     gtk_widget_error_bell (priv->window);
 191     status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Invalid rate: %s", text);
 192     return TRUE;
 193   }
 194
 195   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Setting rate to %3.2lf", new_rate);
 196
 197   demo_player_set_rate (priv->player, new_rate);
 198   return FALSE;
 199 }
 200
 201 static void
 202 demo_gui_do_toggle_advanced (GtkAction   *action,
 203                              gpointer     data)
 204 {
 205   GValueArray *gvalues = (GValueArray *)data;
 206   DemoGui *gui = DEMO_GUI (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
 207   GtkWidget *stride_ui  = GTK_WIDGET (g_value_get_object (g_value_array_get_nth (gvalues, 1)));
 208   GtkWidget *overlap_ui = GTK_WIDGET (g_value_get_object (g_value_array_get_nth (gvalues, 2)));
 209   GtkWidget *search_ui  = GTK_WIDGET (g_value_get_object (g_value_array_get_nth (gvalues, 3)));
 210   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 211
 212   status_bar_printf (priv->status_bar, 1, "Toggling advanced mode");
 213
 214   gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 215   gtk_widget_set_sensitive (stride_ui, active);
 216   gtk_widget_set_sensitive (overlap_ui, active);
 217   gtk_widget_set_sensitive (search_ui, active);
 218 }
 219
 220 static void
 221 demo_gui_do_toggle_disabled (GtkAction   *action,
 222                              gpointer     data)
 223 {
 224   GValueArray *gvalues = (GValueArray *)data;
 225   DemoGui *gui = DEMO_GUI (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
 226   GtkAction *advanced_action = GTK_ACTION (g_value_get_object (g_value_array_get_nth (gvalues, 1)));
 227   GtkWidget *advanced_ui     = GTK_WIDGET (g_value_get_object (g_value_array_get_nth (gvalues, 2)));
 228
 229   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 230
 231   status_bar_printf (priv->status_bar, 1, "Toggling disabled");
 232
 233   gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 234   gtk_action_set_sensitive (GTK_ACTION (advanced_action), !active);
 235   gtk_widget_set_sensitive (GTK_WIDGET (advanced_ui), !active);
 236   g_object_set (G_OBJECT (priv->player), "disabled", active, NULL);
 237 }
 238
 239 static void
 240 demo_gui_do_seek (GtkAction   *action,
 241                   gpointer     data)
 242 {
 243   GValueArray *gvalues = (GValueArray *)data;
 244   DemoGui *gui = DEMO_GUI (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
 245   gint seconds = g_value_get_int (g_value_array_get_nth (gvalues, 1));
 246
 247   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 248
 249   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Requesting seek by %i seconds", seconds);
 250
 251   demo_player_seek_by (priv->player, seconds);
 252 }
 253
 254 static void
 255 demo_gui_do_play (GtkAction   *action,
 256                   gpointer     data)
 257 {
 258   DemoGui *gui = DEMO_GUI (data);
 259   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 260
 261   if (priv->is_playing) {
 262     g_signal_emit (gui, demo_gui_signals[SIGNAL_ERROR], 0, "Already playing");
 263     return;
 264   }
 265
 266   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Requesting playback start");
 267
 268   demo_player_play (priv->player);
 269 }
 270
 271 static void
 272 demo_gui_do_pause (GtkAction   *action,
 273                    gpointer     data)
 274 {
 275   DemoGui *gui = DEMO_GUI (data);
 276   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 277
 278   if (!priv->is_playing) {
 279     g_signal_emit (gui, demo_gui_signals[SIGNAL_ERROR], 0, "Already paused");
 280     return;
 281   }
 282
 283   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Requesting playback pause");
 284
 285   demo_player_pause (priv->player);
 286 }
 287
 288 static void
 289 demo_gui_do_play_pause (GtkAction   *action,
 290                         gpointer     data)
 291 {
 292   DemoGui *gui = DEMO_GUI (data);
 293   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 294
 295   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Reqesting playback toggle");
 296
 297   if (priv->is_playing)
 298     gtk_action_activate (priv->pause_action);
 299   else
 300     gtk_action_activate (priv->play_action);
 301 }
 302
 303 static void
 304 demo_gui_do_open_file (GtkAction   *action,
 305                        gpointer     data)
 306 {
 307   DemoGui *gui = DEMO_GUI (data);
 308   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 309
 310   GtkWidget *dialog = gtk_file_chooser_dialog_new ("Open File",
 311       GTK_WINDOW (priv->window),
 312       GTK_FILE_CHOOSER_ACTION_OPEN,
 313       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 314       GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 315       NULL);
 316
 317   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
 318     char *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 319     GError *err = NULL;
 320     g_list_free (priv->uris);
 321     priv->uris = NULL;
 322     priv->now_playing = NULL;
 323     demo_player_load_uri (priv->player, g_filename_to_uri (filename, NULL, &err));
 324     g_free (filename);
 325   }
 326   gtk_widget_destroy (dialog);
 327 }
 328
 329 static void
 330 demo_gui_do_playlist_prev (GtkAction   *action,
 331                            gpointer     data)
 332 {
 333   DemoGui *gui = DEMO_GUI (data);
 334   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 335
 336   if (priv->now_playing) {
 337     if (priv->now_playing->prev) {
 338       status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playlist previous");
 339       priv->now_playing = priv->now_playing->prev;
 340     } else {
 341       priv->now_playing = NULL;
 342       gtk_widget_error_bell (priv->window);
 343       status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Beginning of playlist");
 344       return;
 345     }
 346   } else if (priv->uris) {
 347     status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playlist previous: wrap");
 348     priv->now_playing = g_list_last (priv->uris);
 349   } else {
 350     gtk_action_activate (priv->open_file);
 351     return;
 352   }
 353
 354   demo_player_load_uri (priv->player, priv->now_playing->data);
 355 }
 356
 357 static void
 358 demo_gui_do_playlist_next (GtkAction   *action,
 359                            gpointer     data)
 360 {
 361   DemoGui *gui = DEMO_GUI (data);
 362   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 363
 364   if (priv->now_playing) {
 365     if (priv->now_playing->next) {
 366       status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playlist next");
 367       priv->now_playing = priv->now_playing->next;
 368     } else {
 369       priv->now_playing = NULL;
 370       gtk_widget_error_bell (priv->window);
 371       status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "End of playlist");
 372       return;
 373     }
 374   } else if (priv->uris) {
 375     status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playlist next: wrap");
 376     priv->now_playing = priv->uris;
 377   } else {
 378     gtk_action_activate (priv->open_file);
 379     return;
 380   }
 381
 382   demo_player_load_uri (priv->player, priv->now_playing->data);
 383 }
 384
 385 static void
 386 demo_gui_do_quit (gpointer    source,
 387                   gpointer    data)
 388 {
 389   gtk_main_quit ();
 390   g_signal_emit (DEMO_GUI (data), demo_gui_signals[SIGNAL_QUITING], 0, NULL);
 391 }
 392
 393 static gboolean
 394 demo_gui_request_set_stride (GtkSpinButton   *spinbutton,
 395                              gpointer         data)
 396 {
 397   DemoGui *gui = DEMO_GUI (data);
 398   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 399   guint new_stride = gtk_spin_button_get_value_as_int (spinbutton);
 400   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Reqesting setting stride to %u ms", new_stride);
 401   g_object_set (G_OBJECT (priv->player), "stride", new_stride, NULL);
 402   return TRUE;
 403 }
 404
 405 static gboolean
 406 demo_gui_request_set_overlap (GtkSpinButton   *spinbutton,
 407                               gpointer         data)
 408 {
 409   DemoGui *gui = DEMO_GUI (data);
 410   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 411   gdouble new_overlap = gtk_spin_button_get_value_as_int (spinbutton);
 412   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Requesting setting overlap to %2.0lf%%", new_overlap);
 413   g_object_set (G_OBJECT (priv->player), "overlap", new_overlap/100.0, NULL);
 414   return TRUE;
 415 }
 416
 417 static gboolean
 418 demo_gui_request_set_search (GtkSpinButton   *spinbutton,
 419                              gpointer         data)
 420 {
 421   DemoGui *gui = DEMO_GUI (data);
 422   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 423   guint new_search = gtk_spin_button_get_value_as_int (spinbutton);
 424   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Requesting setting search to %u ms", new_search);
 425   g_object_set (G_OBJECT (priv->player), "search", new_search, NULL);
 426   return TRUE;
 427 }
 428
 429
 430 /* Callbacks from signals */
 431 static void
 432 demo_gui_rate_changed (DemoPlayer   *player,
 433                        gdouble       new_rate,
 434                        gpointer      data)
 435 {
 436   DemoGui *gui = DEMO_GUI (data);
 437   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 438   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Rate changed to %3.2lf", new_rate);
 439
 440   gchar e[6];
 441   g_snprintf (e, 6, "%3.2f", new_rate);
 442   gtk_entry_set_text (GTK_ENTRY (priv->rate_entry), e);
 443 }
 444
 445 static void
 446 demo_gui_playing_started (DemoPlayer   *player,
 447                           gpointer      data)
 448 {
 449   DemoGui *gui = DEMO_GUI (data);
 450   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 451
 452   priv->is_playing = TRUE;
 453   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playing started");
 454
 455   gtk_action_set_sensitive (priv->play_action, FALSE);
 456   gtk_action_set_sensitive (priv->pause_action, TRUE);
 457   gtk_action_set_visible (priv->play_action, FALSE);
 458   gtk_action_set_visible (priv->pause_action, TRUE);
 459
 460   if (priv->position_updater_id) {
 461     g_source_remove (priv->position_updater_id);
 462     priv->position_updater_id = 0;
 463   }
 464   update_position (gui);
 465   priv->position_updater_id = g_timeout_add (1000, update_position, gui);
 466 }
 467
 468 static void
 469 demo_gui_playing_paused (DemoPlayer   *player,
 470                          gpointer      data)
 471 {
 472   DemoGui *gui = DEMO_GUI (data);
 473   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 474
 475   gtk_action_set_sensitive (priv->play_action, TRUE);
 476   gtk_action_set_sensitive (priv->pause_action, FALSE);
 477   gtk_action_set_visible (priv->play_action, TRUE);
 478   gtk_action_set_visible (priv->pause_action, FALSE);
 479
 480   priv->is_playing = FALSE;
 481
 482   if (priv->position_updater_id)
 483     g_source_remove (priv->position_updater_id);
 484   priv->position_updater_id = 0;
 485   update_position (gui);
 486
 487   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playing paused");
 488 }
 489
 490 static void
 491 demo_gui_playing_ended (DemoPlayer   *player,
 492                         gpointer      data)
 493 {
 494   DemoGui *gui = DEMO_GUI (data);
 495   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 496   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Playing ended");
 497   gtk_action_activate (priv->playlist_next);
 498 }
 499
 500 static void
 501 demo_gui_player_errored (DemoPlayer    *player,
 502                          const gchar   *msg,
 503                          gpointer       data)
 504 {
 505   DemoGui *gui = DEMO_GUI (data);
 506   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 507   status_bar_printf (priv->status_bar, 5, msg);
 508 }
 509
 510 static void
 511 demo_gui_stride_changed (DemoPlayer   *player,
 512                          GParamSpec   *pspec,
 513                          gpointer      data)
 514 {
 515   GValueArray *gvalues = (GValueArray *)data;
 516   DemoGui *gui = DEMO_GUI (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
 517   GtkEntry *entry = GTK_ENTRY (g_value_get_object (g_value_array_get_nth (gvalues, 1)));
 518   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 519
 520   guint new_stride;
 521   g_object_get (G_OBJECT (player), "stride", &new_stride, NULL);
 522   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Stride changed to %u", new_stride);
 523
 524   gchar e[6];
 525   snprintf (e, 6, "%u", new_stride);
 526   gtk_entry_set_text (entry, e);
 527 }
 528
 529 static void
 530 demo_gui_overlap_changed (DemoPlayer   *player,
 531                           GParamSpec   *pspec,
 532                           gpointer      data)
 533 {
 534   GValueArray *gvalues = (GValueArray *)data;
 535   DemoGui *gui = DEMO_GUI (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
 536   GtkEntry *entry = GTK_ENTRY (g_value_get_object (g_value_array_get_nth (gvalues, 1)));
 537   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 538
 539   gdouble new_overlap;
 540   g_object_get (G_OBJECT (player), "overlap", &new_overlap, NULL);
 541   new_overlap *= 100;
 542   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Overlap changed to %2.0lf%%", new_overlap);
 543
 544   gchar e[6];
 545   snprintf (e, 6, "%2.0f", new_overlap);
 546   gtk_entry_set_text (entry, e);
 547 }
 548
 549 static void
 550 demo_gui_search_changed (DemoPlayer   *player,
 551                          GParamSpec   *pspec,
 552                          gpointer      data)
 553 {
 554   GValueArray *gvalues = (GValueArray *)data;
 555   DemoGui *gui = DEMO_GUI (g_value_get_object (g_value_array_get_nth (gvalues, 0)));
 556   GtkEntry *entry = GTK_ENTRY (g_value_get_object (g_value_array_get_nth (gvalues, 1)));
 557   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 558
 559   guint new_search;
 560   g_object_get (G_OBJECT (player), "search", &new_search, NULL);
 561   status_bar_printf (priv->status_bar, DEFAULT_STATUS_BAR_TIMEOUT, "Search changed to %u", new_search);
 562
 563   gchar e[6];
 564   snprintf (e, 6, "%u", new_search);
 565   gtk_entry_set_text (entry, e);
 566 }
 567
 568
 569 /* method implementations */
 570 static void
 571 demo_gui_set_player_func (DemoGui      *gui,
 572                           DemoPlayer   *player)
 573 {
 574   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 575   if (priv->player) {
 576     g_signal_handlers_disconnect_by_func (G_OBJECT (priv->player), G_CALLBACK (demo_gui_rate_changed), gui);
 577     g_signal_handlers_disconnect_by_func (G_OBJECT (priv->player), G_CALLBACK (demo_gui_playing_started), gui);
 578     g_signal_handlers_disconnect_by_func (G_OBJECT (priv->player), G_CALLBACK (demo_gui_playing_paused), gui);
 579     g_signal_handlers_disconnect_by_func (G_OBJECT (priv->player), G_CALLBACK (demo_gui_playing_ended), gui);
 580     g_signal_handlers_disconnect_by_func (G_OBJECT (priv->player), G_CALLBACK (demo_gui_player_errored), gui);
 581     g_object_unref (priv->player);
 582   }
 583   g_object_ref (player);
 584   priv->player = player;
 585   g_signal_connect (G_OBJECT (priv->player), "error", G_CALLBACK (demo_gui_player_errored), gui);
 586   g_signal_connect (G_OBJECT (priv->player), "rate-changed", G_CALLBACK (demo_gui_rate_changed), gui);
 587   g_signal_connect (G_OBJECT (priv->player), "playing-started", G_CALLBACK (demo_gui_playing_started), gui);
 588   g_signal_connect (G_OBJECT (priv->player), "playing-paused", G_CALLBACK (demo_gui_playing_paused), gui);
 589   g_signal_connect (G_OBJECT (priv->player), "playing-ended", G_CALLBACK (demo_gui_playing_ended), gui);
 590   priv->is_playing = FALSE;
 591 }
 592
 593 static void
 594 demo_gui_set_playlist_func (DemoGui    *gui,
 595                             GList      *uris)
 596 {
 597   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 598   priv->uris = uris;
 599 }
 600
 601 typedef struct _ActionEntry {
 602   GtkAction        *action;
 603   GtkWidget        *button;
 604   const gchar      *accel;
 605   const gchar      *name;
 606   const gchar      *label;
 607   const gchar      *tooltip;
 608   const gchar      *stock_id;
 609   GtkAccelGroup    *accel_group;
 610   GtkActionGroup   *action_group;
 611   GCallback         callback;
 612   gpointer          data;
 613 } ActionEntry;
 614
 615 static GValueArray *
 616 build_gvalue_array (guint n_values,
 617                     ...)
 618 {
 619   va_list args;
 620   va_start (args, n_values);
 621   GValueArray *gva = g_value_array_new (n_values);
 622   int i;
 623   for (i=0; i<n_values; i++) {
 624     GType type = va_arg (args, GType);
 625     GValue *gval = g_new0 (GValue, 1);
 626     if (type == G_TYPE_INT) {
 627       gint value = va_arg (args, gint);
 628       g_value_set_int (g_value_init (gval, G_TYPE_INT), value);
 629     } else if (type == G_TYPE_UINT) {
 630       guint value = va_arg (args, guint);
 631       g_value_set_uint (g_value_init (gval, G_TYPE_UINT), value);
 632     } else if (type == G_TYPE_DOUBLE) {
 633       double value = va_arg (args, double);
 634       g_value_set_double (g_value_init (gval, G_TYPE_DOUBLE), value);
 635     } else if (type == G_TYPE_OBJECT) {
 636       GObject *value = va_arg (args, GObject *);
 637       g_value_set_object (g_value_init (gval, G_TYPE_OBJECT), value);
 638     } else {
 639       g_critical ("build_gvalue_array cannot handle type (%s)", g_type_name (type));
 640       va_end (args);
 641       return NULL;
 642     }
 643     g_value_array_append (gva, gval);
 644   }
 645   va_end (args);
 646   return gva;
 647 }
 648
 649 static void
 650 create_action (ActionEntry *p)
 651 {
 652   p->action = gtk_action_new (p->name, p->label, p->tooltip, p->stock_id);
 653
 654   gtk_action_group_add_action_with_accel (p->action_group, p->action, p->accel);
 655   gtk_action_set_accel_group (p->action, p->accel_group);
 656   gtk_action_connect_accelerator (p->action);
 657
 658   p->button = gtk_button_new ();
 659   gtk_action_connect_proxy (p->action, p->button);
 660   gtk_button_set_image (GTK_BUTTON (p->button), gtk_action_create_icon (p->action, GTK_ICON_SIZE_BUTTON));
 661   g_signal_connect (G_OBJECT (p->action), "activate", p->callback, p->data);
 662 }
 663
 664 static void
 665 demo_gui_show_func (DemoGui   *gui) {
 666   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
 667
 668   gtk_init (NULL, NULL);
 669   GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 670   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (demo_gui_do_quit), gui);
 671
 672   GtkAccelGroup *accel_group = gtk_accel_group_new ();
 673   gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
 674   GtkActionGroup *action_group = gtk_action_group_new ("toolbar");
 675
 676   ActionEntry *slower_lg = &(ActionEntry){
 677       NULL, NULL,
 678       "braceleft", "slower-large",
 679       "2x Slower", "half playback rate",
 680       GTK_STOCK_GO_DOWN, accel_group, action_group,
 681       G_CALLBACK (demo_gui_do_change_rate),
 682       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_DOUBLE, 0.5)
 683   };
 684   create_action (slower_lg);
 685
 686   ActionEntry *slower_sm = &(ActionEntry){
 687       NULL, NULL,
 688       "bracketleft", "slower-small",
 689       "_Slower", "decrease playback rate",
 690       GTK_STOCK_GO_DOWN, accel_group, action_group,
 691       G_CALLBACK (demo_gui_do_change_rate),
 692       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_DOUBLE, pow (2, -1.0/12))
 693   };
 694   create_action (slower_sm);
 695
 696   ActionEntry *faster_sm = &(ActionEntry){
 697       NULL, NULL,
 698       "bracketright", "faster-small",
 699       "_Faster", "increase playback rate",
 700       GTK_STOCK_GO_UP, accel_group, action_group,
 701       G_CALLBACK (demo_gui_do_change_rate),
 702       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_DOUBLE, pow (2, 1.0/12))
 703   };
 704   create_action (faster_sm);
 705
 706   ActionEntry *faster_lg = &(ActionEntry){
 707       NULL, NULL,
 708       "braceright", "faster-large",
 709       "2X Faster", "double playback rate",
 710       GTK_STOCK_GO_UP, accel_group, action_group,
 711       G_CALLBACK (demo_gui_do_change_rate),
 712       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_DOUBLE, 2.0)
 713   };
 714   create_action (faster_lg);
 715
 716   ActionEntry *normal = &(ActionEntry){
 717       NULL, NULL,
 718       "backslash", "normal",
 719       "_Normal", "playback normal rate",
 720       GTK_STOCK_CLEAR, accel_group, action_group,
 721       G_CALLBACK (demo_gui_do_set_rate),
 722       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_DOUBLE, 1.0)
 723   };
 724   create_action (normal);
 725
 726   ActionEntry *rewind_lg = &(ActionEntry){
 727       NULL, NULL,
 728       "<ctrl><shift>Left", "seek-rewind-large",
 729       "Rewind (large)", "seek -30 seconds",
 730       GTK_STOCK_MEDIA_REWIND, accel_group, action_group,
 731       G_CALLBACK (demo_gui_do_seek),
 732       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_INT, -30)
 733   };
 734   create_action (rewind_lg);
 735
 736   ActionEntry *rewind_sm = &(ActionEntry){
 737       NULL, NULL,
 738       "<ctrl>Left", "seek-rewind-small",
 739       "Rewind", "seek -15 seconds",
 740       GTK_STOCK_MEDIA_REWIND, accel_group, action_group,
 741       G_CALLBACK (demo_gui_do_seek),
 742       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_INT, -5)
 743   };
 744   create_action (rewind_sm);
 745
 746   ActionEntry *forward_sm = &(ActionEntry){
 747       NULL, NULL,
 748       "<ctrl>Right", "seek-forward-small",
 749       "Forward", "seek +5 seconds",
 750       GTK_STOCK_MEDIA_FORWARD, accel_group, action_group,
 751       G_CALLBACK (demo_gui_do_seek),
 752       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_INT, 5)
 753   };
 754   create_action (forward_sm);
 755
 756   ActionEntry *forward_lg = &(ActionEntry){
 757       NULL, NULL,
 758       "<ctrl><shift>Right", "seek-forward-large",
 759       "Forward (large)", "seek +30 seconds",
 760       GTK_STOCK_MEDIA_FORWARD, accel_group, action_group,
 761       G_CALLBACK (demo_gui_do_seek),
 762       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_INT, 30)
 763   };
 764   create_action (forward_lg);
 765
 766   ActionEntry *pause = &(ActionEntry){
 767       NULL, NULL,
 768       "p", "pause",
 769       "Pause", "Pause playback",
 770       GTK_STOCK_MEDIA_PAUSE, accel_group, action_group,
 771       G_CALLBACK (demo_gui_do_pause), gui
 772   };
 773   create_action (pause);
 774
 775   ActionEntry *play = &(ActionEntry){
 776       NULL, NULL,
 777       "<ctrl>p", "play",
 778       "Play", "Start Playback",
 779       GTK_STOCK_MEDIA_PLAY, accel_group, action_group,
 780       G_CALLBACK (demo_gui_do_play), gui
 781   };
 782   create_action (play);
 783   GtkRequisition pause_size;
 784   gtk_widget_size_request (pause->button, &pause_size);
 785   gtk_widget_set_size_request (play->button, pause_size.width, -1);
 786
 787   ActionEntry *play_pause = &(ActionEntry){
 788       NULL, NULL,
 789       "space", "play-pause",
 790       "Play/Pause", "Toggle playback",
 791       NULL, accel_group, action_group,
 792       G_CALLBACK (demo_gui_do_play_pause), gui
 793   };
 794   create_action (play_pause);
 795
 796   ActionEntry *open_file = &(ActionEntry){
 797       NULL, NULL,
 798       "<ctrl>o", "open-file",
 799       "Open File", "Open file for playing",
 800       GTK_STOCK_OPEN, accel_group, action_group,
 801       G_CALLBACK (demo_gui_do_open_file), gui
 802   };
 803   create_action (open_file);
 804
 805   ActionEntry *playlist_prev = &(ActionEntry){
 806       NULL, NULL,
 807       "less", "playlist-previous",
 808       "Previous", "Previous in playlist",
 809       GTK_STOCK_MEDIA_PREVIOUS, accel_group, action_group,
 810       G_CALLBACK (demo_gui_do_playlist_prev), gui
 811   };
 812   create_action (playlist_prev);
 813
 814   ActionEntry *playlist_next = &(ActionEntry){
 815       NULL, NULL,
 816       "greater", "playlist-next",
 817       "Next", "Next in playlist",
 818       GTK_STOCK_MEDIA_NEXT, accel_group, action_group,
 819       G_CALLBACK (demo_gui_do_playlist_next), gui
 820   };
 821   create_action (playlist_next);
 822
 823   ActionEntry *quit = &(ActionEntry){
 824       NULL, NULL,
 825       "q", "quit",
 826       "Quit", "Quit demo",
 827       GTK_STOCK_QUIT, accel_group, action_group,
 828       G_CALLBACK (demo_gui_do_quit), gui
 829   };
 830   create_action (quit);
 831
 832   GtkWidget *rate_entry = gtk_entry_new ();
 833   GtkWidget *rate_label = gtk_label_new ("Rate:");
 834   gtk_entry_set_max_length (GTK_ENTRY (rate_entry), 5);
 835   gtk_entry_set_text (GTK_ENTRY (rate_entry), "1.0");
 836   gtk_entry_set_width_chars (GTK_ENTRY (rate_entry), 5);
 837   g_signal_connect (G_OBJECT (rate_entry), "activate", G_CALLBACK (demo_gui_do_rate_entered), gui);
 838
 839   GtkWidget *toolbox = gtk_hbox_new (FALSE, 0);
 840   gtk_box_pack_start (GTK_BOX (toolbox), slower_sm->button, FALSE, FALSE, 2);
 841   gtk_box_pack_start (GTK_BOX (toolbox), rate_label, FALSE, FALSE, 2);
 842   gtk_box_pack_start (GTK_BOX (toolbox), rate_entry, FALSE, FALSE, 2);
 843   gtk_box_pack_start (GTK_BOX (toolbox), faster_sm->button, FALSE, FALSE, 2);
 844   gtk_box_pack_start (GTK_BOX (toolbox), normal->button, FALSE, FALSE, 2);
 845
 846
 847   GtkWidget *stride_ui  = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (60, 1, 1000, 1, 10, 0)), 0, 0);
 848   GtkWidget *overlap_ui = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (20, 0, 100,  5, 10, .00001)), 0, 0);
 849   GtkWidget *search_ui  = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (14, 0, 1000, 1, 10, 0)), 0, 0);
 850   gtk_widget_set_sensitive (stride_ui, FALSE);
 851   gtk_widget_set_sensitive (overlap_ui, FALSE);
 852   gtk_widget_set_sensitive (search_ui, FALSE);
 853   g_signal_connect (G_OBJECT (stride_ui),  "output", G_CALLBACK (demo_gui_request_set_stride), gui);
 854   g_signal_connect (G_OBJECT (overlap_ui), "output", G_CALLBACK (demo_gui_request_set_overlap), gui);
 855   g_signal_connect (G_OBJECT (search_ui),  "output", G_CALLBACK (demo_gui_request_set_search), gui);
 856   g_signal_connect (G_OBJECT (priv->player), "notify::stride", G_CALLBACK (demo_gui_stride_changed),
 857       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_OBJECT, stride_ui));
 858   g_signal_connect (G_OBJECT (priv->player), "notify::overlap", G_CALLBACK (demo_gui_overlap_changed),
 859       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_OBJECT, overlap_ui));
 860   g_signal_connect (G_OBJECT (priv->player), "notify::search", G_CALLBACK (demo_gui_search_changed),
 861       build_gvalue_array (2, G_TYPE_OBJECT, gui, G_TYPE_OBJECT, search_ui));
 862   GtkWidget *propbox = gtk_hbox_new (FALSE, 0);
 863   GtkWidget *adv_check = gtk_check_button_new ();
 864   gtk_box_pack_start (GTK_BOX (propbox), gtk_label_new ("stride:"), FALSE, FALSE, 2);
 865   gtk_box_pack_start (GTK_BOX (propbox), stride_ui, FALSE, FALSE, 2);
 866   gtk_box_pack_start (GTK_BOX (propbox), gtk_label_new ("overlap:"), FALSE, FALSE, 2);
 867   gtk_box_pack_start (GTK_BOX (propbox), overlap_ui, FALSE, FALSE, 2);
 868   gtk_box_pack_start (GTK_BOX (propbox), gtk_label_new ("search:"), FALSE, FALSE, 2);
 869   gtk_box_pack_start (GTK_BOX (propbox), search_ui, FALSE, FALSE, 2);
 870   gtk_box_pack_start (GTK_BOX (propbox), adv_check, FALSE, FALSE, 2);
 871
 872   GtkAction *toggle_advanced = GTK_ACTION (gtk_toggle_action_new ("advanced", "Enable Parameters", "Toggle advanced controls", 0));
 873   gtk_action_group_add_action_with_accel (action_group, toggle_advanced, "<ctrl>a");
 874   gtk_action_set_accel_group (toggle_advanced, accel_group);
 875   gtk_action_connect_accelerator (toggle_advanced);
 876   gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (toggle_advanced), FALSE);
 877   gtk_action_connect_proxy (toggle_advanced, adv_check);
 878   g_signal_connect (G_OBJECT (toggle_advanced), "activate", G_CALLBACK (demo_gui_do_toggle_advanced),
 879       build_gvalue_array (4, G_TYPE_OBJECT, gui, G_TYPE_OBJECT, stride_ui, G_TYPE_OBJECT, overlap_ui, G_TYPE_OBJECT, search_ui));
 880
 881   GtkAction *toggle_disabled = GTK_ACTION (gtk_toggle_action_new ("disabled", "Disable Scaletempo", "Toggle disabling scaletempo", 0));
 882   gtk_action_group_add_action_with_accel (action_group, toggle_disabled, "<ctrl>d");
 883   gtk_action_set_accel_group (toggle_disabled, accel_group);
 884   gtk_action_connect_accelerator (toggle_disabled);
 885   gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (toggle_disabled), FALSE);
 886   GtkWidget *disabled_check = gtk_check_button_new ();
 887   gtk_action_connect_proxy (toggle_disabled, disabled_check);
 888   g_signal_connect (G_OBJECT (toggle_disabled), "activate", G_CALLBACK (demo_gui_do_toggle_disabled),
 889       build_gvalue_array (3, G_TYPE_OBJECT, gui, G_TYPE_OBJECT, toggle_advanced, G_TYPE_OBJECT, propbox));
 890   gtk_box_pack_start (GTK_BOX (toolbox), disabled_check, FALSE, FALSE, 2);
 891
 892
 893   GtkWidget *media_controls = gtk_hbox_new (FALSE, 0);
 894   gtk_box_pack_start (GTK_BOX (media_controls), playlist_prev->button, FALSE, FALSE, 2);
 895   gtk_box_pack_start (GTK_BOX (media_controls), rewind_sm->button, FALSE, FALSE, 2);
 896   gtk_box_pack_start (GTK_BOX (media_controls), play->button, FALSE, FALSE, 2);
 897   gtk_box_pack_start (GTK_BOX (media_controls), pause->button, FALSE, FALSE, 2);
 898   gtk_box_pack_start (GTK_BOX (media_controls), forward_sm->button, FALSE, FALSE, 2);
 899   gtk_box_pack_start (GTK_BOX (media_controls), playlist_next->button, FALSE, FALSE, 2);
 900
 901   GtkWidget *amount_played = gtk_label_new ("?:??:??");
 902   GtkWidget *amount_to_play = gtk_label_new ("-?:??:??");
 903   gtk_label_set_width_chars (GTK_LABEL (amount_played), 8);
 904   gtk_label_set_width_chars (GTK_LABEL (amount_to_play), 8);
 905   gtk_misc_set_alignment (GTK_MISC (amount_played), 1, 1);
 906   gtk_misc_set_alignment (GTK_MISC (amount_to_play), 0, 1);
 907   GtkWidget *seek_range = gtk_hscale_new (
 908       GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 5.0, 30.0, 0.00)));
 909   gtk_range_set_update_policy (GTK_RANGE (seek_range), GTK_UPDATE_DISCONTINUOUS);
 910   GtkWidget *seek_bar = gtk_hbox_new (FALSE, 0);
 911   gtk_box_pack_start (GTK_BOX (seek_bar), amount_played, FALSE, FALSE, 2);
 912   gtk_box_pack_start (GTK_BOX (seek_bar), seek_range, TRUE, TRUE, 2);
 913   gtk_box_pack_start (GTK_BOX (seek_bar), amount_to_play, FALSE, FALSE, 2);
 914   g_signal_connect (G_OBJECT (seek_range), "format-value", G_CALLBACK (demo_gui_seek_bar_format), gui);
 915   g_signal_connect (G_OBJECT (seek_range), "change-value", G_CALLBACK (demo_gui_seek_bar_change), gui);
 916
 917   GtkWidget *status_bar = gtk_statusbar_new ();
 918
 919   /* Menubar*/
 920   GtkWidget *file_menu = gtk_menu_new ();
 921   gtk_menu_set_accel_group (GTK_MENU (file_menu), accel_group);
 922   gtk_menu_shell_append (GTK_MENU_SHELL (file_menu), gtk_action_create_menu_item (open_file->action));
 923   gtk_menu_shell_append (GTK_MENU_SHELL (file_menu), gtk_action_create_menu_item (quit->action));
 924   GtkWidget *file_menu_item = gtk_menu_item_new_with_mnemonic ("_File");
 925   gtk_menu_item_set_submenu (GTK_MENU_ITEM (file_menu_item), file_menu);
 926
 927   GtkWidget *media_menu = gtk_menu_new ();
 928   gtk_menu_set_accel_group (GTK_MENU (media_menu), accel_group);
 929   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (rewind_lg->action));
 930   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (rewind_sm->action));
 931   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (forward_sm->action));
 932   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (forward_lg->action));
 933   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (play->action));
 934   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (pause->action));
 935   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (play_pause->action));
 936   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (playlist_prev->action));
 937   gtk_menu_shell_append (GTK_MENU_SHELL (media_menu), gtk_action_create_menu_item (playlist_next->action));
 938   GtkWidget *media_menu_item = gtk_menu_item_new_with_mnemonic ("_Media");
 939   gtk_menu_item_set_submenu (GTK_MENU_ITEM (media_menu_item), media_menu);
 940
 941   GtkWidget *demo_menu = gtk_menu_new ();
 942   gtk_menu_set_accel_group (GTK_MENU (demo_menu), accel_group);
 943   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (faster_lg->action));
 944   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (faster_sm->action));
 945   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (slower_sm->action));
 946   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (slower_lg->action));
 947   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (normal->action));
 948   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (toggle_disabled));
 949   gtk_menu_shell_append (GTK_MENU_SHELL (demo_menu), gtk_action_create_menu_item (toggle_advanced));
 950   GtkWidget *demo_menu_item = gtk_menu_item_new_with_mnemonic ("_Scaletempo");
 951   gtk_menu_item_set_submenu (GTK_MENU_ITEM (demo_menu_item), demo_menu);
 952
 953   GtkWidget *menu_bar = gtk_menu_bar_new ();
 954   gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), file_menu_item);
 955   gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), media_menu_item);
 956   gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), demo_menu_item);
 957
 958   /* Toplevel Window */
 959   gtk_window_set_title (GTK_WINDOW (window), "Scaletempo Demo");
 960   GtkWidget *toplevel_box = gtk_vbox_new (FALSE, 0);
 961   gtk_container_set_border_width (GTK_CONTAINER (toplevel_box), 3);
 962   gtk_container_add (GTK_CONTAINER (window), toplevel_box);
 963   gtk_box_pack_start (GTK_BOX (toplevel_box), menu_bar, FALSE, FALSE, 2);
 964   gtk_box_pack_start (GTK_BOX (toplevel_box), media_controls, FALSE, FALSE, 2);
 965   gtk_box_pack_start (GTK_BOX (toplevel_box), toolbox, FALSE, FALSE, 2);
 966   gtk_box_pack_start (GTK_BOX (toplevel_box), propbox, FALSE, FALSE, 2);
 967   gtk_box_pack_start (GTK_BOX (toplevel_box), seek_bar, FALSE, FALSE, 2);
 968   gtk_box_pack_start (GTK_BOX (toplevel_box), status_bar, FALSE, FALSE, 2);
 969
 970   priv->window         = window;
 971   priv->rate_entry     = GTK_ENTRY (rate_entry);
 972   priv->status_bar     = GTK_STATUSBAR (status_bar);
 973   priv->seek_range     = GTK_RANGE (seek_range);
 974   priv->amount_played  = GTK_LABEL (amount_played);
 975   priv->amount_to_play = GTK_LABEL (amount_to_play);
 976   priv->play_action    = GTK_ACTION (play->action);
 977   priv->pause_action   = GTK_ACTION (pause->action);
 978   priv->open_file      = GTK_ACTION (open_file->action);
 979   priv->playlist_next  = GTK_ACTION (playlist_next->action);
 980
 981   gtk_action_set_sensitive (priv->pause_action, FALSE);
 982   gtk_action_set_visible (priv->pause_action, FALSE);
 983
 984   gtk_widget_show_all (window);
 985   gtk_widget_grab_focus (seek_range);
 986   gtk_action_activate (priv->playlist_next);
 987   status_bar_printf (GTK_STATUSBAR (status_bar), 5, "Welcome to the Scaletempo demo.");
 988
 989   GError *error;
 990   if (!g_thread_create ((GThreadFunc)gtk_main, NULL, FALSE, &error)) {
 991     g_signal_emit (gui, demo_gui_signals[SIGNAL_ERROR], 0, error->message);
 992   }
 993 }
 994
 995
 996 /* Method wrappers */
 997 void
 998 demo_gui_set_player (DemoGui      *gui,
 999                      DemoPlayer   *player)
1000 {
1001   g_return_if_fail (DEMO_IS_GUI (gui));
1002   g_return_if_fail (DEMO_IS_PLAYER (player));
1003
1004   DEMO_GUI_GET_CLASS (gui)->set_player (gui, player);
1005 }
1006
1007 void
1008 demo_gui_set_playlist (DemoGui    *gui,
1009                        GList      *uris)
1010 {
1011   g_return_if_fail (DEMO_IS_GUI (gui));
1012
1013   DEMO_GUI_GET_CLASS (gui)->set_playlist (gui, uris);
1014 }
1015
1016 void
1017 demo_gui_show (DemoGui   *gui)
1018 {
1019   g_return_if_fail (DEMO_IS_GUI (gui));
1020
1021   DEMO_GUI_GET_CLASS (gui)->show (gui);
1022 }
1023
1024
1025
1026 /* GObject overrides */
1027 static void
1028 demo_gui_get_property (GObject      *object,
1029                        guint         property_id,
1030                        GValue       *value,
1031                        GParamSpec   *pspec)
1032 {
1033   //DemoGui *gui = DEMO_GUI (object);
1034   switch (property_id) {
1035     default:
1036       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1037       break;
1038   }
1039 }
1040
1041 static void
1042 demo_gui_set_property (GObject       *object,
1043                        guint           property_id,
1044                        const GValue   *value,
1045                        GParamSpec     *pspec)
1046 {
1047   //DemoGui *gui = DEMO_GUI (object);
1048   switch (property_id) {
1049     default:
1050       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1051       break;
1052   }
1053 }
1054
1055
1056 /* GTypeInfo functions */
1057 static void
1058 demo_gui_init (GTypeInstance   *instance,
1059                gpointer         klass)
1060 {
1061   DemoGui *gui = (DemoGui *)instance;
1062
1063   DemoGuiPrivate *priv = DEMO_GUI_GET_PRIVATE (gui);
1064   priv->player              = NULL;
1065   priv->uris                = NULL;
1066   priv->now_playing         = NULL;
1067   priv->is_playing          = FALSE;
1068   priv->window              = NULL;
1069   priv->rate_entry          = NULL;
1070   priv->position_updater_id = 0;
1071   priv->seek_range          = NULL;
1072   priv->amount_played       = NULL;
1073   priv->amount_to_play      = NULL;
1074 }
1075
1076 static void
1077 demo_gui_class_init (gpointer   klass,
1078                      gpointer   class_data)
1079 {
1080   g_type_class_add_private (klass, sizeof (DemoGuiPrivate));
1081
1082   /* DemiPlayer */
1083   DemoGuiClass *gui_class = (DemoGuiClass *)klass;
1084   gui_class->set_player   = demo_gui_set_player_func;
1085   gui_class->set_playlist = demo_gui_set_playlist_func;
1086   gui_class->show         = demo_gui_show_func;
1087
1088   /* GObject */
1089   GObjectClass *as_object_class = G_OBJECT_CLASS (klass);
1090   as_object_class->get_property = demo_gui_get_property;
1091   as_object_class->set_property = demo_gui_set_property;
1092
1093   /* Properties */
1094
1095   /* Signals */
1096   GType type = G_TYPE_FROM_CLASS (klass);
1097   demo_gui_signals[SIGNAL_ERROR] = g_signal_new ("error", type,
1098       G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
1099       g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
1100
1101   demo_gui_signals[SIGNAL_QUITING] = g_signal_new ("quiting", type,
1102       G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
1103       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, NULL);
1104 }
1105
1106 GType
1107 demo_gui_get_type (void)
1108 {
1109   static GType type = 0;
1110   if (G_UNLIKELY (type == 0)) {
1111     static const GTypeInfo info = {
1112       sizeof /* Class */        (DemoGuiClass),
1113       (GBaseInitFunc)            NULL,
1114       (GBaseFinalizeFunc)        NULL,
1115       (GClassInitFunc)           demo_gui_class_init,
1116       (GClassFinalizeFunc)       NULL,
1117       (gconstpointer)            NULL,   /* class_data */
1118       sizeof /* Instance */     (DemoGui),
1119       /* n_preallocs */          0,
1120       (GInstanceInitFunc)        demo_gui_init,
1121       (const GTypeValueTable *)  NULL
1122       };
1123       type = g_type_register_static (G_TYPE_OBJECT, "DemoGui", &info, 0);
1124     }
1125     return type;
1126 }