bool
mpd_recv_queue_change_brief(struct mpd_connection *connection,
unsigned *position_r, unsigned *id_r)
{
struct mpd_pair *pair;
pair = mpd_recv_pair_named(connection, "cpos");
if (pair == NULL)
return false;
*position_r = atoi(pair->value);
mpd_return_pair(connection, pair);
pair = mpd_recv_pair_named(connection, "Id");
if (pair == NULL) {
mpd_return_pair(connection, pair);
if (!mpd_error_is_defined(&connection->error)) {
mpd_error_code(&connection->error,
MPD_ERROR_MALFORMED);
mpd_error_message(&connection->error,
"No id received");
}
return false;
}
*id_r = atoi(pair->value);
mpd_return_pair(connection, pair);
return !mpd_error_is_defined(&connection->error);
}
struct mpd_playlist *
mpd_recv_playlist(struct mpd_connection *connection)
{
struct mpd_pair *pair;
struct mpd_playlist *playlist;
pair = mpd_recv_pair_named(connection, "playlist");
if (pair == NULL)
return NULL;
playlist = mpd_playlist_begin(pair);
mpd_return_pair(connection, pair);
if (playlist == NULL) {
mpd_error_code(&connection->error, MPD_ERROR_OOM);
return NULL;
}
while ((pair = mpd_recv_pair(connection)) != NULL &&
mpd_playlist_feed(playlist, pair))
mpd_return_pair(connection, pair);
if (mpd_error_is_defined(&connection->error)) {
assert(pair == NULL);
mpd_playlist_free(playlist);
return NULL;
}
/* unread this pair for the next mpd_recv_playlist() call */
mpd_enqueue_pair(connection, pair);
return playlist;
}
struct mpd_entity *
mpd_recv_entity(struct mpd_connection *connection)
{
struct mpd_pair *pair;
struct mpd_entity *entity;
pair = mpd_recv_pair(connection);
if (pair == NULL)
return NULL;
entity = mpd_entity_begin(pair);
mpd_return_pair(connection, pair);
if (entity == NULL) {
mpd_error_entity(&connection->error);
return NULL;
}
while ((pair = mpd_recv_pair(connection)) != NULL &&
mpd_entity_feed(entity, pair))
mpd_return_pair(connection, pair);
if (mpd_error_is_defined(&connection->error)) {
mpd_entity_free(entity);
return NULL;
}
/* unread this pair for the next mpd_recv_entity() call */
mpd_enqueue_pair(connection, pair);
return entity;
}
struct mpd_directory *
mpd_recv_directory(struct mpd_connection *connection)
{
struct mpd_pair *pair;
struct mpd_directory *directory;
pair = mpd_recv_pair_named(connection, "directory");
if (pair == NULL)
return NULL;
directory = mpd_directory_begin(pair);
mpd_return_pair(connection, pair);
if (directory == NULL) {
mpd_error_entity(&connection->error);
return NULL;
}
while ((pair = mpd_recv_pair(connection)) != NULL &&
mpd_directory_feed(directory, pair))
mpd_return_pair(connection, pair);
if (mpd_error_is_defined(&connection->error)) {
assert(pair == NULL);
mpd_directory_free(directory);
return NULL;
}
/* unread this pair for the next mpd_recv_directory() call */
mpd_enqueue_pair(connection, pair);
return directory;
}
struct mpd_song *
mpd_recv_song(struct mpd_connection *connection)
{
struct mpd_pair *pair;
struct mpd_song *song;
pair = mpd_recv_pair_named(connection, "file");
if (pair == NULL)
return NULL;
song = mpd_song_begin(pair);
mpd_return_pair(connection, pair);
if (song == NULL) {
mpd_error_entity(&connection->error);
return NULL;
}
while ((pair = mpd_recv_pair(connection)) != NULL &&
mpd_song_feed(song, pair))
mpd_return_pair(connection, pair);
if (mpd_error_is_defined(&connection->error)) {
mpd_song_free(song);
return NULL;
}
/* unread this pair for the next mpd_recv_song() call */
mpd_enqueue_pair(connection, pair);
return song;
}
int
cmd_replaygain(int argc, char **argv, struct mpd_connection *connection)
{
/* libmpdclient 2.0 doesn't support these commands yet, we
have to roll our own with mpd_send_command() */
if (mpd_connection_cmp_server_version(connection, 0, 16, 0) < 0)
fprintf(stderr, "warning: MPD 0.16 required for this command\n");
if (argc == 0) {
struct mpd_pair *pair;
mpd_send_command(connection, "replay_gain_status", NULL);
while ((pair = mpd_recv_pair(connection)) != NULL) {
printf("%s: %s\n", pair->name, pair->value);
mpd_return_pair(connection, pair);
}
my_finishCommand(connection);
} else {
mpd_send_command(connection, "replay_gain_mode",
argv[0], NULL);
my_finishCommand(connection);
}
return 0;
}
int mpd_list_artists()
{
int num = 0;
mpd_search_db_tags(mpd.conn, MPD_TAG_ARTIST);
if (!mpd_search_commit(mpd.conn)) {
syslog(LOG_DEBUG, "%s: search_commit error\n", __func__);
return 0;
}
struct mpd_pair *pair;
while ((pair = mpd_recv_pair_tag(mpd.conn, MPD_TAG_ARTIST)) != NULL) {
syslog(LOG_DEBUG, "%s: %s\n", __func__, pair->value);
mpd_return_pair(mpd.conn, pair);
num++;
}
if (!mpd_response_finish(mpd.conn)) {
syslog(LOG_DEBUG, "%s: error\n", __func__);
return 0;
}
syslog(LOG_DEBUG, "%s: found %i\n", __func__, num);
return num;
}
/* mpd functions */
bool Mpd::update(mpd_tag_type type, const char *value) {
mpd_pair *pair;
album.clear();
if (!mpd_search_db_tags(conn, MPD_TAG_ALBUM)) { err(); return false; }
if (strcmp(value, "") != 0)
if (!mpd_search_add_tag_constraint(conn, MPD_OPERATOR_DEFAULT, type, value)) { err(); return false; }
if (!mpd_search_commit(conn)) { err(); return false; }
while ((pair = mpd_recv_pair_tag(conn, MPD_TAG_ALBUM)) != NULL) {
album.push_back(Album(pair->value));
mpd_return_pair(conn, pair);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { err(); return false; }
if (!mpd_response_finish(conn)) { err(); return false; }
cout << "Successful Update" << endl;
for (std::vector<Album>::iterator i = album.begin(); i != album.end(); ++i)
i->buildTags();
sys->sortAlbums(MPD_TAG_UNKNOWN);
for (std::vector<Album>::iterator i = album.begin(); i != album.end(); ++i)
i->build();
return true;
}
bool Connection::AddRandomSongs(size_t number)
{
prechecksNoCommandsList();
std::vector<std::string> files;
mpd_send_list_all(m_connection.get(), "/");
while (mpd_pair *item = mpd_recv_pair_named(m_connection.get(), "file"))
{
files.push_back(item->value);
mpd_return_pair(m_connection.get(), item);
}
mpd_response_finish(m_connection.get());
checkErrors();
if (number > files.size())
{
//if (itsErrorHandler)
// itsErrorHandler(this, 0, "Requested number of random songs is bigger than size of your library", itsErrorHandlerUserdata);
return false;
}
else
{
std::random_shuffle(files.begin(), files.end());
StartCommandsList();
auto it = files.begin()+rand()%(std::max(size_t(1), files.size()-number));
for (size_t i = 0; i < number && it != files.end(); ++i, ++it)
AddSong(*it);
CommitCommandsList();
}
return true;
}
int
cmd_list(int argc, char **argv, struct mpd_connection *conn)
{
enum mpd_tag_type type = get_search_type(argv[0]);
if (type == MPD_TAG_UNKNOWN)
return -1;
--argc;
++argv;
mpd_search_db_tags(conn, type);
if (argc > 0 && !add_constraints(argc, argv, conn))
return -1;
if (!mpd_search_commit(conn))
printErrorAndExit(conn);
struct mpd_pair *pair;
while ((pair = mpd_recv_pair_tag(conn, type)) != NULL) {
printf("%s\n", charset_from_utf8(pair->value));
mpd_return_pair(conn, pair);
}
my_finishCommand(conn);
return 0;
}
struct mpd_stats *
mpd_recv_stats(struct mpd_connection *connection)
{
struct mpd_stats * stats;
struct mpd_pair *pair;
assert(connection != NULL);
if (mpd_error_is_defined(&connection->error))
/* refuse to receive a response if the connection's
state is not clean */
return NULL;
stats = mpd_stats_begin();
if (stats == NULL) {
mpd_error_code(&connection->error, MPD_ERROR_OOM);
return NULL;
}
/* read and parse all response lines */
while ((pair = mpd_recv_pair(connection)) != NULL) {
mpd_stats_feed(stats, pair);
mpd_return_pair(connection, pair);
}
if (mpd_error_is_defined(&connection->error)) {
/* an error has occurred; roll back */
mpd_stats_free(stats);
return NULL;
}
return stats;
}
struct mpd_message *
mpd_recv_message(struct mpd_connection *connection)
{
struct mpd_message *message;
struct mpd_pair *pair;
pair = mpd_recv_pair_named(connection, "channel");
if (pair == NULL)
return NULL;
message = mpd_message_begin(pair);
mpd_return_pair(connection, pair);
if (message == NULL) {
mpd_error_code(&connection->error, MPD_ERROR_OOM);
return NULL;
}
while ((pair = mpd_recv_pair(connection)) != NULL &&
mpd_message_feed(message, pair))
mpd_return_pair(connection, pair);
if (mpd_error_is_defined(&connection->error)) {
assert(pair == NULL);
mpd_message_free(message);
return NULL;
}
mpd_enqueue_pair(connection, pair);
if (mpd_message_get_text(message) == NULL) {
mpd_error_code(&connection->error, MPD_ERROR_MALFORMED);
mpd_error_message(&connection->error,
"No 'message' line received");
mpd_message_free(message);
return NULL;
}
return message;
}
std::string Connection::GetReplayGainMode()
{
prechecksNoCommandsList();
mpd_send_command(m_connection.get(), "replay_gain_status", NULL);
std::string result;
if (mpd_pair *pair = mpd_recv_pair_named(m_connection.get(), "replay_gain_mode"))
{
result = pair->value;
mpd_return_pair(m_connection.get(), pair);
}
mpd_response_finish(m_connection.get());
checkErrors();
return result;
}
struct mpd_pair *
mpd_recv_pair_named(struct mpd_connection *connection, const char *name)
{
struct mpd_pair *pair;
while ((pair = mpd_recv_pair(connection)) != NULL) {
if (strcmp(pair->name, name) == 0)
return pair;
mpd_return_pair(connection, pair);
}
return NULL;
}
int
mpd_recv_song_id(struct mpd_connection *connection)
{
struct mpd_pair *pair;
int id = -1;
pair = mpd_recv_pair_named(connection, "Id");
if (pair != NULL) {
id = atoi(pair->value);
mpd_return_pair(connection, pair);
}
return id;
}
unsigned
mpd_recv_update_id(struct mpd_connection *connection)
{
struct mpd_pair *pair;
int ret = 0;
pair = mpd_recv_pair_named(connection, "updating_db");
if (pair != NULL) {
ret = atoi(pair->value);
mpd_return_pair(connection, pair);
}
return ret;
}
StringIterator Connection::GetSupportedExtensions()
{
prechecksNoCommandsList();
mpd_send_command(m_connection.get(), "decoders", NULL);
checkErrors();
return StringIterator(m_connection.get(), [](StringIterator::State &state) {
auto src = mpd_recv_pair_named(state.connection(), "suffix");
if (src != nullptr)
{
state.setObject(src->value);
mpd_return_pair(state.connection(), src);
return true;
}
else
return false;
});
}
StringIterator Connection::GetURLHandlers()
{
prechecksNoCommandsList();
mpd_send_list_url_schemes(m_connection.get());
checkErrors();
return StringIterator(m_connection.get(), [](StringIterator::State &state) {
auto src = mpd_recv_pair_named(state.connection(), "handler");
if (src != nullptr)
{
state.setObject(src->value);
mpd_return_pair(state.connection(), src);
return true;
}
else
return false;
});
}
StringIterator Connection::GetList(mpd_tag_type type)
{
prechecksNoCommandsList();
mpd_search_db_tags(m_connection.get(), type);
mpd_search_commit(m_connection.get());
checkErrors();
return StringIterator(m_connection.get(), [type](StringIterator::State &state) {
auto src = mpd_recv_pair_tag(state.connection(), type);
if (src != nullptr)
{
state.setObject(src->value);
mpd_return_pair(state.connection(), src);
return true;
}
else
return false;
});
}
bool
path_prepare(struct mpd_connection *conn)
{
if (initialized)
return true;
initialized = true;
if (mpd_connection_cmp_server_version(conn, 0, 17, 0) < 0)
/* the "config" command was added in MPD 0.17.1 */
return true;
if (!mpd_send_command(conn, "config", NULL))
return false;
struct mpd_pair *pair = mpd_recv_pair_named(conn, "music_directory");
if (pair != NULL) {
music_directory = strdup(pair->value);
mpd_return_pair(conn, pair);
}
return mpd_response_finish(conn) || mpd_connection_clear_error(conn);
}
int
cmd_replaygain(int argc, char **argv, struct mpd_connection *connection)
{
/* libmpdclient 2.0 doesn't support these commands yet, we
have to roll our own with mpd_send_command() */
if (argc == 0) {
mpd_send_command(connection, "replay_gain_status", NULL);
struct mpd_pair *pair;
while ((pair = mpd_recv_pair(connection)) != NULL) {
printf("%s: %s\n", pair->name, pair->value);
mpd_return_pair(connection, pair);
}
my_finishCommand(connection);
} else {
mpd_send_command(connection, "replay_gain_mode",
argv[0], NULL);
my_finishCommand(connection);
}
return 0;
}
void TopWidget::updateAlbumList()
{
albumList.clear();
albumList << "(Any)";
mpdconfirm(mpd_search_db_tags(mpd, MPD_TAG_ALBUM));
if (selectedArtist != "(Any)")
mpd_search_add_tag_constraint(mpd, MPD_OPERATOR_DEFAULT, MPD_TAG_ARTIST, selectedArtist.toUtf8().constData());
mpd_search_commit(mpd);
mpd_pair * mp;
while((mp = mpd_recv_pair_tag(mpd, MPD_TAG_ALBUM)) != NULL)
{
const QString album = mp->value;
if (album != "")
albumList << album;
mpd_return_pair(mpd, mp);
}
albumListWidget->setModel(albumModel);
albumModel->setStringList(albumList);
parent->setTracks(Track::searchByArtist(selectedArtist));
parent->playlistChanged = true;
parent->trackView->update();
parent->trackView->resetScroll();
}
/*
* Retrieve available commands
*/
bool
Control::get_available_commands()
{
mpd_pair * pair;
EXIT_IDLE;
if (!mpd_send_allowed_commands(conn->h())) {
return false;
}
memset(&commands, 0, sizeof(commands));
while ((pair = mpd_recv_command_pair(conn->h())) != NULL)
{
// FIXME: any other response is not expected
assert(!strcmp(pair->name, "command"));
if (!strcmp(pair->value, "add")) {
commands.add = true;
} else if (!strcmp(pair->value, "addid")) {
commands.addid = true;
} else if (!strcmp(pair->value, "clear")) {
commands.clear = true;
} else if (!strcmp(pair->value, "clearerror")) {
commands.clearerror = true;
} else if (!strcmp(pair->value, "close")) {
commands.close = true;
} else if (!strcmp(pair->value, "commands")) {
commands.commands = true;
} else if (!strcmp(pair->value, "consume")) {
commands.commands = true;
} else if (!strcmp(pair->value, "count")) {
commands.count = true;
} else if (!strcmp(pair->value, "crossfade")) {
commands.crossfade = true;
} else if (!strcmp(pair->value, "currentsong")) {
commands.currentsong = true;
} else if (!strcmp(pair->value, "delete")) {
commands.delete_ = true;
} else if (!strcmp(pair->value, "deleteid")) {
commands.deleteid = true;
} else if (!strcmp(pair->value, "disableoutput")) {
commands.disableoutput = true;
} else if (!strcmp(pair->value, "enableoutput")) {
commands.enableoutput = true;
} else if (!strcmp(pair->value, "find")) {
commands.find = true;
} else if (!strcmp(pair->value, "idle")) {
commands.idle = true;
} else if (!strcmp(pair->value, "kill")) {
commands.kill = true;
} else if (!strcmp(pair->value, "list")) {
commands.list = true;
} else if (!strcmp(pair->value, "listall")) {
commands.listall = true;
} else if (!strcmp(pair->value, "listallinfo")) {
commands.listallinfo = true;
} else if (!strcmp(pair->value, "listplaylist")) {
commands.listplaylist = true;
} else if (!strcmp(pair->value, "listplaylistinfo")) {
commands.listplaylistinfo = true;
} else if (!strcmp(pair->value, "listplaylists")) {
commands.listplaylists = true;
} else if (!strcmp(pair->value, "load")) {
commands.load = true;
} else if (!strcmp(pair->value, "lsinfo")) {
commands.lsinfo = true;
} else if (!strcmp(pair->value, "move")) {
commands.move = true;
} else if (!strcmp(pair->value, "moveid")) {
commands.moveid = true;
} else if (!strcmp(pair->value, "next")) {
commands.next = true;
} else if (!strcmp(pair->value, "notcommands")) {
commands.notcommands = true;
} else if (!strcmp(pair->value, "outputs")) {
commands.outputs = true;
} else if (!strcmp(pair->value, "password")) {
commands.password = true;
} else if (!strcmp(pair->value, "pause")) {
commands.pause = true;
} else if (!strcmp(pair->value, "ping")) {
commands.ping = true;
} else if (!strcmp(pair->value, "play")) {
commands.play = true;
} else if (!strcmp(pair->value, "playid")) {
commands.playid = true;
} else if (!strcmp(pair->value, "playlist")) {
commands.playlist = true;
} else if (!strcmp(pair->value, "playlistadd")) {
commands.playlistadd = true;
} else if (!strcmp(pair->value, "playlistclear")) {
commands.playlistclear = true;
} else if (!strcmp(pair->value, "playlistdelete")) {
commands.playlistdelete = true;
} else if (!strcmp(pair->value, "playlistfind")) {
commands.playlistfind = true;
} else if (!strcmp(pair->value, "playlistid")) {
commands.playlistid = true;
} else if (!strcmp(pair->value, "playlistinfo")) {
commands.playlistinfo = true;
} else if (!strcmp(pair->value, "playlistmove")) {
commands.playlistmove = true;
} else if (!strcmp(pair->value, "playlistsearch")) {
commands.playlistsearch = true;
} else if (!strcmp(pair->value, "plchanges")) {
commands.plchanges = true;
} else if (!strcmp(pair->value, "plchangesposid")) {
commands.plchangesposid = true;
} else if (!strcmp(pair->value, "previous")) {
commands.previous = true;
} else if (!strcmp(pair->value, "random")) {
commands.random = true;
} else if (!strcmp(pair->value, "rename")) {
commands.rename = true;
} else if (!strcmp(pair->value, "repeat")) {
commands.repeat = true;
} else if (!strcmp(pair->value, "single")) {
commands.single = true;
} else if (!strcmp(pair->value, "rm")) {
commands.rm = true;
} else if (!strcmp(pair->value, "save")) {
commands.save = true;
} else if (!strcmp(pair->value, "filter")) {
commands.filter = true;
} else if (!strcmp(pair->value, "seek")) {
commands.seek = true;
} else if (!strcmp(pair->value, "seekid")) {
commands.seekid = true;
} else if (!strcmp(pair->value, "setvol")) {
commands.setvol = true;
} else if (!strcmp(pair->value, "shuffle")) {
commands.shuffle = true;
} else if (!strcmp(pair->value, "stats")) {
commands.stats = true;
} else if (!strcmp(pair->value, "status")) {
commands.status = true;
} else if (!strcmp(pair->value, "stop")) {
commands.stop = true;
} else if (!strcmp(pair->value, "swap")) {
commands.swap = true;
} else if (!strcmp(pair->value, "swapid")) {
commands.swapid = true;
} else if (!strcmp(pair->value, "tagtypes")) {
commands.tagtypes = true;
} else if (!strcmp(pair->value, "update")) {
commands.update = true;
} else if (!strcmp(pair->value, "urlhandlers")) {
commands.urlhandlers = true;
} else if (!strcmp(pair->value, "volume")) {
commands.volume = true;
}
mpd_return_pair(conn->h(), pair);
}
return get_error_bool();
}
int main(int argc, char ** argv) {
struct mpd_connection *conn;
conn = mpd_connection_new(NULL, 0, 30000);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
return handle_error(conn);
{
int i;
for(i=0;i<3;i++) {
printf("version[%i]: %i\n",i,
mpd_connection_get_server_version(conn)[i]);
}
}
if(argc==1) {
struct mpd_status * status;
struct mpd_song *song;
const struct mpd_audio_format *audio_format;
mpd_command_list_begin(conn, true);
mpd_send_status(conn);
mpd_send_current_song(conn);
mpd_command_list_end(conn);
status = mpd_recv_status(conn);
if (status == NULL)
return handle_error(conn);
printf("volume: %i\n", mpd_status_get_volume(status));
printf("repeat: %i\n", mpd_status_get_repeat(status));
printf("queue version: %u\n", mpd_status_get_queue_version(status));
printf("queue length: %i\n", mpd_status_get_queue_length(status));
if (mpd_status_get_error(status) != NULL)
printf("error: %s\n", mpd_status_get_error(status));
if (mpd_status_get_state(status) == MPD_STATE_PLAY ||
mpd_status_get_state(status) == MPD_STATE_PAUSE) {
printf("song: %i\n", mpd_status_get_song_pos(status));
printf("elaspedTime: %i\n",mpd_status_get_elapsed_time(status));
printf("elasped_ms: %u\n", mpd_status_get_elapsed_ms(status));
printf("totalTime: %i\n", mpd_status_get_total_time(status));
printf("bitRate: %i\n", mpd_status_get_kbit_rate(status));
}
audio_format = mpd_status_get_audio_format(status);
if (audio_format != NULL) {
printf("sampleRate: %i\n", audio_format->sample_rate);
printf("bits: %i\n", audio_format->bits);
printf("channels: %i\n", audio_format->channels);
}
mpd_status_free(status);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
return handle_error(conn);
mpd_response_next(conn);
while ((song = mpd_recv_song(conn)) != NULL) {
printf("uri: %s\n", mpd_song_get_uri(song));
print_tag(song, MPD_TAG_ARTIST, "artist");
print_tag(song, MPD_TAG_ALBUM, "album");
print_tag(song, MPD_TAG_TITLE, "title");
print_tag(song, MPD_TAG_TRACK, "track");
print_tag(song, MPD_TAG_NAME, "name");
print_tag(song, MPD_TAG_DATE, "date");
if (mpd_song_get_duration(song) > 0) {
printf("time: %u\n", mpd_song_get_duration(song));
}
printf("pos: %u\n", mpd_song_get_pos(song));
mpd_song_free(song);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
}
else if(argc==3 && strcmp(argv[1],"lsinfo")==0) {
struct mpd_entity * entity;
if (!mpd_send_list_meta(conn, argv[2]))
return handle_error(conn);
while ((entity = mpd_recv_entity(conn)) != NULL) {
const struct mpd_song *song;
const struct mpd_directory *dir;
const struct mpd_playlist *pl;
switch (mpd_entity_get_type(entity)) {
case MPD_ENTITY_TYPE_UNKNOWN:
break;
case MPD_ENTITY_TYPE_SONG:
song = mpd_entity_get_song(entity);
printf("uri: %s\n", mpd_song_get_uri(song));
print_tag(song, MPD_TAG_ARTIST, "artist");
print_tag(song, MPD_TAG_ALBUM, "album");
print_tag(song, MPD_TAG_TITLE, "title");
print_tag(song, MPD_TAG_TRACK, "track");
break;
case MPD_ENTITY_TYPE_DIRECTORY:
dir = mpd_entity_get_directory(entity);
printf("directory: %s\n", mpd_directory_get_path(dir));
break;
case MPD_ENTITY_TYPE_PLAYLIST:
pl = mpd_entity_get_playlist(entity);
printf("playlist: %s\n",
mpd_playlist_get_path(pl));
break;
}
mpd_entity_free(entity);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
}
else if(argc==2 && strcmp(argv[1],"artists")==0) {
struct mpd_pair *pair;
if (!mpd_search_db_tags(conn, MPD_TAG_ARTIST) ||
!mpd_search_commit(conn))
return handle_error(conn);
while ((pair = mpd_recv_pair_tag(conn,
MPD_TAG_ARTIST)) != NULL) {
printf("%s\n", pair->value);
mpd_return_pair(conn, pair);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
} else if (argc == 2 && strcmp(argv[1], "playlists") == 0) {
if (!mpd_send_list_playlists(conn))
return handle_error(conn);
struct mpd_playlist *playlist;
while ((playlist = mpd_recv_playlist(conn)) != NULL) {
printf("%s\n",
mpd_playlist_get_path(playlist));
mpd_playlist_free(playlist);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
} else if (argc == 2 && strcmp(argv[1], "idle") == 0) {
enum mpd_idle idle = mpd_run_idle(conn);
if (idle == 0 &&
mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
return handle_error(conn);
for (unsigned j = 0;; ++j) {
enum mpd_idle i = 1 << j;
const char *name = mpd_idle_name(i);
if (name == NULL)
break;
if (idle & i)
printf("%s\n", name);
}
} else if (argc == 3 && strcmp(argv[1], "subscribe") == 0) {
/* subscribe to a channel and print all messages */
if (!mpd_run_subscribe(conn, argv[2]))
return handle_error(conn);
while (mpd_run_idle_mask(conn, MPD_IDLE_MESSAGE) != 0) {
if (!mpd_send_read_messages(conn))
return handle_error(conn);
struct mpd_message *msg;
while ((msg = mpd_recv_message(conn)) != NULL) {
printf("%s\n", mpd_message_get_text(msg));
mpd_message_free(msg);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
}
return handle_error(conn);
} else if (argc == 2 && strcmp(argv[1], "channels") == 0) {
/* print a list of channels */
if (!mpd_send_channels(conn))
return handle_error(conn);
struct mpd_pair *pair;
while ((pair = mpd_recv_channel_pair(conn)) != NULL) {
printf("%s\n", pair->value);
mpd_return_pair(conn, pair);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
} else if (argc == 4 && strcmp(argv[1], "message") == 0) {
/* send a message to a channel */
if (!mpd_run_send_message(conn, argv[2], argv[3]))
return handle_error(conn);
}
mpd_connection_free(conn);
return 0;
}
TopWidget::TopWidget(MainWindow * parent) : QWidget(parent)
{
this->parent = parent;
setMinimumWidth(300);
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
stopButton = new QToolButton();
stopButton->setIcon(QIcon(DATAPATH "stop.png"));
pauseButton = new QToolButton();
pauseButton->setIcon(QIcon(DATAPATH "pause.png"));
playButton = new QToolButton();
playButton->setIcon(QIcon(DATAPATH "play.png"));
prevButton = new QToolButton();
prevButton->setIcon(QIcon(DATAPATH "prev.png"));
nextButton = new QToolButton();
nextButton->setIcon(QIcon(DATAPATH "next.png"));
randomButton = new QToolButton();
randomButton->setIcon(QIcon(DATAPATH "random.png"));
libraryButton = new QToolButton();
if(Settings::getLibraryFolded())
libraryButton->setIcon(QIcon(DATAPATH "unfold.png"));
else
libraryButton->setIcon(QIcon(DATAPATH "fold.png"));
trackBar = new Slider(parent);
volumeBar = new Slider(parent);
volumeBar->setMaximumWidth(70);
volumeBar->setValue(100);
volumeBar->style = 2;
playModeBox = new QComboBox();
playModeBox->setMaximumWidth(150);
playModeBox->addItem("Normal");
playModeBox->addItem("Loop All");
playModeBox->addItem("Loop Track");
playModeBox->addItem("Shuffle");
grid = new QGridLayout();
grid->addWidget(stopButton, 0, 0);
grid->addWidget(pauseButton, 0, 1);
grid->addWidget(playButton, 0, 2);
grid->addWidget(prevButton, 0, 3);
grid->addWidget(nextButton, 0, 4);
grid->addWidget(randomButton, 0, 5);
grid->addWidget(trackBar, 0, 6);
grid->addWidget(playModeBox, 0, 7);
grid->addWidget(volumeBar, 0, 8);
grid->addWidget(libraryButton, 0, 9);
grid->setContentsMargins(4, 4, 4, 4);
connect(trackBar, SIGNAL(changed()), this, SLOT(onTrackBarChanged()));
connect(volumeBar, SIGNAL(step()), this, SLOT(onVolumeBarChanged()));
connect(pauseButton, SIGNAL(clicked()), this, SLOT(onPauseClick()));
connect(playButton, SIGNAL(clicked()), this, SLOT(onPlayClick()));
connect(stopButton, SIGNAL(clicked()), this, SLOT(onStopClick()));
connect(prevButton, SIGNAL(clicked()), this, SLOT(onPrevClick()));
connect(nextButton, SIGNAL(clicked()), this, SLOT(onNextClick()));
connect(libraryButton, SIGNAL(clicked()), this, SLOT(onLibraryClick()));
setLayout(grid);
//Library View
libraryWidget = new QWidget();
libraryGrid = new QGridLayout();
artistLabel = new QLabel("Artists: ");
artistListWidget = new QListView();
artistListWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
artistModel = new QStringListModel();
albumLabel = new QLabel("Albums: ");
albumListWidget = new QListView();
albumListWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
albumModel = new QStringListModel();
libraryGrid->addWidget(artistLabel, 1, 0);
libraryGrid->addWidget(artistListWidget, 2, 0);
libraryGrid->addWidget(albumLabel, 1, 1);
libraryGrid->addWidget(albumListWidget, 2, 1);
libraryGrid->setContentsMargins(0, 0, 0, 0);
libraryWidget->setLayout(libraryGrid);
if(Settings::getLibraryFolded())
foldLibrary();
else
unfoldLibrary();
artistList << "(Any)";
mpdconfirm(mpd_search_db_tags(mpd, MPD_TAG_ARTIST));
mpd_search_commit(mpd);
mpd_pair * mp;
while((mp = mpd_recv_pair_tag(mpd, MPD_TAG_ARTIST)) != NULL)
{
const QString artist = mp->value;
if (artist != "")
artistList << artist;
mpd_return_pair(mpd, mp);
}
artistListWidget->setModel(artistModel);
artistModel->setStringList(artistList);
albumListWidget->setModel(albumModel);
albumModel->setStringList(albumList);
connect(artistListWidget->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(onArtistSelectionChanged(QItemSelection)));
connect(albumListWidget->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(onAlbumSelectionChanged(QItemSelection)));
artistListWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
albumListWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
selectedArtist = "(Any)";
}
