src/search_engine.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2014 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 "display.h"
  26 #include "global.h"
  27 #include "helpers.h"
  28 #include "menu_impl.h"
  29 #include "playlist.h"
  30 #include "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 "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, const NC::Menu<SEItem>::Item &item, bool filter);
  77
  78 template <bool Const>
  79 struct SongExtractor
  80 {
  81         typedef SongExtractor type;
  82
  83         typedef typename NC::Menu<SEItem>::Item MenuItem;
  84         typedef typename std::conditional<Const, const MenuItem, MenuItem>::type Item;
  85         typedef typename std::conditional<Const, const MPD::Song, MPD::Song>::type Song;
  86
  87         Song *operator()(Item &item) const
  88         {
  89                 Song *ptr = nullptr;
  90                 if (!item.isSeparator() && item.value().isSong())
  91                         ptr = &item.value().song();
  92                 return ptr;
  93         }
  94 };
  95
  96 }
  97
  98 SongIterator SearchEngineWindow::currentS()
  99 {
 100         return makeSongIterator_<SEItem>(current(), SongExtractor<false>());
 101 }
 102
 103 ConstSongIterator SearchEngineWindow::currentS() const
 104 {
 105         return makeConstSongIterator_<SEItem>(current(), SongExtractor<true>());
 106 }
 107
 108 SongIterator SearchEngineWindow::beginS()
 109 {
 110         return makeSongIterator_<SEItem>(begin(), SongExtractor<false>());
 111 }
 112
 113 ConstSongIterator SearchEngineWindow::beginS() const
 114 {
 115         return makeConstSongIterator_<SEItem>(begin(), SongExtractor<true>());
 116 }
 117
 118 SongIterator SearchEngineWindow::endS()
 119 {
 120         return makeSongIterator_<SEItem>(end(), SongExtractor<false>());
 121 }
 122
 123 ConstSongIterator SearchEngineWindow::endS() const
 124 {
 125         return makeConstSongIterator_<SEItem>(end(), SongExtractor<true>());
 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 void SearchEngine::setSearchConstraint(const std::string &constraint)
 250 {
 251         m_search_predicate = Regex::ItemFilter<SEItem>(
 252                 Regex::make(constraint, Config.regex_type),
 253                 std::bind(SEItemEntryMatcher, ph::_1, ph::_2, false)
 254         );
 255 }
 256
 257 void SearchEngine::clearConstraint()
 258 {
 259         m_search_predicate.clear();
 260 }
 261
 262 bool SearchEngine::find(SearchDirection direction, bool wrap, bool skip_current)
 263 {
 264         return search(w, m_search_predicate, direction, wrap, skip_current);
 265 }
 266
 267 /***********************************************************************/
 268
 269 bool SearchEngine::actionRunnable()
 270 {
 271         return !w.empty() && !w.current()->value().isSong();
 272 }
 273
 274 void SearchEngine::runAction()
 275 {
 276         size_t option = w.choice();
 277         if (option > ConstraintsNumber && option < SearchButton)
 278                 w.current()->value().buffer().clear();
 279
 280         if (option < ConstraintsNumber)
 281         {
 282                 Statusbar::ScopedLock slock;
 283                 std::string constraint = ConstraintsNames[option];
 284                 Statusbar::put() << NC::Format::Bold << constraint << NC::Format::NoBold << ": ";
 285                 itsConstraints[option] = Global::wFooter->prompt(itsConstraints[option]);
 286                 w.current()->value().buffer().clear();
 287                 constraint.resize(13, ' ');
 288                 w.current()->value().buffer() << NC::Format::Bold << constraint << NC::Format::NoBold << ": ";
 289                 ShowTag(w.current()->value().buffer(), itsConstraints[option]);
 290         }
 291         else if (option == ConstraintsNumber+1)
 292         {
 293                 Config.search_in_db = !Config.search_in_db;
 294                 w.current()->value().buffer() << NC::Format::Bold << "Search in:" << NC::Format::NoBold << ' ' << (Config.search_in_db ? "Database" : "Current playlist");
 295         }
 296         else if (option == ConstraintsNumber+2)
 297         {
 298                 if (!*++SearchMode)
 299                         SearchMode = &SearchModes[0];
 300                 w.current()->value().buffer() << NC::Format::Bold << "Search mode:" << NC::Format::NoBold << ' ' << *SearchMode;
 301         }
 302         else if (option == SearchButton)
 303         {
 304                 Statusbar::print("Searching...");
 305                 if (w.size() > StaticOptions)
 306                         Prepare();
 307                 Search();
 308                 if (w.rbegin()->value().isSong())
 309                 {
 310                         if (Config.search_engine_display_mode == DisplayMode::Columns)
 311                                 w.setTitle(Config.titles_visibility ? Display::Columns(w.getWidth()) : "");
 312                         size_t found = w.size()-SearchEngine::StaticOptions;
 313                         found += 3; // don't count options inserted below
 314                         w.insertSeparator(ResetButton+1);
 315                         w.insertItem(ResetButton+2, SEItem(), NC::List::Properties::Bold | NC::List::Properties::Inactive);
 316                         w.at(ResetButton+2).value().mkBuffer() << Config.color1 << "Search results: " << Config.color2 << "Found " << found << (found > 1 ? " songs" : " song") << NC::Color::Default;
 317                         w.insertSeparator(ResetButton+3);
 318                         markSongsInPlaylist(w);
 319                         Statusbar::print("Searching finished");
 320                         if (Config.block_search_constraints_change)
 321                                 for (size_t i = 0; i < StaticOptions-4; ++i)
 322                                         w.at(i).setInactive(true);
 323                         w.scroll(NC::Scroll::Down);
 324                         w.scroll(NC::Scroll::Down);
 325                 }
 326                 else
 327                         Statusbar::print("No results found");
 328         }
 329         else if (option == ResetButton)
 330         {
 331                 reset();
 332         }
 333         else
 334                 addSongToPlaylist(w.current()->value().song(), true);
 335 }
 336
 337 /***********************************************************************/
 338
 339 bool SearchEngine::itemAvailable()
 340 {
 341         return !w.empty() && w.current()->value().isSong();
 342 }
 343
 344 bool SearchEngine::addItemToPlaylist(bool play)
 345 {
 346         return addSongToPlaylist(w.current()->value().song(), play);
 347 }
 348
 349 std::vector<MPD::Song> SearchEngine::getSelectedSongs()
 350 {
 351         return w.getSelectedSongs();
 352 }
 353
 354 /***********************************************************************/
 355
 356 void SearchEngine::Prepare()
 357 {
 358         w.setTitle("");
 359         w.clear();
 360         w.resizeList(StaticOptions-3);
 361
 362         for (auto &item : w)
 363                 item.setSelectable(false);
 364
 365         w.at(ConstraintsNumber).setSeparator(true);
 366         w.at(SearchButton-1).setSeparator(true);
 367
 368         for (size_t i = 0; i < ConstraintsNumber; ++i)
 369         {
 370                 std::string constraint = ConstraintsNames[i];
 371                 constraint.resize(13, ' ');
 372                 w[i].value().mkBuffer() << NC::Format::Bold << constraint << NC::Format::NoBold << ": ";
 373                 ShowTag(w[i].value().buffer(), itsConstraints[i]);
 374         }
 375
 376         w.at(ConstraintsNumber+1).value().mkBuffer() << NC::Format::Bold << "Search in:" << NC::Format::NoBold << ' ' << (Config.search_in_db ? "Database" : "Current playlist");
 377         w.at(ConstraintsNumber+2).value().mkBuffer() << NC::Format::Bold << "Search mode:" << NC::Format::NoBold << ' ' << *SearchMode;
 378
 379         w.at(SearchButton).value().mkBuffer() << "Search";
 380         w.at(ResetButton).value().mkBuffer() << "Reset";
 381 }
 382
 383 void SearchEngine::reset()
 384 {
 385         for (size_t i = 0; i < ConstraintsNumber; ++i)
 386                 itsConstraints[i].clear();
 387         w.reset();
 388         Prepare();
 389         Statusbar::print("Search state reset");
 390 }
 391
 392 void SearchEngine::Search()
 393 {
 394         bool constraints_empty = 1;
 395         for (size_t i = 0; i < ConstraintsNumber; ++i)
 396         {
 397                 if (!itsConstraints[i].empty())
 398                 {
 399                         constraints_empty = 0;
 400                         break;
 401                 }
 402         }
 403         if (constraints_empty)
 404                 return;
 405
 406         if (Config.search_in_db && (SearchMode == &SearchModes[0] || SearchMode == &SearchModes[2])) // use built-in mpd searching
 407         {
 408                 Mpd.StartSearch(SearchMode == &SearchModes[2]);
 409                 if (!itsConstraints[0].empty())
 410                         Mpd.AddSearchAny(itsConstraints[0]);
 411                 if (!itsConstraints[1].empty())
 412                         Mpd.AddSearch(MPD_TAG_ARTIST, itsConstraints[1]);
 413                 if (!itsConstraints[2].empty())
 414                         Mpd.AddSearch(MPD_TAG_ALBUM_ARTIST, itsConstraints[2]);
 415                 if (!itsConstraints[3].empty())
 416                         Mpd.AddSearch(MPD_TAG_TITLE, itsConstraints[3]);
 417                 if (!itsConstraints[4].empty())
 418                         Mpd.AddSearch(MPD_TAG_ALBUM, itsConstraints[4]);
 419                 if (!itsConstraints[5].empty())
 420                         Mpd.AddSearchURI(itsConstraints[5]);
 421                 if (!itsConstraints[6].empty())
 422                         Mpd.AddSearch(MPD_TAG_COMPOSER, itsConstraints[6]);
 423                 if (!itsConstraints[7].empty())
 424                         Mpd.AddSearch(MPD_TAG_PERFORMER, itsConstraints[7]);
 425                 if (!itsConstraints[8].empty())
 426                         Mpd.AddSearch(MPD_TAG_GENRE, itsConstraints[8]);
 427                 if (!itsConstraints[9].empty())
 428                         Mpd.AddSearch(MPD_TAG_DATE, itsConstraints[9]);
 429                 if (!itsConstraints[10].empty())
 430                         Mpd.AddSearch(MPD_TAG_COMMENT, itsConstraints[10]);
 431                 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s)
 432                         w.addItem(std::move(*s));
 433                 return;
 434         }
 435
 436         Regex::Regex rx[ConstraintsNumber];
 437         if (SearchMode != &SearchModes[2]) // match to pattern
 438         {
 439                 for (size_t i = 0; i < ConstraintsNumber; ++i)
 440                 {
 441                         if (!itsConstraints[i].empty())
 442                         {
 443                                 try
 444                                 {
 445                                         rx[i] = Regex::make(itsConstraints[i], Config.regex_type);
 446                                 }
 447                                 catch (boost::bad_expression &) { }
 448                         }
 449                 }
 450         }
 451
 452         typedef boost::range_detail::any_iterator<
 453                 const MPD::Song,
 454                 boost::single_pass_traversal_tag,
 455                 const MPD::Song &,
 456                 std::ptrdiff_t
 457         > input_song_iterator;
 458         input_song_iterator s, end;
 459         if (Config.search_in_db)
 460         {
 461                 s = input_song_iterator(getDatabaseIterator(Mpd));
 462                 end = input_song_iterator(MPD::SongIterator());
 463         }
 464         else
 465         {
 466                 s = input_song_iterator(myPlaylist->main().beginV());
 467                 end = input_song_iterator(myPlaylist->main().endV());
 468         }
 469
 470         LocaleStringComparison cmp(std::locale(), Config.ignore_leading_the);
 471         for (; s != end; ++s)
 472         {
 473                 bool any_found = true, found = true;
 474
 475                 if (SearchMode != &SearchModes[2]) // match to pattern
 476                 {
 477                         if (!rx[0].empty())
 478                                 any_found =
 479                                    Regex::search(s->getArtist(), rx[0])
 480                                 || Regex::search(s->getAlbumArtist(), rx[0])
 481                                 || Regex::search(s->getTitle(), rx[0])
 482                                 || Regex::search(s->getAlbum(), rx[0])
 483                                 || Regex::search(s->getName(), rx[0])
 484                                 || Regex::search(s->getComposer(), rx[0])
 485                                 || Regex::search(s->getPerformer(), rx[0])
 486                                 || Regex::search(s->getGenre(), rx[0])
 487                                 || Regex::search(s->getDate(), rx[0])
 488                                 || Regex::search(s->getComment(), rx[0]);
 489                         if (found && !rx[1].empty())
 490                                 found = Regex::search(s->getArtist(), rx[1]);
 491                         if (found && !rx[2].empty())
 492                                 found = Regex::search(s->getAlbumArtist(), rx[2]);
 493                         if (found && !rx[3].empty())
 494                                 found = Regex::search(s->getTitle(), rx[3]);
 495                         if (found && !rx[4].empty())
 496                                 found = Regex::search(s->getAlbum(), rx[4]);
 497                         if (found && !rx[5].empty())
 498                                 found = Regex::search(s->getName(), rx[5]);
 499                         if (found && !rx[6].empty())
 500                                 found = Regex::search(s->getComposer(), rx[6]);
 501                         if (found && !rx[7].empty())
 502                                 found = Regex::search(s->getPerformer(), rx[7]);
 503                         if (found && !rx[8].empty())
 504                                 found = Regex::search(s->getGenre(), rx[8]);
 505                         if (found && !rx[9].empty())
 506                                 found = Regex::search(s->getDate(), rx[9]);
 507                         if (found && !rx[10].empty())
 508                                 found = Regex::search(s->getComment(), rx[10]);
 509                 }
 510                 else // match only if values are equal
 511                 {
 512                         if (!itsConstraints[0].empty())
 513                                 any_found =
 514                                    !cmp(s->getArtist(), itsConstraints[0])
 515                                 || !cmp(s->getAlbumArtist(), itsConstraints[0])
 516                                 || !cmp(s->getTitle(), itsConstraints[0])
 517                                 || !cmp(s->getAlbum(), itsConstraints[0])
 518                                 || !cmp(s->getName(), itsConstraints[0])
 519                                 || !cmp(s->getComposer(), itsConstraints[0])
 520                                 || !cmp(s->getPerformer(), itsConstraints[0])
 521                                 || !cmp(s->getGenre(), itsConstraints[0])
 522                                 || !cmp(s->getDate(), itsConstraints[0])
 523                                 || !cmp(s->getComment(), itsConstraints[0]);
 524
 525                         if (found && !itsConstraints[1].empty())
 526                                 found = !cmp(s->getArtist(), itsConstraints[1]);
 527                         if (found && !itsConstraints[2].empty())
 528                                 found = !cmp(s->getAlbumArtist(), itsConstraints[2]);
 529                         if (found && !itsConstraints[3].empty())
 530                                 found = !cmp(s->getTitle(), itsConstraints[3]);
 531                         if (found && !itsConstraints[4].empty())
 532                                 found = !cmp(s->getAlbum(), itsConstraints[4]);
 533                         if (found && !itsConstraints[5].empty())
 534                                 found = !cmp(s->getName(), itsConstraints[5]);
 535                         if (found && !itsConstraints[6].empty())
 536                                 found = !cmp(s->getComposer(), itsConstraints[6]);
 537                         if (found && !itsConstraints[7].empty())
 538                                 found = !cmp(s->getPerformer(), itsConstraints[7]);
 539                         if (found && !itsConstraints[8].empty())
 540                                 found = !cmp(s->getGenre(), itsConstraints[8]);
 541                         if (found && !itsConstraints[9].empty())
 542                                 found = !cmp(s->getDate(), itsConstraints[9]);
 543                         if (found && !itsConstraints[10].empty())
 544                                 found = !cmp(s->getComment(), itsConstraints[10]);
 545                 }
 546
 547                 if (any_found && found)
 548                         w.addItem(*s);
 549         }
 550 }
 551
 552 namespace {
 553
 554 std::string SEItemToString(const SEItem &ei)
 555 {
 556         std::string result;
 557         if (ei.isSong())
 558         {
 559                 switch (Config.search_engine_display_mode)
 560                 {
 561                         case DisplayMode::Classic:
 562                                 result = Format::stringify<char>(Config.song_list_format, &ei.song());
 563                                 break;
 564                         case DisplayMode::Columns:
 565                                 result = Format::stringify<char>(Config.song_columns_mode_format, &ei.song());
 566                                 break;
 567                 }
 568         }
 569         else
 570                 result = ei.buffer().str();
 571         return result;
 572 }
 573
 574 bool SEItemEntryMatcher(const Regex::Regex &rx, const NC::Menu<SEItem>::Item &item, bool filter)
 575 {
 576         if (item.isSeparator() || !item.value().isSong())
 577                 return filter;
 578         return Regex::search(SEItemToString(item.value()), rx);
 579 }
 580
 581 }