enum RBShellPlayerError

typedef enum {
	RB_SHELL_PLAYER_ERROR_PLAYLIST_PARSE_ERROR,
	RB_SHELL_PLAYER_ERROR_END_OF_PLAYLIST,
	RB_SHELL_PLAYER_ERROR_NOT_PLAYING,
	RB_SHELL_PLAYER_ERROR_NOT_SEEKABLE,
	RB_SHELL_PLAYER_ERROR_POSITION_NOT_AVAILABLE,
} RBShellPlayerError;

rb_shell_player_error_quark ()

GQuark              rb_shell_player_error_quark         (void);

struct RBShellPlayer

struct RBShellPlayer;

struct RBShellPlayerClass

struct RBShellPlayerClass {
	GObjectClass parent_class;

	void (*window_title_changed) (RBShellPlayer *player, const char *window_title);
	void (*elapsed_changed) (RBShellPlayer *player, guint elapsed);
	void (*elapsed_nano_changed) (RBShellPlayer *player, gint64 elapsed);
	void (*playing_changed) (RBShellPlayer *player, gboolean playing);
	void (*playing_source_changed) (RBShellPlayer *player, RBSource *source);
	void (*playing_uri_changed) (RBShellPlayer *player, const char *uri);
	void (*playing_song_changed) (RBShellPlayer *player, RhythmDBEntry *entry);
	void (*playing_song_property_changed) (RBShellPlayer *player,
					       const char *uri,
					       const char *property,
					       GValue *old,
					       GValue *newValue);
};

rb_shell_player_new ()

RBShellPlayer *     rb_shell_player_new                 (RhythmDB *db,
                                                         GtkUIManager *mgr,
                                                         GtkActionGroup *actiongroup);

Creates the RBShellPlayer

rb_shell_player_set_selected_source ()

void                rb_shell_player_set_selected_source (RBShellPlayer *player,
                                                         RBSource *source);

Updates the player to reflect a new source being selected.

rb_shell_player_set_playing_source ()

void                rb_shell_player_set_playing_source  (RBShellPlayer *player,
                                                         RBSource *source);

Replaces the current playing source.

rb_shell_player_get_playing_source ()

RBSource *          rb_shell_player_get_playing_source  (RBShellPlayer *player);

Retrieves the current playing source. That is, the source from which the current song was drawn. This differs from rb_shell_player_get_active_source when the current song came from the play queue.

rb_shell_player_get_active_source ()

RBSource *          rb_shell_player_get_active_source   (RBShellPlayer *player);

Retrieves the active source. This is the source that the user selected for playback.

rb_shell_player_jump_to_current ()

void                rb_shell_player_jump_to_current     (RBShellPlayer *player);

Scrolls the RBEntryView for the current playing source so that the current playing entry is visible and selects the row for the entry. If there is no current playing entry, the selection is cleared instead.

rb_shell_player_play_entry ()

void                rb_shell_player_play_entry          (RBShellPlayer *player,
                                                         RhythmDBEntry *entry,
                                                         RBSource *source);

Plays a specified entry.

rb_shell_player_play ()

gboolean            rb_shell_player_play                (RBShellPlayer *player,
                                                         GError **error);

Starts playback, if it is not already playing.

rb_shell_player_pause ()

gboolean            rb_shell_player_pause               (RBShellPlayer *player,
                                                         GError **error);

Pauses playback if possible, completely stopping if not.

rb_shell_player_playpause ()

gboolean            rb_shell_player_playpause           (RBShellPlayer *player,
                                                         gboolean unused,
                                                         GError **error);

Toggles between playing and paused state. If there is no playing entry, chooses an entry from (in order of preference) the play queue, the selection in the current source, or the play order.

rb_shell_player_stop ()

void                rb_shell_player_stop                (RBShellPlayer *player);

Completely stops playback, freeing resources and unloading the file.

