void PlaylistSequence::Load() {
loading_ = true; // Stops these setter functions calling Save()
SetShuffleMode(
ShuffleMode(settings_->value("shuffle_mode", Shuffle_Off).toInt()));
SetRepeatMode(
RepeatMode(settings_->value("repeat_mode", Repeat_Off).toInt()));
loading_ = false;
}
void PlaylistSequence::ShuffleActionTriggered(QAction* action) {
ShuffleMode mode = Shuffle_Off;
if (action == ui_->action_shuffle_all) mode = Shuffle_All;
if (action == ui_->action_shuffle_inside_album) mode = Shuffle_InsideAlbum;
if (action == ui_->action_shuffle_albums) mode = Shuffle_Albums;
SetShuffleMode(mode);
}
IncomingDataParser::IncomingDataParser(Application* app) : app_(app) {
// Connect all the signals
// due the player is in a different thread, we cannot access these functions
// directly
connect(this, SIGNAL(Play()), app_->player(), SLOT(Play()));
connect(this, SIGNAL(PlayPause()), app_->player(), SLOT(PlayPause()));
connect(this, SIGNAL(Pause()), app_->player(), SLOT(Pause()));
connect(this, SIGNAL(Stop()), app_->player(), SLOT(Stop()));
connect(this, SIGNAL(StopAfterCurrent()), app_->player(),
SLOT(StopAfterCurrent()));
connect(this, SIGNAL(Next()), app_->player(), SLOT(Next()));
connect(this, SIGNAL(Previous()), app_->player(), SLOT(Previous()));
connect(this, SIGNAL(SetVolume(int)), app_->player(), SLOT(SetVolume(int)));
connect(this, SIGNAL(PlayAt(int, Engine::TrackChangeFlags, bool)),
app_->player(), SLOT(PlayAt(int, Engine::TrackChangeFlags, bool)));
connect(this, SIGNAL(SeekTo(int)), app_->player(), SLOT(SeekTo(int)));
connect(this, SIGNAL(SetActivePlaylist(int)), app_->playlist_manager(),
SLOT(SetActivePlaylist(int)));
connect(this, SIGNAL(ShuffleCurrent()), app_->playlist_manager(),
SLOT(ShuffleCurrent()));
connect(this, SIGNAL(SetRepeatMode(PlaylistSequence::RepeatMode)),
app_->playlist_manager()->sequence(),
SLOT(SetRepeatMode(PlaylistSequence::RepeatMode)));
connect(this, SIGNAL(SetShuffleMode(PlaylistSequence::ShuffleMode)),
app_->playlist_manager()->sequence(),
SLOT(SetShuffleMode(PlaylistSequence::ShuffleMode)));
connect(this, SIGNAL(InsertUrls(int, const QList<QUrl>&, int, bool, bool)),
app_->playlist_manager(),
SLOT(InsertUrls(int, const QList<QUrl>&, int, bool, bool)));
connect(this, SIGNAL(RemoveSongs(int, const QList<int>&)),
app_->playlist_manager(),
SLOT(RemoveItemsWithoutUndo(int, const QList<int>&)));
connect(this, SIGNAL(Open(int)), app_->playlist_manager(), SLOT(Open(int)));
connect(this, SIGNAL(Close(int)), app_->playlist_manager(), SLOT(Close(int)));
connect(this, SIGNAL(RateCurrentSong(double)), app_->playlist_manager(),
SLOT(RateCurrentSong(double)));
#ifdef HAVE_LIBLASTFM
connect(this, SIGNAL(Love()), InternetModel::Service<LastFMService>(),
SLOT(Love()));
connect(this, SIGNAL(Ban()), InternetModel::Service<LastFMService>(),
SLOT(Ban()));
#endif
}
void IncomingDataParser::SetShuffleMode(const pb::remote::Shuffle& shuffle) {
switch (shuffle.shuffle_mode()) {
case pb::remote::Shuffle_Off:
emit SetShuffleMode(PlaylistSequence::Shuffle_Off);
break;
case pb::remote::Shuffle_All:
emit SetShuffleMode(PlaylistSequence::Shuffle_All);
break;
case pb::remote::Shuffle_InsideAlbum:
emit SetShuffleMode(PlaylistSequence::Shuffle_InsideAlbum);
break;
case pb::remote::Shuffle_Albums:
emit SetShuffleMode(PlaylistSequence::Shuffle_Albums);
break;
default:
break;
}
}
// called from global shortcut
void PlaylistSequence::CycleShuffleMode() {
ShuffleMode mode = Shuffle_Off;
// we cycle through the shuffle modes
switch (shuffle_mode()) {
case Shuffle_Off:
mode = Shuffle_All;
break;
case Shuffle_All:
mode = Shuffle_InsideAlbum;
break;
case Shuffle_InsideAlbum:
mode = Shuffle_Albums;
break;
case Shuffle_Albums:
break;
}
SetShuffleMode(mode);
}
void IncomingDataParser::Parse(const pb::remote::Message& msg) {
close_connection_ = false;
RemoteClient* client = qobject_cast<RemoteClient*>(sender());
// Now check what's to do
switch (msg.type()) {
case pb::remote::CONNECT:
ClientConnect(msg);
break;
case pb::remote::DISCONNECT:
close_connection_ = true;
break;
case pb::remote::REQUEST_PLAYLISTS:
SendPlaylists(msg);
break;
case pb::remote::REQUEST_PLAYLIST_SONGS:
GetPlaylistSongs(msg);
break;
case pb::remote::SET_VOLUME:
emit SetVolume(msg.request_set_volume().volume());
break;
case pb::remote::PLAY:
emit Play();
break;
case pb::remote::PLAYPAUSE:
emit PlayPause();
break;
case pb::remote::PAUSE:
emit Pause();
break;
case pb::remote::STOP:
emit Stop();
break;
case pb::remote::STOP_AFTER:
emit StopAfterCurrent();
break;
case pb::remote::NEXT:
emit Next();
break;
case pb::remote::PREVIOUS:
emit Previous();
break;
case pb::remote::CHANGE_SONG:
ChangeSong(msg);
break;
case pb::remote::SHUFFLE_PLAYLIST:
emit ShuffleCurrent();
break;
case pb::remote::REPEAT:
SetRepeatMode(msg.repeat());
break;
case pb::remote::SHUFFLE:
SetShuffleMode(msg.shuffle());
break;
case pb::remote::SET_TRACK_POSITION:
emit SeekTo(msg.request_set_track_position().position());
break;
case pb::remote::INSERT_URLS:
InsertUrls(msg);
break;
case pb::remote::REMOVE_SONGS:
RemoveSongs(msg);
break;
case pb::remote::OPEN_PLAYLIST:
OpenPlaylist(msg);
break;
case pb::remote::CLOSE_PLAYLIST:
ClosePlaylist(msg);
break;
case pb::remote::LOVE:
emit Love();
break;
case pb::remote::BAN:
emit Ban();
break;
case pb::remote::GET_LYRICS:
emit GetLyrics();
break;
case pb::remote::DOWNLOAD_SONGS:
emit SendSongs(msg.request_download_songs(), client);
break;
case pb::remote::SONG_OFFER_RESPONSE:
emit ResponseSongOffer(client, msg.response_song_offer().accepted());
break;
case pb::remote::GET_LIBRARY:
emit SendLibrary(client);
break;
case pb::remote::RATE_SONG:
RateSong(msg);
break;
default:
break;
}
}
// For some connects we have to wait for the playlistmanager
// to be initialized
connect(app_->playlist_manager(), SIGNAL(PlaylistManagerInitialized()),
this, SLOT(PlaylistManagerInitialized()));
}
void IncomingDataParser::PlaylistManagerInitialized() {
connect(this, SIGNAL(SetActivePlaylist(int)),
app_->playlist_manager(), SLOT(SetActivePlaylist(int)));
connect(this, SIGNAL(ShuffleCurrent()),
app_->playlist_manager(), SLOT(ShuffleCurrent()));
connect(this, SIGNAL(SetRepeatMode(PlaylistSequence::RepeatMode)),
app_->playlist_manager()->sequence(),
SLOT(SetRepeatMode(PlaylistSequence::RepeatMode)));
connect(this, SIGNAL(SetShuffleMode(PlaylistSequence::ShuffleMode)),
app_->playlist_manager()->sequence(),
SLOT(SetShuffleMode(PlaylistSequence::ShuffleMode)));
}
IncomingDataParser::~IncomingDataParser() {
}
bool IncomingDataParser::close_connection() {
return close_connection_;
}
void IncomingDataParser::Parse(const pb::remote::Message& msg) {
close_connection_ = false;
// Now check what's to do
