src/screens/search_engine.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 <array>
  22 #include <boost/range/detail/any_iterator.hpp>
  23 #include <iomanip>
  24
  25 #include "curses/menu_impl.h"
  26 #include "display.h"
  27 #include "global.h"
  28 #include "helpers.h"
  29 #include "screens/playlist.h"
  30 #include "screens/search_engine.h"
  31 #include "settings.h"
  32 #include "status.h"
  33 #include "statusbar.h"
  34 #include "helpers/song_iterator_maker.h"
  35 #include "utility/comparators.h"
  36 #include "title.h"
  37 #include "screens/screen_switcher.h"
  38
  39 using Global::MainHeight;
  40 using Global::MainStartY;
  41
  42 namespace ph = std::placeholders;
  43
  44 SearchEngine *mySearcher;
  45
  46 namespace {
  47
  48 /*const std::array<const std::string, 11> constraintsNames = {{
  49         "Any",
  50         "Artist",
  51         "Album Artist",
  52         "Title",
  53         "Album",
  54         "Filename",
  55         "Composer",
  56         "Performer",
  57         "Genre",
  58         "Date",
  59         "Comment"
  60 }};
  61
  62 const std::array<const char *, 3> searchModes = {{
  63         "Match if tag contains searched phrase (no regexes)",
  64         "Match if tag contains searched phrase (regexes supported)",
  65         "Match only if both values are the same"
  66 }};
  67
  68 namespace pos {
  69         const size_t searchIn = constraintsNames.size()-1+1+1; // separated
  70         const size_t searchMode = searchIn+1;
  71         const size_t search = searchMode+1+1; // separated
  72         const size_t reset = search+1;
  73 }*/
  74
  75 std::string SEItemToString(const SEItem &ei);
  76 bool SEItemEntryMatcher(const Regex::Regex &rx,
  77                         const NC::Menu<SEItem>::Item &item,
  78                         bool filter);
  79
  80 }
  81
  82 template <>
  83 struct SongPropertiesExtractor<SEItem>
  84 {
  85         template <typename ItemT>
  86         auto &operator()(ItemT &item) const
  87         {
  88                 auto s = !item.isSeparator() && item.value().isSong()
  89                         ? &item.value().song()
  90                         : nullptr;
  91                 return m_cache.assign(&item.properties(), s);
  92         }
  93
  94 private:
  95         mutable SongProperties m_cache;
  96 };
  97
  98 SongIterator SearchEngineWindow::currentS()
  99 {
 100         return makeSongIterator(current());
 101 }
 102
 103 ConstSongIterator SearchEngineWindow::currentS() const
 104 {
 105         return makeConstSongIterator(current());
 106 }
 107
 108 SongIterator SearchEngineWindow::beginS()
 109 {
 110         return makeSongIterator(begin());
 111 }
 112
 113 ConstSongIterator SearchEngineWindow::beginS() const
 114 {
 115         return makeConstSongIterator(begin());
 116 }
 117
 118 SongIterator SearchEngineWindow::endS()
 119 {
 120         return makeSongIterator(end());
 121 }
 122
 123 ConstSongIterator SearchEngineWindow::endS() const
 124 {
 125         return makeConstSongIterator(end());
 126 }
 127
 128 std::vector<MPD::Song> SearchEngineWindow::getSelectedSongs()
 129 {
 130         std::vector<MPD::Song> result;
 131         for (auto &item : *this)
 132         {
 133                 if (item.isSelected())
 134                 {
 135                         assert(item.value().isSong());
 136                         result.push_back(item.value().song());
 137                 }
 138         }
 139         // If no item is selected, add the current one if it's a song.
 140         if (result.empty() && !empty() && current()->value().isSong())
 141                 result.push_back(current()->value().song());
 142         return result;
 143 }
 144
 145 /**********************************************************************/
 146
 147 const char *SearchEngine::ConstraintsNames[] =
 148 {
 149         "Any",
 150         "Artist",
 151         "Album Artist",
 152         "Title",
 153         "Album",
 154         "Filename",
 155         "Composer",
 156         "Performer",
 157         "Genre",
 158         "Date",
 159         "Comment"
 160 };
 161
 162 const char *SearchEngine::SearchModes[] =
 163 {
 164         "Match if tag contains searched phrase (no regexes)",
 165         "Match if tag contains searched phrase (regexes supported)",
 166         "Match only if both values are the same",
 167         0
 168 };
 169
 170 size_t SearchEngine::StaticOptions = 20;
 171 size_t SearchEngine::ResetButton = 16;
 172 size_t SearchEngine::SearchButton = 15;
 173
 174 SearchEngine::SearchEngine()
 175 : Screen(NC::Menu<SEItem>(0, MainStartY, COLS, MainHeight, "", Config.main_color, NC::Border()))
 176 {
 177         w.setHighlightColor(Config.main_highlight_color);
 178         w.cyclicScrolling(Config.use_cyclic_scrolling);
 179         w.centeredCursor(Config.centered_cursor);
 180         w.setItemDisplayer(std::bind(Display::SEItems, ph::_1, std::cref(w)));
 181         w.setSelectedPrefix(Config.selected_item_prefix);
 182         w.setSelectedSuffix(Config.selected_item_suffix);
 183         SearchMode = &SearchModes[Config.search_engine_default_search_mode];
 184 }
 185
 186 void SearchEngine::resize()
 187 {
 188         size_t x_offset, width;
 189         getWindowResizeParams(x_offset, width);
 190         w.resize(width, MainHeight);
 191         w.moveTo(x_offset, MainStartY);
 192         switch (Config.search_engine_display_mode)
 193         {
 194                 case DisplayMode::Columns:
 195                         if (Config.titles_visibility)
 196                         {
 197                                 w.setTitle(Display::Columns(w.getWidth()));
 198                                 break;
 199                         }
 200                 case DisplayMode::Classic:
 201                         w.setTitle("");
 202         }
 203         hasToBeResized = 0;
 204 }
 205
 206 void SearchEngine::switchTo()
 207 {
 208         SwitchTo::execute(this);
 209         if (w.empty())
 210                 Prepare();
 211         markSongsInPlaylist(w);
 212         drawHeader();
 213 }
 214
 215 std::wstring SearchEngine::title()
 216 {
 217         return L"Search engine";
 218 }
 219
 220 void SearchEngine::mouseButtonPressed(MEVENT me)
 221 {
 222         if (w.empty() || !w.hasCoords(me.x, me.y) || size_t(me.y) >= w.size())
 223                 return;
 224         if (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED))
 225         {
 226                 if (!w.Goto(me.y))
 227                         return;
 228                 w.refresh();
 229                 if ((me.bstate & BUTTON3_PRESSED)
 230                     && w.choice() < StaticOptions)
 231                         runAction();
 232                 else if (w.choice() >= StaticOptions)
 233                 {
 234                         bool play = me.bstate & BUTTON3_PRESSED;
 235                         addItemToPlaylist(play);
 236                 }
 237         }
 238         else
 239                 Screen<WindowType>::mouseButtonPressed(me);
 240 }
 241
 242 /***********************************************************************/
 243
 244 bool SearchEngine::allowsSearching()
 245 {
 246         return w.rbegin()->value().isSong();
 247 }
 248
 249 const std::string &SearchEngine::searchConstraint()
 250 {
 251         return m_search_predicate.constraint();
 252 }
 253
 254 void SearchEngine::setSearchConstraint(const std::string &constraint)
 255 {
 256         m_search_predicate = Regex::ItemFilter<SEItem>(
 257                 constraint,
 258                 Config.regex_type,
 259                 std::bind(SEItemEntryMatcher, ph::_1, ph::_2, false));
 260 }
 261
 262 void SearchEngine::clearSearchConstraint()
 263 {
 264         m_search_predicate.clear();
 265 }
 266
 267 bool SearchEngine::search(SearchDirection direction, bool wrap, bool skip_current)
 268 {
 269         return ::search(w, m_search_predicate, direction, wrap, skip_current);
 270 }
 271
 272 /***********************************************************************/
 273
 274 bool SearchEngine::allowsFiltering()
 275 {
 276         return allowsSearching();
 277 }
 278
 279 std::string SearchEngine::currentFilter()
 280 {
 281         std::string result;
 282         if (auto pred = w.filterPredicate<Regex::ItemFilter<SEItem>>())
 283                 result = pred->constraint();
 284         return result;
 285 }
 286
 287 void SearchEngine::applyFilter(const std::string &constraint)
 288 {
 289         if (!constraint.empty())
 290         {
 291                 w.applyFilter(Regex::ItemFilter<SEItem>(
 292                                       constraint,
 293                                       Config.regex_type,
 294                                       std::bind(SEItemEntryMatcher, ph::_1, ph::_2, true)));
 295         }
 296         else
 297                 w.clearFilter();
 298 }
 299
 300 /***********************************************************************/
 301
 302 bool SearchEngine::actionRunnable()
 303 {
 304         return !w.empty() && !w.current()->value().isSong();
 305 }
 306
 307 void SearchEngine::runAction()
 308 {
 309         size_t option = w.choice();
 310         if (option > ConstraintsNumber && option < SearchButton)
 311                 w.current()->value().buffer().clear();
 312
 313         if (option < ConstraintsNumber)
 314         {
 315                 Statusbar::ScopedLock slock;
 316                 std::string constraint = ConstraintsNames[option];
 317                 Statusbar::put() << NC::Format::Bold << constraint << NC::Format::NoBold << ": ";
 318                 itsConstraints[option] = Global::wFooter->prompt(itsConstraints[option]);
 319                 w.current()->value().buffer().clear();
 320                 constraint.resize(13, ' ');
 321                 w.current()->value().buffer() << NC::Format::Bold << constraint << NC::Format::NoBold << ": ";
 322                 ShowTag(w.current()->value().buffer(), itsConstraints[option]);
 323         }
 324         else if (option == ConstraintsNumber+1)
 325         {
 326                 Config.search_in_db = !Config.search_in_db;
 327                 w.current()->value().buffer() << NC::Format::Bold << "Search in:" << NC::Format::NoBold << ' ' << (Config.search_in_db ? "Database" : "Current playlist");
 328         }
 329         else if (option == ConstraintsNumber+2)
 330         {
 331                 if (!*++SearchMode)
 332                         SearchMode = &SearchModes[0];
 333                 w.current()->value().buffer() << NC::Format::Bold << "Search mode:" << NC::Format::NoBold << ' ' << *SearchMode;
 334         }
 335         else if (option == SearchButton)
 336         {
 337                 w.clearFilter();
 338                 Statusbar::print("Searching...");
 339                 if (w.size() > StaticOptions)
 340                         Prepare();
 341                 Search();
 342                 if (w.rbegin()->value().isSong())
 343                 {
 344                         if (Config.search_engine_display_mode == DisplayMode::Columns)
 345                                 w.setTitle(Config.titles_visibility ? Display::Columns(w.getWidth()) : "");
 346                         size_t found = w.size()-SearchEngine::StaticOptions;
 347                         found += 3; // don't count options inserted below
 348                         w.insertSeparator(ResetButton+1);
 349                         w.insertItem(ResetButton+2, SEItem(), NC::List::Properties::Bold | NC::List::Properties::Inactive);
 350                         w.at(ResetButton+2).value().mkBuffer()
 351                                 << Config.color1
 352                                 << "Search results: "
 353                                 << NC::FormattedColor::End(Config.color1)
 354                                 << Config.color2
 355                                 << "Found " << found << (found > 1 ? " songs" : " song")
 356                                 << NC::FormattedColor::End(Config.color2);
 357                         w.insertSeparator(ResetButton+3);
 358                         markSongsInPlaylist(w);
 359                         Statusbar::print("Searching finished");
 360                         if (Config.block_search_constraints_change)
 361                                 for (size_t i = 0; i < StaticOptions-4; ++i)
 362                                         w.at(i).setInactive(true);
 363                         w.scroll(NC::Scroll::Down);
 364                         w.scroll(NC::Scroll::Down);
 365                 }
 366                 else
 367                         Statusbar::print("No results found");
 368         }
 369         else if (option == ResetButton)
 370         {
 371                 reset();
 372         }
 373         else
 374                 addSongToPlaylist(w.current()->value().song(), true);
 375 }
 376
 377 /***********************************************************************/
 378
 379 bool SearchEngine::itemAvailable()
 380 {
 381         return !w.empty() && w.current()->value().isSong();
 382 }
 383
 384 bool SearchEngine::addItemToPlaylist(bool play)
 385 {
 386         return addSongToPlaylist(w.current()->value().song(), play);
 387 }
 388
 389 std::vector<MPD::Song> SearchEngine::getSelectedSongs()
 390 {
 391         return w.getSelectedSongs();
 392 }
 393
 394 /***********************************************************************/
 395
 396 void SearchEngine::Prepare()
 397 {
 398         w.setTitle("");
 399         w.clear();
 400         w.resizeList(StaticOptions-3);
 401
 402         for (auto &item : w)
 403                 item.setSelectable(false);
 404
 405         w.at(ConstraintsNumber).setSeparator(true);
 406         w.at(SearchButton-1).setSeparator(true);
 407
 408         for (size_t i = 0; i < ConstraintsNumber; ++i)
 409         {
 410                 std::string constraint = ConstraintsNames[i];
 411                 constraint.resize(13, ' ');
 412                 w[i].value().mkBuffer() << NC::Format::Bold << constraint << NC::Format::NoBold << ": ";
 413                 ShowTag(w[i].value().buffer(), itsConstraints[i]);
 414         }
 415
 416         w.at(ConstraintsNumber+1).value().mkBuffer() << NC::Format::Bold << "Search in:" << NC::Format::NoBold << ' ' << (Config.search_in_db ? "Database" : "Current playlist");
 417         w.at(ConstraintsNumber+2).value().mkBuffer() << NC::Format::Bold << "Search mode:" << NC::Format::NoBold << ' ' << *SearchMode;
 418
 419         w.at(SearchButton).value().mkBuffer() << "Search";
 420         w.at(ResetButton).value().mkBuffer() << "Reset";
 421 }
 422
 423 void SearchEngine::reset()
 424 {
 425         for (size_t i = 0; i < ConstraintsNumber; ++i)
 426                 itsConstraints[i].clear();
 427         w.reset();
 428         Prepare();
 429         Statusbar::print("Search state reset");
 430 }
 431
 432 void SearchEngine::Search()
 433 {
 434         bool constraints_empty = 1;
 435         for (size_t i = 0; i < ConstraintsNumber; ++i)
 436         {
 437                 if (!itsConstraints[i].empty())
 438                 {
 439                         constraints_empty = 0;
 440                         break;
 441                 }
 442         }
 443         if (constraints_empty)
 444                 return;
 445
 446         if (Config.search_in_db && (SearchMode == &SearchModes[0] || SearchMode == &SearchModes[2])) // use built-in mpd searching
 447         {
 448                 Mpd.StartSearch(SearchMode == &SearchModes[2]);
 449                 if (!itsConstraints[0].empty())
 450                         Mpd.AddSearchAny(itsConstraints[0]);
 451                 if (!itsConstraints[1].empty())
 452                         Mpd.AddSearch(MPD_TAG_ARTIST, itsConstraints[1]);
 453                 if (!itsConstraints[2].empty())
 454                         Mpd.AddSearch(MPD_TAG_ALBUM_ARTIST, itsConstraints[2]);
 455                 if (!itsConstraints[3].empty())
 456                         Mpd.AddSearch(MPD_TAG_TITLE, itsConstraints[3]);
 457                 if (!itsConstraints[4].empty())
 458                         Mpd.AddSearch(MPD_TAG_ALBUM, itsConstraints[4]);
 459                 if (!itsConstraints[5].empty())
 460                         Mpd.AddSearchURI(itsConstraints[5]);
 461                 if (!itsConstraints[6].empty())
 462                         Mpd.AddSearch(MPD_TAG_COMPOSER, itsConstraints[6]);
 463                 if (!itsConstraints[7].empty())
 464                         Mpd.AddSearch(MPD_TAG_PERFORMER, itsConstraints[7]);
 465                 if (!itsConstraints[8].empty())
 466                         Mpd.AddSearch(MPD_TAG_GENRE, itsConstraints[8]);
 467                 if (!itsConstraints[9].empty())
 468                         Mpd.AddSearch(MPD_TAG_DATE, itsConstraints[9]);
 469                 if (!itsConstraints[10].empty())
 470                         Mpd.AddSearch(MPD_TAG_COMMENT, itsConstraints[10]);
 471                 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s)
 472                         w.addItem(std::move(*s));
 473                 return;
 474         }
 475
 476         Regex::Regex rx[ConstraintsNumber];
 477         if (SearchMode != &SearchModes[2]) // match to pattern
 478         {
 479                 for (size_t i = 0; i < ConstraintsNumber; ++i)
 480                 {
 481                         if (!itsConstraints[i].empty())
 482                         {
 483                                 try
 484                                 {
 485                                         rx[i] = Regex::make(itsConstraints[i], Config.regex_type);
 486                                 }
 487                                 catch (boost::bad_expression &) { }
 488                         }
 489                 }
 490         }
 491
 492         typedef boost::range_detail::any_iterator<
 493                 const MPD::Song,
 494                 boost::single_pass_traversal_tag,
 495                 const MPD::Song &,
 496                 std::ptrdiff_t
 497         > input_song_iterator;
 498         input_song_iterator s, end;
 499         if (Config.search_in_db)
 500         {
 501                 s = input_song_iterator(getDatabaseIterator(Mpd));
 502                 end = input_song_iterator(MPD::SongIterator());
 503         }
 504         else
 505         {
 506                 s = input_song_iterator(myPlaylist->main().beginV());
 507                 end = input_song_iterator(myPlaylist->main().endV());
 508         }
 509
 510         LocaleStringComparison cmp(std::locale(), Config.ignore_leading_the);
 511         for (; s != end; ++s)
 512         {
 513                 bool any_found = true, found = true;
 514
 515                 if (SearchMode != &SearchModes[2]) // match to pattern
 516                 {
 517                         if (!rx[0].empty())
 518                                 any_found =
 519                                    Regex::search(s->getArtist(), rx[0])
 520                                 || Regex::search(s->getAlbumArtist(), rx[0])
 521                                 || Regex::search(s->getTitle(), rx[0])
 522                                 || Regex::search(s->getAlbum(), rx[0])
 523                                 || Regex::search(s->getName(), rx[0])
 524                                 || Regex::search(s->getComposer(), rx[0])
 525                                 || Regex::search(s->getPerformer(), rx[0])
 526                                 || Regex::search(s->getGenre(), rx[0])
 527                                 || Regex::search(s->getDate(), rx[0])
 528                                 || Regex::search(s->getComment(), rx[0]);
 529                         if (found && !rx[1].empty())
 530                                 found = Regex::search(s->getArtist(), rx[1]);
 531                         if (found && !rx[2].empty())
 532                                 found = Regex::search(s->getAlbumArtist(), rx[2]);
 533                         if (found && !rx[3].empty())
 534                                 found = Regex::search(s->getTitle(), rx[3]);
 535                         if (found && !rx[4].empty())
 536                                 found = Regex::search(s->getAlbum(), rx[4]);
 537                         if (found && !rx[5].empty())
 538                                 found = Regex::search(s->getName(), rx[5]);
 539                         if (found && !rx[6].empty())
 540                                 found = Regex::search(s->getComposer(), rx[6]);
 541                         if (found && !rx[7].empty())
 542                                 found = Regex::search(s->getPerformer(), rx[7]);
 543                         if (found && !rx[8].empty())
 544                                 found = Regex::search(s->getGenre(), rx[8]);
 545                         if (found && !rx[9].empty())
 546                                 found = Regex::search(s->getDate(), rx[9]);
 547                         if (found && !rx[10].empty())
 548                                 found = Regex::search(s->getComment(), rx[10]);
 549                 }
 550                 else // match only if values are equal
 551                 {
 552                         if (!itsConstraints[0].empty())
 553                                 any_found =
 554                                    !cmp(s->getArtist(), itsConstraints[0])
 555                                 || !cmp(s->getAlbumArtist(), itsConstraints[0])
 556                                 || !cmp(s->getTitle(), itsConstraints[0])
 557                                 || !cmp(s->getAlbum(), itsConstraints[0])
 558                                 || !cmp(s->getName(), itsConstraints[0])
 559                                 || !cmp(s->getComposer(), itsConstraints[0])
 560                                 || !cmp(s->getPerformer(), itsConstraints[0])
 561                                 || !cmp(s->getGenre(), itsConstraints[0])
 562                                 || !cmp(s->getDate(), itsConstraints[0])
 563                                 || !cmp(s->getComment(), itsConstraints[0]);
 564
 565                         if (found && !itsConstraints[1].empty())
 566                                 found = !cmp(s->getArtist(), itsConstraints[1]);
 567                         if (found && !itsConstraints[2].empty())
 568                                 found = !cmp(s->getAlbumArtist(), itsConstraints[2]);
 569                         if (found && !itsConstraints[3].empty())
 570                                 found = !cmp(s->getTitle(), itsConstraints[3]);
 571                         if (found && !itsConstraints[4].empty())
 572                                 found = !cmp(s->getAlbum(), itsConstraints[4]);
 573                         if (found && !itsConstraints[5].empty())
 574                                 found = !cmp(s->getName(), itsConstraints[5]);
 575                         if (found && !itsConstraints[6].empty())
 576                                 found = !cmp(s->getComposer(), itsConstraints[6]);
 577                         if (found && !itsConstraints[7].empty())
 578                                 found = !cmp(s->getPerformer(), itsConstraints[7]);
 579                         if (found && !itsConstraints[8].empty())
 580                                 found = !cmp(s->getGenre(), itsConstraints[8]);
 581                         if (found && !itsConstraints[9].empty())
 582                                 found = !cmp(s->getDate(), itsConstraints[9]);
 583                         if (found && !itsConstraints[10].empty())
 584                                 found = !cmp(s->getComment(), itsConstraints[10]);
 585                 }
 586
 587                 if (any_found && found)
 588                         w.addItem(*s);
 589         }
 590 }
 591
 592 namespace {
 593
 594 std::string SEItemToString(const SEItem &ei)
 595 {
 596         std::string result;
 597         if (ei.isSong())
 598         {
 599                 switch (Config.search_engine_display_mode)
 600                 {
 601                         case DisplayMode::Classic:
 602                                 result = Format::stringify<char>(Config.song_list_format, &ei.song());
 603                                 break;
 604                         case DisplayMode::Columns:
 605                                 result = Format::stringify<char>(Config.song_columns_mode_format, &ei.song());
 606                                 break;
 607                 }
 608         }
 609         else
 610                 result = ei.buffer().str();
 611         return result;
 612 }
 613
 614 bool SEItemEntryMatcher(const Regex::Regex &rx, const NC::Menu<SEItem>::Item &item, bool filter)
 615 {
 616         if (item.isSeparator() || !item.value().isSong())
 617                 return filter;
 618         return Regex::search(SEItemToString(item.value()), rx);
 619 }
 620
 621 }