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