src/screens/media_library.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2017 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   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     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <boost/date_time/posix_time/posix_time.hpp>
  22 #include <boost/locale/conversion.hpp>
  23 #include <algorithm>
  24 #include <array>
  25 #include <cassert>
  26
  27 #include "charset.h"
  28 #include "display.h"
  29 #include "helpers.h"
  30 #include "global.h"
  31 #include "curses/menu_impl.h"
  32 #include "mpdpp.h"
  33 #include "screens/playlist.h"
  34 #include "screens/media_library.h"
  35 #include "status.h"
  36 #include "statusbar.h"
  37 #include "helpers/song_iterator_maker.h"
  38 #include "utility/comparators.h"
  39 #include "utility/functional.h"
  40 #include "utility/type_conversions.h"
  41 #include "title.h"
  42 #include "screens/screen_switcher.h"
  43
  44 using Global::MainHeight;
  45 using Global::MainStartY;
  46 using Global::myScreen;
  47
  48 namespace ph = std::placeholders;
  49
  50 MediaLibrary *myLibrary;
  51
  52 namespace {
  53
  54 bool hasTwoColumns;
  55 size_t itsLeftColStartX;
  56 size_t itsLeftColWidth;
  57 size_t itsMiddleColWidth;
  58 size_t itsMiddleColStartX;
  59 size_t itsRightColWidth;
  60 size_t itsRightColStartX;
  61
  62 typedef MediaLibrary::PrimaryTag PrimaryTag;
  63 typedef MediaLibrary::AlbumEntry AlbumEntry;
  64
  65 MPD::SongIterator getSongsFromAlbum(const AlbumEntry &album)
  66 {
  67         Mpd.StartSearch(true);
  68         Mpd.AddSearch(Config.media_lib_primary_tag, album.entry().tag());
  69         if (!album.isAllTracksEntry())
  70         {
  71                 Mpd.AddSearch(MPD_TAG_ALBUM, album.entry().album());
  72                 Mpd.AddSearch(MPD_TAG_DATE, album.entry().date());
  73         }
  74         return Mpd.CommitSearchSongs();
  75 }
  76
  77 std::string AlbumToString(const AlbumEntry &ae);
  78 std::string SongToString(const MPD::Song &s);
  79
  80 bool TagEntryMatcher(const Regex::Regex &rx, const MediaLibrary::PrimaryTag &tagmtime);
  81 bool AlbumEntryMatcher(const Regex::Regex &rx, const NC::Menu<AlbumEntry>::Item &item, bool filter);
  82 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s);
  83
  84 bool MoveToTag(NC::Menu<PrimaryTag> &tags, const std::string &primary_tag);
  85 bool MoveToAlbum(NC::Menu<AlbumEntry> &albums, const std::string &primary_tag, const MPD::Song &s);
  86
  87 struct SortSongs {
  88         typedef NC::Menu<MPD::Song>::Item SongItem;
  89
  90         static const std::array<MPD::Song::GetFunction, 3> GetFuns;
  91
  92         LocaleStringComparison m_cmp;
  93         std::ptrdiff_t m_offset;
  94
  95 public:
  96         SortSongs(bool disc_only = false)
  97         : m_cmp(std::locale(), Config.ignore_leading_the), m_offset(disc_only ? 2 : 0) { }
  98
  99         bool operator()(const SongItem &a, const SongItem &b) {
 100                 return (*this)(a.value(), b.value());
 101         }
 102         bool operator()(const MPD::Song &a, const MPD::Song &b) {
 103                 for (auto get = GetFuns.begin()+m_offset; get != GetFuns.end(); ++get) {
 104                         int ret = m_cmp(a.getTags(*get),
 105                                         b.getTags(*get));
 106                         if (ret != 0)
 107                                 return ret < 0;
 108                 }
 109                 try {
 110                         int ret = boost::lexical_cast<int>(a.getTags(&MPD::Song::getTrackNumber))
 111                                 - boost::lexical_cast<int>(b.getTags(&MPD::Song::getTrackNumber));
 112                         return ret < 0;
 113                 } catch (boost::bad_lexical_cast &) {
 114                         return a.getTrackNumber() < b.getTrackNumber();
 115                 }
 116         }
 117 };
 118
 119 const std::array<MPD::Song::GetFunction, 3> SortSongs::GetFuns = {{
 120         &MPD::Song::getDate,
 121         &MPD::Song::getAlbum,
 122         &MPD::Song::getDisc
 123 }};
 124
 125 class SortAlbumEntries {
 126         typedef MediaLibrary::Album Album;
 127
 128         LocaleStringComparison m_cmp;
 129
 130 public:
 131         SortAlbumEntries() : m_cmp(std::locale(), Config.ignore_leading_the) { }
 132
 133         bool operator()(const AlbumEntry &a, const AlbumEntry &b) const {
 134                 return (*this)(a.entry(), b.entry());
 135         }
 136
 137         bool operator()(const Album &a, const Album &b) const {
 138                 if (Config.media_library_sort_by_mtime)
 139                         return a.mtime() > b.mtime();
 140                 else
 141                 {
 142                         int result;
 143                         result = m_cmp(a.tag(), b.tag());
 144                         if (result != 0)
 145                                 return result < 0;
 146                         result = m_cmp(a.date(), b.date());
 147                         if (result != 0)
 148                                 return result < 0;
 149                         return m_cmp(a.album(), b.album()) < 0;
 150                 }
 151         }
 152 };
 153
 154 class SortPrimaryTags {
 155         LocaleStringComparison m_cmp;
 156
 157 public:
 158         SortPrimaryTags() : m_cmp(std::locale(), Config.ignore_leading_the) { }
 159
 160         bool operator()(const PrimaryTag &a, const PrimaryTag &b) const {
 161                 if (Config.media_library_sort_by_mtime)
 162                         return a.mtime() > b.mtime();
 163                 else
 164                         return m_cmp(a.tag(), b.tag()) < 0;
 165         }
 166 };
 167
 168 }
 169
 170 MediaLibrary::MediaLibrary()
 171 : m_timer(boost::posix_time::from_time_t(0))
 172 , m_window_timeout(Config.data_fetching_delay ? 250 : BaseScreen::defaultWindowTimeout)
 173 , m_fetching_delay(boost::posix_time::milliseconds(Config.data_fetching_delay ? 250 : -1))
 174 {
 175         hasTwoColumns = 0;
 176         itsLeftColWidth = COLS/3-1;
 177         itsMiddleColWidth = COLS/3;
 178         itsMiddleColStartX = itsLeftColWidth+1;
 179         itsRightColWidth = COLS-COLS/3*2-1;
 180         itsRightColStartX = itsLeftColWidth+itsMiddleColWidth+2;
 181
 182         Tags = NC::Menu<PrimaryTag>(0, MainStartY, itsLeftColWidth, MainHeight, Config.titles_visibility ? tagTypeToString(Config.media_lib_primary_tag) + "s" : "", Config.main_color, NC::Border());
 183         Tags.setHighlightColor(Config.active_column_color);
 184         Tags.cyclicScrolling(Config.use_cyclic_scrolling);
 185         Tags.centeredCursor(Config.centered_cursor);
 186         Tags.setSelectedPrefix(Config.selected_item_prefix);
 187         Tags.setSelectedSuffix(Config.selected_item_suffix);
 188         Tags.setItemDisplayer([](NC::Menu<PrimaryTag> &menu) {
 189                 const std::string &tag = menu.drawn()->value().tag();
 190                 if (tag.empty())
 191                         menu << Config.empty_tag;
 192                 else
 193                         menu << Charset::utf8ToLocale(tag);
 194         });
 195
 196         Albums = NC::Menu<AlbumEntry>(itsMiddleColStartX, MainStartY, itsMiddleColWidth, MainHeight, Config.titles_visibility ? "Albums" : "", Config.main_color, NC::Border());
 197         Albums.setHighlightColor(Config.main_highlight_color);
 198         Albums.cyclicScrolling(Config.use_cyclic_scrolling);
 199         Albums.centeredCursor(Config.centered_cursor);
 200         Albums.setSelectedPrefix(Config.selected_item_prefix);
 201         Albums.setSelectedSuffix(Config.selected_item_suffix);
 202         Albums.setItemDisplayer([](NC::Menu<AlbumEntry> &menu) {
 203                 menu << Charset::utf8ToLocale(AlbumToString(menu.drawn()->value()));
 204         });
 205
 206         Songs = NC::Menu<MPD::Song>(itsRightColStartX, MainStartY, itsRightColWidth, MainHeight, Config.titles_visibility ? "Songs" : "", Config.main_color, NC::Border());
 207         Songs.setHighlightColor(Config.main_highlight_color);
 208         Songs.cyclicScrolling(Config.use_cyclic_scrolling);
 209         Songs.centeredCursor(Config.centered_cursor);
 210         Songs.setSelectedPrefix(Config.selected_item_prefix);
 211         Songs.setSelectedSuffix(Config.selected_item_suffix);
 212         Songs.setItemDisplayer(std::bind(
 213                 Display::Songs, ph::_1, std::cref(Songs), std::cref(Config.song_library_format)
 214         ));
 215
 216         w = &Tags;
 217 }
 218
 219 void MediaLibrary::resize()
 220 {
 221         size_t x_offset, width;
 222         getWindowResizeParams(x_offset, width);
 223         if (!hasTwoColumns)
 224         {
 225                 itsLeftColStartX = x_offset;
 226                 itsLeftColWidth = width/3-1;
 227                 itsMiddleColStartX = itsLeftColStartX+itsLeftColWidth+1;
 228                 itsMiddleColWidth = width/3;
 229                 itsRightColStartX = itsMiddleColStartX+itsMiddleColWidth+1;
 230                 itsRightColWidth = width-width/3*2-1;
 231         }
 232         else
 233         {
 234                 itsMiddleColStartX = x_offset;
 235                 itsMiddleColWidth = width/2;
 236                 itsRightColStartX = x_offset+itsMiddleColWidth+1;
 237                 itsRightColWidth = width-itsMiddleColWidth-1;
 238         }
 239
 240         Tags.resize(itsLeftColWidth, MainHeight);
 241         Albums.resize(itsMiddleColWidth, MainHeight);
 242         Songs.resize(itsRightColWidth, MainHeight);
 243
 244         Tags.moveTo(itsLeftColStartX, MainStartY);
 245         Albums.moveTo(itsMiddleColStartX, MainStartY);
 246         Songs.moveTo(itsRightColStartX, MainStartY);
 247
 248         hasToBeResized = 0;
 249 }
 250
 251 void MediaLibrary::refresh()
 252 {
 253         Tags.display();
 254         drawSeparator(itsMiddleColStartX-1);
 255         Albums.display();
 256         drawSeparator(itsRightColStartX-1);
 257         Songs.display();
 258         if (Albums.empty())
 259         {
 260                 Albums << NC::XY(0, 0) << "No albums found.";
 261                 Albums.Window::refresh();
 262         }
 263 }
 264
 265 void MediaLibrary::switchTo()
 266 {
 267         SwitchTo::execute(this);
 268         drawHeader();
 269         refresh();
 270 }
 271
 272 std::wstring MediaLibrary::title()
 273 {
 274         return L"Media library";
 275 }
 276
 277 void MediaLibrary::update()
 278 {
 279         if (hasTwoColumns)
 280         {
 281                 ScopedUnfilteredMenu<AlbumEntry> sunfilter_albums(ReapplyFilter::No, Albums);
 282                 if (Albums.empty() || m_albums_update_request)
 283                 {
 284                         m_albums_update_request = false;
 285                         sunfilter_albums.set(ReapplyFilter::Yes, true);
 286                         std::map<std::tuple<std::string, std::string, std::string>, time_t> albums;
 287                         for (MPD::SongIterator s = getDatabaseIterator(Mpd), end; s != end; ++s)
 288                         {
 289                                 std::string tag;
 290                                 unsigned idx = 0;
 291                                 while (!(tag = s->get(Config.media_lib_primary_tag, idx++)).empty())
 292                                 {
 293                                         auto key = std::make_tuple(std::move(tag), s->getAlbum(), s->getDate());
 294                                         auto it = albums.find(key);
 295                                         if (it == albums.end())
 296                                                 albums[std::move(key)] = s->getMTime();
 297                                         else
 298                                                 it->second = s->getMTime();
 299                                 }
 300                         }
 301                         size_t idx = 0;
 302                         for (const auto &album : albums)
 303                         {
 304                                 auto entry = AlbumEntry(
 305                                         Album(std::move(std::get<0>(album.first)),
 306                                               std::move(std::get<1>(album.first)),
 307                                               std::move(std::get<2>(album.first)),
 308                                               album.second));
 309                                 if (idx < Albums.size())
 310                                         Albums[idx].value() = std::move(entry);
 311                                 else
 312                                         Albums.addItem(std::move(entry));
 313                                 ++idx;
 314                         }
 315                         if (idx < Albums.size())
 316                                 Albums.resizeList(idx);
 317                         std::sort(Albums.beginV(), Albums.endV(), SortAlbumEntries());
 318                 }
 319         }
 320         else
 321         {
 322                 {
 323                         ScopedUnfilteredMenu<PrimaryTag> sunfilter_tags(ReapplyFilter::No, Tags);
 324                         if (Tags.empty() || m_tags_update_request)
 325                         {
 326                                 m_tags_update_request = false;
 327                                 sunfilter_tags.set(ReapplyFilter::Yes, true);
 328                                 std::map<std::string, time_t> tags;
 329                                 if (Config.media_library_sort_by_mtime)
 330                                 {
 331                                         for (MPD::SongIterator s = getDatabaseIterator(Mpd), end; s != end; ++s)
 332                                         {
 333                                                 std::string tag;
 334                                                 unsigned idx = 0;
 335                                                 while (!(tag = s->get(Config.media_lib_primary_tag, idx++)).empty())
 336                                                 {
 337                                                         auto it = tags.find(tag);
 338                                                         if (it == tags.end())
 339                                                                 tags[std::move(tag)] = s->getMTime();
 340                                                         else
 341                                                                 it->second = std::max(it->second, s->getMTime());
 342                                                 }
 343                                         }
 344                                 }
 345                                 else
 346                                 {
 347                                         MPD::StringIterator tag = Mpd.GetList(Config.media_lib_primary_tag), end;
 348                                         for (; tag != end; ++tag)
 349                                                 tags[std::move(*tag)] = 0;
 350                                 }
 351                                 size_t idx = 0;
 352                                 for (const auto &tag : tags)
 353                                 {
 354                                         auto ptag = PrimaryTag(std::move(tag.first), tag.second);
 355                                         if (idx < Tags.size())
 356                                                 Tags[idx].value() = std::move(ptag);
 357                                         else
 358                                                 Tags.addItem(std::move(ptag));
 359                                         ++idx;
 360                                 }
 361                                 if (idx < Tags.size())
 362                                         Tags.resizeList(idx);
 363                                 std::sort(Tags.beginV(), Tags.endV(), SortPrimaryTags());
 364                         }
 365                 }
 366
 367                 {
 368                         ScopedUnfilteredMenu<AlbumEntry> sunfilter_albums(ReapplyFilter::No, Albums);
 369                         if (!Tags.empty()
 370                             && ((Albums.empty() && Global::Timer - m_timer > m_fetching_delay)
 371                                 || m_albums_update_request))
 372                         {
 373                                 m_albums_update_request = false;
 374                                 sunfilter_albums.set(ReapplyFilter::Yes, true);
 375                                 auto &primary_tag = Tags.current()->value().tag();
 376                                 Mpd.StartSearch(true);
 377                                 Mpd.AddSearch(Config.media_lib_primary_tag, primary_tag);
 378                                 std::map<std::tuple<std::string, std::string>, time_t> albums;
 379                                 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s)
 380                                 {
 381                                         auto key = std::make_tuple(s->getAlbum(), s->getDate());
 382                                         auto it = albums.find(key);
 383                                         if (it == albums.end())
 384                                                 albums[std::move(key)] = s->getMTime();
 385                                         else
 386                                                 it->second = std::max(it->second, s->getMTime());
 387                                 };
 388                                 size_t idx = 0;
 389                                 for (const auto &album : albums)
 390                                 {
 391                                         auto entry = AlbumEntry(
 392                                                 Album(primary_tag,
 393                                                       std::move(std::get<0>(album.first)),
 394                                                       std::move(std::get<1>(album.first)),
 395                                                       album.second));
 396                                         if (idx < Albums.size())
 397                                         {
 398                                                 Albums[idx].value() = std::move(entry);
 399                                                 Albums[idx].setSeparator(false);
 400                                         }
 401                                         else
 402                                                 Albums.addItem(std::move(entry));
 403                                         ++idx;
 404                                 }
 405                                 if (idx < Albums.size())
 406                                         Albums.resizeList(idx);
 407                                 std::sort(Albums.beginV(), Albums.endV(), SortAlbumEntries());
 408                                 if (albums.size() > 1)
 409                                 {
 410                                         Albums.addSeparator();
 411                                         Albums.addItem(AlbumEntry::mkAllTracksEntry(primary_tag));
 412                                 }
 413                         }
 414                 }
 415         }
 416
 417         ScopedUnfilteredMenu<MPD::Song> sunfilter_songs(ReapplyFilter::No, Songs);
 418         if (!Albums.empty()
 419             && ((Songs.empty() && Global::Timer - m_timer > m_fetching_delay)
 420                 || m_songs_update_request))
 421         {
 422                 m_songs_update_request = false;
 423                 sunfilter_songs.set(ReapplyFilter::Yes, true);
 424                 auto &album = Albums.current()->value();
 425                 Mpd.StartSearch(true);
 426                 Mpd.AddSearch(Config.media_lib_primary_tag, album.entry().tag());
 427                 if (!album.isAllTracksEntry())
 428                 {
 429                         Mpd.AddSearch(MPD_TAG_ALBUM, album.entry().album());
 430                         Mpd.AddSearch(MPD_TAG_DATE, album.entry().date());
 431                 }
 432                 size_t idx = 0;
 433                 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s, ++idx)
 434                 {
 435                         if (idx < Songs.size())
 436                                 Songs[idx].value() = std::move(*s);
 437                         else
 438                                 Songs.addItem(std::move(*s));
 439                 };
 440                 if (idx < Songs.size())
 441                         Songs.resizeList(idx);
 442                 std::sort(Songs.begin(), Songs.end(), SortSongs(!album.isAllTracksEntry()));
 443         }
 444 }
 445
 446 int MediaLibrary::windowTimeout()
 447 {
 448         ScopedUnfilteredMenu<AlbumEntry> sunfilter_albums(ReapplyFilter::No, Albums);
 449         ScopedUnfilteredMenu<MPD::Song> sunfilter_songs(ReapplyFilter::No, Songs);
 450         if (Albums.empty() || Songs.empty())
 451                 return m_window_timeout;
 452         else
 453                 return Screen<WindowType>::windowTimeout();
 454 }
 455
 456 void MediaLibrary::mouseButtonPressed(MEVENT me)
 457 {
 458         auto tryNextColumn = [this]() -> bool {
 459                 bool result = true;
 460                 if (!isActiveWindow(Songs))
 461                 {
 462                         if (nextColumnAvailable())
 463                                 nextColumn();
 464                         else
 465                                 result = false;
 466                 }
 467                 return result;
 468         };
 469         auto tryPreviousColumn = [this]() -> bool {
 470                 bool result = true;
 471                 if (!isActiveWindow(Tags))
 472                 {
 473                         if (previousColumnAvailable())
 474                                 previousColumn();
 475                         else
 476                                 result = false;
 477                 }
 478                 return result;
 479         };
 480         if (Tags.hasCoords(me.x, me.y))
 481         {
 482                 if (!tryPreviousColumn() || !tryPreviousColumn())
 483                         return;
 484                 if (size_t(me.y) < Tags.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 485                 {
 486                         Tags.Goto(me.y);
 487                         if (me.bstate & BUTTON3_PRESSED)
 488                                 addItemToPlaylist(false);
 489                 }
 490                 else
 491                         Screen<WindowType>::mouseButtonPressed(me);
 492                 Albums.clear();
 493                 Songs.clear();
 494         }
 495         else if (Albums.hasCoords(me.x, me.y))
 496         {
 497                 if (!isActiveWindow(Albums))
 498                 {
 499                         bool success;
 500                         if (isActiveWindow(Tags))
 501                                 success = tryNextColumn();
 502                         else
 503                                 success = tryPreviousColumn();
 504                         if (!success)
 505                                 return;
 506                 }
 507                 if (size_t(me.y) < Albums.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 508                 {
 509                         Albums.Goto(me.y);
 510                         if (me.bstate & BUTTON3_PRESSED)
 511                                 addItemToPlaylist(false);
 512                 }
 513                 else
 514                         Screen<WindowType>::mouseButtonPressed(me);
 515                 Songs.clear();
 516         }
 517         else if (Songs.hasCoords(me.x, me.y))
 518         {
 519                 if (!tryNextColumn() || !tryNextColumn())
 520                         return;
 521                 if (size_t(me.y) < Songs.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 522                 {
 523                         Songs.Goto(me.y);
 524                         bool play = me.bstate & BUTTON3_PRESSED;
 525                         addItemToPlaylist(play);
 526                 }
 527                 else
 528                         Screen<WindowType>::mouseButtonPressed(me);
 529         }
 530 }
 531
 532 /***********************************************************************/
 533
 534 bool MediaLibrary::allowsSearching()
 535 {
 536         return true;
 537 }
 538
 539 const std::string &MediaLibrary::searchConstraint()
 540 {
 541         if (isActiveWindow(Tags))
 542                 return m_tags_search_predicate.constraint();
 543         else if (isActiveWindow(Albums))
 544                 return m_albums_search_predicate.constraint();
 545         else if (isActiveWindow(Songs))
 546                 return m_songs_search_predicate.constraint();
 547         throw std::runtime_error("no active window");
 548 }
 549
 550 void MediaLibrary::setSearchConstraint(const std::string &constraint)
 551 {
 552         if (isActiveWindow(Tags))
 553         {
 554                 m_tags_search_predicate = Regex::Filter<PrimaryTag>(
 555                         constraint,
 556                         Config.regex_type,
 557                         TagEntryMatcher);
 558         }
 559         else if (isActiveWindow(Albums))
 560         {
 561                 m_albums_search_predicate = Regex::ItemFilter<AlbumEntry>(
 562                         constraint,
 563                         Config.regex_type,
 564                         std::bind(AlbumEntryMatcher, ph::_1, ph::_2, false));
 565         }
 566         else if (isActiveWindow(Songs))
 567         {
 568                 m_songs_search_predicate = Regex::Filter<MPD::Song>(
 569                         constraint,
 570                         Config.regex_type,
 571                         SongEntryMatcher);
 572         }
 573 }
 574
 575 void MediaLibrary::clearSearchConstraint()
 576 {
 577         if (isActiveWindow(Tags))
 578                 m_tags_search_predicate.clear();
 579         else if (isActiveWindow(Albums))
 580                 m_albums_search_predicate.clear();
 581         else if (isActiveWindow(Songs))
 582                 m_songs_search_predicate.clear();
 583 }
 584
 585 bool MediaLibrary::search(SearchDirection direction, bool wrap, bool skip_current)
 586 {
 587         bool result = false;
 588         if (isActiveWindow(Tags))
 589                 result = ::search(Tags, m_tags_search_predicate, direction, wrap, skip_current);
 590         else if (isActiveWindow(Albums))
 591                 result = ::search(Albums, m_albums_search_predicate, direction, wrap, skip_current);
 592         else if (isActiveWindow(Songs))
 593                 result = ::search(Songs, m_songs_search_predicate, direction, wrap, skip_current);
 594         return result;
 595 }
 596
 597 /***********************************************************************/
 598
 599 bool MediaLibrary::allowsFiltering()
 600 {
 601         return allowsSearching();
 602 }
 603
 604 std::string MediaLibrary::currentFilter()
 605 {
 606         std::string result;
 607         if (isActiveWindow(Tags))
 608         {
 609                 if (auto pred = Tags.filterPredicate<Regex::Filter<PrimaryTag>>())
 610                         result = pred->constraint();
 611         }
 612         else if (isActiveWindow(Albums))
 613         {
 614                 if (auto pred = Albums.filterPredicate<Regex::ItemFilter<AlbumEntry>>())
 615                         result = pred->constraint();
 616         }
 617         else if (isActiveWindow(Songs))
 618         {
 619                 if (auto pred = Songs.filterPredicate<Regex::Filter<MPD::Song>>())
 620                         result = pred->constraint();
 621         }
 622         return result;
 623 }
 624
 625 void MediaLibrary::applyFilter(const std::string &constraint)
 626 {
 627         if (isActiveWindow(Tags))
 628         {
 629                 if (!constraint.empty())
 630                 {
 631                         Tags.applyFilter(Regex::Filter<PrimaryTag>(
 632                                                  constraint,
 633                                                  Config.regex_type,
 634                                                  TagEntryMatcher));
 635                 }
 636                 else
 637                         Tags.clearFilter();
 638         }
 639         else if (isActiveWindow(Albums))
 640         {
 641                 if (!constraint.empty())
 642                 {
 643                         Albums.applyFilter(Regex::ItemFilter<AlbumEntry>(
 644                                                    constraint,
 645                                                    Config.regex_type,
 646                                                    std::bind(AlbumEntryMatcher, ph::_1, ph::_2, true)));
 647                 }
 648                 else
 649                         Albums.clearFilter();
 650         }
 651         else if (isActiveWindow(Songs))
 652         {
 653                 if (!constraint.empty())
 654                 {
 655                         Songs.applyFilter(Regex::Filter<MPD::Song>(
 656                                                   constraint,
 657                                                   Config.regex_type,
 658                                                   SongEntryMatcher));
 659                 }
 660                 else
 661                         Songs.clearFilter();
 662
 663         }
 664 }
 665
 666 /***********************************************************************/
 667
 668 bool MediaLibrary::itemAvailable()
 669 {
 670         if (isActiveWindow(Tags))
 671                 return !Tags.empty();
 672         if (isActiveWindow(Albums))
 673                 return !Albums.empty();
 674         if (isActiveWindow(Songs))
 675                 return !Songs.empty();
 676         return false;
 677 }
 678
 679 bool MediaLibrary::addItemToPlaylist(bool play)
 680 {
 681         bool result = false;
 682         if (isActiveWindow(Songs))
 683                 result = addSongToPlaylist(Songs.current()->value(), play);
 684         else
 685         {
 686                 if (isActiveWindow(Tags)
 687                 ||  (isActiveWindow(Albums) && Albums.current()->value().isAllTracksEntry()))
 688                 {
 689                         Mpd.StartSearch(true);
 690                         Mpd.AddSearch(Config.media_lib_primary_tag, Tags.current()->value().tag());
 691                         std::vector<MPD::Song> list(
 692                                 std::make_move_iterator(Mpd.CommitSearchSongs()),
 693                                 std::make_move_iterator(MPD::SongIterator()));
 694                         std::sort(list.begin(), list.end(), SortSongs());
 695                         result = addSongsToPlaylist(list.begin(), list.end(), play, -1);
 696                         std::string tag_type = boost::locale::to_lower(
 697                                 tagTypeToString(Config.media_lib_primary_tag));
 698                         Statusbar::printf("Songs with %1% \"%2%\" added%3%",
 699                                 tag_type, Tags.current()->value().tag(), withErrors(result));
 700                 }
 701                 else if (isActiveWindow(Albums))
 702                 {
 703                         std::vector<MPD::Song> list(
 704                                 std::make_move_iterator(getSongsFromAlbum(Albums.current()->value())),
 705                                 std::make_move_iterator(MPD::SongIterator()));
 706                         std::sort(list.begin(), list.end(), SortSongs());
 707                         result = addSongsToPlaylist(list.begin(), list.end(), play, -1);
 708                         Statusbar::printf("Songs from album \"%1%\" added%2%",
 709                                 Albums.current()->value().entry().album(), withErrors(result));
 710                 }
 711         }
 712         return result;
 713 }
 714
 715 std::vector<MPD::Song> MediaLibrary::getSelectedSongs()
 716 {
 717         std::vector<MPD::Song> result;
 718         if (isActiveWindow(Tags))
 719         {
 720                 auto tag_handler = [&result](const std::string &tag) {
 721                         Mpd.StartSearch(true);
 722                         Mpd.AddSearch(Config.media_lib_primary_tag, tag);
 723                         size_t begin = result.size();
 724                         std::copy(
 725                                 std::make_move_iterator(Mpd.CommitSearchSongs()),
 726                                 std::make_move_iterator(MPD::SongIterator()),
 727                                 std::back_inserter(result));
 728                         std::sort(result.begin()+begin, result.end(), SortSongs());
 729                 };
 730                 bool any_selected = false;
 731                 for (auto &e : Tags)
 732                 {
 733                         if (e.isSelected())
 734                         {
 735                                 any_selected = true;
 736                                 tag_handler(e.value().tag());
 737                         }
 738                 }
 739                 // if no item is selected, add current one
 740                 if (!any_selected && !Tags.empty())
 741                         tag_handler(Tags.current()->value().tag());
 742         }
 743         else if (isActiveWindow(Albums))
 744         {
 745                 bool any_selected = false;
 746                 for (auto it = Albums.begin(); it != Albums.end() && !it->isSeparator(); ++it)
 747                 {
 748                         if (it->isSelected())
 749                         {
 750                                 any_selected = true;
 751                                 auto &sc = it->value();
 752                                 Mpd.StartSearch(true);
 753                                 if (hasTwoColumns)
 754                                         Mpd.AddSearch(Config.media_lib_primary_tag, sc.entry().tag());
 755                                 else
 756                                         Mpd.AddSearch(Config.media_lib_primary_tag,
 757                                                       Tags.current()->value().tag());
 758                                         Mpd.AddSearch(MPD_TAG_ALBUM, sc.entry().album());
 759                                 Mpd.AddSearch(MPD_TAG_DATE, sc.entry().date());
 760                                 size_t begin = result.size();
 761                                 std::copy(
 762                                         std::make_move_iterator(Mpd.CommitSearchSongs()),
 763                                         std::make_move_iterator(MPD::SongIterator()),
 764                                         std::back_inserter(result));
 765                                 std::sort(result.begin()+begin, result.end(), SortSongs());
 766                         }
 767                 }
 768                 // if no item is selected, add songs from right column
 769                 ScopedUnfilteredMenu<MPD::Song> sunfilter_songs(ReapplyFilter::No, Songs);
 770                 if (!any_selected && !Albums.empty())
 771                 {
 772                         size_t begin = result.size();
 773                         std::copy(
 774                                 std::make_move_iterator(getSongsFromAlbum(Albums.current()->value().entry())),
 775                                 std::make_move_iterator(MPD::SongIterator()),
 776                                 std::back_inserter(result)
 777                         );
 778                         std::sort(result.begin()+begin, result.end(), SortSongs());
 779                 }
 780         }
 781         else if (isActiveWindow(Songs))
 782                 result = Songs.getSelectedSongs();
 783         return result;
 784 }
 785
 786 /***********************************************************************/
 787
 788 bool MediaLibrary::previousColumnAvailable()
 789 {
 790         assert(!hasTwoColumns || !isActiveWindow(Tags));
 791         if (isActiveWindow(Songs))
 792         {
 793                 ScopedUnfilteredMenu<AlbumEntry> sunfilter_albums(ReapplyFilter::No, Albums);
 794                 if (!Albums.empty())
 795                         return true;
 796         }
 797         else if (isActiveWindow(Albums))
 798         {
 799                 ScopedUnfilteredMenu<PrimaryTag> sunfilter_tags(ReapplyFilter::No, Tags);
 800                 if (!hasTwoColumns && !Tags.empty())
 801                         return true;
 802         }
 803         return false;
 804 }
 805
 806 void MediaLibrary::previousColumn()
 807 {
 808         if (isActiveWindow(Songs))
 809         {
 810                 Songs.setHighlightColor(Config.main_highlight_color);
 811                 w->refresh();
 812                 w = &Albums;
 813                 Albums.setHighlightColor(Config.active_column_color);
 814         }
 815         else if (isActiveWindow(Albums) && !hasTwoColumns)
 816         {
 817                 Albums.setHighlightColor(Config.main_highlight_color);
 818                 w->refresh();
 819                 w = &Tags;
 820                 Tags.setHighlightColor(Config.active_column_color);
 821         }
 822 }
 823
 824 bool MediaLibrary::nextColumnAvailable()
 825 {
 826         assert(!hasTwoColumns || !isActiveWindow(Tags));
 827         if (isActiveWindow(Tags))
 828         {
 829                 ScopedUnfilteredMenu<AlbumEntry> sunfilter_albums(ReapplyFilter::No, Albums);
 830                 if (!Albums.empty())
 831                         return true;
 832         }
 833         else if (isActiveWindow(Albums))
 834         {
 835                 ScopedUnfilteredMenu<MPD::Song> sunfilter_songs(ReapplyFilter::No, Songs);
 836                 if (!Songs.empty())
 837                         return true;
 838         }
 839         return false;
 840 }
 841
 842 void MediaLibrary::nextColumn()
 843 {
 844         if (isActiveWindow(Tags))
 845         {
 846                 Tags.setHighlightColor(Config.main_highlight_color);
 847                 w->refresh();
 848                 w = &Albums;
 849                 Albums.setHighlightColor(Config.active_column_color);
 850         }
 851         else if (isActiveWindow(Albums))
 852         {
 853                 Albums.setHighlightColor(Config.main_highlight_color);
 854                 w->refresh();
 855                 w = &Songs;
 856                 Songs.setHighlightColor(Config.active_column_color);
 857         }
 858 }
 859
 860 /***********************************************************************/
 861
 862 void MediaLibrary::updateTimer()
 863 {
 864         m_timer = Global::Timer;
 865 }
 866
 867 void MediaLibrary::toggleColumnsMode()
 868 {
 869         hasTwoColumns = !hasTwoColumns;
 870         Tags.clear();
 871         Albums.clear();
 872         Albums.reset();
 873         Songs.clear();
 874         if (hasTwoColumns)
 875         {
 876                 if (isActiveWindow(Tags))
 877                         nextColumn();
 878                 if (Config.titles_visibility)
 879                 {
 880                         std::string item_type = boost::locale::to_lower(
 881                                 tagTypeToString(Config.media_lib_primary_tag));
 882                         std::string and_mtime = Config.media_library_sort_by_mtime ? " and mtime" : "";
 883                         Albums.setTitle("Albums (sorted by " + item_type + and_mtime + ")");
 884                 }
 885         }
 886         else
 887                 Albums.setTitle(Config.titles_visibility ? "Albums" : "");
 888         resize();
 889 }
 890
 891 int MediaLibrary::columns()
 892 {
 893         if (hasTwoColumns)
 894                 return 2;
 895         else
 896                 return 3;
 897 }
 898
 899 void MediaLibrary::toggleSortMode()
 900 {
 901         Config.media_library_sort_by_mtime = !Config.media_library_sort_by_mtime;
 902         Statusbar::printf("Sorting library by: %1%",
 903                 Config.media_library_sort_by_mtime ? "modification time" : "name");
 904         if (hasTwoColumns)
 905         {
 906                 ScopedUnfilteredMenu<AlbumEntry> sunfilter_albums(ReapplyFilter::No, Albums);
 907                 std::sort(Albums.beginV(), Albums.endV(), SortAlbumEntries());
 908                 Albums.refresh();
 909                 Songs.clear();
 910                 if (Config.titles_visibility)
 911                 {
 912                         std::string item_type = boost::locale::to_lower(
 913                                 tagTypeToString(Config.media_lib_primary_tag));
 914                         std::string and_mtime = Config.media_library_sort_by_mtime ? (" " "and mtime") : "";
 915                         Albums.setTitle("Albums (sorted by " + item_type + and_mtime + ")");
 916                 }
 917         }
 918         else
 919         {
 920                 ScopedUnfilteredMenu<PrimaryTag> sunfilter_tags(ReapplyFilter::No, Tags);
 921                 // if we already have modification times, just resort. otherwise refetch the list.
 922                 if (!Tags.empty() && Tags[0].value().mtime() > 0)
 923                 {
 924                         std::sort(Tags.beginV(), Tags.endV(), SortPrimaryTags());
 925                         Tags.refresh();
 926                 }
 927                 else
 928                 {
 929                         Tags.clear();
 930                 }
 931                 Albums.clear();
 932                 Songs.clear();
 933         }
 934         update();
 935 }
 936
 937 void MediaLibrary::locateSong(const MPD::Song &s)
 938 {
 939         std::string primary_tag = s.get(Config.media_lib_primary_tag);
 940         if (primary_tag.empty())
 941         {
 942                 std::string item_type = boost::locale::to_lower(
 943                         tagTypeToString(Config.media_lib_primary_tag));
 944                 Statusbar::printf("Can't use this function because the song has no %s tag", item_type);
 945                 return;
 946         }
 947
 948         if (!s.isFromDatabase())
 949         {
 950                 Statusbar::print("Song is not from the database");
 951                 return;
 952         }
 953
 954         if (myScreen != this)
 955                 switchTo();
 956         Statusbar::put() << "Jumping to song...";
 957         Global::wFooter->refresh();
 958
 959         if (!hasTwoColumns)
 960         {
 961                 Tags.clearFilter();
 962                 if (Tags.empty())
 963                 {
 964                         requestTagsUpdate();
 965                         update();
 966                 }
 967
 968                 if (!MoveToTag(Tags, primary_tag))
 969                 {
 970                         // The tag could not be found. Since this was called from an existing
 971                         // song, the tag should exist in the library, but it was not listed by
 972                         // list/listallinfo. This is the case with some players where it is not
 973                         // possible to list all of the library, e.g. mopidy with mopidy-spotify.
 974                         // To workaround this we simply insert the missing tag.
 975                         Tags.addItem(PrimaryTag(primary_tag, s.getMTime()));
 976                         std::sort(Tags.beginV(), Tags.endV(), SortPrimaryTags());
 977                         Tags.refresh();
 978                         MoveToTag(Tags, primary_tag);
 979                 }
 980                 Albums.clear();
 981         }
 982
 983         Albums.clearFilter();
 984         if (Albums.empty())
 985         {
 986                 requestAlbumsUpdate();
 987                 update();
 988         }
 989
 990         // When you locate a song in the media library, if no albums or no songs
 991         // are found, set the active column to the previous one (tags if no albums,
 992         // and albums if no songs). This makes sure that the active column is not
 993         // empty, which may make it impossible to move out of.
 994         //
 995         // The problem was if you highlight some song in the rightmost column in
 996         // the media browser and then go to some other window and select locate
 997         // song. If the tag or album it looked up in the media library was
 998         // empty, the selection would stay in the songs column while it was empty.
 999         // This made the selection impossible to change.
1000         //
1001         // This only is a problem if a song has some tag or album for which the
1002         // find command doesn't return any results. This should never really happen
1003         // unless there is some inconsistency in the player. However, it may
1004         // happen, so we need to handle it.
1005         //
1006         // Note: We don't want to return when no albums are found in two column
1007         // mode. In this case, we try to insert the album, as we do with tags when
1008         // they are not found.
1009         if (hasTwoColumns || !Albums.empty())
1010         {
1011                 if (!MoveToAlbum(Albums, primary_tag, s))
1012                 {
1013                         // The album could not be found, insert it if in two column mode.
1014                         // See comment about tags not found above. This is the equivalent
1015                         // for two column mode.
1016                         Albums.addItem(AlbumEntry(
1017                                 Album(primary_tag, s.getAlbum(), s.getDate(), s.getMTime())
1018                         ));
1019                         std::sort(Albums.beginV(), Albums.endV(), SortAlbumEntries());
1020                         Albums.refresh();
1021                         MoveToAlbum(Albums, primary_tag, s);
1022                 }
1023
1024                 Songs.clearFilter();
1025                 requestSongsUpdate();
1026                 update();
1027
1028                 if (!Songs.empty())
1029                 {
1030                         if (s != Songs.current()->value())
1031                         {
1032                                 auto begin = Songs.beginV(), end = Songs.endV();
1033                                 auto it = std::find(begin, end, s);
1034                                 if (it != end)
1035                                         Songs.highlight(it-begin);
1036                         }
1037                         nextColumn();
1038                         nextColumn();
1039                 }
1040                 else // invalid album was added, clear the list
1041                         Albums.clear();
1042         }
1043         else // invalid tag was added, clear the list
1044                 Tags.clear();
1045         refresh();
1046 }
1047
1048 namespace {
1049
1050 std::string AlbumToString(const AlbumEntry &ae)
1051 {
1052         std::string result;
1053         if (ae.isAllTracksEntry())
1054                 result = "All tracks";
1055         else
1056         {
1057                 if (hasTwoColumns)
1058                 {
1059                         if (ae.entry().tag().empty())
1060                                 result += Config.empty_tag;
1061                         else
1062                                 result += ae.entry().tag();
1063                         result += " - ";
1064                 }
1065                 if (Config.media_lib_primary_tag != MPD_TAG_DATE && !ae.entry().date().empty())
1066                         result += "(" + ae.entry().date() + ") ";
1067                 result += ae.entry().album().empty() ? "<no album>" : ae.entry().album();
1068         }
1069         return result;
1070 }
1071
1072 std::string SongToString(const MPD::Song &s)
1073 {
1074         return Format::stringify<char>(
1075                 Config.song_library_format, &s
1076         );
1077 }
1078
1079 bool TagEntryMatcher(const Regex::Regex &rx, const PrimaryTag &pt)
1080 {
1081         return Regex::search(pt.tag(), rx);
1082 }
1083
1084 bool AlbumEntryMatcher(const Regex::Regex &rx, const NC::Menu<AlbumEntry>::Item &item, bool filter)
1085 {
1086         if (item.isSeparator() || item.value().isAllTracksEntry())
1087                 return filter;
1088         return Regex::search(AlbumToString(item.value()), rx);
1089 }
1090
1091 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s)
1092 {
1093         return Regex::search(SongToString(s), rx);
1094 }
1095
1096 bool MoveToTag(NC::Menu<PrimaryTag> &tags, const std::string &primary_tag)
1097 {
1098         if (tags.empty())
1099                 return false;
1100
1101         auto equals_fun_argument = [&](PrimaryTag &e) {
1102                 return e.tag() == primary_tag;
1103         };
1104
1105         if (equals_fun_argument(*tags.currentV()))
1106                 return true;
1107
1108         auto begin = tags.beginV(), end = tags.endV();
1109         auto it = std::find_if(begin, end, equals_fun_argument);
1110         if (it != end)
1111         {
1112                 tags.highlight(it-begin);
1113                 return true;
1114         }
1115
1116         return false;
1117 }
1118
1119 bool MoveToAlbum(NC::Menu<AlbumEntry> &albums, const std::string &primary_tag, const MPD::Song &s)
1120 {
1121         if (albums.empty())
1122                 return false;
1123
1124         std::string album = s.getAlbum();
1125         std::string date = s.getDate();
1126
1127         auto equals_fun_argument = [&](AlbumEntry &e) {
1128                 return (!hasTwoColumns || e.entry().tag() == primary_tag)
1129                     && e.entry().album() == album
1130                     && e.entry().date() == date;
1131         };
1132
1133         if (equals_fun_argument(*albums.currentV()))
1134                 return true;
1135
1136         auto begin = albums.beginV(), end = albums.endV();
1137         auto it = std::find_if(begin, end, equals_fun_argument);
1138         if (it != end)
1139         {
1140                 albums.highlight(it-begin);
1141                 return true;
1142         }
1143
1144         return false;
1145 }
1146
1147 }