In general rb_shell_player_pause() should be used instead, as it stops the audio, but does not completely free resources.

rb_shell_player_do_previous ()

gboolean            rb_shell_player_do_previous         (RBShellPlayer *player,
                                                         GError **error);

If the current song has been playing for more than 3 seconds, restarts it, otherwise, goes back to the previous song. Fails if there is no current song, or if inside the first 3 seconds of the first song in the play order.

rb_shell_player_do_next ()

gboolean            rb_shell_player_do_next             (RBShellPlayer *player,
                                                         GError **error);

Skips to the next song. Consults the play queue and handles transitions between the play queue and the active source. Fails if there is no entry to play after the current one.

rb_shell_player_get_playing_time_string ()

char *              rb_shell_player_get_playing_time_string
                                                        (RBShellPlayer *player);

Constructs a string showing the current playback position, taking the time display settings into account.

rb_shell_player_get_playing_time ()

gboolean            rb_shell_player_get_playing_time    (RBShellPlayer *player,
                                                         guint *time,
                                                         GError **error);

Retrieves the current playback position. Fails if the player currently cannot provide the playback position.

rb_shell_player_set_playing_time ()

gboolean            rb_shell_player_set_playing_time    (RBShellPlayer *player,
                                                         guint time,
                                                         GError **error);

Attempts to set the playback position. Fails if the current song is not seekable.

rb_shell_player_seek ()

gboolean            rb_shell_player_seek                (RBShellPlayer *player,
                                                         gint32 offset,
                                                         GError **error);

Seeks forwards or backwards in the current playing song. Fails if the current song is not seekable.

rb_shell_player_get_playing_song_duration ()

long                rb_shell_player_get_playing_song_duration
                                                        (RBShellPlayer *player);

Retrieves the duration of the current playing song.

rb_shell_player_get_playing ()

gboolean            rb_shell_player_get_playing         (RBShellPlayer *player,
                                                         gboolean *playing,
                                                         GError **error);

Reports whether playback is occuring by setting playing.

rb_shell_player_get_playing_path ()

gboolean            rb_shell_player_get_playing_path    (RBShellPlayer *player,
                                                         const gchar **path,
                                                         GError **error);

Retrieves the URI of the current playing entry. The caller must not free the returned string.

rb_shell_player_set_playback_state ()

void                rb_shell_player_set_playback_state  (RBShellPlayer *player,
                                                         gboolean shuffle,
                                                         gboolean repeat);

Sets the state of the shuffle and repeat settings.

rb_shell_player_get_playback_state ()

gboolean            rb_shell_player_get_playback_state  (RBShellPlayer *player,
                                                         gboolean *shuffle,
                                                         gboolean *repeat);

Retrieves the current state of the shuffle and repeat settings.

rb_shell_player_get_playing_entry ()

RhythmDBEntry *     rb_shell_player_get_playing_entry   (RBShellPlayer *player);

Retrieves the currently playing RhythmDBEntry, or NULL if nothing is playing. The caller must unref the entry (using rhythmdb_entry_unref) when it is no longer needed.

rb_shell_player_set_volume ()

gboolean            rb_shell_player_set_volume          (RBShellPlayer *player,
                                                         gdouble volume,
                                                         GError **error);

Sets the playback volume level.

rb_shell_player_get_volume ()

gboolean            rb_shell_player_get_volume          (RBShellPlayer *player,
                                                         gdouble *volume,
                                                         GError **error);

Returns the current volume level

rb_shell_player_set_volume_relative ()

gboolean            rb_shell_player_set_volume_relative (RBShellPlayer *player,
                                                         gdouble delta,
                                                         GError **error);

Adds the specified value to the current volume level.

rb_shell_player_set_mute ()

gboolean            rb_shell_player_set_mute            (RBShellPlayer *player,
                                                         gboolean mute,
                                                         GError **error);

Updates the mute setting on the player.

rb_shell_player_get_mute ()

