?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
check for emptiness in some more places
[ncmpcpp.git] / src / search_engine.cpp
blob476614284b353769ea3cc7a94c2cdca91efbd087
1 /***************************************************************************
2 * Copyright (C) 2008-2010 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 <iomanip>
22
23 #include "display.h"
24 #include "global.h"
25 #include "helpers.h"
26 #include "playlist.h"
27 #include "search_engine.h"
28 #include "settings.h"
29 #include "status.h"
30
31 using Global::MainHeight;
32 using Global::MainStartY;
33
34 SearchEngine *mySearcher = new SearchEngine;
35
36 const char *SearchEngine::ConstraintsNames[] =
37 {
38 "Any:",
39 "Artist:",
40 "Title:",
41 "Album:",
42 "Filename:",
43 "Composer:",
44 "Performer:",
45 "Genre:",
46 "Year:",
47 "Comment:"
48 };
49
50 const char *SearchEngine::SearchModes[] =
51 {
52 "Match if tag contains searched phrase (no regexes)",
53 "Match if tag contains searched phrase (regexes supported)",
54 "Match only if both values are the same",
55 0
56 };
57
58 size_t SearchEngine::StaticOptions = 19;
59 size_t SearchEngine::ResetButton = 15;
60 size_t SearchEngine::SearchButton = 14;
61
62 void SearchEngine::Init()
63 {
64 w = new Menu< std::pair<Buffer *, MPD::Song *> >(0, MainStartY, COLS, MainHeight, "", Config.main_color, brNone);
65 w->HighlightColor(Config.main_highlight_color);
66 w->CyclicScrolling(Config.use_cyclic_scrolling);
67 w->CenteredCursor(Config.centered_cursor);
68 w->SetItemDisplayer(Display::SearchEngine);
69 w->SetSelectPrefix(&Config.selected_item_prefix);
70 w->SetSelectSuffix(&Config.selected_item_suffix);
71 w->SetGetStringFunction(SearchEngineOptionToString);
72 SearchMode = &SearchModes[Config.search_engine_default_search_mode];
73 isInitialized = 1;
74 }
75
76 void SearchEngine::Resize()
77 {
78 w->Resize(COLS, MainHeight);
79 w->MoveTo(0, MainStartY);
80 hasToBeResized = 0;
81 }
82
83 void SearchEngine::SwitchTo()
84 {
85 using Global::myScreen;
86
87 if (myScreen == this)
88 {
89 Reset();
90 return;
91 }
92
93 if (!isInitialized)
94 Init();
95
96 if (hasToBeResized)
97 Resize();
98
99 if (w->Empty())
100 Prepare();
101
102 if (myScreen != this && myScreen->isTabbable())
103 Global::myPrevScreen = myScreen;
104 myScreen = this;
105 Global::RedrawHeader = 1;
106
107 if (!w->Back().first)
108 {
109 *w << XY(0, 0) << "Updating list...";
110 UpdateFoundList();
111 }
112 }
113
114 std::basic_string<my_char_t> SearchEngine::Title()
115 {
116 return U("Search engine");
117 }
118
119 void SearchEngine::EnterPressed()
120 {
121 size_t option = w->Choice();
122 if (option > ConstraintsNumber && option < SearchButton)
123 w->Current().first->Clear();
124 if (option < SearchButton)
125 LockStatusbar();
126
127 if (option < ConstraintsNumber)
128 {
129 Statusbar() << fmtBold << ConstraintsNames[option] << fmtBoldEnd << ' ';
130 itsConstraints[option] = Global::wFooter->GetString(itsConstraints[option]);
131 w->Current().first->Clear();
132 *w->Current().first << fmtBold << std::setw(10) << std::left << ConstraintsNames[option] << fmtBoldEnd << ' ';
133 ShowTag(*w->Current().first, itsConstraints[option]);
134 }
135 else if (option == ConstraintsNumber+1)
136 {
137 Config.search_in_db = !Config.search_in_db;
138 *w->Current().first << fmtBold << "Search in:" << fmtBoldEnd << ' ' << (Config.search_in_db ? "Database" : "Current playlist");
139 }
140 else if (option == ConstraintsNumber+2)
141 {
142 if (!*++SearchMode)
143 SearchMode = &SearchModes[0];
144 *w->Current().first << fmtBold << "Search mode:" << fmtBoldEnd << ' ' << *SearchMode;
145 }
146 else if (option == SearchButton)
147 {
148 ShowMessage("Searching...");
149 if (w->Size() > StaticOptions)
150 Prepare();
151 Search();
152 if (!w->Back().first)
153 {
154 if (Config.columns_in_search_engine)
155 w->SetTitle(Display::Columns());
156 size_t found = w->Size()-SearchEngine::StaticOptions;
157 found += 3; // don't count options inserted below
158 w->InsertSeparator(ResetButton+1);
159 w->InsertOption(ResetButton+2, std::make_pair(static_cast<Buffer *>(0), static_cast<MPD::Song *>(0)), 1, 1);
160 w->at(ResetButton+2).first = new Buffer();
161 *w->at(ResetButton+2).first << Config.color1 << "Search results: " << Config.color2 << "Found " << found << (found > 1 ? " songs" : " song") << clDefault;
162 w->InsertSeparator(ResetButton+3);
163 UpdateFoundList();
164 ShowMessage("Searching finished!");
165 if (Config.block_search_constraints_change)
166 for (size_t i = 0; i < StaticOptions-4; ++i)
167 w->Static(i, 1);
168 w->Scroll(wDown);
169 w->Scroll(wDown);
170 }
171 else
172 ShowMessage("No results found");
173 }
174 else if (option == ResetButton)
175 {
176 Reset();
177 }
178 else
179 w->Bold(w->Choice(), myPlaylist->Add(*w->Current().second, w->isBold(), 1));
180
181 if (option < SearchButton)
182 UnlockStatusbar();
183 }
184
185 void SearchEngine::SpacePressed()
186 {
187 if (w->Current().first)
188 return;
189
190 if (Config.space_selects)
191 {
192 w->Select(w->Choice(), !w->isSelected());
193 w->Scroll(wDown);
194 return;
195 }
196
197 w->Bold(w->Choice(), myPlaylist->Add(*w->Current().second, w->isBold(), 0));
198 w->Scroll(wDown);
199 }
200
201 void SearchEngine::MouseButtonPressed(MEVENT me)
202 {
203 if (w->Empty() || !w->hasCoords(me.x, me.y) || size_t(me.y) >= w->Size())
204 return;
205 if (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED))
206 {
207 if (!w->Goto(me.y))
208 return;
209 w->Refresh();
210 if ((me.bstate & BUTTON3_PRESSED || w->Choice() > ConstraintsNumber) && w->Choice() < StaticOptions)
211 EnterPressed();
212 else if (w->Choice() >= StaticOptions)
213 {
214 if (me.bstate & BUTTON1_PRESSED)
215 {
216 size_t pos = w->Choice();
217 SpacePressed();
218 if (pos < w->Size()-1)
219 w->Scroll(wUp);
220 }
221 else
222 EnterPressed();
223 }
224 }
225 else
226 Screen< Menu< std::pair<Buffer *, MPD::Song *> > >::MouseButtonPressed(me);
227 }
228
229 MPD::Song *SearchEngine::CurrentSong()
230 {
231 return !w->Empty() ? w->Current().second : 0;
232 }
233
234 void SearchEngine::GetSelectedSongs(MPD::SongList &v)
235 {
236 if (w->Empty())
237 return;
238 std::vector<size_t> selected;
239 w->GetSelected(selected);
240 if (selected.empty() && w->Choice() >= StaticOptions)
241 selected.push_back(w->Choice());
242 for (std::vector<size_t>::const_iterator it = selected.begin(); it != selected.end(); ++it)
243 v.push_back(new MPD::Song(*w->at(*it).second));
244 }
245
246 void SearchEngine::ApplyFilter(const std::string &s)
247 {
248 w->ApplyFilter(s, StaticOptions, REG_ICASE | Config.regex_type);
249 }
250
251 void SearchEngine::UpdateFoundList()
252 {
253 bool bold = 0;
254 for (size_t i = StaticOptions; i < w->Size(); ++i)
255 {
256 for (size_t j = 0; j < myPlaylist->Items->Size(); ++j)
257 {
258 if (myPlaylist->Items->at(j).GetHash() == w->at(i).second->GetHash())
259 {
260 bold = 1;
261 break;
262 }
263 }
264 w->Bold(i, bold);
265 bold = 0;
266 }
267 }
268
269 void SearchEngine::Scroll(int input)
270 {
271 size_t pos = w->Choice();
272
273 // above the reset button
274 if (pos < ResetButton)
275 {
276 if (Keypressed(input, Key.UpAlbum) || Keypressed(input, Key.UpArtist))
277 w->Highlight(0);
278 else if (Keypressed(input, Key.DownAlbum) || Keypressed(input, Key.DownArtist))
279 w->Highlight(ResetButton);
280 }
281 // reset button
282 else if (pos == ResetButton)
283 {
284 if (Keypressed(input, Key.UpAlbum) || Keypressed(input, Key.UpArtist))
285 w->Highlight(0);
286 else if (Keypressed(input, Key.DownAlbum) || Keypressed(input, Key.DownArtist))
287 w->Highlight(StaticOptions); // first search result
288 }
289 // we are in the search results at this point
290 else if (pos >= StaticOptions)
291 {
292 if (Keypressed(input, Key.UpAlbum))
293 {
294 if (pos == StaticOptions)
295 {
296 w->Highlight(ResetButton);
297 return;
298 }
299 else
300 {
301 std::string album = w->at(pos).second->GetAlbum();
302 while (pos > StaticOptions)
303 if (w->at(--pos).second->GetAlbum() != album)
304 break;
305 }
306 }
307 else if (Keypressed(input, Key.DownAlbum))
308 {
309 std::string album = w->at(pos).second->GetAlbum();
310 while (pos < w->Size() - 1)
311 if (w->at(++pos).second->GetAlbum() != album)
312 break;
313 }
314 else if (Keypressed(input, Key.UpArtist))
315 {
316 if (pos == StaticOptions)
317 {
318 w->Highlight(0);
319 return;
320 }
321 else
322 {
323 std::string artist = w->at(pos).second->GetArtist();
324 while (pos > StaticOptions)
325 if (w->at(--pos).second->GetArtist() != artist)
326 break;
327 }
328 }
329 else if (Keypressed(input, Key.DownArtist))
330 {
331 std::string artist = w->at(pos).second->GetArtist();
332 while (pos < w->Size() - 1)
333 if (w->at(++pos).second->GetArtist() != artist)
334 break;
335 }
336 w->Highlight(pos);
337 }
338 }
339
340 void SearchEngine::Prepare()
341 {
342 for (size_t i = 0; i < w->Size(); ++i)
343 {
344 if (i == ConstraintsNumber || i == SearchButton-1 || i == ResetButton+1 || i == ResetButton+3) // separators
345 continue;
346 delete (*w)[i].first;
347 delete (*w)[i].second;
348 }
349
350 w->SetTitle("");
351 w->Clear();
352 w->ResizeList(StaticOptions-3);
353
354 w->IntoSeparator(ConstraintsNumber);
355 w->IntoSeparator(SearchButton-1);
356
357 for (size_t i = 0; i < StaticOptions-3; ++i)
358 {
359 if (i == ConstraintsNumber || i == SearchButton-1) // separators
360 continue;
361 (*w)[i].first = new Buffer();
362 }
363
364 for (size_t i = 0; i < ConstraintsNumber; ++i)
365 {
366 *(*w)[i].first << fmtBold << std::setw(10) << std::left << ConstraintsNames[i] << fmtBoldEnd << ' ';
367 ShowTag(*(*w)[i].first, itsConstraints[i]);
368 }
369
370 *w->at(ConstraintsNumber+1).first << fmtBold << "Search in:" << fmtBoldEnd << ' ' << (Config.search_in_db ? "Database" : "Current playlist");
371 *w->at(ConstraintsNumber+2).first << fmtBold << "Search mode:" << fmtBoldEnd << ' ' << *SearchMode;
372
373 *w->at(SearchButton).first << "Search";
374 *w->at(ResetButton).first << "Reset";
375 }
376
377 void SearchEngine::Reset()
378 {
379 for (size_t i = 0; i < ConstraintsNumber; ++i)
380 itsConstraints[i].clear();
381 w->Reset();
382 Prepare();
383 ShowMessage("Search state reset");
384 }
385
386 void SearchEngine::Search()
387 {
388 bool constraints_empty = 1;
389 for (size_t i = 0; i < ConstraintsNumber; ++i)
390 {
391 if (!itsConstraints[i].empty())
392 {
393 constraints_empty = 0;
394 break;
395 }
396 }
397 if (constraints_empty)
398 return;
399
400 if (Config.search_in_db && (SearchMode == &SearchModes[0] || SearchMode == &SearchModes[2])) // use built-in mpd searching
401 {
402 Mpd.StartSearch(SearchMode == &SearchModes[2]);
403 if (!itsConstraints[0].empty())
404 Mpd.AddSearchAny(itsConstraints[0]);
405 if (!itsConstraints[1].empty())
406 Mpd.AddSearch(MPD_TAG_ARTIST, itsConstraints[1]);
407 if (!itsConstraints[2].empty())
408 Mpd.AddSearch(MPD_TAG_TITLE, itsConstraints[2]);
409 if (!itsConstraints[3].empty())
410 Mpd.AddSearch(MPD_TAG_ALBUM, itsConstraints[3]);
411 if (!itsConstraints[4].empty())
412 Mpd.AddSearchURI(itsConstraints[4]);
413 if (!itsConstraints[5].empty())
414 Mpd.AddSearch(MPD_TAG_COMPOSER, itsConstraints[5]);
415 if (!itsConstraints[6].empty())
416 Mpd.AddSearch(MPD_TAG_PERFORMER, itsConstraints[6]);
417 if (!itsConstraints[7].empty())
418 Mpd.AddSearch(MPD_TAG_GENRE, itsConstraints[7]);
419 if (!itsConstraints[8].empty())
420 Mpd.AddSearch(MPD_TAG_DATE, itsConstraints[8]);
421 if (!itsConstraints[9].empty())
422 Mpd.AddSearch(MPD_TAG_COMMENT, itsConstraints[9]);
423 MPD::SongList results;
424 Mpd.CommitSearch(results);
425 for (MPD::SongList::const_iterator it = results.begin(); it != results.end(); ++it)
426 w->AddOption(std::make_pair(static_cast<Buffer *>(0), *it));
427 return;
428 }
429
430 MPD::SongList list;
431 if (Config.search_in_db)
432 Mpd.GetDirectoryRecursive("/", list);
433 else
434 {
435 list.reserve(myPlaylist->Items->Size());
436 for (size_t i = 0; i < myPlaylist->Items->Size(); ++i)
437 list.push_back(&(*myPlaylist->Items)[i]);
438 }
439
440 bool any_found = 1;
441 bool found = 1;
442
443 for (MPD::SongList::const_iterator it = list.begin(); it != list.end(); ++it)
444 {
445 if (SearchMode != &SearchModes[2]) // match to pattern
446 {
447 regex_t rx;
448 if (!itsConstraints[0].empty())
449 {
450 if (regcomp(&rx, itsConstraints[0].c_str(), REG_ICASE | Config.regex_type) == 0)
451 {
452 any_found =
453 !regexec(&rx, (*it)->GetArtist().c_str(), 0, 0, 0)
454 || !regexec(&rx, (*it)->GetTitle().c_str(), 0, 0, 0)
455 || !regexec(&rx, (*it)->GetAlbum().c_str(), 0, 0, 0)
456 || !regexec(&rx, (*it)->GetName().c_str(), 0, 0, 0)
457 || !regexec(&rx, (*it)->GetComposer().c_str(), 0, 0, 0)
458 || !regexec(&rx, (*it)->GetPerformer().c_str(), 0, 0, 0)
459 || !regexec(&rx, (*it)->GetGenre().c_str(), 0, 0, 0)
460 || !regexec(&rx, (*it)->GetDate().c_str(), 0, 0, 0)
461 || !regexec(&rx, (*it)->GetComment().c_str(), 0, 0, 0);
462 }
463 regfree(&rx);
464 }
465
466 if (found && !itsConstraints[1].empty())
467 {
468 if (!regcomp(&rx, itsConstraints[1].c_str(), REG_ICASE | Config.regex_type))
469 found = !regexec(&rx, (*it)->GetArtist().c_str(), 0, 0, 0);
470 regfree(&rx);
471 }
472 if (found && !itsConstraints[2].empty())
473 {
474 if (!regcomp(&rx, itsConstraints[2].c_str(), REG_ICASE | Config.regex_type))
475 found = !regexec(&rx, (*it)->GetTitle().c_str(), 0, 0, 0);
476 regfree(&rx);
477 }
478 if (found && !itsConstraints[3].empty())
479 {
480 if (!regcomp(&rx, itsConstraints[3].c_str(), REG_ICASE | Config.regex_type))
481 found = !regexec(&rx, (*it)->GetAlbum().c_str(), 0, 0, 0);
482 regfree(&rx);
483 }
484 if (found && !itsConstraints[4].empty())
485 {
486 if (!regcomp(&rx, itsConstraints[4].c_str(), REG_ICASE | Config.regex_type))
487 found = !regexec(&rx, (*it)->GetName().c_str(), 0, 0, 0);
488 regfree(&rx);
489 }
490 if (found && !itsConstraints[5].empty())
491 {
492 if (!regcomp(&rx, itsConstraints[5].c_str(), REG_ICASE | Config.regex_type))
493 found = !regexec(&rx, (*it)->GetComposer().c_str(), 0, 0, 0);
494 regfree(&rx);
495 }
496 if (found && !itsConstraints[6].empty())
497 {
498 if (!regcomp(&rx, itsConstraints[6].c_str(), REG_ICASE | Config.regex_type))
499 found = !regexec(&rx, (*it)->GetPerformer().c_str(), 0, 0, 0);
500 regfree(&rx);
501 }
502 if (found && !itsConstraints[7].empty())
503 {
504 if (!regcomp(&rx, itsConstraints[7].c_str(), REG_ICASE | Config.regex_type))
505 found = !regexec(&rx, (*it)->GetGenre().c_str(), 0, 0, 0);
506 regfree(&rx);
507 }
508 if (found && !itsConstraints[8].empty())
509 {
510 if (!regcomp(&rx, itsConstraints[8].c_str(), REG_ICASE | Config.regex_type))
511 found = !regexec(&rx, (*it)->GetDate().c_str(), 0, 0, 0);
512 regfree(&rx);
513 }
514 if (found && !itsConstraints[9].empty())
515 {
516 if (!regcomp(&rx, itsConstraints[9].c_str(), REG_ICASE | Config.regex_type))
517 found = !regexec(&rx, (*it)->GetComment().c_str(), 0, 0, 0);
518 regfree(&rx);
519 }
520 }
521 else // match only if values are equal
522 {
523 CaseInsensitiveStringComparison cmp;
524
525 if (!itsConstraints[0].empty())
526 any_found =
527 !cmp((*it)->GetArtist(), itsConstraints[0])
528 || !cmp((*it)->GetTitle(), itsConstraints[0])
529 || !cmp((*it)->GetAlbum(), itsConstraints[0])
530 || !cmp((*it)->GetName(), itsConstraints[0])
531 || !cmp((*it)->GetComposer(), itsConstraints[0])
532 || !cmp((*it)->GetPerformer(), itsConstraints[0])
533 || !cmp((*it)->GetGenre(), itsConstraints[0])
534 || !cmp((*it)->GetDate(), itsConstraints[0])
535 || !cmp((*it)->GetComment(), itsConstraints[0]);
536
537 if (found && !itsConstraints[1].empty())
538 found = !cmp((*it)->GetArtist(), itsConstraints[1]);
539 if (found && !itsConstraints[2].empty())
540 found = !cmp((*it)->GetTitle(), itsConstraints[2]);
541 if (found && !itsConstraints[3].empty())
542 found = !cmp((*it)->GetAlbum(), itsConstraints[3]);
543 if (found && !itsConstraints[4].empty())
544 found = !cmp((*it)->GetName(), itsConstraints[4]);
545 if (found && !itsConstraints[5].empty())
546 found = !cmp((*it)->GetComposer(), itsConstraints[5]);
547 if (found && !itsConstraints[6].empty())
548 found = !cmp((*it)->GetPerformer(), itsConstraints[6]);
549 if (found && !itsConstraints[7].empty())
550 found = !cmp((*it)->GetGenre(), itsConstraints[7]);
551 if (found && !itsConstraints[8].empty())
552 found = !cmp((*it)->GetDate(), itsConstraints[8]);
553 if (found && !itsConstraints[9].empty())
554 found = !cmp((*it)->GetComment(), itsConstraints[9]);
555 }
556
557 if (found && any_found)
558 {
559 MPD::Song *ss = Config.search_in_db ? *it : new MPD::Song(**it);
560 w->AddOption(std::make_pair(static_cast<Buffer *>(0), ss));
561 list[it-list.begin()] = 0;
562 }
563 found = 1;
564 any_found = 1;
565 }
566 if (Config.search_in_db) // free song list only if it's database
567 MPD::FreeSongList(list);
568 }
569
570 std::string SearchEngine::SearchEngineOptionToString(const std::pair<Buffer *, MPD::Song *> &pair, void *)
571 {
572 if (!Config.columns_in_search_engine)
573 return pair.second->toString(Config.song_list_format);
574 else
575 return Playlist::SongInColumnsToString(*pair.second, 0);
576 }
577
an ncurses mpd client inspired by ncmpc