src/playlist.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2012 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 <sstream>
  23
  24 #include "display.h"
  25 #include "global.h"
  26 #include "helpers.h"
  27 #include "menu.h"
  28 #include "playlist.h"
  29 #include "regex_filter.h"
  30 #include "song.h"
  31 #include "status.h"
  32 #include "utility/comparators.h"
  33
  34 using namespace std::placeholders;
  35
  36 using Global::MainHeight;
  37 using Global::MainStartY;
  38
  39 Playlist *myPlaylist = new Playlist;
  40
  41 bool Playlist::ReloadTotalLength = 0;
  42 bool Playlist::ReloadRemaining = false;
  43
  44 namespace {//
  45
  46 NC::Menu< std::pair<std::string, MPD::Song::GetFunction> > *SortDialog = 0;
  47 size_t SortDialogHeight;
  48
  49 const size_t SortOptions = 10;
  50 const size_t SortDialogWidth = 30;
  51
  52 std::string songToString(const MPD::Song &s);
  53 bool playlistEntryMatcher(const Regex &rx, const MPD::Song &s);
  54
  55 }
  56
  57 void Playlist::Init()
  58 {
  59         Items = new NC::Menu<MPD::Song>(0, MainStartY, COLS, MainHeight, Config.columns_in_playlist && Config.titles_visibility ? Display::Columns(COLS) : "", Config.main_color, NC::brNone);
  60         Items->cyclicScrolling(Config.use_cyclic_scrolling);
  61         Items->centeredCursor(Config.centered_cursor);
  62         Items->setHighlightColor(Config.main_highlight_color);
  63         Items->setSelectedPrefix(Config.selected_item_prefix);
  64         Items->setSelectedSuffix(Config.selected_item_suffix);
  65         if (Config.columns_in_playlist)
  66                 Items->setItemDisplayer(std::bind(Display::SongsInColumns, _1, *this));
  67         else
  68                 Items->setItemDisplayer(std::bind(Display::Songs, _1, *this, Config.song_list_format));
  69
  70         if (!SortDialog)
  71         {
  72                 SortDialogHeight = std::min(int(MainHeight), 17);
  73
  74                 SortDialog = new NC::Menu< std::pair<std::string, MPD::Song::GetFunction> >((COLS-SortDialogWidth)/2, (MainHeight-SortDialogHeight)/2+MainStartY, SortDialogWidth, SortDialogHeight, "Sort songs by...", Config.main_color, Config.window_border);
  75                 SortDialog->cyclicScrolling(Config.use_cyclic_scrolling);
  76                 SortDialog->centeredCursor(Config.centered_cursor);
  77                 SortDialog->setItemDisplayer(Display::Pair<std::string, MPD::Song::GetFunction>);
  78
  79                 SortDialog->addItem(std::make_pair("Artist", &MPD::Song::getArtist));
  80                 SortDialog->addItem(std::make_pair("Album", &MPD::Song::getAlbum));
  81                 SortDialog->addItem(std::make_pair("Disc", &MPD::Song::getDisc));
  82                 SortDialog->addItem(std::make_pair("Track", &MPD::Song::getTrack));
  83                 SortDialog->addItem(std::make_pair("Genre", &MPD::Song::getGenre));
  84                 SortDialog->addItem(std::make_pair("Date", &MPD::Song::getDate));
  85                 SortDialog->addItem(std::make_pair("Composer", &MPD::Song::getComposer));
  86                 SortDialog->addItem(std::make_pair("Performer", &MPD::Song::getPerformer));
  87                 SortDialog->addItem(std::make_pair("Title", &MPD::Song::getTitle));
  88                 SortDialog->addItem(std::make_pair("Filename", &MPD::Song::getURI));
  89                 SortDialog->addSeparator();
  90                 SortDialog->addItem(std::make_pair("Sort", static_cast<MPD::Song::GetFunction>(0)));
  91                 SortDialog->addItem(std::make_pair("Cancel", static_cast<MPD::Song::GetFunction>(0)));
  92         }
  93
  94         w = Items;
  95         isInitialized = 1;
  96 }
  97
  98 void Playlist::SwitchTo()
  99 {
 100         using Global::myScreen;
 101         using Global::myLockedScreen;
 102         using Global::myInactiveScreen;
 103
 104         if (myScreen == this)
 105                 return;
 106
 107         if (!isInitialized)
 108                 Init();
 109
 110         itsScrollBegin = 0;
 111
 112         if (myLockedScreen)
 113                 UpdateInactiveScreen(this);
 114
 115         if (hasToBeResized || myLockedScreen)
 116                 Resize();
 117
 118         if (myScreen != this && myScreen->isTabbable())
 119                 Global::myPrevScreen = myScreen;
 120         myScreen = this;
 121         EnableHighlighting();
 122         if (w != Items) // even if sorting window is active, background has to be refreshed anyway
 123                 Items->display();
 124         Global::RedrawHeader = true;
 125 }
 126
 127 void Playlist::Resize()
 128 {
 129         size_t x_offset, width;
 130         GetWindowResizeParams(x_offset, width);
 131         Items->resize(width, MainHeight);
 132         Items->moveTo(x_offset, MainStartY);
 133
 134         Items->setTitle(Config.columns_in_playlist && Config.titles_visibility ? Display::Columns(Items->getWidth()) : "");
 135         if (w == SortDialog) // if sorting window is active, playlist needs refreshing
 136                 Items->display();
 137
 138         SortDialogHeight = std::min(int(MainHeight), 17);
 139         if (Items->getWidth() >= SortDialogWidth && MainHeight >= 5)
 140         {
 141                 SortDialog->resize(SortDialogWidth, SortDialogHeight);
 142                 SortDialog->moveTo(x_offset+(width-SortDialogWidth)/2, (MainHeight-SortDialogHeight)/2+MainStartY);
 143         }
 144         else // if screen is too low to display sorting window, fall back to items list
 145                 w = Items;
 146
 147         hasToBeResized = 0;
 148 }
 149
 150 std::basic_string<my_char_t> Playlist::Title()
 151 {
 152         std::basic_string<my_char_t> result = U("Playlist ");
 153         if (ReloadTotalLength || ReloadRemaining)
 154                 itsBufferedStats = TotalLength();
 155         result += Scroller(TO_WSTRING(itsBufferedStats), itsScrollBegin, COLS-result.length()-(Config.new_design ? 2 : Global::VolumeState.length()));
 156         return result;
 157 }
 158
 159 void Playlist::EnterPressed()
 160 {
 161         if (w == Items)
 162         {
 163                 if (!Items->empty())
 164                         Mpd.PlayID(Items->current().value().getID());
 165         }
 166         else if (w == SortDialog)
 167         {
 168                 size_t pos = SortDialog->choice();
 169
 170                 size_t beginning = 0;
 171                 size_t end = Items->size();
 172                 if (Items->hasSelected())
 173                 {
 174                         std::vector<size_t> list;
 175                         Items->getSelected(list);
 176                         beginning = *list.begin();
 177                         end = *list.rbegin()+1;
 178                 }
 179
 180                 if (pos > SortOptions)
 181                 {
 182                         if (pos == SortOptions+2) // cancel
 183                         {
 184                                 w = Items;
 185                                 return;
 186                         }
 187                 }
 188                 else
 189                 {
 190                         ShowMessage("Move tag types up and down to adjust sort order");
 191                         return;
 192                 }
 193
 194                 MPD::SongList playlist;
 195                 playlist.reserve(end-beginning);
 196                 for (size_t i = beginning; i < end; ++i)
 197                         playlist.push_back((*Items)[i].value());
 198
 199                 std::function<void(MPD::SongList::iterator, MPD::SongList::iterator)> iter_swap, quick_sort;
 200                 auto song_cmp = [](const MPD::Song &a, const MPD::Song &b) -> bool {
 201                         CaseInsensitiveStringComparison cmp;
 202                                 for (size_t i = 0; i < SortOptions; ++i)
 203                                         if (int ret = cmp(a.getTags((*SortDialog)[i].value().second), b.getTags((*SortDialog)[i].value().second)))
 204                                                 return ret < 0;
 205                                 return a.getPosition() < b.getPosition();
 206                 };
 207                 iter_swap = [&playlist](MPD::SongList::iterator a, MPD::SongList::iterator b) {
 208                         std::iter_swap(a, b);
 209                         Mpd.Swap(a-playlist.begin(), b-playlist.begin());
 210                 };
 211                 quick_sort = [this, &song_cmp, &quick_sort, &iter_swap](MPD::SongList::iterator first, MPD::SongList::iterator last) {
 212                         if (last-first > 1)
 213                         {
 214                                 MPD::SongList::iterator pivot = first+rand()%(last-first);
 215                                 iter_swap(pivot, last-1);
 216                                 pivot = last-1;
 217
 218                                 MPD::SongList::iterator tmp = first;
 219                                 for (MPD::SongList::iterator i = first; i != pivot; ++i)
 220                                         if (song_cmp(*i, *pivot))
 221                                                 iter_swap(i, tmp++);
 222                                 iter_swap(tmp, pivot);
 223
 224                                 quick_sort(first, tmp);
 225                                 quick_sort(tmp+1, last);
 226                         }
 227                 };
 228
 229                 ShowMessage("Sorting...");
 230                 Mpd.StartCommandsList();
 231                 quick_sort(playlist.begin(), playlist.end());
 232                 if (Mpd.CommitCommandsList())
 233                         ShowMessage("Playlist sorted");
 234                 w = Items;
 235         }
 236 }
 237
 238 void Playlist::SpacePressed()
 239 {
 240         if (w == Items && !Items->empty())
 241         {
 242                 Items->current().setSelected(!Items->current().isSelected());
 243                 Items->scroll(NC::wDown);
 244         }
 245 }
 246
 247 void Playlist::MouseButtonPressed(MEVENT me)
 248 {
 249         if (w == Items && !Items->empty() && Items->hasCoords(me.x, me.y))
 250         {
 251                 if (size_t(me.y) < Items->size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 252                 {
 253                         Items->Goto(me.y);
 254                         if (me.bstate & BUTTON3_PRESSED)
 255                                 EnterPressed();
 256                 }
 257                 else
 258                         Screen<NC::Window>::MouseButtonPressed(me);
 259         }
 260         else if (w == SortDialog && SortDialog->hasCoords(me.x, me.y))
 261         {
 262                 if (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED))
 263                 {
 264                         SortDialog->Goto(me.y);
 265                         if (me.bstate & BUTTON3_PRESSED)
 266                                 EnterPressed();
 267                 }
 268                 else
 269                         Screen<NC::Window>::MouseButtonPressed(me);
 270         }
 271 }
 272
 273 /***********************************************************************/
 274
 275 bool Playlist::allowsFiltering()
 276 {
 277         return true;
 278 }
 279
 280 std::string Playlist::currentFilter()
 281 {
 282         std::string filter;
 283         if (w == Items)
 284                 filter = RegexFilter<MPD::Song>::currentFilter(*Items);
 285         return filter;
 286 }
 287
 288 void Playlist::applyFilter(const std::string &filter)
 289 {
 290         if (w == Items)
 291         {
 292                 Items->showAll();
 293                 auto rx = RegexFilter<MPD::Song>(filter, Config.regex_type, playlistEntryMatcher);
 294                 Items->filter(Items->begin(), Items->end(), rx);
 295         }
 296 }
 297
 298 /***********************************************************************/
 299
 300 bool Playlist::allowsSearching()
 301 {
 302         return true;
 303 }
 304
 305 bool Playlist::search(const std::string &constraint)
 306 {
 307         bool result = false;
 308         if (w == Items)
 309         {
 310                 auto rx = RegexFilter<MPD::Song>(constraint, Config.regex_type, playlistEntryMatcher);
 311                 result = Items->search(Items->begin(), Items->end(), rx);
 312         }
 313         return result;
 314 }
 315
 316 void Playlist::nextFound(bool wrap)
 317 {
 318         if (w == Items)
 319                 Items->nextFound(wrap);
 320 }
 321
 322 void Playlist::prevFound(bool wrap)
 323 {
 324         if (w == Items)
 325                 Items->prevFound(wrap);
 326 }
 327
 328 /***********************************************************************/
 329
 330 std::shared_ptr<ProxySongList> Playlist::getProxySongList()
 331 {
 332         auto ptr = nullProxySongList();
 333         if (w == Items)
 334                 ptr = mkProxySongList(*Items, [](NC::Menu<MPD::Song>::Item &item) {
 335                         return &item.value();
 336                 });
 337         return ptr;
 338 }
 339
 340 MPD::Song *Playlist::getSong(size_t pos)
 341 {
 342         MPD::Song *ptr = 0;
 343         if (w == Items)
 344                 ptr = &(*Items)[pos].value();
 345         return ptr;
 346 }
 347
 348 MPD::Song *Playlist::currentSong()
 349 {
 350         if (Items->empty())
 351                 return 0;
 352         else
 353                 return getSong(Items->choice());
 354 }
 355
 356 bool Playlist::allowsSelection()
 357 {
 358         return w == Items;
 359 }
 360
 361 void Playlist::reverseSelection()
 362 {
 363         reverseSelectionHelper(Items->begin(), Items->end());
 364 }
 365
 366 MPD::SongList Playlist::getSelectedSongs()
 367 {
 368         MPD::SongList result;
 369         if (w == Items)
 370         {
 371                 for (auto it = Items->begin(); it != Items->end(); ++it)
 372                         if (it->isSelected())
 373                                 result.push_back(it->value());
 374                 if (result.empty() && !Items->empty())
 375                         result.push_back(Items->current().value());
 376         }
 377         return result;
 378 }
 379
 380 /***********************************************************************/
 381
 382
 383 bool Playlist::isFiltered()
 384 {
 385         if (Items->isFiltered())
 386         {
 387                 ShowMessage("Function currently unavailable due to filtered playlist");
 388                 return true;
 389         }
 390         return false;
 391 }
 392
 393 void Playlist::MoveSelectedItems(Movement where)
 394 {
 395         if (Items->empty() || isFiltered())
 396                 return;
 397
 398         switch (where)
 399         {
 400                 case mUp:
 401                 {
 402                         if (Items->hasSelected())
 403                         {
 404                                 std::vector<size_t> list;
 405                                 myPlaylist->Items->getSelected(list);
 406                                 if (list.front() > 0)
 407                                 {
 408                                         Mpd.StartCommandsList();
 409                                         std::vector<size_t>::const_iterator it = list.begin();
 410                                         for (; it != list.end(); ++it)
 411                                                 Mpd.Move(*it-1, *it);
 412                                         if (Mpd.CommitCommandsList())
 413                                         {
 414                                                 Items->at(list.back()).setSelected(false);
 415                                                 Items->at(list.front()-1).setSelected(true);
 416                                                 Items->highlight(list[(list.size()-1)/2]-1);
 417                                         }
 418                                 }
 419                         }
 420                         else
 421                         {
 422                                 size_t pos = myPlaylist->Items->choice();
 423                                 if (pos > 0)
 424                                 {
 425                                         if (Mpd.Move(pos-1, pos))
 426                                                 Items->scroll(NC::wUp);
 427                                 }
 428                         }
 429                         break;
 430                 }
 431                 case mDown:
 432                 {
 433                         if (Items->hasSelected())
 434                         {
 435                                 std::vector<size_t> list;
 436                                 Items->getSelected(list);
 437
 438                                 if (list.back() < Items->size()-1)
 439                                 {
 440                                         Mpd.StartCommandsList();
 441                                         std::vector<size_t>::const_reverse_iterator it = list.rbegin();
 442                                         for (; it != list.rend(); ++it)
 443                                                 Mpd.Move(*it, *it+1);
 444                                         if (Mpd.CommitCommandsList())
 445                                         {
 446                                                 Items->at(list.front()).setSelected(false);
 447                                                 Items->at(list.back()+1).setSelected(true);
 448                                                 Items->highlight(list[(list.size()-1)/2]+1);
 449                                         }
 450                                 }
 451                         }
 452                         else
 453                         {
 454                                 size_t pos = Items->choice();
 455                                 if (pos < Items->size()-1)
 456                                 {
 457                                         if (Mpd.Move(pos, pos+1))
 458                                                 Items->scroll(NC::wDown);
 459                                 }
 460                         }
 461                         break;
 462                 }
 463         }
 464 }
 465
 466 void Playlist::Sort()
 467 {
 468         if (isFiltered())
 469                 return;
 470         if (Items->getWidth() < SortDialogWidth || MainHeight < 5)
 471                 ShowMessage("Screen is too small to display dialog window");
 472         else
 473         {
 474                 SortDialog->reset();
 475                 w = SortDialog;
 476         }
 477 }
 478
 479 void Playlist::Reverse()
 480 {
 481         if (isFiltered())
 482                 return;
 483         ShowMessage("Reversing playlist order...");
 484         size_t beginning = -1, end = -1;
 485         for (size_t i = 0; i < Items->size(); ++i)
 486         {
 487                 if (Items->at(i).isSelected())
 488                 {
 489                         if (beginning == size_t(-1))
 490                                 beginning = i;
 491                         end = i;
 492                 }
 493         }
 494         if (beginning == size_t(-1)) // no selected items
 495         {
 496                 beginning = 0;
 497                 end = Items->size();
 498         }
 499         Mpd.StartCommandsList();
 500         for (size_t i = beginning, j = end-1; i < (beginning+end)/2; ++i, --j)
 501                 Mpd.Swap(i, j);
 502         if (Mpd.CommitCommandsList())
 503                  ShowMessage("Playlist reversed");
 504 }
 505
 506 void Playlist::AdjustSortOrder(Movement where)
 507 {
 508         switch (where)
 509         {
 510                 case mUp:
 511                 {
 512                         size_t pos = SortDialog->choice();
 513                         if (pos > 0 && pos < SortOptions)
 514                         {
 515                                 SortDialog->Swap(pos, pos-1);
 516                                 SortDialog->scroll(NC::wUp);
 517                         }
 518                         break;
 519                 }
 520                 case mDown:
 521                 {
 522                         size_t pos = SortDialog->choice();
 523                         if (pos < SortOptions-1)
 524                         {
 525                                 SortDialog->Swap(pos, pos+1);
 526                                 SortDialog->scroll(NC::wDown);
 527                         }
 528                         break;
 529                 }
 530         }
 531 }
 532
 533 void Playlist::EnableHighlighting()
 534 {
 535         Items->setHighlighting(1);
 536         UpdateTimer();
 537 }
 538
 539 bool Playlist::SortingInProgress()
 540 {
 541         return w == SortDialog;
 542 }
 543
 544 std::string Playlist::TotalLength()
 545 {
 546         std::ostringstream result;
 547
 548         if (ReloadTotalLength)
 549         {
 550                 itsTotalLength = 0;
 551                 for (size_t i = 0; i < Items->size(); ++i)
 552                         itsTotalLength += (*Items)[i].value().getDuration();
 553                 ReloadTotalLength = 0;
 554         }
 555         if (Config.playlist_show_remaining_time && ReloadRemaining && !Items->isFiltered())
 556         {
 557                 itsRemainingTime = 0;
 558                 for (size_t i = NowPlaying; i < Items->size(); ++i)
 559                         itsRemainingTime += (*Items)[i].value().getDuration();
 560                 ReloadRemaining = false;
 561         }
 562
 563         result << '(' << Items->size() << (Items->size() == 1 ? " item" : " items");
 564
 565         if (Items->isFiltered())
 566         {
 567                 Items->showAll();
 568                 size_t real_size = Items->size();
 569                 Items->showFiltered();
 570                 if (Items->size() != real_size)
 571                         result << " (out of " << Mpd.GetPlaylistLength() << ")";
 572         }
 573
 574         if (itsTotalLength)
 575         {
 576                 result << ", length: ";
 577                 ShowTime(result, itsTotalLength, Config.playlist_shorten_total_times);
 578         }
 579         if (Config.playlist_show_remaining_time && itsRemainingTime && !Items->isFiltered() && Items->size() > 1)
 580         {
 581                 result << " :: remaining: ";
 582                 ShowTime(result, itsRemainingTime, Config.playlist_shorten_total_times);
 583         }
 584         result << ')';
 585         return result.str();
 586 }
 587
 588 const MPD::Song *Playlist::NowPlayingSong()
 589 {
 590         bool was_filtered = Items->isFiltered();
 591         Items->showAll();
 592         const MPD::Song *s = isPlaying() ? &Items->at(NowPlaying).value() : 0;
 593         if (was_filtered)
 594                 Items->showFiltered();
 595         return s;
 596 }
 597
 598 bool Playlist::Add(const MPD::Song &s, bool in_playlist, bool play, int position)
 599 {
 600         if (Config.ncmpc_like_songs_adding && in_playlist)
 601         {
 602                 unsigned hash = s.getHash();
 603                 if (play)
 604                 {
 605                         for (size_t i = 0; i < Items->size(); ++i)
 606                         {
 607                                 if (Items->at(i).value().getHash() == hash)
 608                                 {
 609                                         Mpd.Play(i);
 610                                         break;
 611                                 }
 612                         }
 613                         return true;
 614                 }
 615                 else
 616                 {
 617                         Mpd.StartCommandsList();
 618                         for (size_t i = 0; i < Items->size(); ++i)
 619                         {
 620                                 if ((*Items)[i].value().getHash() == hash)
 621                                 {
 622                                         Mpd.Delete(i);
 623                                         Items->deleteItem(i);
 624                                         i--;
 625                                 }
 626                         }
 627                         Mpd.CommitCommandsList();
 628                         return false;
 629                 }
 630         }
 631         else
 632         {
 633                 int id = Mpd.AddSong(s, position);
 634                 if (id >= 0)
 635                 {
 636                         ShowMessage("Added to playlist: %s", s.toString(Config.song_status_format_no_colors).c_str());
 637                         if (play)
 638                                 Mpd.PlayID(id);
 639                         return true;
 640                 }
 641                 else
 642                         return false;
 643         }
 644 }
 645
 646 bool Playlist::Add(const MPD::SongList &l, bool play, int position)
 647 {
 648         if (l.empty())
 649                 return false;
 650
 651         Mpd.StartCommandsList();
 652         if (position < 0)
 653         {
 654                 for (auto it = l.begin(); it != l.end(); ++it)
 655                         if (Mpd.AddSong(*it) < 0)
 656                                 break;
 657         }
 658         else
 659         {
 660                 for (auto j = l.rbegin(); j != l.rend(); ++j)
 661                         if (Mpd.AddSong(*j, position) < 0)
 662                                 break;
 663         }
 664         if (!Mpd.CommitCommandsList())
 665                 return false;
 666         if (play)
 667                 PlayNewlyAddedSongs();
 668         return true;
 669 }
 670
 671 void Playlist::PlayNewlyAddedSongs()
 672 {
 673         bool is_filtered = Items->isFiltered();
 674         Items->showAll();
 675         size_t old_size = Items->size();
 676         Mpd.UpdateStatus();
 677         if (old_size < Items->size())
 678                 Mpd.Play(old_size);
 679         if (is_filtered)
 680                 Items->showFiltered();
 681 }
 682
 683 void Playlist::SetSelectedItemsPriority(int prio)
 684 {
 685         std::vector<size_t> list;
 686         myPlaylist->Items->getSelected(list);
 687         if (list.empty())
 688                 list.push_back(Items->choice());
 689         Mpd.StartCommandsList();
 690         for (std::vector<size_t>::const_iterator it = list.begin(); it != list.end(); ++it)
 691                 Mpd.SetPriority((*Items)[*it].value(), prio);
 692         if (Mpd.CommitCommandsList())
 693                 ShowMessage("Priority set");
 694 }
 695
 696 bool Playlist::checkForSong (const MPD::Song &s)
 697 {
 698         for (size_t i = 0; i < Items->size(); ++i)
 699                 if (s.getHash() == (*Items)[i].value().getHash())
 700                         return true;
 701         return false;
 702 }
 703
 704 namespace {//
 705
 706 std::string songToString(const MPD::Song &s)
 707 {
 708         std::string result;
 709         if (Config.columns_in_playlist)
 710                 result = s.toString(Config.song_in_columns_to_string_format);
 711         else
 712                 result = s.toString(Config.song_list_format_dollar_free);
 713         return result;
 714 }
 715
 716 bool playlistEntryMatcher(const Regex &rx, const MPD::Song &s)
 717 {
 718         return rx.match(songToString(s));
 719 }
 720
 721 }