src/browser.cpp

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