?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
searchable: retrieve currently applied search constraint
[ncmpcpp.git] / src / actions.cpp
blobf8f994f7b6fa245e91021b825880e162aee5e380
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 <cassert>
22 #include <cerrno>
23 #include <cstring>
24 #include <boost/array.hpp>
25 #include <boost/date_time/posix_time/posix_time.hpp>
26 #include <boost/filesystem/operations.hpp>
27 #include <boost/locale/conversion.hpp>
28 #include <boost/lexical_cast.hpp>
29 #include <algorithm>
30 #include <iostream>
31
32 #include "actions.h"
33 #include "charset.h"
34 #include "config.h"
35 #include "display.h"
36 #include "global.h"
37 #include "mpdpp.h"
38 #include "helpers.h"
39 #include "statusbar.h"
40 #include "utility/comparators.h"
41 #include "utility/conversion.h"
42
43 #include "bindings.h"
44 #include "browser.h"
45 #include "clock.h"
46 #include "help.h"
47 #include "media_library.h"
48 #include "menu_impl.h"
49 #include "lastfm.h"
50 #include "lyrics.h"
51 #include "playlist.h"
52 #include "playlist_editor.h"
53 #include "sort_playlist.h"
54 #include "search_engine.h"
55 #include "sel_items_adder.h"
56 #include "server_info.h"
57 #include "song_info.h"
58 #include "outputs.h"
59 #include "utility/readline.h"
60 #include "utility/string.h"
61 #include "utility/type_conversions.h"
62 #include "tag_editor.h"
63 #include "tiny_tag_editor.h"
64 #include "visualizer.h"
65 #include "title.h"
66 #include "tags.h"
67
68 #ifdef HAVE_TAGLIB_H
69 # include "fileref.h"
70 # include "tag.h"
71 #endif // HAVE_TAGLIB_H
72
73 using Global::myScreen;
74
75 namespace ph = std::placeholders;
76
77 namespace {
78
79 boost::array<
80 Actions::BaseAction *, static_cast<size_t>(Actions::Type::_numberOfActions)
81 > AvailableActions;
82
83 void populateActions();
84
85 bool scrollTagCanBeRun(NC::List *&list, SongList *&songs);
86 void scrollTagUpRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get);
87 void scrollTagDownRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get);
88
89 void seek();
90 void findItem(const SearchDirection direction);
91 void listsChangeFinisher();
92
93 template <typename Iterator>
94 bool findSelectedRangeAndPrintInfoIfNot(Iterator &first, Iterator &last)
95 {
96 bool success = findSelectedRange(first, last);
97 if (!success)
98 Statusbar::print("No range selected");
99 return success;
100 }
101
102 }
103
104 namespace Actions {
105
106 bool OriginalStatusbarVisibility;
107 bool ExitMainLoop = false;
108
109 size_t HeaderHeight;
110 size_t FooterHeight;
111 size_t FooterStartY;
112
113 void validateScreenSize()
114 {
115 using Global::MainHeight;
116
117 if (COLS < 30 || MainHeight < 5)
118 {
119 NC::destroyScreen();
120 std::cout << "Screen is too small to handle ncmpcpp correctly\n";
121 exit(1);
122 }
123 }
124
125 void initializeScreens()
126 {
127 myHelp = new Help;
128 myPlaylist = new Playlist;
129 myBrowser = new Browser;
130 mySearcher = new SearchEngine;
131 myLibrary = new MediaLibrary;
132 myPlaylistEditor = new PlaylistEditor;
133 myLyrics = new Lyrics;
134 mySelectedItemsAdder = new SelectedItemsAdder;
135 mySongInfo = new SongInfo;
136 myServerInfo = new ServerInfo;
137 mySortPlaylistDialog = new SortPlaylistDialog;
138
139 # ifdef HAVE_CURL_CURL_H
140 myLastfm = new Lastfm;
141 # endif // HAVE_CURL_CURL_H
142
143 # ifdef HAVE_TAGLIB_H
144 myTinyTagEditor = new TinyTagEditor;
145 myTagEditor = new TagEditor;
146 # endif // HAVE_TAGLIB_H
147
148 # ifdef ENABLE_VISUALIZER
149 myVisualizer = new Visualizer;
150 # endif // ENABLE_VISUALIZER
151
152 # ifdef ENABLE_OUTPUTS
153 myOutputs = new Outputs;
154 # endif // ENABLE_OUTPUTS
155
156 # ifdef ENABLE_CLOCK
157 myClock = new Clock;
158 # endif // ENABLE_CLOCK
159
160 }
161
162 void setResizeFlags()
163 {
164 myHelp->hasToBeResized = 1;
165 myPlaylist->hasToBeResized = 1;
166 myBrowser->hasToBeResized = 1;
167 mySearcher->hasToBeResized = 1;
168 myLibrary->hasToBeResized = 1;
169 myPlaylistEditor->hasToBeResized = 1;
170 myLyrics->hasToBeResized = 1;
171 mySelectedItemsAdder->hasToBeResized = 1;
172 mySongInfo->hasToBeResized = 1;
173 myServerInfo->hasToBeResized = 1;
174 mySortPlaylistDialog->hasToBeResized = 1;
175
176 # ifdef HAVE_CURL_CURL_H
177 myLastfm->hasToBeResized = 1;
178 # endif // HAVE_CURL_CURL_H
179
180 # ifdef HAVE_TAGLIB_H
181 myTinyTagEditor->hasToBeResized = 1;
182 myTagEditor->hasToBeResized = 1;
183 # endif // HAVE_TAGLIB_H
184
185 # ifdef ENABLE_VISUALIZER
186 myVisualizer->hasToBeResized = 1;
187 # endif // ENABLE_VISUALIZER
188
189 # ifdef ENABLE_OUTPUTS
190 myOutputs->hasToBeResized = 1;
191 # endif // ENABLE_OUTPUTS
192
193 # ifdef ENABLE_CLOCK
194 myClock->hasToBeResized = 1;
195 # endif // ENABLE_CLOCK
196 }
197
198 void resizeScreen(bool reload_main_window)
199 {
200 using Global::MainHeight;
201 using Global::wHeader;
202 using Global::wFooter;
203
204 // update internal screen dimensions
205 if (reload_main_window)
206 {
207 rl_resize_terminal();
208 endwin();
209 refresh();
210 }
211
212 MainHeight = LINES-(Config.design == Design::Alternative ? 7 : 4);
213
214 validateScreenSize();
215
216 if (!Config.header_visibility)
217 MainHeight += 2;
218 if (!Config.statusbar_visibility)
219 ++MainHeight;
220
221 setResizeFlags();
222
223 applyToVisibleWindows(&BaseScreen::resize);
224
225 if (Config.header_visibility || Config.design == Design::Alternative)
226 wHeader->resize(COLS, HeaderHeight);
227
228 FooterStartY = LINES-(Config.statusbar_visibility ? 2 : 1);
229 wFooter->moveTo(0, FooterStartY);
230 wFooter->resize(COLS, Config.statusbar_visibility ? 2 : 1);
231
232 applyToVisibleWindows(&BaseScreen::refresh);
233
234 Status::Changes::elapsedTime(false);
235 Status::Changes::playerState();
236 // Note: routines for drawing separator if alternative user
237 // interface is active and header is hidden are placed in
238 // NcmpcppStatusChanges.StatusFlags
239 Status::Changes::flags();
240 drawHeader();
241 wFooter->refresh();
242 refresh();
243 }
244
245 void setWindowsDimensions()
246 {
247 using Global::MainStartY;
248 using Global::MainHeight;
249
250 MainStartY = Config.design == Design::Alternative ? 5 : 2;
251 MainHeight = LINES-(Config.design == Design::Alternative ? 7 : 4);
252
253 if (!Config.header_visibility)
254 {
255 MainStartY -= 2;
256 MainHeight += 2;
257 }
258 if (!Config.statusbar_visibility)
259 ++MainHeight;
260
261 HeaderHeight = Config.design == Design::Alternative ? (Config.header_visibility ? 5 : 3) : 2;
262 FooterStartY = LINES-(Config.statusbar_visibility ? 2 : 1);
263 FooterHeight = Config.statusbar_visibility ? 2 : 1;
264 }
265
266 void confirmAction(const boost::format &description)
267 {
268 Statusbar::ScopedLock slock;
269 Statusbar::put() << description.str()
270 << " [" << NC::Format::Bold << 'y' << NC::Format::NoBold
271 << '/' << NC::Format::Bold << 'n' << NC::Format::NoBold
272 << "] ";
273 auto answer = Statusbar::Helpers::promptReturnOneOf({"y", "n"});
274 if (answer == "n")
275 throw NC::PromptAborted(std::move(answer));
276 }
277
278 bool isMPDMusicDirSet()
279 {
280 if (Config.mpd_music_dir.empty())
281 {
282 Statusbar::print("Proper mpd_music_dir variable has to be set in configuration file");
283 return false;
284 }
285 return true;
286 }
287
288 BaseAction &get(Actions::Type at)
289 {
290 if (AvailableActions[1] == nullptr)
291 populateActions();
292 BaseAction *action = AvailableActions[static_cast<size_t>(at)];
293 // action should be always present if action type in queried
294 assert(action != nullptr);
295 return *action;
296 }
297
298 BaseAction *get(const std::string &name)
299 {
300 BaseAction *result = 0;
301 if (AvailableActions[1] == nullptr)
302 populateActions();
303 for (auto it = AvailableActions.begin(); it != AvailableActions.end(); ++it)
304 {
305 if (*it != nullptr && (*it)->name() == name)
306 {
307 result = *it;
308 break;
309 }
310 }
311 return result;
312 }
313
314 UpdateEnvironment::UpdateEnvironment()
315 : BaseAction(Type::UpdateEnvironment, "update_environment")
316 , m_past(boost::posix_time::from_time_t(0))
317 { }
318
319 void UpdateEnvironment::run(bool update_timer, bool refresh_window)
320 {
321 using Global::Timer;
322
323 // update timer, status if necessary etc.
324 Status::trace(update_timer, true);
325
326 // header stuff
327 if ((myScreen == myPlaylist || myScreen == myBrowser || myScreen == myLyrics)
328 && (Timer - m_past > boost::posix_time::milliseconds(500))
329 )
330 {
331 drawHeader();
332 m_past = Timer;
333 }
334
335 if (refresh_window)
336 myScreen->refreshWindow();
337 }
338
339 void UpdateEnvironment::run()
340 {
341 run(true, true);
342 }
343
344 bool MouseEvent::canBeRun()
345 {
346 return Config.mouse_support;
347 }
348
349 void MouseEvent::run()
350 {
351 using Global::VolumeState;
352 using Global::wFooter;
353
354 m_old_mouse_event = m_mouse_event;
355 m_mouse_event = wFooter->getMouseEvent();
356
357 //Statusbar::printf("(%1%, %2%, %3%)", m_mouse_event.bstate, m_mouse_event.x, m_mouse_event.y);
358
359 if (m_mouse_event.bstate & BUTTON1_PRESSED
360 && m_mouse_event.y == LINES-(Config.statusbar_visibility ? 2 : 1)
361 ) // progressbar
362 {
363 if (Status::State::player() == MPD::psStop)
364 return;
365 Mpd.Seek(Status::State::currentSongPosition(),
366 Status::State::totalTime()*m_mouse_event.x/double(COLS));
367 }
368 else if (m_mouse_event.bstate & BUTTON1_PRESSED
369 && (Config.statusbar_visibility || Config.design == Design::Alternative)
370 && Status::State::player() != MPD::psStop
371 && m_mouse_event.y == (Config.design == Design::Alternative ? 1 : LINES-1)
372 && m_mouse_event.x < 9
373 ) // playing/paused
374 {
375 Mpd.Toggle();
376 }
377 else if ((m_mouse_event.bstate & BUTTON5_PRESSED || m_mouse_event.bstate & BUTTON4_PRESSED)
378 && (Config.header_visibility || Config.design == Design::Alternative)
379 && m_mouse_event.y == 0 && size_t(m_mouse_event.x) > COLS-VolumeState.length()
380 ) // volume
381 {
382 if (m_mouse_event.bstate & BUTTON5_PRESSED)
383 get(Type::VolumeDown).execute();
384 else
385 get(Type::VolumeUp).execute();
386 }
387 else if (m_mouse_event.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED | BUTTON4_PRESSED | BUTTON5_PRESSED))
388 myScreen->mouseButtonPressed(m_mouse_event);
389 }
390
391 void ScrollUp::run()
392 {
393 myScreen->scroll(NC::Scroll::Up);
394 listsChangeFinisher();
395 }
396
397 void ScrollDown::run()
398 {
399 myScreen->scroll(NC::Scroll::Down);
400 listsChangeFinisher();
401 }
402
403 bool ScrollUpArtist::canBeRun()
404 {
405 return scrollTagCanBeRun(m_list, m_songs);
406 }
407
408 void ScrollUpArtist::run()
409 {
410 scrollTagUpRun(m_list, m_songs, &MPD::Song::getArtist);
411 }
412
413 bool ScrollUpAlbum::canBeRun()
414 {
415 return scrollTagCanBeRun(m_list, m_songs);
416 }
417
418 void ScrollUpAlbum::run()
419 {
420 scrollTagUpRun(m_list, m_songs, &MPD::Song::getAlbum);
421 }
422
423 bool ScrollDownArtist::canBeRun()
424 {
425 return scrollTagCanBeRun(m_list, m_songs);
426 }
427
428 void ScrollDownArtist::run()
429 {
430 scrollTagDownRun(m_list, m_songs, &MPD::Song::getArtist);
431 }
432
433 bool ScrollDownAlbum::canBeRun()
434 {
435 return scrollTagCanBeRun(m_list, m_songs);
436 }
437
438 void ScrollDownAlbum::run()
439 {
440 scrollTagDownRun(m_list, m_songs, &MPD::Song::getAlbum);
441 }
442
443 void PageUp::run()
444 {
445 myScreen->scroll(NC::Scroll::PageUp);
446 listsChangeFinisher();
447 }
448
449 void PageDown::run()
450 {
451 myScreen->scroll(NC::Scroll::PageDown);
452 listsChangeFinisher();
453 }
454
455 void MoveHome::run()
456 {
457 myScreen->scroll(NC::Scroll::Home);
458 listsChangeFinisher();
459 }
460
461 void MoveEnd::run()
462 {
463 myScreen->scroll(NC::Scroll::End);
464 listsChangeFinisher();
465 }
466
467 void ToggleInterface::run()
468 {
469 switch (Config.design)
470 {
471 case Design::Classic:
472 Config.design = Design::Alternative;
473 Config.statusbar_visibility = false;
474 break;
475 case Design::Alternative:
476 Config.design = Design::Classic;
477 Config.statusbar_visibility = OriginalStatusbarVisibility;
478 break;
479 }
480 setWindowsDimensions();
481 resizeScreen(false);
482 // unlock progressbar
483 Progressbar::ScopedLock();
484 Status::Changes::mixer();
485 Status::Changes::elapsedTime(false);
486 Statusbar::printf("User interface: %1%", Config.design);
487 }
488
489 bool JumpToParentDirectory::canBeRun()
490 {
491 return (myScreen == myBrowser)
492 # ifdef HAVE_TAGLIB_H
493 || (myScreen->activeWindow() == myTagEditor->Dirs)
494 # endif // HAVE_TAGLIB_H
495 ;
496 }
497
498 void JumpToParentDirectory::run()
499 {
500 if (myScreen == myBrowser)
501 {
502 if (!myBrowser->inRootDirectory())
503 {
504 myBrowser->main().reset();
505 myBrowser->enterDirectory();
506 }
507 }
508 # ifdef HAVE_TAGLIB_H
509 else if (myScreen == myTagEditor)
510 {
511 if (myTagEditor->CurrentDir() != "/")
512 {
513 myTagEditor->Dirs->reset();
514 myTagEditor->enterDirectory();
515 }
516 }
517 # endif // HAVE_TAGLIB_H
518 }
519
520 bool RunAction::canBeRun()
521 {
522 m_ha = dynamic_cast<HasActions *>(myScreen);
523 return m_ha != nullptr
524 && m_ha->actionRunnable();
525 }
526
527 void RunAction::run()
528 {
529 m_ha->runAction();
530 }
531
532 bool PreviousColumn::canBeRun()
533 {
534 m_hc = dynamic_cast<HasColumns *>(myScreen);
535 return m_hc != nullptr
536 && m_hc->previousColumnAvailable();
537 }
538
539 void PreviousColumn::run()
540 {
541 m_hc->previousColumn();
542 }
543
544 bool NextColumn::canBeRun()
545 {
546 m_hc = dynamic_cast<HasColumns *>(myScreen);
547 return m_hc != nullptr
548 && m_hc->nextColumnAvailable();
549 }
550
551 void NextColumn::run()
552 {
553 m_hc->nextColumn();
554 }
555
556 bool MasterScreen::canBeRun()
557 {
558 using Global::myLockedScreen;
559 using Global::myInactiveScreen;
560
561 return myLockedScreen
562 && myInactiveScreen
563 && myLockedScreen != myScreen
564 && myScreen->isMergable();
565 }
566
567 void MasterScreen::run()
568 {
569 using Global::myInactiveScreen;
570 using Global::myLockedScreen;
571
572 myInactiveScreen = myScreen;
573 myScreen = myLockedScreen;
574 drawHeader();
575 }
576
577 bool SlaveScreen::canBeRun()
578 {
579 using Global::myLockedScreen;
580 using Global::myInactiveScreen;
581
582 return myLockedScreen
583 && myInactiveScreen
584 && myLockedScreen == myScreen
585 && myScreen->isMergable();
586 }
587
588 void SlaveScreen::run()
589 {
590 using Global::myInactiveScreen;
591 using Global::myLockedScreen;
592
593 myScreen = myInactiveScreen;
594 myInactiveScreen = myLockedScreen;
595 drawHeader();
596 }
597
598 void VolumeUp::run()
599 {
600 int volume = std::min(Status::State::volume()+Config.volume_change_step, 100u);
601 Mpd.SetVolume(volume);
602 }
603
604 void VolumeDown::run()
605 {
606 int volume = std::max(int(Status::State::volume()-Config.volume_change_step), 0);
607 Mpd.SetVolume(volume);
608 }
609
610 bool AddItemToPlaylist::canBeRun()
611 {
612 m_hs = dynamic_cast<HasSongs *>(myScreen);
613 return m_hs != nullptr && m_hs->itemAvailable();
614 }
615
616 void AddItemToPlaylist::run()
617 {
618 bool success = m_hs->addItemToPlaylist(false);
619 if (success)
620 {
621 myScreen->scroll(NC::Scroll::Down);
622 listsChangeFinisher();
623 }
624 }
625
626 bool PlayItem::canBeRun()
627 {
628 m_hs = dynamic_cast<HasSongs *>(myScreen);
629 return m_hs != nullptr && m_hs->itemAvailable();
630 }
631
632 void PlayItem::run()
633 {
634 bool success = m_hs->addItemToPlaylist(true);
635 if (success)
636 listsChangeFinisher();
637 }
638
639 bool DeletePlaylistItems::canBeRun()
640 {
641 return (myScreen == myPlaylist && !myPlaylist->main().empty())
642 || (myScreen->isActiveWindow(myPlaylistEditor->Content) && !myPlaylistEditor->Content.empty());
643 }
644
645 void DeletePlaylistItems::run()
646 {
647 if (myScreen == myPlaylist)
648 {
649 Statusbar::print("Deleting items...");
650 auto delete_fun = std::bind(&MPD::Connection::Delete, ph::_1, ph::_2);
651 deleteSelectedSongs(myPlaylist->main(), delete_fun);
652 Statusbar::print("Item(s) deleted");
653 }
654 else if (myScreen->isActiveWindow(myPlaylistEditor->Content))
655 {
656 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
657 auto delete_fun = std::bind(&MPD::Connection::PlaylistDelete, ph::_1, playlist, ph::_2);
658 Statusbar::print("Deleting items...");
659 deleteSelectedSongs(myPlaylistEditor->Content, delete_fun);
660 Statusbar::print("Item(s) deleted");
661 }
662 }
663
664 bool DeleteBrowserItems::canBeRun()
665 {
666 auto check_if_deletion_allowed = []() {
667 if (Config.allow_for_physical_item_deletion)
668 return true;
669 else
670 {
671 Statusbar::print("Flag \"allow_for_physical_item_deletion\" needs to be enabled in configuration file");
672 return false;
673 }
674 };
675 return myScreen == myBrowser
676 && !myBrowser->main().empty()
677 && isMPDMusicDirSet()
678 && check_if_deletion_allowed();
679 }
680
681 void DeleteBrowserItems::run()
682 {
683 auto get_name = [](const MPD::Item &item) -> std::string {
684 std::string iname;
685 switch (item.type())
686 {
687 case MPD::Item::Type::Directory:
688 iname = getBasename(item.directory().path());
689 break;
690 case MPD::Item::Type::Song:
691 iname = item.song().getName();
692 break;
693 case MPD::Item::Type::Playlist:
694 iname = getBasename(item.playlist().path());
695 break;
696 }
697 return iname;
698 };
699
700 boost::format question;
701 if (hasSelected(myBrowser->main().begin(), myBrowser->main().end()))
702 question = boost::format("Delete selected items?");
703 else
704 {
705 const auto &item = myBrowser->main().current()->value();
706 // parent directories are not accepted (and they
707 // can't be selected, so in other cases it's fine).
708 if (myBrowser->isParentDirectory(item))
709 return;
710 const char msg[] = "Delete \"%1%\"?";
711 question = boost::format(msg) % wideShorten(
712 get_name(item), COLS-const_strlen(msg)-5
713 );
714 }
715 confirmAction(question);
716
717 auto items = getSelectedOrCurrent(
718 myBrowser->main().begin(),
719 myBrowser->main().end(),
720 myBrowser->main().current()
721 );
722 for (const auto &item : items)
723 {
724 myBrowser->remove(item->value());
725 const char msg[] = "Deleted %1% \"%2%\"";
726 Statusbar::printf(msg,
727 itemTypeToString(item->value().type()),
728 wideShorten(get_name(item->value()), COLS-const_strlen(msg))
729 );
730 }
731
732 if (!myBrowser->isLocal())
733 Mpd.UpdateDirectory(myBrowser->currentDirectory());
734 myBrowser->requestUpdate();
735 }
736
737 bool DeleteStoredPlaylist::canBeRun()
738 {
739 return myScreen->isActiveWindow(myPlaylistEditor->Playlists);
740 }
741
742 void DeleteStoredPlaylist::run()
743 {
744 if (myPlaylistEditor->Playlists.empty())
745 return;
746 boost::format question;
747 if (hasSelected(myPlaylistEditor->Playlists.begin(), myPlaylistEditor->Playlists.end()))
748 question = boost::format("Delete selected playlists?");
749 else
750 question = boost::format("Delete playlist \"%1%\"?")
751 % wideShorten(myPlaylistEditor->Playlists.current()->value().path(), COLS-question.size()-10);
752 confirmAction(question);
753 auto list = getSelectedOrCurrent(
754 myPlaylistEditor->Playlists.begin(),
755 myPlaylistEditor->Playlists.end(),
756 myPlaylistEditor->Playlists.current()
757 );
758 for (const auto &item : list)
759 Mpd.DeletePlaylist(item->value().path());
760 Statusbar::printf("%1% deleted", list.size() == 1 ? "Playlist" : "Playlists");
761 // force playlists update. this happens automatically, but only after call
762 // to Key::read, therefore when we call PlaylistEditor::Update, it won't
763 // yet see it, so let's point that it needs to update it.
764 myPlaylistEditor->requestPlaylistsUpdate();
765 }
766
767 void ReplaySong::run()
768 {
769 if (Status::State::player() != MPD::psStop)
770 Mpd.Seek(Status::State::currentSongPosition(), 0);
771 }
772
773 void PreviousSong::run()
774 {
775 Mpd.Prev();
776 }
777
778 void NextSong::run()
779 {
780 Mpd.Next();
781 }
782
783 void Pause::run()
784 {
785 Mpd.Toggle();
786 }
787
788 void SavePlaylist::run()
789 {
790 using Global::wFooter;
791
792 std::string playlist_name;
793 {
794 Statusbar::ScopedLock slock;
795 Statusbar::put() << "Save playlist as: ";
796 playlist_name = wFooter->prompt();
797 }
798 try
799 {
800 Mpd.SavePlaylist(playlist_name);
801 Statusbar::printf("Playlist saved as \"%1%\"", playlist_name);
802 }
803 catch (MPD::ServerError &e)
804 {
805 if (e.code() == MPD_SERVER_ERROR_EXIST)
806 {
807 confirmAction(
808 boost::format("Playlist \"%1%\" already exists, overwrite?") % playlist_name
809 );
810 Mpd.DeletePlaylist(playlist_name);
811 Mpd.SavePlaylist(playlist_name);
812 Statusbar::print("Playlist overwritten");
813 }
814 else
815 throw;
816 }
817 }
818
819 void Stop::run()
820 {
821 Mpd.Stop();
822 }
823
824 void ExecuteCommand::run()
825 {
826 using Global::wFooter;
827
828 std::string cmd_name;
829 {
830 Statusbar::ScopedLock slock;
831 NC::Window::ScopedPromptHook helper(*wFooter,
832 Statusbar::Helpers::TryExecuteImmediateCommand()
833 );
834 Statusbar::put() << NC::Format::Bold << ":" << NC::Format::NoBold;
835 cmd_name = wFooter->prompt();
836 }
837
838 auto cmd = Bindings.findCommand(cmd_name);
839 if (cmd)
840 {
841 Statusbar::printf(1, "Executing %1%...", cmd_name);
842 bool res = cmd->binding().execute();
843 Statusbar::printf("Execution of command \"%1%\" %2%.",
844 cmd_name, res ? "successful" : "unsuccessful"
845 );
846 }
847 else
848 Statusbar::printf("No command named \"%1%\"", cmd_name);
849 }
850
851 bool MoveSortOrderUp::canBeRun()
852 {
853 return myScreen == mySortPlaylistDialog;
854 }
855
856 void MoveSortOrderUp::run()
857 {
858 mySortPlaylistDialog->moveSortOrderUp();
859 }
860
861 bool MoveSortOrderDown::canBeRun()
862 {
863 return myScreen == mySortPlaylistDialog;
864 }
865
866 void MoveSortOrderDown::run()
867 {
868 mySortPlaylistDialog->moveSortOrderDown();
869 }
870
871 bool MoveSelectedItemsUp::canBeRun()
872 {
873 return ((myScreen == myPlaylist
874 && !myPlaylist->main().empty())
875 || (myScreen->isActiveWindow(myPlaylistEditor->Content)
876 && !myPlaylistEditor->Content.empty()));
877 }
878
879 void MoveSelectedItemsUp::run()
880 {
881 if (myScreen == myPlaylist)
882 {
883 moveSelectedItemsUp(myPlaylist->main(), std::bind(&MPD::Connection::Move, ph::_1, ph::_2, ph::_3));
884 }
885 else if (myScreen == myPlaylistEditor)
886 {
887 assert(!myPlaylistEditor->Playlists.empty());
888 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
889 auto move_fun = std::bind(&MPD::Connection::PlaylistMove, ph::_1, playlist, ph::_2, ph::_3);
890 moveSelectedItemsUp(myPlaylistEditor->Content, move_fun);
891 }
892 }
893
894 bool MoveSelectedItemsDown::canBeRun()
895 {
896 return ((myScreen == myPlaylist
897 && !myPlaylist->main().empty())
898 || (myScreen->isActiveWindow(myPlaylistEditor->Content)
899 && !myPlaylistEditor->Content.empty()));
900 }
901
902 void MoveSelectedItemsDown::run()
903 {
904 if (myScreen == myPlaylist)
905 {
906 moveSelectedItemsDown(myPlaylist->main(), std::bind(&MPD::Connection::Move, ph::_1, ph::_2, ph::_3));
907 }
908 else if (myScreen == myPlaylistEditor)
909 {
910 assert(!myPlaylistEditor->Playlists.empty());
911 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
912 auto move_fun = std::bind(&MPD::Connection::PlaylistMove, ph::_1, playlist, ph::_2, ph::_3);
913 moveSelectedItemsDown(myPlaylistEditor->Content, move_fun);
914 }
915 }
916
917 bool MoveSelectedItemsTo::canBeRun()
918 {
919 return myScreen == myPlaylist
920 || myScreen->isActiveWindow(myPlaylistEditor->Content);
921 }
922
923 void MoveSelectedItemsTo::run()
924 {
925 if (myScreen == myPlaylist)
926 {
927 if (!myPlaylist->main().empty())
928 moveSelectedItemsTo(myPlaylist->main(), std::bind(&MPD::Connection::Move, ph::_1, ph::_2, ph::_3));
929 }
930 else
931 {
932 assert(!myPlaylistEditor->Playlists.empty());
933 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
934 auto move_fun = std::bind(&MPD::Connection::PlaylistMove, ph::_1, playlist, ph::_2, ph::_3);
935 moveSelectedItemsTo(myPlaylistEditor->Content, move_fun);
936 }
937 }
938
939 bool Add::canBeRun()
940 {
941 return myScreen != myPlaylistEditor
942 || !myPlaylistEditor->Playlists.empty();
943 }
944
945 void Add::run()
946 {
947 using Global::wFooter;
948
949 std::string path;
950 {
951 Statusbar::ScopedLock slock;
952 Statusbar::put() << (myScreen == myPlaylistEditor ? "Add to playlist: " : "Add: ");
953 path = wFooter->prompt();
954 }
955
956 // confirm when one wants to add the whole database
957 if (path.empty())
958 confirmAction("Are you sure you want to add the whole database?");
959
960 Statusbar::put() << "Adding...";
961 wFooter->refresh();
962 if (myScreen == myPlaylistEditor)
963 Mpd.AddToPlaylist(myPlaylistEditor->Playlists.current()->value().path(), path);
964 else
965 {
966 try
967 {
968 Mpd.Add(path);
969 }
970 catch (MPD::ServerError &err)
971 {
972 // If a path is not a file or directory, assume it is a playlist.
973 if (err.code() == MPD_SERVER_ERROR_NO_EXIST)
974 Mpd.LoadPlaylist(path);
975 else
976 throw;
977 }
978 }
979 }
980
981 bool SeekForward::canBeRun()
982 {
983 return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
984 }
985
986 void SeekForward::run()
987 {
988 seek();
989 }
990
991 bool SeekBackward::canBeRun()
992 {
993 return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
994 }
995
996 void SeekBackward::run()
997 {
998 seek();
999 }
1000
1001 bool ToggleDisplayMode::canBeRun()
1002 {
1003 return myScreen == myPlaylist
1004 || myScreen == myBrowser
1005 || myScreen == mySearcher
1006 || myScreen->isActiveWindow(myPlaylistEditor->Content);
1007 }
1008
1009 void ToggleDisplayMode::run()
1010 {
1011 if (myScreen == myPlaylist)
1012 {
1013 switch (Config.playlist_display_mode)
1014 {
1015 case DisplayMode::Classic:
1016 Config.playlist_display_mode = DisplayMode::Columns;
1017 myPlaylist->main().setItemDisplayer(std::bind(
1018 Display::SongsInColumns, ph::_1, std::cref(myPlaylist->main())
1019 ));
1020 if (Config.titles_visibility)
1021 myPlaylist->main().setTitle(Display::Columns(myPlaylist->main().getWidth()));
1022 else
1023 myPlaylist->main().setTitle("");
1024 break;
1025 case DisplayMode::Columns:
1026 Config.playlist_display_mode = DisplayMode::Classic;
1027 myPlaylist->main().setItemDisplayer(std::bind(
1028 Display::Songs, ph::_1, std::cref(myPlaylist->main()), std::cref(Config.song_list_format)
1029 ));
1030 myPlaylist->main().setTitle("");
1031 }
1032 Statusbar::printf("Playlist display mode: %1%", Config.playlist_display_mode);
1033 }
1034 else if (myScreen == myBrowser)
1035 {
1036 switch (Config.browser_display_mode)
1037 {
1038 case DisplayMode::Classic:
1039 Config.browser_display_mode = DisplayMode::Columns;
1040 if (Config.titles_visibility)
1041 myBrowser->main().setTitle(Display::Columns(myBrowser->main().getWidth()));
1042 else
1043 myBrowser->main().setTitle("");
1044 break;
1045 case DisplayMode::Columns:
1046 Config.browser_display_mode = DisplayMode::Classic;
1047 myBrowser->main().setTitle("");
1048 break;
1049 }
1050 Statusbar::printf("Browser display mode: %1%", Config.browser_display_mode);
1051 }
1052 else if (myScreen == mySearcher)
1053 {
1054 switch (Config.search_engine_display_mode)
1055 {
1056 case DisplayMode::Classic:
1057 Config.search_engine_display_mode = DisplayMode::Columns;
1058 break;
1059 case DisplayMode::Columns:
1060 Config.search_engine_display_mode = DisplayMode::Classic;
1061 break;
1062 }
1063 Statusbar::printf("Search engine display mode: %1%", Config.search_engine_display_mode);
1064 if (mySearcher->main().size() > SearchEngine::StaticOptions)
1065 mySearcher->main().setTitle(
1066 Config.search_engine_display_mode == DisplayMode::Columns
1067 && Config.titles_visibility
1068 ? Display::Columns(mySearcher->main().getWidth())
1069 : ""
1070 );
1071 }
1072 else if (myScreen->isActiveWindow(myPlaylistEditor->Content))
1073 {
1074 switch (Config.playlist_editor_display_mode)
1075 {
1076 case DisplayMode::Classic:
1077 Config.playlist_editor_display_mode = DisplayMode::Columns;
1078 myPlaylistEditor->Content.setItemDisplayer(std::bind(
1079 Display::SongsInColumns, ph::_1, std::cref(myPlaylistEditor->Content)
1080 ));
1081 break;
1082 case DisplayMode::Columns:
1083 Config.playlist_editor_display_mode = DisplayMode::Classic;
1084 myPlaylistEditor->Content.setItemDisplayer(std::bind(
1085 Display::Songs, ph::_1, std::cref(myPlaylistEditor->Content), std::cref(Config.song_list_format)
1086 ));
1087 break;
1088 }
1089 Statusbar::printf("Playlist editor display mode: %1%", Config.playlist_editor_display_mode);
1090 }
1091 }
1092
1093 bool ToggleSeparatorsBetweenAlbums::canBeRun()
1094 {
1095 return true;
1096 }
1097
1098 void ToggleSeparatorsBetweenAlbums::run()
1099 {
1100 Config.playlist_separate_albums = !Config.playlist_separate_albums;
1101 Statusbar::printf("Separators between albums: %1%",
1102 Config.playlist_separate_albums ? "on" : "off"
1103 );
1104 }
1105
1106 bool ToggleLyricsUpdateOnSongChange::canBeRun()
1107 {
1108 return myScreen == myLyrics;
1109 }
1110
1111 void ToggleLyricsUpdateOnSongChange::run()
1112 {
1113 Config.now_playing_lyrics = !Config.now_playing_lyrics;
1114 Statusbar::printf("Update lyrics if song changes: %1%",
1115 Config.now_playing_lyrics ? "on" : "off"
1116 );
1117 }
1118
1119 #ifndef HAVE_CURL_CURL_H
1120 bool ToggleLyricsFetcher::canBeRun()
1121 {
1122 return false;
1123 }
1124 #endif // NOT HAVE_CURL_CURL_H
1125
1126 void ToggleLyricsFetcher::run()
1127 {
1128 # ifdef HAVE_CURL_CURL_H
1129 myLyrics->ToggleFetcher();
1130 # endif // HAVE_CURL_CURL_H
1131 }
1132
1133 #ifndef HAVE_CURL_CURL_H
1134 bool ToggleFetchingLyricsInBackground::canBeRun()
1135 {
1136 return false;
1137 }
1138 #endif // NOT HAVE_CURL_CURL_H
1139
1140 void ToggleFetchingLyricsInBackground::run()
1141 {
1142 # ifdef HAVE_CURL_CURL_H
1143 Config.fetch_lyrics_in_background = !Config.fetch_lyrics_in_background;
1144 Statusbar::printf("Fetching lyrics for playing songs in background: %1%",
1145 Config.fetch_lyrics_in_background ? "on" : "off"
1146 );
1147 # endif // HAVE_CURL_CURL_H
1148 }
1149
1150 void TogglePlayingSongCentering::run()
1151 {
1152 Config.autocenter_mode = !Config.autocenter_mode;
1153 Statusbar::printf("Centering playing song: %1%",
1154 Config.autocenter_mode ? "on" : "off"
1155 );
1156 if (Config.autocenter_mode)
1157 {
1158 auto s = myPlaylist->nowPlayingSong();
1159 if (!s.empty())
1160 myPlaylist->main().highlight(s.getPosition());
1161 }
1162 }
1163
1164 void UpdateDatabase::run()
1165 {
1166 if (myScreen == myBrowser)
1167 Mpd.UpdateDirectory(myBrowser->currentDirectory());
1168 # ifdef HAVE_TAGLIB_H
1169 else if (myScreen == myTagEditor)
1170 Mpd.UpdateDirectory(myTagEditor->CurrentDir());
1171 # endif // HAVE_TAGLIB_H
1172 else
1173 Mpd.UpdateDirectory("/");
1174 }
1175
1176 bool JumpToPlayingSong::canBeRun()
1177 {
1178 return myScreen == myPlaylist
1179 || myScreen == myBrowser
1180 || myScreen == myLibrary;
1181 }
1182
1183 void JumpToPlayingSong::run()
1184 {
1185 auto s = myPlaylist->nowPlayingSong();
1186 if (s.empty())
1187 return;
1188 if (myScreen == myPlaylist)
1189 {
1190 myPlaylist->main().highlight(s.getPosition());
1191 }
1192 else if (myScreen == myBrowser)
1193 {
1194 myBrowser->locateSong(s);
1195 }
1196 else if (myScreen == myLibrary)
1197 {
1198 myLibrary->LocateSong(s);
1199 }
1200 }
1201
1202 void ToggleRepeat::run()
1203 {
1204 Mpd.SetRepeat(!Status::State::repeat());
1205 }
1206
1207 bool Shuffle::canBeRun()
1208 {
1209 if (myScreen != myPlaylist)
1210 return false;
1211 m_begin = myPlaylist->main().begin();
1212 m_end = myPlaylist->main().end();
1213 return findSelectedRangeAndPrintInfoIfNot(m_begin, m_end);
1214 }
1215
1216 void Shuffle::run()
1217 {
1218 if (Config.ask_before_shuffling_playlists)
1219 confirmAction("Do you really want to shuffle selected range?");
1220 auto begin = myPlaylist->main().begin();
1221 Mpd.ShuffleRange(m_begin-begin, m_end-begin);
1222 Statusbar::print("Range shuffled");
1223 }
1224
1225 void ToggleRandom::run()
1226 {
1227 Mpd.SetRandom(!Status::State::random());
1228 }
1229
1230 bool StartSearching::canBeRun()
1231 {
1232 return myScreen == mySearcher && !mySearcher->main()[0].isInactive();
1233 }
1234
1235 void StartSearching::run()
1236 {
1237 mySearcher->main().highlight(SearchEngine::SearchButton);
1238 mySearcher->main().setHighlighting(0);
1239 mySearcher->main().refresh();
1240 mySearcher->main().setHighlighting(1);
1241 mySearcher->runAction();
1242 }
1243
1244 bool SaveTagChanges::canBeRun()
1245 {
1246 # ifdef HAVE_TAGLIB_H
1247 return myScreen == myTinyTagEditor
1248 || myScreen->activeWindow() == myTagEditor->TagTypes;
1249 # else
1250 return false;
1251 # endif // HAVE_TAGLIB_H
1252 }
1253
1254 void SaveTagChanges::run()
1255 {
1256 # ifdef HAVE_TAGLIB_H
1257 if (myScreen == myTinyTagEditor)
1258 {
1259 myTinyTagEditor->main().highlight(myTinyTagEditor->main().size()-2); // Save
1260 myTinyTagEditor->runAction();
1261 }
1262 else if (myScreen->activeWindow() == myTagEditor->TagTypes)
1263 {
1264 myTagEditor->TagTypes->highlight(myTagEditor->TagTypes->size()-1); // Save
1265 myTagEditor->runAction();
1266 }
1267 # endif // HAVE_TAGLIB_H
1268 }
1269
1270 void ToggleSingle::run()
1271 {
1272 Mpd.SetSingle(!Status::State::single());
1273 }
1274
1275 void ToggleConsume::run()
1276 {
1277 Mpd.SetConsume(!Status::State::consume());
1278 }
1279
1280 void ToggleCrossfade::run()
1281 {
1282 Mpd.SetCrossfade(Status::State::crossfade() ? 0 : Config.crossfade_time);
1283 }
1284
1285 void SetCrossfade::run()
1286 {
1287 using Global::wFooter;
1288
1289 Statusbar::ScopedLock slock;
1290 Statusbar::put() << "Set crossfade to: ";
1291 auto crossfade = fromString<unsigned>(wFooter->prompt());
1292 lowerBoundCheck(crossfade, 0u);
1293 Config.crossfade_time = crossfade;
1294 Mpd.SetCrossfade(crossfade);
1295 }
1296
1297 void SetVolume::run()
1298 {
1299 using Global::wFooter;
1300
1301 unsigned volume;
1302 {
1303 Statusbar::ScopedLock slock;
1304 Statusbar::put() << "Set volume to: ";
1305 volume = fromString<unsigned>(wFooter->prompt());
1306 boundsCheck(volume, 0u, 100u);
1307 Mpd.SetVolume(volume);
1308 }
1309 Statusbar::printf("Volume set to %1%%%", volume);
1310 }
1311
1312 bool EnterDirectory::canBeRun()
1313 {
1314 bool result = false;
1315 if (myScreen == myBrowser && !myBrowser->main().empty())
1316 {
1317 result = myBrowser->main().current()->value().type()
1318 == MPD::Item::Type::Directory;
1319 }
1320 #ifdef HAVE_TAGLIB_H
1321 else if (myScreen->activeWindow() == myTagEditor->Dirs)
1322 result = true;
1323 #endif // HAVE_TAGLIB_H
1324 return result;
1325 }
1326
1327 void EnterDirectory::run()
1328 {
1329 if (myScreen == myBrowser)
1330 myBrowser->enterDirectory();
1331 #ifdef HAVE_TAGLIB_H
1332 else if (myScreen->activeWindow() == myTagEditor->Dirs)
1333 {
1334 if (!myTagEditor->enterDirectory())
1335 Statusbar::print("No subdirectories found");
1336 }
1337 #endif // HAVE_TAGLIB_H
1338 }
1339
1340 bool EditSong::canBeRun()
1341 {
1342 # ifdef HAVE_TAGLIB_H
1343 m_song = currentSong(myScreen);
1344 return m_song != nullptr && isMPDMusicDirSet();
1345 # else
1346 return false;
1347 # endif // HAVE_TAGLIB_H
1348 }
1349
1350 void EditSong::run()
1351 {
1352 # ifdef HAVE_TAGLIB_H
1353 myTinyTagEditor->SetEdited(*m_song);
1354 myTinyTagEditor->switchTo();
1355 # endif // HAVE_TAGLIB_H
1356 }
1357
1358 bool EditLibraryTag::canBeRun()
1359 {
1360 # ifdef HAVE_TAGLIB_H
1361 return myScreen->isActiveWindow(myLibrary->Tags)
1362 && !myLibrary->Tags.empty()
1363 && isMPDMusicDirSet();
1364 # else
1365 return false;
1366 # endif // HAVE_TAGLIB_H
1367 }
1368
1369 void EditLibraryTag::run()
1370 {
1371 # ifdef HAVE_TAGLIB_H
1372 using Global::wFooter;
1373
1374 std::string new_tag;
1375 {
1376 Statusbar::ScopedLock slock;
1377 Statusbar::put() << NC::Format::Bold << tagTypeToString(Config.media_lib_primary_tag) << NC::Format::NoBold << ": ";
1378 new_tag = wFooter->prompt(myLibrary->Tags.current()->value().tag());
1379 }
1380 if (!new_tag.empty() && new_tag != myLibrary->Tags.current()->value().tag())
1381 {
1382 Statusbar::print("Updating tags...");
1383 Mpd.StartSearch(true);
1384 Mpd.AddSearch(Config.media_lib_primary_tag, myLibrary->Tags.current()->value().tag());
1385 MPD::MutableSong::SetFunction set = tagTypeToSetFunction(Config.media_lib_primary_tag);
1386 assert(set);
1387 bool success = true;
1388 std::string dir_to_update;
1389 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s)
1390 {
1391 MPD::MutableSong ms = std::move(*s);
1392 ms.setTags(set, new_tag);
1393 Statusbar::printf("Updating tags in \"%1%\"...", ms.getName());
1394 std::string path = Config.mpd_music_dir + ms.getURI();
1395 if (!Tags::write(ms))
1396 {
1397 success = false;
1398 const char msg[] = "Error while updating tags in \"%1%\"";
1399 Statusbar::printf(msg, wideShorten(ms.getURI(), COLS-const_strlen(msg)));
1400 s.finish();
1401 break;
1402 }
1403 if (dir_to_update.empty())
1404 dir_to_update = ms.getURI();
1405 else
1406 dir_to_update = getSharedDirectory(dir_to_update, ms.getURI());
1407 };
1408 if (success)
1409 {
1410 Mpd.UpdateDirectory(dir_to_update);
1411 Statusbar::print("Tags updated successfully");
1412 }
1413 }
1414 # endif // HAVE_TAGLIB_H
1415 }
1416
1417 bool EditLibraryAlbum::canBeRun()
1418 {
1419 # ifdef HAVE_TAGLIB_H
1420 return myScreen->isActiveWindow(myLibrary->Albums)
1421 && !myLibrary->Albums.empty()
1422 && isMPDMusicDirSet();
1423 # else
1424 return false;
1425 # endif // HAVE_TAGLIB_H
1426 }
1427
1428 void EditLibraryAlbum::run()
1429 {
1430 # ifdef HAVE_TAGLIB_H
1431 using Global::wFooter;
1432 // FIXME: merge this and EditLibraryTag. also, prompt on failure if user wants to continue
1433 std::string new_album;
1434 {
1435 Statusbar::ScopedLock slock;
1436 Statusbar::put() << NC::Format::Bold << "Album: " << NC::Format::NoBold;
1437 new_album = wFooter->prompt(myLibrary->Albums.current()->value().entry().album());
1438 }
1439 if (!new_album.empty() && new_album != myLibrary->Albums.current()->value().entry().album())
1440 {
1441 bool success = 1;
1442 Statusbar::print("Updating tags...");
1443 for (size_t i = 0; i < myLibrary->Songs.size(); ++i)
1444 {
1445 Statusbar::printf("Updating tags in \"%1%\"...", myLibrary->Songs[i].value().getName());
1446 std::string path = Config.mpd_music_dir + myLibrary->Songs[i].value().getURI();
1447 TagLib::FileRef f(path.c_str());
1448 if (f.isNull())
1449 {
1450 const char msg[] = "Error while opening file \"%1%\"";
1451 Statusbar::printf(msg, wideShorten(myLibrary->Songs[i].value().getURI(), COLS-const_strlen(msg)));
1452 success = 0;
1453 break;
1454 }
1455 f.tag()->setAlbum(ToWString(new_album));
1456 if (!f.save())
1457 {
1458 const char msg[] = "Error while writing tags in \"%1%\"";
1459 Statusbar::printf(msg, wideShorten(myLibrary->Songs[i].value().getURI(), COLS-const_strlen(msg)));
1460 success = 0;
1461 break;
1462 }
1463 }
1464 if (success)
1465 {
1466 Mpd.UpdateDirectory(getSharedDirectory(myLibrary->Songs.beginV(), myLibrary->Songs.endV()));
1467 Statusbar::print("Tags updated successfully");
1468 }
1469 }
1470 # endif // HAVE_TAGLIB_H
1471 }
1472
1473 bool EditDirectoryName::canBeRun()
1474 {
1475 return ((myScreen == myBrowser
1476 && !myBrowser->main().empty()
1477 && myBrowser->main().current()->value().type() == MPD::Item::Type::Directory)
1478 # ifdef HAVE_TAGLIB_H
1479 || (myScreen->activeWindow() == myTagEditor->Dirs
1480 && !myTagEditor->Dirs->empty()
1481 && myTagEditor->Dirs->choice() > 0)
1482 # endif // HAVE_TAGLIB_H
1483 ) && isMPDMusicDirSet();
1484 }
1485
1486 void EditDirectoryName::run()
1487 {
1488 using Global::wFooter;
1489 if (myScreen == myBrowser)
1490 {
1491 std::string old_dir = myBrowser->main().current()->value().directory().path();
1492 std::string new_dir;
1493 {
1494 Statusbar::ScopedLock slock;
1495 Statusbar::put() << NC::Format::Bold << "Directory: " << NC::Format::NoBold;
1496 new_dir = wFooter->prompt(old_dir);
1497 }
1498 if (!new_dir.empty() && new_dir != old_dir)
1499 {
1500 std::string full_old_dir;
1501 if (!myBrowser->isLocal())
1502 full_old_dir += Config.mpd_music_dir;
1503 full_old_dir += old_dir;
1504 std::string full_new_dir;
1505 if (!myBrowser->isLocal())
1506 full_new_dir += Config.mpd_music_dir;
1507 full_new_dir += new_dir;
1508 boost::filesystem::rename(full_old_dir, full_new_dir);
1509 const char msg[] = "Directory renamed to \"%1%\"";
1510 Statusbar::printf(msg, wideShorten(new_dir, COLS-const_strlen(msg)));
1511 if (!myBrowser->isLocal())
1512 Mpd.UpdateDirectory(getSharedDirectory(old_dir, new_dir));
1513 myBrowser->requestUpdate();
1514 }
1515 }
1516 # ifdef HAVE_TAGLIB_H
1517 else if (myScreen->activeWindow() == myTagEditor->Dirs)
1518 {
1519 std::string old_dir = myTagEditor->Dirs->current()->value().first, new_dir;
1520 {
1521 Statusbar::ScopedLock slock;
1522 Statusbar::put() << NC::Format::Bold << "Directory: " << NC::Format::NoBold;
1523 new_dir = wFooter->prompt(old_dir);
1524 }
1525 if (!new_dir.empty() && new_dir != old_dir)
1526 {
1527 std::string full_old_dir = Config.mpd_music_dir + myTagEditor->CurrentDir() + "/" + old_dir;
1528 std::string full_new_dir = Config.mpd_music_dir + myTagEditor->CurrentDir() + "/" + new_dir;
1529 if (rename(full_old_dir.c_str(), full_new_dir.c_str()) == 0)
1530 {
1531 const char msg[] = "Directory renamed to \"%1%\"";
1532 Statusbar::printf(msg, wideShorten(new_dir, COLS-const_strlen(msg)));
1533 Mpd.UpdateDirectory(myTagEditor->CurrentDir());
1534 }
1535 else
1536 {
1537 const char msg[] = "Couldn't rename \"%1%\": %2%";
1538 Statusbar::printf(msg, wideShorten(old_dir, COLS-const_strlen(msg)-25), strerror(errno));
1539 }
1540 }
1541 }
1542 # endif // HAVE_TAGLIB_H
1543 }
1544
1545 bool EditPlaylistName::canBeRun()
1546 {
1547 return (myScreen->isActiveWindow(myPlaylistEditor->Playlists)
1548 && !myPlaylistEditor->Playlists.empty())
1549 || (myScreen == myBrowser
1550 && !myBrowser->main().empty()
1551 && myBrowser->main().current()->value().type() == MPD::Item::Type::Playlist);
1552 }
1553
1554 void EditPlaylistName::run()
1555 {
1556 using Global::wFooter;
1557 std::string old_name, new_name;
1558 if (myScreen->isActiveWindow(myPlaylistEditor->Playlists))
1559 old_name = myPlaylistEditor->Playlists.current()->value().path();
1560 else
1561 old_name = myBrowser->main().current()->value().playlist().path();
1562 {
1563 Statusbar::ScopedLock slock;
1564 Statusbar::put() << NC::Format::Bold << "Playlist: " << NC::Format::NoBold;
1565 new_name = wFooter->prompt(old_name);
1566 }
1567 if (!new_name.empty() && new_name != old_name)
1568 {
1569 Mpd.Rename(old_name, new_name);
1570 const char msg[] = "Playlist renamed to \"%1%\"";
1571 Statusbar::printf(msg, wideShorten(new_name, COLS-const_strlen(msg)));
1572 }
1573 }
1574
1575 bool EditLyrics::canBeRun()
1576 {
1577 return myScreen == myLyrics;
1578 }
1579
1580 void EditLyrics::run()
1581 {
1582 myLyrics->Edit();
1583 }
1584
1585 bool JumpToBrowser::canBeRun()
1586 {
1587 m_song = currentSong(myScreen);
1588 return m_song != nullptr;
1589 }
1590
1591 void JumpToBrowser::run()
1592 {
1593 myBrowser->locateSong(*m_song);
1594 }
1595
1596 bool JumpToMediaLibrary::canBeRun()
1597 {
1598 m_song = currentSong(myScreen);
1599 return m_song != nullptr;
1600 }
1601
1602 void JumpToMediaLibrary::run()
1603 {
1604 myLibrary->LocateSong(*m_song);
1605 }
1606
1607 bool JumpToPlaylistEditor::canBeRun()
1608 {
1609 return myScreen == myBrowser
1610 && myBrowser->main().current()->value().type() == MPD::Item::Type::Playlist;
1611 }
1612
1613 void JumpToPlaylistEditor::run()
1614 {
1615 myPlaylistEditor->Locate(myBrowser->main().current()->value().playlist());
1616 }
1617
1618 void ToggleScreenLock::run()
1619 {
1620 using Global::wFooter;
1621 using Global::myLockedScreen;
1622 const char *msg_unlockable_screen = "Current screen can't be locked";
1623 if (myLockedScreen != nullptr)
1624 {
1625 BaseScreen::unlock();
1626 Actions::setResizeFlags();
1627 myScreen->resize();
1628 Statusbar::print("Screen unlocked");
1629 }
1630 else if (!myScreen->isLockable())
1631 {
1632 Statusbar::print(msg_unlockable_screen);
1633 }
1634 else
1635 {
1636 unsigned part = Config.locked_screen_width_part*100;
1637 if (Config.ask_for_locked_screen_width_part)
1638 {
1639 Statusbar::ScopedLock slock;
1640 Statusbar::put() << "% of the locked screen's width to be reserved (20-80): ";
1641 part = fromString<unsigned>(wFooter->prompt(boost::lexical_cast<std::string>(part)));
1642 }
1643 boundsCheck(part, 20u, 80u);
1644 Config.locked_screen_width_part = part/100.0;
1645 if (myScreen->lock())
1646 Statusbar::printf("Screen locked (with %1%%% width)", part);
1647 else
1648 Statusbar::print(msg_unlockable_screen);
1649 }
1650 }
1651
1652 bool JumpToTagEditor::canBeRun()
1653 {
1654 # ifdef HAVE_TAGLIB_H
1655 m_song = currentSong(myScreen);
1656 return m_song != nullptr && isMPDMusicDirSet();
1657 # else
1658 return false;
1659 # endif // HAVE_TAGLIB_H
1660 }
1661
1662 void JumpToTagEditor::run()
1663 {
1664 # ifdef HAVE_TAGLIB_H
1665 myTagEditor->LocateSong(*m_song);
1666 # endif // HAVE_TAGLIB_H
1667 }
1668
1669 bool JumpToPositionInSong::canBeRun()
1670 {
1671 return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
1672 }
1673
1674 void JumpToPositionInSong::run()
1675 {
1676 using Global::wFooter;
1677
1678 const MPD::Song s = myPlaylist->nowPlayingSong();
1679
1680 std::string spos;
1681 {
1682 Statusbar::ScopedLock slock;
1683 Statusbar::put() << "Position to go (in %/m:ss/seconds(s)): ";
1684 spos = wFooter->prompt();
1685 }
1686
1687 boost::regex rx;
1688 boost::smatch what;
1689 if (boost::regex_match(spos, what, rx.assign("([0-9]+):([0-9]{2})"))) // mm:ss
1690 {
1691 auto mins = fromString<unsigned>(what[1]);
1692 auto secs = fromString<unsigned>(what[2]);
1693 boundsCheck(secs, 0u, 60u);
1694 Mpd.Seek(s.getPosition(), mins * 60 + secs);
1695 }
1696 else if (boost::regex_match(spos, what, rx.assign("([0-9]+)s"))) // position in seconds
1697 {
1698 auto secs = fromString<unsigned>(what[1]);
1699 Mpd.Seek(s.getPosition(), secs);
1700 }
1701 else if (boost::regex_match(spos, what, rx.assign("([0-9]+)[%]{0,1}"))) // position in %
1702 {
1703 auto percent = fromString<unsigned>(what[1]);
1704 boundsCheck(percent, 0u, 100u);
1705 int secs = (percent * s.getDuration()) / 100.0;
1706 Mpd.Seek(s.getPosition(), secs);
1707 }
1708 else
1709 Statusbar::print("Invalid format ([m]:[ss], [s]s, [%]%, [%] accepted)");
1710 }
1711
1712 bool SelectItem::canBeRun()
1713 {
1714 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1715 return m_list != nullptr
1716 && !m_list->empty()
1717 && m_list->currentP()->isSelectable();
1718 }
1719
1720 void SelectItem::run()
1721 {
1722 auto current = m_list->currentP();
1723 current->setSelected(!current->isSelected());
1724 }
1725
1726 bool SelectRange::canBeRun()
1727 {
1728 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1729 if (m_list == nullptr)
1730 return false;
1731 m_begin = m_list->beginP();
1732 m_end = m_list->endP();
1733 return findRange(m_begin, m_end);
1734 }
1735
1736 void SelectRange::run()
1737 {
1738 for (; m_begin != m_end; ++m_begin)
1739 m_begin->setSelected(true);
1740 Statusbar::print("Range selected");
1741 }
1742
1743 bool ReverseSelection::canBeRun()
1744 {
1745 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1746 return m_list != nullptr;
1747 }
1748
1749 void ReverseSelection::run()
1750 {
1751 for (auto &p : *m_list)
1752 p.setSelected(!p.isSelected());
1753 Statusbar::print("Selection reversed");
1754 }
1755
1756 bool RemoveSelection::canBeRun()
1757 {
1758 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1759 return m_list != nullptr;
1760 }
1761
1762 void RemoveSelection::run()
1763 {
1764 for (auto &p : *m_list)
1765 p.setSelected(false);
1766 Statusbar::print("Selection removed");
1767 }
1768
1769 bool SelectAlbum::canBeRun()
1770 {
1771 auto *w = myScreen->activeWindow();
1772 if (m_list != static_cast<void *>(w))
1773 m_list = dynamic_cast<NC::List *>(w);
1774 if (m_songs != static_cast<void *>(w))
1775 m_songs = dynamic_cast<SongList *>(w);
1776 return m_list != nullptr && !m_list->empty()
1777 && m_songs != nullptr;
1778 }
1779
1780 void SelectAlbum::run()
1781 {
1782 const auto front = m_songs->beginS(), current = m_songs->currentS(), end = m_songs->endS();
1783 auto *s = current->get<Bit::Song>();
1784 if (s == nullptr)
1785 return;
1786 auto get = &MPD::Song::getAlbum;
1787 const std::string tag = s->getTags(get);
1788 // go up
1789 for (auto it = current; it != front;)
1790 {
1791 --it;
1792 s = it->get<Bit::Song>();
1793 if (s == nullptr || s->getTags(get) != tag)
1794 break;
1795 it->get<Bit::Properties>().setSelected(true);
1796 }
1797 // go down
1798 for (auto it = current;;)
1799 {
1800 it->get<Bit::Properties>().setSelected(true);
1801 if (++it == end)
1802 break;
1803 s = it->get<Bit::Song>();
1804 if (s == nullptr || s->getTags(get) != tag)
1805 break;
1806 }
1807 Statusbar::print("Album around cursor position selected");
1808 }
1809
1810 bool SelectFoundItems::canBeRun()
1811 {
1812 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1813 if (m_list == nullptr || m_list->empty())
1814 return false;
1815 m_searchable = dynamic_cast<Searchable *>(myScreen);
1816 return m_searchable != nullptr && m_searchable->allowsSearching();
1817 }
1818
1819 void SelectFoundItems::run()
1820 {
1821 auto current_pos = m_list->choice();
1822 myScreen->activeWindow()->scroll(NC::Scroll::Home);
1823 bool found = m_searchable->search(SearchDirection::Forward, false, false);
1824 if (found)
1825 {
1826 Statusbar::print("Searching for items...");
1827 m_list->currentP()->setSelected(true);
1828 while (m_searchable->search(SearchDirection::Forward, false, true))
1829 m_list->currentP()->setSelected(true);
1830 Statusbar::print("Found items selected");
1831 }
1832 m_list->highlight(current_pos);
1833 }
1834
1835 bool AddSelectedItems::canBeRun()
1836 {
1837 return myScreen != mySelectedItemsAdder;
1838 }
1839
1840 void AddSelectedItems::run()
1841 {
1842 mySelectedItemsAdder->switchTo();
1843 }
1844
1845 void CropMainPlaylist::run()
1846 {
1847 auto &w = myPlaylist->main();
1848 // cropping doesn't make sense in this case
1849 if (w.size() <= 1)
1850 return;
1851 if (Config.ask_before_clearing_playlists)
1852 confirmAction("Do you really want to crop main playlist?");
1853 Statusbar::print("Cropping playlist...");
1854 selectCurrentIfNoneSelected(w);
1855 cropPlaylist(w, std::bind(&MPD::Connection::Delete, ph::_1, ph::_2));
1856 Statusbar::print("Playlist cropped");
1857 }
1858
1859 bool CropPlaylist::canBeRun()
1860 {
1861 return myScreen == myPlaylistEditor;
1862 }
1863
1864 void CropPlaylist::run()
1865 {
1866 auto &w = myPlaylistEditor->Content;
1867 // cropping doesn't make sense in this case
1868 if (w.size() <= 1)
1869 return;
1870 assert(!myPlaylistEditor->Playlists.empty());
1871 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
1872 if (Config.ask_before_clearing_playlists)
1873 confirmAction(boost::format("Do you really want to crop playlist \"%1%\"?") % playlist);
1874 selectCurrentIfNoneSelected(w);
1875 Statusbar::printf("Cropping playlist \"%1%\"...", playlist);
1876 cropPlaylist(w, std::bind(&MPD::Connection::PlaylistDelete, ph::_1, playlist, ph::_2));
1877 Statusbar::printf("Playlist \"%1%\" cropped", playlist);
1878 }
1879
1880 void ClearMainPlaylist::run()
1881 {
1882 if (!myPlaylist->main().empty() && Config.ask_before_clearing_playlists)
1883 confirmAction("Do you really want to clear main playlist?");
1884 Mpd.ClearMainPlaylist();
1885 Statusbar::print("Playlist cleared");
1886 myPlaylist->main().reset();
1887 }
1888
1889 bool ClearPlaylist::canBeRun()
1890 {
1891 return myScreen == myPlaylistEditor;
1892 }
1893
1894 void ClearPlaylist::run()
1895 {
1896 if (myPlaylistEditor->Playlists.empty())
1897 return;
1898 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
1899 if (Config.ask_before_clearing_playlists)
1900 confirmAction(boost::format("Do you really want to clear playlist \"%1%\"?") % playlist);
1901 Mpd.ClearPlaylist(playlist);
1902 Statusbar::printf("Playlist \"%1%\" cleared", playlist);
1903 }
1904
1905 bool SortPlaylist::canBeRun()
1906 {
1907 if (myScreen != myPlaylist)
1908 return false;
1909 auto first = myPlaylist->main().begin(), last = myPlaylist->main().end();
1910 return findSelectedRangeAndPrintInfoIfNot(first, last);
1911 }
1912
1913 void SortPlaylist::run()
1914 {
1915 mySortPlaylistDialog->switchTo();
1916 }
1917
1918 bool ReversePlaylist::canBeRun()
1919 {
1920 if (myScreen != myPlaylist)
1921 return false;
1922 m_begin = myPlaylist->main().begin();
1923 m_end = myPlaylist->main().end();
1924 return findSelectedRangeAndPrintInfoIfNot(m_begin, m_end);
1925 }
1926
1927 void ReversePlaylist::run()
1928 {
1929 Statusbar::print("Reversing range...");
1930 Mpd.StartCommandsList();
1931 for (--m_end; m_begin < m_end; ++m_begin, --m_end)
1932 Mpd.Swap(m_begin->value().getPosition(), m_end->value().getPosition());
1933 Mpd.CommitCommandsList();
1934 Statusbar::print("Range reversed");
1935 }
1936
1937 bool ApplyFilter::canBeRun()
1938 {
1939 return false;
1940 }
1941
1942 void ApplyFilter::run()
1943 { }
1944
1945 bool Find::canBeRun()
1946 {
1947 return myScreen == myHelp
1948 || myScreen == myLyrics
1949 # ifdef HAVE_CURL_CURL_H
1950 || myScreen == myLastfm
1951 # endif // HAVE_CURL_CURL_H
1952 ;
1953 }
1954
1955 void Find::run()
1956 {
1957 using Global::wFooter;
1958
1959 std::string token;
1960 {
1961 Statusbar::ScopedLock slock;
1962 Statusbar::put() << "Find: ";
1963 token = wFooter->prompt();
1964 }
1965
1966 Statusbar::print("Searching...");
1967 auto s = static_cast<Screen<NC::Scrollpad> *>(myScreen);
1968 s->main().removeProperties();
1969 if (token.empty() || s->main().setProperties(NC::Format::Reverse, token, NC::Format::NoReverse, Config.regex_type))
1970 Statusbar::print("Done");
1971 else
1972 Statusbar::print("No matching patterns found");
1973 s->main().flush();
1974 }
1975
1976 bool FindItemBackward::canBeRun()
1977 {
1978 auto w = dynamic_cast<Searchable *>(myScreen);
1979 return w && w->allowsSearching();
1980 }
1981
1982 void FindItemForward::run()
1983 {
1984 findItem(SearchDirection::Forward);
1985 listsChangeFinisher();
1986 }
1987
1988 bool FindItemForward::canBeRun()
1989 {
1990 auto w = dynamic_cast<Searchable *>(myScreen);
1991 return w && w->allowsSearching();
1992 }
1993
1994 void FindItemBackward::run()
1995 {
1996 findItem(SearchDirection::Backward);
1997 listsChangeFinisher();
1998 }
1999
2000 bool NextFoundItem::canBeRun()
2001 {
2002 return dynamic_cast<Searchable *>(myScreen);
2003 }
2004
2005 void NextFoundItem::run()
2006 {
2007 Searchable *w = dynamic_cast<Searchable *>(myScreen);
2008 assert(w != nullptr);
2009 w->search(SearchDirection::Forward, Config.wrapped_search, true);
2010 listsChangeFinisher();
2011 }
2012
2013 bool PreviousFoundItem::canBeRun()
2014 {
2015 return dynamic_cast<Searchable *>(myScreen);
2016 }
2017
2018 void PreviousFoundItem::run()
2019 {
2020 Searchable *w = dynamic_cast<Searchable *>(myScreen);
2021 assert(w != nullptr);
2022 w->search(SearchDirection::Backward, Config.wrapped_search, true);
2023 listsChangeFinisher();
2024 }
2025
2026 void ToggleFindMode::run()
2027 {
2028 Config.wrapped_search = !Config.wrapped_search;
2029 Statusbar::printf("Search mode: %1%",
2030 Config.wrapped_search ? "Wrapped" : "Normal"
2031 );
2032 }
2033
2034 void ToggleReplayGainMode::run()
2035 {
2036 using Global::wFooter;
2037
2038 char rgm = 0;
2039 {
2040 Statusbar::ScopedLock slock;
2041 Statusbar::put() << "Replay gain mode? "
2042 << "[" << NC::Format::Bold << 'o' << NC::Format::NoBold << "ff"
2043 << "/" << NC::Format::Bold << 't' << NC::Format::NoBold << "rack"
2044 << "/" << NC::Format::Bold << 'a' << NC::Format::NoBold << "lbum"
2045 << "] ";
2046 rgm = Statusbar::Helpers::promptReturnOneOf({"t", "a", "o"})[0];
2047 }
2048 switch (rgm)
2049 {
2050 case 't':
2051 Mpd.SetReplayGainMode(MPD::rgmTrack);
2052 break;
2053 case 'a':
2054 Mpd.SetReplayGainMode(MPD::rgmAlbum);
2055 break;
2056 case 'o':
2057 Mpd.SetReplayGainMode(MPD::rgmOff);
2058 break;
2059 default: // impossible
2060 throw std::runtime_error(
2061 (boost::format("ToggleReplayGainMode: impossible case reached: %1%") % rgm).str()
2062 );
2063 }
2064 Statusbar::printf("Replay gain mode: %1%", Mpd.GetReplayGainMode());
2065 }
2066
2067 void ToggleAddMode::run()
2068 {
2069 std::string mode_desc;
2070 switch (Config.space_add_mode)
2071 {
2072 case SpaceAddMode::AddRemove:
2073 Config.space_add_mode = SpaceAddMode::AlwaysAdd;
2074 mode_desc = "always add an item to playlist";
2075 break;
2076 case SpaceAddMode::AlwaysAdd:
2077 Config.space_add_mode = SpaceAddMode::AddRemove;
2078 mode_desc = "add an item to playlist or remove if already added";
2079 break;
2080 }
2081 Statusbar::printf("Add mode: %1%", mode_desc);
2082 }
2083
2084 void ToggleMouse::run()
2085 {
2086 Config.mouse_support = !Config.mouse_support;
2087 if (Config.mouse_support)
2088 NC::Mouse::enable();
2089 else
2090 NC::Mouse::disable();
2091 Statusbar::printf("Mouse support %1%",
2092 Config.mouse_support ? "enabled" : "disabled"
2093 );
2094 }
2095
2096 void ToggleBitrateVisibility::run()
2097 {
2098 Config.display_bitrate = !Config.display_bitrate;
2099 Statusbar::printf("Bitrate visibility %1%",
2100 Config.display_bitrate ? "enabled" : "disabled"
2101 );
2102 }
2103
2104 void AddRandomItems::run()
2105 {
2106 using Global::wFooter;
2107 char rnd_type = 0;
2108 {
2109 Statusbar::ScopedLock slock;
2110 Statusbar::put() << "Add random? "
2111 << "[" << NC::Format::Bold << 's' << NC::Format::NoBold << "ongs"
2112 << "/" << NC::Format::Bold << 'a' << NC::Format::NoBold << "rtists"
2113 << "/" << "album" << NC::Format::Bold << 'A' << NC::Format::NoBold << "rtists"
2114 << "/" << "al" << NC::Format::Bold << 'b' << NC::Format::NoBold << "ums"
2115 << "] ";
2116 rnd_type = Statusbar::Helpers::promptReturnOneOf({"s", "a", "A", "b"})[0];
2117 }
2118
2119 mpd_tag_type tag_type = MPD_TAG_ARTIST;
2120 std::string tag_type_str ;
2121 if (rnd_type != 's')
2122 {
2123 tag_type = charToTagType(rnd_type);
2124 tag_type_str = boost::locale::to_lower(tagTypeToString(tag_type));
2125 }
2126 else
2127 tag_type_str = "song";
2128
2129 unsigned number;
2130 {
2131 Statusbar::ScopedLock slock;
2132 Statusbar::put() << "Number of random " << tag_type_str << "s: ";
2133 number = fromString<unsigned>(wFooter->prompt());
2134 }
2135 if (number > 0)
2136 {
2137 bool success;
2138 if (rnd_type == 's')
2139 success = Mpd.AddRandomSongs(number, Global::RNG);
2140 else
2141 success = Mpd.AddRandomTag(tag_type, number, Global::RNG);
2142 if (success)
2143 Statusbar::printf("%1% random %2%%3% added to playlist", number, tag_type_str, number == 1 ? "" : "s");
2144 }
2145 }
2146
2147 bool ToggleBrowserSortMode::canBeRun()
2148 {
2149 return myScreen == myBrowser;
2150 }
2151
2152 void ToggleBrowserSortMode::run()
2153 {
2154 switch (Config.browser_sort_mode)
2155 {
2156 case SortMode::Name:
2157 Config.browser_sort_mode = SortMode::ModificationTime;
2158 Statusbar::print("Sort songs by: modification time");
2159 break;
2160 case SortMode::ModificationTime:
2161 Config.browser_sort_mode = SortMode::CustomFormat;
2162 Statusbar::print("Sort songs by: custom format");
2163 break;
2164 case SortMode::CustomFormat:
2165 Config.browser_sort_mode = SortMode::NoOp;
2166 Statusbar::print("Do not sort songs");
2167 break;
2168 case SortMode::NoOp:
2169 Config.browser_sort_mode = SortMode::Name;
2170 Statusbar::print("Sort songs by: name");
2171 }
2172 if (Config.browser_sort_mode != SortMode::NoOp)
2173 {
2174 size_t sort_offset = myBrowser->inRootDirectory() ? 0 : 1;
2175 std::sort(myBrowser->main().begin()+sort_offset, myBrowser->main().end(),
2176 LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode)
2177 );
2178 }
2179 }
2180
2181 bool ToggleLibraryTagType::canBeRun()
2182 {
2183 return (myScreen->isActiveWindow(myLibrary->Tags))
2184 || (myLibrary->Columns() == 2 && myScreen->isActiveWindow(myLibrary->Albums));
2185 }
2186
2187 void ToggleLibraryTagType::run()
2188 {
2189 using Global::wFooter;
2190
2191 char tag_type = 0;
2192 {
2193 Statusbar::ScopedLock slock;
2194 Statusbar::put() << "Tag type? "
2195 << "[" << NC::Format::Bold << 'a' << NC::Format::NoBold << "rtist"
2196 << "/" << "album" << NC::Format::Bold << 'A' << NC::Format::NoBold << "rtist"
2197 << "/" << NC::Format::Bold << 'y' << NC::Format::NoBold << "ear"
2198 << "/" << NC::Format::Bold << 'g' << NC::Format::NoBold << "enre"
2199 << "/" << NC::Format::Bold << 'c' << NC::Format::NoBold << "omposer"
2200 << "/" << NC::Format::Bold << 'p' << NC::Format::NoBold << "erformer"
2201 << "] ";
2202 tag_type = Statusbar::Helpers::promptReturnOneOf({"a", "A", "y", "g", "c", "p"})[0];
2203 }
2204 mpd_tag_type new_tagitem = charToTagType(tag_type);
2205 if (new_tagitem != Config.media_lib_primary_tag)
2206 {
2207 Config.media_lib_primary_tag = new_tagitem;
2208 std::string item_type = tagTypeToString(Config.media_lib_primary_tag);
2209 myLibrary->Tags.setTitle(Config.titles_visibility ? item_type + "s" : "");
2210 myLibrary->Tags.reset();
2211 item_type = boost::locale::to_lower(item_type);
2212 std::string and_mtime = Config.media_library_sort_by_mtime ?
2213 " and mtime" :
2214 "";
2215 if (myLibrary->Columns() == 2)
2216 {
2217 myLibrary->Songs.clear();
2218 myLibrary->Albums.reset();
2219 myLibrary->Albums.clear();
2220 myLibrary->Albums.setTitle(Config.titles_visibility ? "Albums (sorted by " + item_type + and_mtime + ")" : "");
2221 myLibrary->Albums.display();
2222 }
2223 else
2224 {
2225 myLibrary->Tags.clear();
2226 myLibrary->Tags.display();
2227 }
2228 Statusbar::printf("Switched to the list of %1%s", item_type);
2229 }
2230 }
2231
2232 bool ToggleMediaLibrarySortMode::canBeRun()
2233 {
2234 return myScreen == myLibrary;
2235 }
2236
2237 void ToggleMediaLibrarySortMode::run()
2238 {
2239 myLibrary->toggleSortMode();
2240 }
2241
2242 bool RefetchLyrics::canBeRun()
2243 {
2244 # ifdef HAVE_CURL_CURL_H
2245 return myScreen == myLyrics;
2246 # else
2247 return false;
2248 # endif // HAVE_CURL_CURL_H
2249 }
2250
2251 void RefetchLyrics::run()
2252 {
2253 # ifdef HAVE_CURL_CURL_H
2254 myLyrics->Refetch();
2255 # endif // HAVE_CURL_CURL_H
2256 }
2257
2258 bool SetSelectedItemsPriority::canBeRun()
2259 {
2260 if (Mpd.Version() < 17)
2261 {
2262 Statusbar::print("Priorities are supported in MPD >= 0.17.0");
2263 return false;
2264 }
2265 return myScreen == myPlaylist && !myPlaylist->main().empty();
2266 }
2267
2268 void SetSelectedItemsPriority::run()
2269 {
2270 using Global::wFooter;
2271
2272 unsigned prio;
2273 {
2274 Statusbar::ScopedLock slock;
2275 Statusbar::put() << "Set priority [0-255]: ";
2276 prio = fromString<unsigned>(wFooter->prompt());
2277 boundsCheck(prio, 0u, 255u);
2278 }
2279 myPlaylist->setSelectedItemsPriority(prio);
2280 }
2281
2282 bool ToggleOutput::canBeRun()
2283 {
2284 #ifdef ENABLE_OUTPUTS
2285 return myScreen == myOutputs;
2286 #else
2287 return false;
2288 #endif // ENABLE_OUTPUTS
2289 }
2290
2291 void ToggleOutput::run()
2292 {
2293 #ifdef ENABLE_OUTPUTS
2294 myOutputs->toggleOutput();
2295 #endif // ENABLE_OUTPUTS
2296 }
2297
2298 bool ToggleVisualizationType::canBeRun()
2299 {
2300 # ifdef ENABLE_VISUALIZER
2301 return myScreen == myVisualizer;
2302 # else
2303 return false;
2304 # endif // ENABLE_VISUALIZER
2305 }
2306
2307 void ToggleVisualizationType::run()
2308 {
2309 # ifdef ENABLE_VISUALIZER
2310 myVisualizer->ToggleVisualizationType();
2311 # endif // ENABLE_VISUALIZER
2312 }
2313
2314 bool SetVisualizerSampleMultiplier::canBeRun()
2315 {
2316 # ifdef ENABLE_VISUALIZER
2317 return myScreen == myVisualizer;
2318 # else
2319 return false;
2320 # endif // ENABLE_VISUALIZER
2321 }
2322
2323 void SetVisualizerSampleMultiplier::run()
2324 {
2325 # ifdef ENABLE_VISUALIZER
2326 using Global::wFooter;
2327
2328 double multiplier;
2329 {
2330 Statusbar::ScopedLock slock;
2331 Statusbar::put() << "Set visualizer sample multiplier: ";
2332 multiplier = fromString<double>(wFooter->prompt());
2333 lowerBoundCheck(multiplier, 0.0);
2334 Config.visualizer_sample_multiplier = multiplier;
2335 }
2336 Statusbar::printf("Visualizer sample multiplier set to %1%", multiplier);
2337 # endif // ENABLE_VISUALIZER
2338 }
2339
2340 void ShowSongInfo::run()
2341 {
2342 mySongInfo->switchTo();
2343 }
2344
2345 bool ShowArtistInfo::canBeRun()
2346 {
2347 #ifdef HAVE_CURL_CURL_H
2348 return myScreen == myLastfm
2349 || (myScreen->isActiveWindow(myLibrary->Tags)
2350 && !myLibrary->Tags.empty()
2351 && Config.media_lib_primary_tag == MPD_TAG_ARTIST)
2352 || currentSong(myScreen);
2353 # else
2354 return false;
2355 # endif // NOT HAVE_CURL_CURL_H
2356 }
2357
2358 void ShowArtistInfo::run()
2359 {
2360 # ifdef HAVE_CURL_CURL_H
2361 if (myScreen == myLastfm)
2362 {
2363 myLastfm->switchTo();
2364 return;
2365 }
2366
2367 std::string artist;
2368 if (myScreen->isActiveWindow(myLibrary->Tags))
2369 {
2370 assert(!myLibrary->Tags.empty());
2371 assert(Config.media_lib_primary_tag == MPD_TAG_ARTIST);
2372 artist = myLibrary->Tags.current()->value().tag();
2373 }
2374 else
2375 {
2376 auto s = currentSong(myScreen);
2377 assert(s);
2378 artist = s->getArtist();
2379 }
2380
2381 if (!artist.empty())
2382 {
2383 myLastfm->queueJob(new LastFm::ArtistInfo(artist, Config.lastfm_preferred_language));
2384 myLastfm->switchTo();
2385 }
2386 # endif // HAVE_CURL_CURL_H
2387 }
2388
2389 void ShowLyrics::run()
2390 {
2391 myLyrics->switchTo();
2392 }
2393
2394 void Quit::run()
2395 {
2396 ExitMainLoop = true;
2397 }
2398
2399 void NextScreen::run()
2400 {
2401 if (Config.screen_switcher_previous)
2402 {
2403 if (auto tababble = dynamic_cast<Tabbable *>(myScreen))
2404 tababble->switchToPreviousScreen();
2405 }
2406 else if (!Config.screen_sequence.empty())
2407 {
2408 const auto &seq = Config.screen_sequence;
2409 auto screen_type = std::find(seq.begin(), seq.end(), myScreen->type());
2410 if (++screen_type == seq.end())
2411 toScreen(seq.front())->switchTo();
2412 else
2413 toScreen(*screen_type)->switchTo();
2414 }
2415 }
2416
2417 void PreviousScreen::run()
2418 {
2419 if (Config.screen_switcher_previous)
2420 {
2421 if (auto tababble = dynamic_cast<Tabbable *>(myScreen))
2422 tababble->switchToPreviousScreen();
2423 }
2424 else if (!Config.screen_sequence.empty())
2425 {
2426 const auto &seq = Config.screen_sequence;
2427 auto screen_type = std::find(seq.begin(), seq.end(), myScreen->type());
2428 if (screen_type == seq.begin())
2429 toScreen(seq.back())->switchTo();
2430 else
2431 toScreen(*--screen_type)->switchTo();
2432 }
2433 }
2434
2435 bool ShowHelp::canBeRun()
2436 {
2437 return myScreen != myHelp
2438 # ifdef HAVE_TAGLIB_H
2439 && myScreen != myTinyTagEditor
2440 # endif // HAVE_TAGLIB_H
2441 ;
2442 }
2443
2444 void ShowHelp::run()
2445 {
2446 myHelp->switchTo();
2447 }
2448
2449 bool ShowPlaylist::canBeRun()
2450 {
2451 return myScreen != myPlaylist
2452 # ifdef HAVE_TAGLIB_H
2453 && myScreen != myTinyTagEditor
2454 # endif // HAVE_TAGLIB_H
2455 ;
2456 }
2457
2458 void ShowPlaylist::run()
2459 {
2460 myPlaylist->switchTo();
2461 }
2462
2463 bool ShowBrowser::canBeRun()
2464 {
2465 return myScreen != myBrowser
2466 # ifdef HAVE_TAGLIB_H
2467 && myScreen != myTinyTagEditor
2468 # endif // HAVE_TAGLIB_H
2469 ;
2470 }
2471
2472 void ShowBrowser::run()
2473 {
2474 myBrowser->switchTo();
2475 }
2476
2477 bool ChangeBrowseMode::canBeRun()
2478 {
2479 return myScreen == myBrowser;
2480 }
2481
2482 void ChangeBrowseMode::run()
2483 {
2484 myBrowser->changeBrowseMode();
2485 }
2486
2487 bool ShowSearchEngine::canBeRun()
2488 {
2489 return myScreen != mySearcher
2490 # ifdef HAVE_TAGLIB_H
2491 && myScreen != myTinyTagEditor
2492 # endif // HAVE_TAGLIB_H
2493 ;
2494 }
2495
2496 void ShowSearchEngine::run()
2497 {
2498 mySearcher->switchTo();
2499 }
2500
2501 bool ResetSearchEngine::canBeRun()
2502 {
2503 return myScreen == mySearcher;
2504 }
2505
2506 void ResetSearchEngine::run()
2507 {
2508 mySearcher->reset();
2509 }
2510
2511 bool ShowMediaLibrary::canBeRun()
2512 {
2513 return myScreen != myLibrary
2514 # ifdef HAVE_TAGLIB_H
2515 && myScreen != myTinyTagEditor
2516 # endif // HAVE_TAGLIB_H
2517 ;
2518 }
2519
2520 void ShowMediaLibrary::run()
2521 {
2522 myLibrary->switchTo();
2523 }
2524
2525 bool ToggleMediaLibraryColumnsMode::canBeRun()
2526 {
2527 return myScreen == myLibrary;
2528 }
2529
2530 void ToggleMediaLibraryColumnsMode::run()
2531 {
2532 myLibrary->toggleColumnsMode();
2533 myLibrary->refresh();
2534 }
2535
2536 bool ShowPlaylistEditor::canBeRun()
2537 {
2538 return myScreen != myPlaylistEditor
2539 # ifdef HAVE_TAGLIB_H
2540 && myScreen != myTinyTagEditor
2541 # endif // HAVE_TAGLIB_H
2542 ;
2543 }
2544
2545 void ShowPlaylistEditor::run()
2546 {
2547 myPlaylistEditor->switchTo();
2548 }
2549
2550 bool ShowTagEditor::canBeRun()
2551 {
2552 # ifdef HAVE_TAGLIB_H
2553 return myScreen != myTagEditor
2554 && myScreen != myTinyTagEditor;
2555 # else
2556 return false;
2557 # endif // HAVE_TAGLIB_H
2558 }
2559
2560 void ShowTagEditor::run()
2561 {
2562 # ifdef HAVE_TAGLIB_H
2563 if (isMPDMusicDirSet())
2564 myTagEditor->switchTo();
2565 # endif // HAVE_TAGLIB_H
2566 }
2567
2568 bool ShowOutputs::canBeRun()
2569 {
2570 # ifdef ENABLE_OUTPUTS
2571 return myScreen != myOutputs
2572 # ifdef HAVE_TAGLIB_H
2573 && myScreen != myTinyTagEditor
2574 # endif // HAVE_TAGLIB_H
2575 ;
2576 # else
2577 return false;
2578 # endif // ENABLE_OUTPUTS
2579 }
2580
2581 void ShowOutputs::run()
2582 {
2583 # ifdef ENABLE_OUTPUTS
2584 myOutputs->switchTo();
2585 # endif // ENABLE_OUTPUTS
2586 }
2587
2588 bool ShowVisualizer::canBeRun()
2589 {
2590 # ifdef ENABLE_VISUALIZER
2591 return myScreen != myVisualizer
2592 # ifdef HAVE_TAGLIB_H
2593 && myScreen != myTinyTagEditor
2594 # endif // HAVE_TAGLIB_H
2595 ;
2596 # else
2597 return false;
2598 # endif // ENABLE_VISUALIZER
2599 }
2600
2601 void ShowVisualizer::run()
2602 {
2603 # ifdef ENABLE_VISUALIZER
2604 myVisualizer->switchTo();
2605 # endif // ENABLE_VISUALIZER
2606 }
2607
2608 bool ShowClock::canBeRun()
2609 {
2610 # ifdef ENABLE_CLOCK
2611 return myScreen != myClock
2612 # ifdef HAVE_TAGLIB_H
2613 && myScreen != myTinyTagEditor
2614 # endif // HAVE_TAGLIB_H
2615 ;
2616 # else
2617 return false;
2618 # endif // ENABLE_CLOCK
2619 }
2620
2621 void ShowClock::run()
2622 {
2623 # ifdef ENABLE_CLOCK
2624 myClock->switchTo();
2625 # endif // ENABLE_CLOCK
2626 }
2627
2628 #ifdef HAVE_TAGLIB_H
2629 bool ShowServerInfo::canBeRun()
2630 {
2631 return myScreen != myTinyTagEditor;
2632 }
2633 #endif // HAVE_TAGLIB_H
2634
2635 void ShowServerInfo::run()
2636 {
2637 myServerInfo->switchTo();
2638 }
2639
2640 }
2641
2642 namespace {
2643
2644 void populateActions()
2645 {
2646 auto insert_action = [](Actions::BaseAction *a) {
2647 AvailableActions[static_cast<size_t>(a->type())] = a;
2648 };
2649 insert_action(new Actions::Dummy());
2650 insert_action(new Actions::UpdateEnvironment());
2651 insert_action(new Actions::MouseEvent());
2652 insert_action(new Actions::ScrollUp());
2653 insert_action(new Actions::ScrollDown());
2654 insert_action(new Actions::ScrollUpArtist());
2655 insert_action(new Actions::ScrollUpAlbum());
2656 insert_action(new Actions::ScrollDownArtist());
2657 insert_action(new Actions::ScrollDownAlbum());
2658 insert_action(new Actions::PageUp());
2659 insert_action(new Actions::PageDown());
2660 insert_action(new Actions::MoveHome());
2661 insert_action(new Actions::MoveEnd());
2662 insert_action(new Actions::ToggleInterface());
2663 insert_action(new Actions::JumpToParentDirectory());
2664 insert_action(new Actions::RunAction());
2665 insert_action(new Actions::SelectItem());
2666 insert_action(new Actions::SelectRange());
2667 insert_action(new Actions::PreviousColumn());
2668 insert_action(new Actions::NextColumn());
2669 insert_action(new Actions::MasterScreen());
2670 insert_action(new Actions::SlaveScreen());
2671 insert_action(new Actions::VolumeUp());
2672 insert_action(new Actions::VolumeDown());
2673 insert_action(new Actions::AddItemToPlaylist());
2674 insert_action(new Actions::DeletePlaylistItems());
2675 insert_action(new Actions::DeleteStoredPlaylist());
2676 insert_action(new Actions::DeleteBrowserItems());
2677 insert_action(new Actions::ReplaySong());
2678 insert_action(new Actions::PreviousSong());
2679 insert_action(new Actions::NextSong());
2680 insert_action(new Actions::Pause());
2681 insert_action(new Actions::Stop());
2682 insert_action(new Actions::ExecuteCommand());
2683 insert_action(new Actions::SavePlaylist());
2684 insert_action(new Actions::MoveSortOrderUp());
2685 insert_action(new Actions::MoveSortOrderDown());
2686 insert_action(new Actions::MoveSelectedItemsUp());
2687 insert_action(new Actions::MoveSelectedItemsDown());
2688 insert_action(new Actions::MoveSelectedItemsTo());
2689 insert_action(new Actions::Add());
2690 insert_action(new Actions::PlayItem());
2691 insert_action(new Actions::SeekForward());
2692 insert_action(new Actions::SeekBackward());
2693 insert_action(new Actions::ToggleDisplayMode());
2694 insert_action(new Actions::ToggleSeparatorsBetweenAlbums());
2695 insert_action(new Actions::ToggleLyricsUpdateOnSongChange());
2696 insert_action(new Actions::ToggleLyricsFetcher());
2697 insert_action(new Actions::ToggleFetchingLyricsInBackground());
2698 insert_action(new Actions::TogglePlayingSongCentering());
2699 insert_action(new Actions::UpdateDatabase());
2700 insert_action(new Actions::JumpToPlayingSong());
2701 insert_action(new Actions::ToggleRepeat());
2702 insert_action(new Actions::Shuffle());
2703 insert_action(new Actions::ToggleRandom());
2704 insert_action(new Actions::StartSearching());
2705 insert_action(new Actions::SaveTagChanges());
2706 insert_action(new Actions::ToggleSingle());
2707 insert_action(new Actions::ToggleConsume());
2708 insert_action(new Actions::ToggleCrossfade());
2709 insert_action(new Actions::SetCrossfade());
2710 insert_action(new Actions::SetVolume());
2711 insert_action(new Actions::EnterDirectory());
2712 insert_action(new Actions::EditSong());
2713 insert_action(new Actions::EditLibraryTag());
2714 insert_action(new Actions::EditLibraryAlbum());
2715 insert_action(new Actions::EditDirectoryName());
2716 insert_action(new Actions::EditPlaylistName());
2717 insert_action(new Actions::EditLyrics());
2718 insert_action(new Actions::JumpToBrowser());
2719 insert_action(new Actions::JumpToMediaLibrary());
2720 insert_action(new Actions::JumpToPlaylistEditor());
2721 insert_action(new Actions::ToggleScreenLock());
2722 insert_action(new Actions::JumpToTagEditor());
2723 insert_action(new Actions::JumpToPositionInSong());
2724 insert_action(new Actions::ReverseSelection());
2725 insert_action(new Actions::RemoveSelection());
2726 insert_action(new Actions::SelectAlbum());
2727 insert_action(new Actions::SelectFoundItems());
2728 insert_action(new Actions::AddSelectedItems());
2729 insert_action(new Actions::CropMainPlaylist());
2730 insert_action(new Actions::CropPlaylist());
2731 insert_action(new Actions::ClearMainPlaylist());
2732 insert_action(new Actions::ClearPlaylist());
2733 insert_action(new Actions::SortPlaylist());
2734 insert_action(new Actions::ReversePlaylist());
2735 insert_action(new Actions::ApplyFilter());
2736 insert_action(new Actions::Find());
2737 insert_action(new Actions::FindItemForward());
2738 insert_action(new Actions::FindItemBackward());
2739 insert_action(new Actions::NextFoundItem());
2740 insert_action(new Actions::PreviousFoundItem());
2741 insert_action(new Actions::ToggleFindMode());
2742 insert_action(new Actions::ToggleReplayGainMode());
2743 insert_action(new Actions::ToggleAddMode());
2744 insert_action(new Actions::ToggleMouse());
2745 insert_action(new Actions::ToggleBitrateVisibility());
2746 insert_action(new Actions::AddRandomItems());
2747 insert_action(new Actions::ToggleBrowserSortMode());
2748 insert_action(new Actions::ToggleLibraryTagType());
2749 insert_action(new Actions::ToggleMediaLibrarySortMode());
2750 insert_action(new Actions::RefetchLyrics());
2751 insert_action(new Actions::SetSelectedItemsPriority());
2752 insert_action(new Actions::ToggleOutput());
2753 insert_action(new Actions::ToggleVisualizationType());
2754 insert_action(new Actions::SetVisualizerSampleMultiplier());
2755 insert_action(new Actions::ShowSongInfo());
2756 insert_action(new Actions::ShowArtistInfo());
2757 insert_action(new Actions::ShowLyrics());
2758 insert_action(new Actions::Quit());
2759 insert_action(new Actions::NextScreen());
2760 insert_action(new Actions::PreviousScreen());
2761 insert_action(new Actions::ShowHelp());
2762 insert_action(new Actions::ShowPlaylist());
2763 insert_action(new Actions::ShowBrowser());
2764 insert_action(new Actions::ChangeBrowseMode());
2765 insert_action(new Actions::ShowSearchEngine());
2766 insert_action(new Actions::ResetSearchEngine());
2767 insert_action(new Actions::ShowMediaLibrary());
2768 insert_action(new Actions::ToggleMediaLibraryColumnsMode());
2769 insert_action(new Actions::ShowPlaylistEditor());
2770 insert_action(new Actions::ShowTagEditor());
2771 insert_action(new Actions::ShowOutputs());
2772 insert_action(new Actions::ShowVisualizer());
2773 insert_action(new Actions::ShowClock());
2774 insert_action(new Actions::ShowServerInfo());
2775 }
2776
2777 bool scrollTagCanBeRun(NC::List *&list, SongList *&songs)
2778 {
2779 auto w = myScreen->activeWindow();
2780 if (list != static_cast<void *>(w))
2781 list = dynamic_cast<NC::List *>(w);
2782 if (songs != static_cast<void *>(w))
2783 songs = dynamic_cast<SongList *>(w);
2784 return list != nullptr && !list->empty()
2785 && songs != nullptr;
2786 }
2787
2788 void scrollTagUpRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get)
2789 {
2790 const auto front = songs->beginS();
2791 auto it = songs->currentS();
2792 if (auto *s = it->get<Bit::Song>())
2793 {
2794 const std::string tag = s->getTags(get);
2795 while (it != front)
2796 {
2797 --it;
2798 s = it->get<Bit::Song>();
2799 if (s == nullptr || s->getTags(get) != tag)
2800 break;
2801 }
2802 list->highlight(it-front);
2803 }
2804 }
2805
2806 void scrollTagDownRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get)
2807 {
2808 const auto front = songs->beginS(), back = --songs->endS();
2809 auto it = songs->currentS();
2810 if (auto *s = it->get<Bit::Song>())
2811 {
2812 const std::string tag = s->getTags(get);
2813 while (it != back)
2814 {
2815 ++it;
2816 s = it->get<Bit::Song>();
2817 if (s == nullptr || s->getTags(get) != tag)
2818 break;
2819 }
2820 list->highlight(it-front);
2821 }
2822 }
2823
2824 void seek()
2825 {
2826 using Global::wHeader;
2827 using Global::wFooter;
2828 using Global::Timer;
2829 using Global::SeekingInProgress;
2830
2831 if (!Status::State::totalTime())
2832 {
2833 Statusbar::print("Unknown item length");
2834 return;
2835 }
2836
2837 Progressbar::ScopedLock progressbar_lock;
2838 Statusbar::ScopedLock statusbar_lock;
2839
2840 unsigned songpos = Status::State::elapsedTime();
2841 auto t = Timer;
2842
2843 int old_timeout = wFooter->getTimeout();
2844 wFooter->setTimeout(BaseScreen::defaultWindowTimeout);
2845
2846 // Accept single action of a given type or action chain for which all actions
2847 // can be run and one of them is of the given type. This will still not work
2848 // in some contrived cases, but allows for more flexibility than accepting
2849 // single actions only.
2850 auto hasRunnableAction = [](BindingsConfiguration::BindingIteratorPair &bindings, Actions::Type type) {
2851 bool success = false;
2852 for (auto binding = bindings.first; binding != bindings.second; ++binding)
2853 {
2854 auto &actions = binding->actions();
2855 for (const auto &action : actions)
2856 {
2857 if (action->canBeRun())
2858 {
2859 if (action->type() == type)
2860 success = true;
2861 }
2862 else
2863 {
2864 success = false;
2865 break;
2866 }
2867 }
2868 if (success)
2869 break;
2870 }
2871 return success;
2872 };
2873
2874 SeekingInProgress = true;
2875 while (true)
2876 {
2877 Status::trace();
2878
2879 unsigned howmuch = Config.incremental_seeking
2880 ? (Timer-t).total_seconds()/2+Config.seek_time
2881 : Config.seek_time;
2882
2883 NC::Key::Type input = readKey(*wFooter);
2884
2885 auto k = Bindings.get(input);
2886 if (hasRunnableAction(k, Actions::Type::SeekForward))
2887 {
2888 if (songpos < Status::State::totalTime())
2889 songpos = std::min(songpos + howmuch, Status::State::totalTime());
2890 }
2891 else if (hasRunnableAction(k, Actions::Type::SeekBackward))
2892 {
2893 if (songpos > 0)
2894 {
2895 if (songpos < howmuch)
2896 songpos = 0;
2897 else
2898 songpos -= howmuch;
2899 }
2900 }
2901 else
2902 break;
2903
2904 *wFooter << NC::Format::Bold;
2905 std::string tracklength;
2906 // FIXME: merge this with the code in status.cpp
2907 switch (Config.design)
2908 {
2909 case Design::Classic:
2910 tracklength = " [";
2911 if (Config.display_remaining_time)
2912 {
2913 tracklength += "-";
2914 tracklength += MPD::Song::ShowTime(Status::State::totalTime()-songpos);
2915 }
2916 else
2917 tracklength += MPD::Song::ShowTime(songpos);
2918 tracklength += "/";
2919 tracklength += MPD::Song::ShowTime(Status::State::totalTime());
2920 tracklength += "]";
2921 *wFooter << NC::XY(wFooter->getWidth()-tracklength.length(), 1) << tracklength;
2922 break;
2923 case Design::Alternative:
2924 if (Config.display_remaining_time)
2925 {
2926 tracklength = "-";
2927 tracklength += MPD::Song::ShowTime(Status::State::totalTime()-songpos);
2928 }
2929 else
2930 tracklength = MPD::Song::ShowTime(songpos);
2931 tracklength += "/";
2932 tracklength += MPD::Song::ShowTime(Status::State::totalTime());
2933 *wHeader << NC::XY(0, 0) << tracklength << " ";
2934 wHeader->refresh();
2935 break;
2936 }
2937 *wFooter << NC::Format::NoBold;
2938 Progressbar::draw(songpos, Status::State::totalTime());
2939 wFooter->refresh();
2940 }
2941 SeekingInProgress = false;
2942 Mpd.Seek(Status::State::currentSongPosition(), songpos);
2943
2944 wFooter->setTimeout(old_timeout);
2945 }
2946
2947 void findItem(const SearchDirection direction)
2948 {
2949 using Global::wFooter;
2950
2951 Searchable *w = dynamic_cast<Searchable *>(myScreen);
2952 assert(w != nullptr);
2953 assert(w->allowsSearching());
2954
2955 std::string constraint;
2956 {
2957 Statusbar::ScopedLock slock;
2958 NC::Window::ScopedPromptHook prompt_hook(*wFooter,
2959 Statusbar::Helpers::FindImmediately(w, direction)
2960 );
2961 Statusbar::put() << (boost::format("Find %1%: ") % direction).str();
2962 constraint = wFooter->prompt(w->searchConstraint());
2963 }
2964
2965 try
2966 {
2967 if (constraint.empty())
2968 {
2969 Statusbar::printf("Constraint unset");
2970 w->clearSearchConstraint();
2971 }
2972 else
2973 {
2974 w->setSearchConstraint(constraint);
2975 Statusbar::printf("Using constraint \"%1%\"", constraint);
2976 }
2977 }
2978 catch (boost::bad_expression &e)
2979 {
2980 Statusbar::printf("%1%", e.what());
2981 }
2982 }
2983
2984 void listsChangeFinisher()
2985 {
2986 if (myScreen == myLibrary
2987 || myScreen == myPlaylistEditor
2988 # ifdef HAVE_TAGLIB_H
2989 || myScreen == myTagEditor
2990 # endif // HAVE_TAGLIB_H
2991 )
2992 {
2993 if (myScreen->activeWindow() == &myLibrary->Tags)
2994 {
2995 myLibrary->Albums.clear();
2996 myLibrary->Albums.refresh();
2997 myLibrary->Songs.clear();
2998 myLibrary->Songs.refresh();
2999 myLibrary->updateTimer();
3000 }
3001 else if (myScreen->activeWindow() == &myLibrary->Albums)
3002 {
3003 myLibrary->Songs.clear();
3004 myLibrary->Songs.refresh();
3005 myLibrary->updateTimer();
3006 }
3007 else if (myScreen->isActiveWindow(myPlaylistEditor->Playlists))
3008 {
3009 myPlaylistEditor->Content.clear();
3010 myPlaylistEditor->Content.refresh();
3011 myPlaylistEditor->updateTimer();
3012 }
3013 # ifdef HAVE_TAGLIB_H
3014 else if (myScreen->activeWindow() == myTagEditor->Dirs)
3015 {
3016 myTagEditor->Tags->clear();
3017 }
3018 # endif // HAVE_TAGLIB_H
3019 }
3020 }
3021
3022 }
an ncurses mpd client inspired by ncmpc