gboolean            rb_shell_player_get_mute            (RBShellPlayer *player,
                                                         gboolean *mute,
                                                         GError **error);

Returns TRUE if currently muted

rb_shell_player_add_play_order ()

void                rb_shell_player_add_play_order      (RBShellPlayer *player,
                                                         const char *name,
                                                         const char *description,
                                                         GType order_type,
                                                         gboolean hidden);

Adds a new play order to the set of available play orders.

rb_shell_player_remove_play_order ()

void                rb_shell_player_remove_play_order   (RBShellPlayer *player,
                                                         const char *name);

Removes a play order previously added with rb_shell_player_add_play_order from the set of available play orders.

The "action-group" property

  "action-group"             GtkActionGroup*       : Read / Write / Construct Only

The GtkActionGroup to use for player actions

The "db" property

  "db"                       RhythmDB*             : Read / Write / Construct Only

The RhythmDB

The "has-next" property

  "has-next"                 gboolean              : Read

Whether there is a track to play after the current track.

Default value: FALSE

The "has-prev" property

  "has-prev"                 gboolean              : Read

Whether there was a previous track before the current track.

Default value: FALSE

The "header" property

  "header"                   RBHeader*             : Read / Write

The RBHeader object

The "mute" property

  "mute"                     gboolean              : Read / Write

Whether playback is currently muted.

Default value: FALSE

The "play-order" property

  "play-order"               gchar*                : Read

The current play order object.

Default value: "linear"

The "player" property

  "player"                   GObject*              : Read

The player backend object (an object implementing the RBPlayer interface).

The "playing" property

  "playing"                  gboolean              : Read

Whether Rhythmbox is currently playing something

Default value: FALSE

The "playing-from-queue" property

  "playing-from-queue"       gboolean              : Read

If TRUE, the current playing entry came from the play queue.

Default value: FALSE

The "queue-only" property

  "queue-only"               gboolean              : Read / Write

If TRUE, activating an entry should only add it to the play queue.

Default value: FALSE

The "queue-source" property

  "queue-source"             RBPlaylistSource*     : Read / Write

The play queue source

The "source" property

  "source"                   RBSource*             : Read / Write

The current source that is selected for playback.

The "ui-manager" property

  "ui-manager"               GtkUIManager*         : Read / Write / Construct Only

The GtkUIManager

The "volume" property

  "volume"                   gfloat                : Read / Write

The current playback volume (between 0.0 and 1.0)

Allowed values: [0,1]

Default value: 1

The "elapsed-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        guint          elapsed,
                                                        gpointer       user_data)      : Run Last

Emitted when the playback position changes.

The "elapsed-nano-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        gint64         elapsed,
                                                        gpointer       user_data)      : Run Last

Emitted when the playback position changes. Only use this (as opposed to elapsed-changed) when you require subsecond precision. This signal will be emitted multiple times per second.

The "playing-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        gboolean       playing,
                                                        gpointer       user_data)      : Run Last

Emitted when playback either stops or starts.

The "playing-song-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        RhythmDBEntry *entry,
                                                        gpointer       user_data)      : Run Last

Emitted when the playing database entry changes

The "playing-song-property-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        gchar         *uri,
                                                        gchar         *property,
                                                        GValue        *old,
                                                        GValue        *newvalue,
                                                        gpointer       user_data)      : Run Last

Emitted when a property of the playing database entry changes.

The "playing-source-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        RBSource      *source,
                                                        gpointer       user_data)      : Run Last

Emitted when a new RBSource instance starts playing

The "playing-uri-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        gchar         *uri,
                                                        gpointer       user_data)      : Run Last

Emitted when the playing database entry changes, providing the URI of the entry.

The "window-title-changed" signal

void                user_function                      (RBShellPlayer *player,
                                                        gchar         *title,
                                                        gpointer       user_data)      : Run Last

Emitted when the main window title text should be changed