src/AlbumListPage.cxx

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2018 The Music Player Daemon Project
   3  * Project homepage: http://musicpd.org
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include "AlbumListPage.hxx"
  21 #include "screen_interface.hxx"
  22 #include "screen_status.hxx"
  23 #include "screen_find.hxx"
  24 #include "screen_browser.hxx"
  25 #include "screen.hxx"
  26 #include "i18n.h"
  27 #include "charset.hxx"
  28 #include "mpdclient.hxx"
  29
  30 #include <glib.h>
  31
  32 #include <algorithm>
  33
  34 #include <assert.h>
  35 #include <string.h>
  36
  37 #define BUFSIZE 1024
  38
  39 gcc_pure
  40 static bool
  41 CompareUTF8(const std::string &a, const std::string &b)
  42 {
  43         char *key1 = g_utf8_collate_key(a.c_str(), -1);
  44         char *key2 = g_utf8_collate_key(b.c_str(), -1);
  45         int n = strcmp(key1,key2);
  46         g_free(key1);
  47         g_free(key2);
  48         return n < 0;
  49 }
  50
  51 /* list_window callback */
  52 static const char *
  53 album_lw_callback(unsigned idx, void *data)
  54 {
  55         const auto &list = *(const std::vector<std::string> *)data;
  56
  57         assert(idx < list.size());
  58
  59         const char *str_utf8 = list[idx].c_str();
  60
  61         static char buf[BUFSIZE];
  62         g_strlcpy(buf, Utf8ToLocale(str_utf8).c_str(), sizeof(buf));
  63         return buf;
  64 }
  65
  66 /* list_window callback */
  67 static const char *
  68 AlbumListCallback(unsigned idx, void *data)
  69 {
  70         const auto &list = *(const std::vector<std::string> *)data;
  71
  72         if (idx == 0)
  73                 return "..";
  74         else if (idx == list.size() + 1)
  75                 return _("All tracks");
  76
  77         --idx;
  78
  79         return album_lw_callback(idx, data);
  80 }
  81
  82 static void
  83 recv_tag_values(struct mpd_connection *connection, enum mpd_tag_type tag,
  84                 std::vector<std::string> &list)
  85 {
  86         struct mpd_pair *pair;
  87
  88         while ((pair = mpd_recv_pair_tag(connection, tag)) != nullptr) {
  89                 list.emplace_back(pair->value);
  90                 mpd_return_pair(connection, pair);
  91         }
  92 }
  93
  94 void
  95 AlbumListPage::LoadAlbumList(struct mpdclient &c)
  96 {
  97         struct mpd_connection *connection = mpdclient_get_connection(&c);
  98
  99         album_list.clear();
 100
 101         if (connection != nullptr) {
 102                 mpd_search_db_tags(connection, MPD_TAG_ALBUM);
 103                 mpd_search_add_tag_constraint(connection,
 104                                               MPD_OPERATOR_DEFAULT,
 105                                               MPD_TAG_ARTIST,
 106                                               artist.c_str());
 107                 mpd_search_commit(connection);
 108
 109                 recv_tag_values(connection, MPD_TAG_ALBUM, album_list);
 110
 111                 mpdclient_finish_command(&c);
 112         }
 113
 114         /* sort list */
 115         std::sort(album_list.begin(), album_list.end(), CompareUTF8);
 116         lw.SetLength(album_list.size() + 2);
 117 }
 118
 119 void
 120 AlbumListPage::Reload(struct mpdclient &c)
 121 {
 122         LoadAlbumList(c);
 123 }
 124
 125 /**
 126  * Paint one item in the album list.  There are two virtual items
 127  * inserted: at the beginning, there's the special item ".." to go to
 128  * the parent directory, and at the end, there's the item "All tracks"
 129  * to view the tracks of all albums.
 130  */
 131 void
 132 AlbumListPage::PaintListItem(WINDOW *w, unsigned i,
 133                              gcc_unused unsigned y, unsigned width,
 134                              bool selected) const
 135 {
 136         const char *p;
 137         char *q = nullptr;
 138
 139         if (i == 0)
 140                 p = "..";
 141         else if (i == album_list.size() + 1)
 142                 p = _("All tracks");
 143         else
 144                 p = q = utf8_to_locale(album_list[i - 1].c_str());
 145
 146         screen_browser_paint_directory(w, width, selected, p);
 147         g_free(q);
 148 }
 149
 150 void
 151 AlbumListPage::Paint() const
 152 {
 153         lw.Paint(*this);
 154 }
 155
 156 const char *
 157 AlbumListPage::GetTitle(char *str, size_t size) const
 158 {
 159         if (artist.empty())
 160                 return _("Albums");
 161
 162         g_snprintf(str, size, _("Albums of artist: %s"),
 163                    Utf8ToLocale(artist.c_str()).c_str());
 164         return str;
 165 }
 166
 167 void
 168 AlbumListPage::Update(struct mpdclient &c, unsigned events)
 169 {
 170         if (events & MPD_IDLE_DATABASE) {
 171                 /* the db has changed -> update the list */
 172                 Reload(c);
 173                 SetDirty();
 174         }
 175 }
 176
 177 /* add_query - Add all songs satisfying specified criteria.
 178    _artist is actually only used in the ALBUM case to distinguish albums with
 179    the same name from different artists. */
 180 static void
 181 add_query(struct mpdclient *c, enum mpd_tag_type table, const char *_filter,
 182           const char *_artist)
 183 {
 184         struct mpd_connection *connection = mpdclient_get_connection(c);
 185
 186         assert(_filter != nullptr);
 187
 188         if (connection == nullptr)
 189                 return;
 190
 191         screen_status_printf(_("Adding \'%s\' to queue"),
 192                              Utf8ToLocale(_filter).c_str());
 193
 194         mpd_search_add_db_songs(connection, true);
 195         mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT,
 196                                       table, _filter);
 197         if (table == MPD_TAG_ALBUM)
 198                 mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT,
 199                                               MPD_TAG_ARTIST, _artist);
 200         mpd_search_commit(connection);
 201         mpdclient_finish_command(c);
 202 }
 203
 204 bool
 205 AlbumListPage::OnCommand(struct mpdclient &c, command_t cmd)
 206 {
 207         switch(cmd) {
 208                 const char *selected;
 209
 210         case CMD_PLAY:
 211                 if (lw.selected == 0) {
 212                         /* handle ".." */
 213                         screen.OnCommand(c, CMD_GO_PARENT_DIRECTORY);
 214                         return true;
 215                 }
 216
 217                 break;
 218
 219         case CMD_SELECT:
 220         case CMD_ADD:
 221                 for (const unsigned i : lw.GetRange()) {
 222                         if(i == album_list.size() + 1)
 223                                 add_query(&c, MPD_TAG_ARTIST, artist.c_str(),
 224                                           nullptr);
 225                         else if (i > 0) {
 226                                 selected = album_list[lw.selected - 1].c_str();
 227                                 add_query(&c, MPD_TAG_ALBUM, selected,
 228                                           artist.c_str());
 229                                 cmd = CMD_LIST_NEXT; /* continue and select next item... */
 230                         }
 231                 }
 232                 break;
 233
 234                 /* continue and update... */
 235         case CMD_SCREEN_UPDATE:
 236                 Reload(c);
 237                 return false;
 238
 239         case CMD_LIST_FIND:
 240         case CMD_LIST_RFIND:
 241         case CMD_LIST_FIND_NEXT:
 242         case CMD_LIST_RFIND_NEXT:
 243                 screen_find(screen, &lw, cmd,
 244                             AlbumListCallback, &album_list);
 245                 SetDirty();
 246                 return true;
 247
 248         case CMD_LIST_JUMP:
 249                 screen_jump(screen, &lw,
 250                             AlbumListCallback, &album_list,
 251                             this);
 252                 SetDirty();
 253                 return true;
 254
 255         default:
 256                 break;
 257         }
 258
 259         if (lw.HandleCommand(cmd)) {
 260                 SetDirty();
 261                 return true;
 262         }
 263
 264         return false;
 265 }