src/screens/browser.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 <algorithm>
  22 #include <boost/algorithm/string/predicate.hpp>
  23 #include <boost/filesystem.hpp>
  24 #include <boost/locale/conversion.hpp>
  25 #include <time.h>
  26
  27 #include "screens/browser.h"
  28 #include "charset.h"
  29 #include "display.h"
  30 #include "global.h"
  31 #include "helpers.h"
  32 #include "screens/playlist.h"
  33 #include "curses/menu_impl.h"
  34 #include "screens/screen_switcher.h"
  35 #include "settings.h"
  36 #include "status.h"
  37 #include "statusbar.h"
  38 #include "screens/tag_editor.h"
  39 #include "title.h"
  40 #include "tags.h"
  41 #include "helpers/song_iterator_maker.h"
  42 #include "utility/comparators.h"
  43 #include "utility/string.h"
  44 #include "configuration.h"
  45
  46 using Global::MainHeight;
  47 using Global::MainStartY;
  48 using Global::myScreen;
  49
  50 namespace fs = boost::filesystem;
  51 namespace ph = std::placeholders;
  52
  53 Browser *myBrowser;
  54
  55 namespace {
  56
  57 std::set<std::string> lm_supported_extensions;
  58
  59 std::string realPath(bool local_browser, std::string path);
  60 bool isStringParentDirectory(const std::string &directory);
  61 bool isItemParentDirectory(const MPD::Item &item);
  62 bool isRootDirectory(const std::string &directory);
  63 bool isHidden(const fs::directory_iterator &entry);
  64 bool hasSupportedExtension(const fs::directory_entry &entry);
  65 MPD::Song getLocalSong(const fs::directory_entry &entry, bool read_tags);
  66 void getLocalDirectory(NC::Menu<MPD::Item> &menu, const std::string &directory);
  67 void getLocalDirectoryRecursively(std::vector<MPD::Song> &songs,
  68                                   const std::string &directory);
  69 void clearDirectory(const std::string &directory);
  70
  71 std::string itemToString(const MPD::Item &item);
  72 bool browserEntryMatcher(const Regex::Regex &rx, const MPD::Item &item, bool filter);
  73
  74 }
  75
  76 template <>
  77 struct SongPropertiesExtractor<MPD::Item>
  78 {
  79         template <typename ItemT>
  80         auto &operator()(ItemT &item) const
  81         {
  82                 auto s = item.value().type() == MPD::Item::Type::Song
  83                         ? &item.value().song()
  84                         : nullptr;
  85                 m_cache.assign(&item.properties(), s);
  86                 return m_cache;
  87         }
  88
  89 private:
  90         mutable SongProperties m_cache;
  91 };
  92
  93 SongIterator BrowserWindow::currentS()
  94 {
  95         return makeSongIterator(current());
  96 }
  97
  98 ConstSongIterator BrowserWindow::currentS() const
  99 {
 100         return makeConstSongIterator(current());
 101 }
 102
 103 SongIterator BrowserWindow::beginS()
 104 {
 105         return makeSongIterator(begin());
 106 }
 107
 108 ConstSongIterator BrowserWindow::beginS() const
 109 {
 110         return makeConstSongIterator(begin());
 111 }
 112
 113 SongIterator BrowserWindow::endS()
 114 {
 115         return makeSongIterator(end());
 116 }
 117
 118 ConstSongIterator BrowserWindow::endS() const
 119 {
 120         return makeConstSongIterator(end());
 121 }
 122
 123 std::vector<MPD::Song> BrowserWindow::getSelectedSongs()
 124 {
 125         return {}; // TODO
 126 }
 127
 128 /**********************************************************************/
 129
 130 Browser::Browser()
 131 : m_update_request(true)
 132 , m_local_browser(false)
 133 , m_scroll_beginning(0)
 134 , m_current_directory("/")
 135 {
 136         w = NC::Menu<MPD::Item>(0, MainStartY, COLS, MainHeight, Config.browser_display_mode == DisplayMode::Columns && Config.titles_visibility ? Display::Columns(COLS) : "", Config.main_color, NC::Border());
 137         w.setHighlightColor(Config.main_highlight_color);
 138         w.cyclicScrolling(Config.use_cyclic_scrolling);
 139         w.centeredCursor(Config.centered_cursor);
 140         w.setSelectedPrefix(Config.selected_item_prefix);
 141         w.setSelectedSuffix(Config.selected_item_suffix);
 142         w.setItemDisplayer(std::bind(Display::Items, ph::_1, std::cref(w)));
 143 }
 144
 145 void Browser::resize()
 146 {
 147         size_t x_offset, width;
 148         getWindowResizeParams(x_offset, width);
 149         w.resize(width, MainHeight);
 150         w.moveTo(x_offset, MainStartY);
 151         switch (Config.browser_display_mode)
 152         {
 153                 case DisplayMode::Columns:
 154                         if (Config.titles_visibility)
 155                         {
 156                                 w.setTitle(Display::Columns(w.getWidth()));
 157                                 break;
 158                         }
 159                 case DisplayMode::Classic:
 160                         w.setTitle("");
 161                         break;
 162         }
 163         hasToBeResized = 0;
 164 }
 165
 166 void Browser::switchTo()
 167 {
 168         SwitchTo::execute(this);
 169         drawHeader();
 170 }
 171
 172 std::wstring Browser::title()
 173 {
 174         std::wstring result = L"Browse: ";
 175         result += Scroller(ToWString(m_current_directory), m_scroll_beginning, COLS-result.length()-(Config.design == Design::Alternative ? 2 : Global::VolumeState.length()));
 176         return result;
 177 }
 178
 179 void Browser::update()
 180 {
 181         if (m_update_request)
 182         {
 183                 m_update_request = false;
 184                 bool directory_changed = false;
 185                 do
 186                 {
 187                         try
 188                         {
 189                                 getDirectory(m_current_directory);
 190                                 w.refresh();
 191                         }
 192                         catch (MPD::ServerError &err)
 193                         {
 194                                 // If current directory doesn't exist, try getting its
 195                                 // parent until we either succeed or reach the root.
 196                                 if (err.code() == MPD_SERVER_ERROR_NO_EXIST)
 197                                 {
 198                                         m_current_directory = getParentDirectory(m_current_directory);
 199                                         directory_changed = true;
 200                                 }
 201                                 else
 202                                         throw;
 203                         }
 204                 }
 205                 while (w.empty() && !inRootDirectory());
 206                 if (directory_changed)
 207                         drawHeader();
 208         }
 209 }
 210
 211 void Browser::mouseButtonPressed(MEVENT me)
 212 {
 213         if (w.empty() || !w.hasCoords(me.x, me.y) || size_t(me.y) >= w.size())
 214                 return;
 215         if (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED))
 216         {
 217                 w.Goto(me.y);
 218                 switch (w.current()->value().type())
 219                 {
 220                         case MPD::Item::Type::Directory:
 221                                 if (me.bstate & BUTTON1_PRESSED)
 222                                         enterDirectory();
 223                                 else
 224                                         addItemToPlaylist(false);
 225                                 break;
 226                         case MPD::Item::Type::Playlist:
 227                         case MPD::Item::Type::Song:
 228                         {
 229                                 bool play = me.bstate & BUTTON3_PRESSED;
 230                                 addItemToPlaylist(play);
 231                                 break;
 232                         }
 233                 }
 234         }
 235         else
 236                 Screen<WindowType>::mouseButtonPressed(me);
 237 }
 238
 239 /***********************************************************************/
 240
 241 bool Browser::allowsSearching()
 242 {
 243         return true;
 244 }
 245
 246 const std::string &Browser::searchConstraint()
 247 {
 248         return m_search_predicate.constraint();
 249 }
 250
 251 void Browser::setSearchConstraint(const std::string &constraint)
 252 {
 253         m_search_predicate = Regex::Filter<MPD::Item>(
 254                 constraint,
 255                 Config.regex_type,
 256                 std::bind(browserEntryMatcher, ph::_1, ph::_2, false));
 257 }
 258
 259 void Browser::clearSearchConstraint()
 260 {
 261         m_search_predicate.clear();
 262 }
 263
 264 bool Browser::search(SearchDirection direction, bool wrap, bool skip_current)
 265 {
 266         return ::search(w, m_search_predicate, direction, wrap, skip_current);
 267 }
 268
 269 /***********************************************************************/
 270
 271 bool Browser::allowsFiltering()
 272 {
 273         return allowsSearching();
 274 }
 275
 276 std::string Browser::currentFilter()
 277 {
 278         std::string result;
 279         if (auto pred = w.filterPredicate<Regex::Filter<MPD::Item>>())
 280                 result = pred->constraint();
 281         return result;
 282 }
 283
 284 void Browser::applyFilter(const std::string &constraint)
 285 {
 286         if (!constraint.empty())
 287         {
 288                 w.applyFilter(Regex::Filter<MPD::Item>(
 289                                       constraint,
 290                                       Config.regex_type,
 291                                       std::bind(browserEntryMatcher, ph::_1, ph::_2, true)));
 292         }
 293         else
 294                 w.clearFilter();
 295 }
 296
 297
 298 /***********************************************************************/
 299
 300 bool Browser::itemAvailable()
 301 {
 302         return !w.empty()
 303                 // ignore parent directory
 304                 && !isParentDirectory(w.current()->value());
 305 }
 306
 307 bool Browser::addItemToPlaylist(bool play)
 308 {
 309         bool result = false;
 310
 311         auto tryToPlay = [] {
 312                 // Cheap trick that might fail in presence of multiple
 313                 // clients modifying the playlist at the same time, but
 314                 // oh well, this approach correctly loads cue playlists
 315                 // and is much faster in general as it doesn't require
 316                 // fetching song data.
 317                 try
 318                 {
 319                         Mpd.Play(Status::State::playlistLength());
 320                 }
 321                 catch (MPD::ServerError &e)
 322                 {
 323                         // If not bad index, rethrow.
 324                         if (e.code() != MPD_SERVER_ERROR_ARG)
 325                                 throw;
 326                 }
 327         };
 328
 329         const MPD::Item &item = w.current()->value();
 330         switch (item.type())
 331         {
 332                 case MPD::Item::Type::Directory:
 333                 {
 334                         if (m_local_browser)
 335                         {
 336                                 std::vector<MPD::Song> songs;
 337                                 getLocalDirectoryRecursively(songs, item.directory().path());
 338                                 result = addSongsToPlaylist(songs.begin(), songs.end(), play, -1);
 339                         }
 340                         else
 341                         {
 342                                 Mpd.Add(item.directory().path());
 343                                 if (play)
 344                                         tryToPlay();
 345                                 result = true;
 346                         }
 347                         Statusbar::printf("Directory \"%1%\" added%2%",
 348                                 item.directory().path(), withErrors(result));
 349                         break;
 350                 }
 351                 case MPD::Item::Type::Song:
 352                         result = addSongToPlaylist(item.song(), play);
 353                         break;
 354                 case MPD::Item::Type::Playlist:
 355                         Mpd.LoadPlaylist(item.playlist().path());
 356                         if (play)
 357                                 tryToPlay();
 358                         Statusbar::printf("Playlist \"%1%\" loaded", item.playlist().path());
 359                         result = true;
 360                         break;
 361         }
 362         return result;
 363 }
 364
 365 std::vector<MPD::Song> Browser::getSelectedSongs()
 366 {
 367         std::vector<MPD::Song> songs;
 368         auto item_handler = [this, &songs](const MPD::Item &item) {
 369                 switch (item.type())
 370                 {
 371                         case MPD::Item::Type::Directory:
 372                                 if (m_local_browser)
 373                                         getLocalDirectoryRecursively(songs, item.directory().path());
 374                                 else
 375                                 {
 376                                         std::copy(
 377                                                 std::make_move_iterator(Mpd.GetDirectoryRecursive(item.directory().path())),
 378                                                 std::make_move_iterator(MPD::SongIterator()),
 379                                                 std::back_inserter(songs)
 380                                         );
 381                                 }
 382                                 break;
 383                         case MPD::Item::Type::Song:
 384                                 songs.push_back(item.song());
 385                                 break;
 386                         case MPD::Item::Type::Playlist:
 387                                 std::copy(
 388                                         std::make_move_iterator(Mpd.GetPlaylistContent(item.playlist().path())),
 389                                         std::make_move_iterator(MPD::SongIterator()),
 390                                         std::back_inserter(songs)
 391                                 );
 392                                 break;
 393                 }
 394         };
 395         for (const auto &item : w)
 396                 if (item.isSelected())
 397                         item_handler(item.value());
 398         // if no item is selected, add current one
 399         if (songs.empty() && !w.empty())
 400                 item_handler(w.current()->value());
 401         return songs;
 402 }
 403
 404 /***********************************************************************/
 405
 406 bool Browser::inRootDirectory()
 407 {
 408         return isRootDirectory(m_current_directory);
 409 }
 410
 411 bool Browser::isParentDirectory(const MPD::Item &item)
 412 {
 413         return isItemParentDirectory(item);
 414 }
 415
 416 const std::string& Browser::currentDirectory()
 417 {
 418         return m_current_directory;
 419 }
 420
 421 void Browser::locateSong(const MPD::Song &s)
 422 {
 423         if (s.getDirectory().empty())
 424                 throw std::runtime_error("Song's directory is empty");
 425
 426         m_local_browser = !s.isFromDatabase();
 427
 428         if (myScreen != this)
 429                 switchTo();
 430
 431         w.clearFilter();
 432
 433         // change to relevant directory
 434         if (m_current_directory != s.getDirectory())
 435         {
 436                 getDirectory(s.getDirectory());
 437                 drawHeader();
 438         }
 439
 440         // highlight the item
 441         auto begin = w.beginV(), end = w.endV();
 442         auto it = std::find(begin, end, MPD::Item(s));
 443         if (it != end)
 444                 w.highlight(it-begin);
 445 }
 446
 447 bool Browser::enterDirectory()
 448 {
 449         bool result = false;
 450         if (!w.empty())
 451         {
 452                 const auto &item = w.current()->value();
 453                 if (item.type() == MPD::Item::Type::Directory)
 454                 {
 455                         getDirectory(item.directory().path());
 456                         drawHeader();
 457                         result = true;
 458                 }
 459         }
 460         return result;
 461 }
 462
 463 void Browser::getDirectory(std::string directory)
 464 {
 465         {
 466                 ScopedUnfilteredMenu<MPD::Item> sunfilter(ReapplyFilter::Yes, w);
 467
 468                 m_scroll_beginning = 0;
 469                 w.clear();
 470
 471                 // Reset the position if we change directories.
 472                 if (m_current_directory != directory)
 473                         w.reset();
 474
 475                 // Check if it's a parent directory.
 476                 if (isStringParentDirectory(directory))
 477                 {
 478                         directory.resize(directory.length()-3);
 479                         directory = getParentDirectory(directory);
 480                 }
 481                 // When we go down to root, it can be empty.
 482                 if (directory.empty())
 483                         directory = "/";
 484
 485                 bool is_root = isRootDirectory(directory);
 486                 // If the requested directory is not root, add parent directory.
 487                 if (!is_root)
 488                 {
 489                         // Make it so that display function doesn't have to handle special cases.
 490                         w.addItem(MPD::Directory(directory + "/.."), NC::List::Properties::None);
 491                 }
 492
 493                 if (m_local_browser)
 494                         getLocalDirectory(w, directory);
 495                 else
 496                 {
 497                         MPD::ItemIterator end;
 498                         for (auto dir = Mpd.GetDirectory(directory); dir != end; ++dir)
 499                                 w.addItem(std::move(*dir));
 500                 }
 501
 502                 if (Config.browser_sort_mode != SortMode::NoOp)
 503                 {
 504                         std::sort(w.begin() + (is_root ? 0 : 1), w.end(),
 505                                   LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode));
 506                 }
 507         }
 508
 509         for (size_t i = 0; i < w.size(); ++i)
 510         {
 511                 if (w[i].value().type() == MPD::Item::Type::Directory
 512                     && w[i].value().directory().path() == m_current_directory)
 513                 {
 514                         w.highlight(i);
 515                         break;
 516                 }
 517         }
 518         m_current_directory = directory;
 519 }
 520
 521 void Browser::changeBrowseMode()
 522 {
 523         if (Mpd.GetHostname()[0] != '/')
 524         {
 525                 Statusbar::print("For browsing local filesystem connection to MPD via UNIX Socket is required");
 526                 return;
 527         }
 528
 529         m_local_browser = !m_local_browser;
 530         Statusbar::printf("Browse mode: %1%",
 531                 m_local_browser ? "local filesystem" : "MPD database"
 532         );
 533         if (m_local_browser)
 534         {
 535                 m_current_directory = "~";
 536                 expand_home(m_current_directory);
 537         }
 538         else
 539                 m_current_directory = "/";
 540         w.reset();
 541         getDirectory(m_current_directory);
 542         drawHeader();
 543 }
 544
 545 void Browser::remove(const MPD::Item &item)
 546 {
 547         if (!Config.allow_for_physical_item_deletion)
 548                 throw std::runtime_error("physical deletion is forbidden");
 549         if (isParentDirectory((item)))
 550                 throw std::runtime_error("deletion of parent directory is forbidden");
 551
 552         std::string path;
 553         switch (item.type())
 554         {
 555                 case MPD::Item::Type::Directory:
 556                         path = realPath(m_local_browser, item.directory().path());
 557                         clearDirectory(path);
 558                         fs::remove(path);
 559                         break;
 560                 case MPD::Item::Type::Song:
 561                         path = realPath(m_local_browser, item.song().getURI());
 562                         fs::remove(path);
 563                         break;
 564                 case MPD::Item::Type::Playlist:
 565                         path = item.playlist().path();
 566                         try {
 567                                 Mpd.DeletePlaylist(path);
 568                         } catch (MPD::ServerError &e) {
 569                                 // if there is no such mpd playlist, it's a local one
 570                                 if (e.code() == MPD_SERVER_ERROR_NO_EXIST)
 571                                 {
 572                                         path = realPath(m_local_browser, std::move(path));
 573                                         fs::remove(path);
 574                                 }
 575                                 else
 576                                         throw;
 577                         }
 578                         break;
 579         }
 580 }
 581
 582 /***********************************************************************/
 583
 584 void Browser::fetchSupportedExtensions()
 585 {
 586         lm_supported_extensions.clear();
 587         MPD::StringIterator extension = Mpd.GetSupportedExtensions(), end;
 588         for (; extension != end; ++extension)
 589                 lm_supported_extensions.insert("." + std::move(*extension));
 590 }
 591
 592 /***********************************************************************/
 593
 594 namespace {
 595
 596 std::string realPath(bool local_browser, std::string path)
 597 {
 598         if (!local_browser)
 599                 path = Config.mpd_music_dir + path;
 600         return path;
 601 }
 602
 603 bool isStringParentDirectory(const std::string &directory)
 604 {
 605         return boost::algorithm::ends_with(directory, "/..");
 606 }
 607
 608 bool isItemParentDirectory(const MPD::Item &item)
 609 {
 610         return item.type() == MPD::Item::Type::Directory
 611             && isStringParentDirectory(item.directory().path());
 612 }
 613
 614 bool isRootDirectory(const std::string &directory)
 615 {
 616         return directory == "/";
 617 }
 618
 619 bool isHidden(const fs::directory_iterator &entry)
 620 {
 621         return entry->path().filename().native()[0] == '.';
 622 }
 623
 624 bool hasSupportedExtension(const fs::directory_entry &entry)
 625 {
 626         return lm_supported_extensions.find(entry.path().extension().native())
 627             != lm_supported_extensions.end();
 628 }
 629
 630 MPD::Song getLocalSong(const fs::directory_entry &entry, bool read_tags)
 631 {
 632         mpd_pair pair = { "file", entry.path().c_str() };
 633         mpd_song *s = mpd_song_begin(&pair);
 634         if (s == nullptr)
 635                 throw std::runtime_error("invalid path: " + entry.path().native());
 636         if (read_tags)
 637         {
 638 #ifdef HAVE_TAGLIB_H
 639                 Tags::setAttribute(s, "Last-Modified",
 640                         timeFormat("%Y-%m-%dT%H:%M:%SZ", fs::last_write_time(entry.path()))
 641                 );
 642                 // read tags
 643                 Tags::read(s);
 644 #endif // HAVE_TAGLIB_H
 645         }
 646         return s;
 647 }
 648
 649 void getLocalDirectory(NC::Menu<MPD::Item> &menu, const std::string &directory)
 650 {
 651         for (fs::directory_iterator entry(directory), end; entry != end; ++entry)
 652         {
 653                 if (!Config.local_browser_show_hidden_files && isHidden(entry))
 654                         continue;
 655
 656         if (fs::is_directory(*entry))
 657         {
 658                 menu.addItem(MPD::Directory(entry->path().native(),
 659                                             fs::last_write_time(entry->path())));
 660         }
 661         else if (hasSupportedExtension(*entry))
 662                 menu.addItem(getLocalSong(*entry, true));
 663         }
 664 }
 665
 666 void getLocalDirectoryRecursively(std::vector<MPD::Song> &songs, const std::string &directory)
 667 {
 668         size_t sort_offset = songs.size();
 669         for (fs::directory_iterator entry(directory), end; entry != end; ++entry)
 670         {
 671                 if (!Config.local_browser_show_hidden_files && isHidden(entry))
 672                         continue;
 673
 674                 if (fs::is_directory(*entry))
 675                 {
 676                         getLocalDirectoryRecursively(songs, entry->path().native());
 677                         sort_offset = songs.size();
 678                 }
 679                 else if (hasSupportedExtension(*entry))
 680                         songs.push_back(getLocalSong(*entry, false));
 681         };
 682
 683         if (Config.browser_sort_mode != SortMode::NoOp)
 684         {
 685                 std::sort(songs.begin()+sort_offset, songs.end(),
 686                         LocaleBasedSorting(std::locale(), Config.ignore_leading_the)
 687                 );
 688         }
 689 }
 690
 691 void clearDirectory(const std::string &directory)
 692 {
 693         for (fs::directory_iterator entry(directory), end; entry != end; ++entry)
 694         {
 695                 if (!fs::is_symlink(*entry) && fs::is_directory(*entry))
 696                         clearDirectory(entry->path().native());
 697                 const char msg[] = "Deleting \"%1%\"...";
 698                 Statusbar::printf(msg, wideShorten(entry->path().native(), COLS-const_strlen(msg)));
 699                 fs::remove(entry->path());
 700         };
 701 }
 702
 703 /***********************************************************************/
 704
 705 std::string itemToString(const MPD::Item &item)
 706 {
 707         std::string result;
 708         switch (item.type())
 709         {
 710                 case MPD::Item::Type::Directory:
 711                         result = "[" + getBasename(item.directory().path()) + "]";
 712                         break;
 713                 case MPD::Item::Type::Song:
 714                         switch (Config.browser_display_mode)
 715                         {
 716                                 case DisplayMode::Classic:
 717                                         result = Format::stringify<char>(Config.song_list_format, &item.song());
 718                                         break;
 719                                 case DisplayMode::Columns:
 720                                         result = Format::stringify<char>(Config.song_columns_mode_format, &item.song());
 721                                         break;
 722                         }
 723                         break;
 724                 case MPD::Item::Type::Playlist:
 725                         result = Config.browser_playlist_prefix.str();
 726                         result += getBasename(item.playlist().path());
 727                         break;
 728         }
 729         return result;
 730 }
 731
 732 bool browserEntryMatcher(const Regex::Regex &rx, const MPD::Item &item, bool filter)
 733 {
 734         if (isItemParentDirectory(item))
 735                 return filter;
 736         return Regex::search(itemToString(item), rx);
 737 }
 738
 739 }