?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add ifdefs to fix conditional compilation
[ncmpcpp.git] / src / actions.cpp
blob0d6f2bb4f7ea09aa34b86bf4db18dccbbfcee97b
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 #include <readline/readline.h>
32
33 #include "actions.h"
34 #include "charset.h"
35 #include "config.h"
36 #include "display.h"
37 #include "global.h"
38 #include "mpdpp.h"
39 #include "helpers.h"
40 #include "statusbar.h"
41 #include "utility/comparators.h"
42 #include "utility/conversion.h"
43
44 #include "bindings.h"
45 #include "browser.h"
46 #include "clock.h"
47 #include "help.h"
48 #include "media_library.h"
49 #include "menu_impl.h"
50 #include "lastfm.h"
51 #include "lyrics.h"
52 #include "playlist.h"
53 #include "playlist_editor.h"
54 #include "sort_playlist.h"
55 #include "search_engine.h"
56 #include "sel_items_adder.h"
57 #include "server_info.h"
58 #include "song_info.h"
59 #include "outputs.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) : 1;
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 confirmAction("Do you really want to shuffle selected range?");
1219 auto begin = myPlaylist->main().begin();
1220 Mpd.ShuffleRange(m_begin-begin, m_end-begin);
1221 Statusbar::print("Range shuffled");
1222 }
1223
1224 void ToggleRandom::run()
1225 {
1226 Mpd.SetRandom(!Status::State::random());
1227 }
1228
1229 bool StartSearching::canBeRun()
1230 {
1231 return myScreen == mySearcher && !mySearcher->main()[0].isInactive();
1232 }
1233
1234 void StartSearching::run()
1235 {
1236 mySearcher->main().highlight(SearchEngine::SearchButton);
1237 mySearcher->main().setHighlighting(0);
1238 mySearcher->main().refresh();
1239 mySearcher->main().setHighlighting(1);
1240 mySearcher->runAction();
1241 }
1242
1243 bool SaveTagChanges::canBeRun()
1244 {
1245 # ifdef HAVE_TAGLIB_H
1246 return myScreen == myTinyTagEditor
1247 || myScreen->activeWindow() == myTagEditor->TagTypes;
1248 # else
1249 return false;
1250 # endif // HAVE_TAGLIB_H
1251 }
1252
1253 void SaveTagChanges::run()
1254 {
1255 # ifdef HAVE_TAGLIB_H
1256 if (myScreen == myTinyTagEditor)
1257 {
1258 myTinyTagEditor->main().highlight(myTinyTagEditor->main().size()-2); // Save
1259 myTinyTagEditor->runAction();
1260 }
1261 else if (myScreen->activeWindow() == myTagEditor->TagTypes)
1262 {
1263 myTagEditor->TagTypes->highlight(myTagEditor->TagTypes->size()-1); // Save
1264 myTagEditor->runAction();
1265 }
1266 # endif // HAVE_TAGLIB_H
1267 }
1268
1269 void ToggleSingle::run()
1270 {
1271 Mpd.SetSingle(!Status::State::single());
1272 }
1273
1274 void ToggleConsume::run()
1275 {
1276 Mpd.SetConsume(!Status::State::consume());
1277 }
1278
1279 void ToggleCrossfade::run()
1280 {
1281 Mpd.SetCrossfade(Status::State::crossfade() ? 0 : Config.crossfade_time);
1282 }
1283
1284 void SetCrossfade::run()
1285 {
1286 using Global::wFooter;
1287
1288 Statusbar::ScopedLock slock;
1289 Statusbar::put() << "Set crossfade to: ";
1290 auto crossfade = fromString<unsigned>(wFooter->prompt());
1291 lowerBoundCheck(crossfade, 0u);
1292 Config.crossfade_time = crossfade;
1293 Mpd.SetCrossfade(crossfade);
1294 }
1295
1296 void SetVolume::run()
1297 {
1298 using Global::wFooter;
1299
1300 unsigned volume;
1301 {
1302 Statusbar::ScopedLock slock;
1303 Statusbar::put() << "Set volume to: ";
1304 volume = fromString<unsigned>(wFooter->prompt());
1305 boundsCheck(volume, 0u, 100u);
1306 Mpd.SetVolume(volume);
1307 }
1308 Statusbar::printf("Volume set to %1%%%", volume);
1309 }
1310
1311 bool EnterDirectory::canBeRun()
1312 {
1313 bool result = false;
1314 if (myScreen == myBrowser && !myBrowser->main().empty())
1315 {
1316 result = myBrowser->main().current()->value().type()
1317 == MPD::Item::Type::Directory;
1318 }
1319 #ifdef HAVE_TAGLIB_H
1320 else if (myScreen->activeWindow() == myTagEditor->Dirs)
1321 result = true;
1322 #endif // HAVE_TAGLIB_H
1323 return result;
1324 }
1325
1326 void EnterDirectory::run()
1327 {
1328 if (myScreen == myBrowser)
1329 myBrowser->enterDirectory();
1330 #ifdef HAVE_TAGLIB_H
1331 else if (myScreen->activeWindow() == myTagEditor->Dirs)
1332 {
1333 if (!myTagEditor->enterDirectory())
1334 Statusbar::print("No subdirectories found");
1335 }
1336 #endif // HAVE_TAGLIB_H
1337 }
1338
1339 bool EditSong::canBeRun()
1340 {
1341 # ifdef HAVE_TAGLIB_H
1342 m_song = currentSong(myScreen);
1343 return m_song != nullptr && isMPDMusicDirSet();
1344 # else
1345 return false;
1346 # endif // HAVE_TAGLIB_H
1347 }
1348
1349 void EditSong::run()
1350 {
1351 # ifdef HAVE_TAGLIB_H
1352 myTinyTagEditor->SetEdited(*m_song);
1353 myTinyTagEditor->switchTo();
1354 # endif // HAVE_TAGLIB_H
1355 }
1356
1357 bool EditLibraryTag::canBeRun()
1358 {
1359 # ifdef HAVE_TAGLIB_H
1360 return myScreen->isActiveWindow(myLibrary->Tags)
1361 && !myLibrary->Tags.empty()
1362 && isMPDMusicDirSet();
1363 # else
1364 return false;
1365 # endif // HAVE_TAGLIB_H
1366 }
1367
1368 void EditLibraryTag::run()
1369 {
1370 # ifdef HAVE_TAGLIB_H
1371 using Global::wFooter;
1372
1373 std::string new_tag;
1374 {
1375 Statusbar::ScopedLock slock;
1376 Statusbar::put() << NC::Format::Bold << tagTypeToString(Config.media_lib_primary_tag) << NC::Format::NoBold << ": ";
1377 new_tag = wFooter->prompt(myLibrary->Tags.current()->value().tag());
1378 }
1379 if (!new_tag.empty() && new_tag != myLibrary->Tags.current()->value().tag())
1380 {
1381 Statusbar::print("Updating tags...");
1382 Mpd.StartSearch(true);
1383 Mpd.AddSearch(Config.media_lib_primary_tag, myLibrary->Tags.current()->value().tag());
1384 MPD::MutableSong::SetFunction set = tagTypeToSetFunction(Config.media_lib_primary_tag);
1385 assert(set);
1386 bool success = true;
1387 std::string dir_to_update;
1388 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s)
1389 {
1390 MPD::MutableSong ms = std::move(*s);
1391 ms.setTags(set, new_tag);
1392 Statusbar::printf("Updating tags in \"%1%\"...", ms.getName());
1393 std::string path = Config.mpd_music_dir + ms.getURI();
1394 if (!Tags::write(ms))
1395 {
1396 success = false;
1397 const char msg[] = "Error while updating tags in \"%1%\"";
1398 Statusbar::printf(msg, wideShorten(ms.getURI(), COLS-const_strlen(msg)));
1399 s.finish();
1400 break;
1401 }
1402 if (dir_to_update.empty())
1403 dir_to_update = ms.getURI();
1404 else
1405 dir_to_update = getSharedDirectory(dir_to_update, ms.getURI());
1406 };
1407 if (success)
1408 {
1409 Mpd.UpdateDirectory(dir_to_update);
1410 Statusbar::print("Tags updated successfully");
1411 }
1412 }
1413 # endif // HAVE_TAGLIB_H
1414 }
1415
1416 bool EditLibraryAlbum::canBeRun()
1417 {
1418 # ifdef HAVE_TAGLIB_H
1419 return myScreen->isActiveWindow(myLibrary->Albums)
1420 && !myLibrary->Albums.empty()
1421 && isMPDMusicDirSet();
1422 # else
1423 return false;
1424 # endif // HAVE_TAGLIB_H
1425 }
1426
1427 void EditLibraryAlbum::run()
1428 {
1429 # ifdef HAVE_TAGLIB_H
1430 using Global::wFooter;
1431 // FIXME: merge this and EditLibraryTag. also, prompt on failure if user wants to continue
1432 std::string new_album;
1433 {
1434 Statusbar::ScopedLock slock;
1435 Statusbar::put() << NC::Format::Bold << "Album: " << NC::Format::NoBold;
1436 new_album = wFooter->prompt(myLibrary->Albums.current()->value().entry().album());
1437 }
1438 if (!new_album.empty() && new_album != myLibrary->Albums.current()->value().entry().album())
1439 {
1440 bool success = 1;
1441 Statusbar::print("Updating tags...");
1442 for (size_t i = 0; i < myLibrary->Songs.size(); ++i)
1443 {
1444 Statusbar::printf("Updating tags in \"%1%\"...", myLibrary->Songs[i].value().getName());
1445 std::string path = Config.mpd_music_dir + myLibrary->Songs[i].value().getURI();
1446 TagLib::FileRef f(path.c_str());
1447 if (f.isNull())
1448 {
1449 const char msg[] = "Error while opening file \"%1%\"";
1450 Statusbar::printf(msg, wideShorten(myLibrary->Songs[i].value().getURI(), COLS-const_strlen(msg)));
1451 success = 0;
1452 break;
1453 }
1454 f.tag()->setAlbum(ToWString(new_album));
1455 if (!f.save())
1456 {
1457 const char msg[] = "Error while writing tags in \"%1%\"";
1458 Statusbar::printf(msg, wideShorten(myLibrary->Songs[i].value().getURI(), COLS-const_strlen(msg)));
1459 success = 0;
1460 break;
1461 }
1462 }
1463 if (success)
1464 {
1465 Mpd.UpdateDirectory(getSharedDirectory(myLibrary->Songs.beginV(), myLibrary->Songs.endV()));
1466 Statusbar::print("Tags updated successfully");
1467 }
1468 }
1469 # endif // HAVE_TAGLIB_H
1470 }
1471
1472 bool EditDirectoryName::canBeRun()
1473 {
1474 return ((myScreen == myBrowser
1475 && !myBrowser->main().empty()
1476 && myBrowser->main().current()->value().type() == MPD::Item::Type::Directory)
1477 # ifdef HAVE_TAGLIB_H
1478 || (myScreen->activeWindow() == myTagEditor->Dirs
1479 && !myTagEditor->Dirs->empty()
1480 && myTagEditor->Dirs->choice() > 0)
1481 # endif // HAVE_TAGLIB_H
1482 ) && isMPDMusicDirSet();
1483 }
1484
1485 void EditDirectoryName::run()
1486 {
1487 using Global::wFooter;
1488 if (myScreen == myBrowser)
1489 {
1490 std::string old_dir = myBrowser->main().current()->value().directory().path();
1491 std::string new_dir;
1492 {
1493 Statusbar::ScopedLock slock;
1494 Statusbar::put() << NC::Format::Bold << "Directory: " << NC::Format::NoBold;
1495 new_dir = wFooter->prompt(old_dir);
1496 }
1497 if (!new_dir.empty() && new_dir != old_dir)
1498 {
1499 std::string full_old_dir;
1500 if (!myBrowser->isLocal())
1501 full_old_dir += Config.mpd_music_dir;
1502 full_old_dir += old_dir;
1503 std::string full_new_dir;
1504 if (!myBrowser->isLocal())
1505 full_new_dir += Config.mpd_music_dir;
1506 full_new_dir += new_dir;
1507 boost::filesystem::rename(full_old_dir, full_new_dir);
1508 const char msg[] = "Directory renamed to \"%1%\"";
1509 Statusbar::printf(msg, wideShorten(new_dir, COLS-const_strlen(msg)));
1510 if (!myBrowser->isLocal())
1511 Mpd.UpdateDirectory(getSharedDirectory(old_dir, new_dir));
1512 myBrowser->requestUpdate();
1513 }
1514 }
1515 # ifdef HAVE_TAGLIB_H
1516 else if (myScreen->activeWindow() == myTagEditor->Dirs)
1517 {
1518 std::string old_dir = myTagEditor->Dirs->current()->value().first, new_dir;
1519 {
1520 Statusbar::ScopedLock slock;
1521 Statusbar::put() << NC::Format::Bold << "Directory: " << NC::Format::NoBold;
1522 new_dir = wFooter->prompt(old_dir);
1523 }
1524 if (!new_dir.empty() && new_dir != old_dir)
1525 {
1526 std::string full_old_dir = Config.mpd_music_dir + myTagEditor->CurrentDir() + "/" + old_dir;
1527 std::string full_new_dir = Config.mpd_music_dir + myTagEditor->CurrentDir() + "/" + new_dir;
1528 if (rename(full_old_dir.c_str(), full_new_dir.c_str()) == 0)
1529 {
1530 const char msg[] = "Directory renamed to \"%1%\"";
1531 Statusbar::printf(msg, wideShorten(new_dir, COLS-const_strlen(msg)));
1532 Mpd.UpdateDirectory(myTagEditor->CurrentDir());
1533 }
1534 else
1535 {
1536 const char msg[] = "Couldn't rename \"%1%\": %2%";
1537 Statusbar::printf(msg, wideShorten(old_dir, COLS-const_strlen(msg)-25), strerror(errno));
1538 }
1539 }
1540 }
1541 # endif // HAVE_TAGLIB_H
1542 }
1543
1544 bool EditPlaylistName::canBeRun()
1545 {
1546 return (myScreen->isActiveWindow(myPlaylistEditor->Playlists)
1547 && !myPlaylistEditor->Playlists.empty())
1548 || (myScreen == myBrowser
1549 && !myBrowser->main().empty()
1550 && myBrowser->main().current()->value().type() == MPD::Item::Type::Playlist);
1551 }
1552
1553 void EditPlaylistName::run()
1554 {
1555 using Global::wFooter;
1556 std::string old_name, new_name;
1557 if (myScreen->isActiveWindow(myPlaylistEditor->Playlists))
1558 old_name = myPlaylistEditor->Playlists.current()->value().path();
1559 else
1560 old_name = myBrowser->main().current()->value().playlist().path();
1561 {
1562 Statusbar::ScopedLock slock;
1563 Statusbar::put() << NC::Format::Bold << "Playlist: " << NC::Format::NoBold;
1564 new_name = wFooter->prompt(old_name);
1565 }
1566 if (!new_name.empty() && new_name != old_name)
1567 {
1568 Mpd.Rename(old_name, new_name);
1569 const char msg[] = "Playlist renamed to \"%1%\"";
1570 Statusbar::printf(msg, wideShorten(new_name, COLS-const_strlen(msg)));
1571 }
1572 }
1573
1574 bool EditLyrics::canBeRun()
1575 {
1576 return myScreen == myLyrics;
1577 }
1578
1579 void EditLyrics::run()
1580 {
1581 myLyrics->Edit();
1582 }
1583
1584 bool JumpToBrowser::canBeRun()
1585 {
1586 m_song = currentSong(myScreen);
1587 return m_song != nullptr;
1588 }
1589
1590 void JumpToBrowser::run()
1591 {
1592 myBrowser->locateSong(*m_song);
1593 }
1594
1595 bool JumpToMediaLibrary::canBeRun()
1596 {
1597 m_song = currentSong(myScreen);
1598 return m_song != nullptr;
1599 }
1600
1601 void JumpToMediaLibrary::run()
1602 {
1603 myLibrary->LocateSong(*m_song);
1604 }
1605
1606 bool JumpToPlaylistEditor::canBeRun()
1607 {
1608 return myScreen == myBrowser
1609 && myBrowser->main().current()->value().type() == MPD::Item::Type::Playlist;
1610 }
1611
1612 void JumpToPlaylistEditor::run()
1613 {
1614 myPlaylistEditor->Locate(myBrowser->main().current()->value().playlist());
1615 }
1616
1617 void ToggleScreenLock::run()
1618 {
1619 using Global::wFooter;
1620 using Global::myLockedScreen;
1621 const char *msg_unlockable_screen = "Current screen can't be locked";
1622 if (myLockedScreen != nullptr)
1623 {
1624 BaseScreen::unlock();
1625 Actions::setResizeFlags();
1626 myScreen->resize();
1627 Statusbar::print("Screen unlocked");
1628 }
1629 else if (!myScreen->isLockable())
1630 {
1631 Statusbar::print(msg_unlockable_screen);
1632 }
1633 else
1634 {
1635 unsigned part = Config.locked_screen_width_part*100;
1636 if (Config.ask_for_locked_screen_width_part)
1637 {
1638 Statusbar::ScopedLock slock;
1639 Statusbar::put() << "% of the locked screen's width to be reserved (20-80): ";
1640 part = fromString<unsigned>(wFooter->prompt(boost::lexical_cast<std::string>(part)));
1641 }
1642 boundsCheck(part, 20u, 80u);
1643 Config.locked_screen_width_part = part/100.0;
1644 if (myScreen->lock())
1645 Statusbar::printf("Screen locked (with %1%%% width)", part);
1646 else
1647 Statusbar::print(msg_unlockable_screen);
1648 }
1649 }
1650
1651 bool JumpToTagEditor::canBeRun()
1652 {
1653 # ifdef HAVE_TAGLIB_H
1654 m_song = currentSong(myScreen);
1655 return m_song != nullptr && isMPDMusicDirSet();
1656 # else
1657 return false;
1658 # endif // HAVE_TAGLIB_H
1659 }
1660
1661 void JumpToTagEditor::run()
1662 {
1663 # ifdef HAVE_TAGLIB_H
1664 myTagEditor->LocateSong(*m_song);
1665 # endif // HAVE_TAGLIB_H
1666 }
1667
1668 bool JumpToPositionInSong::canBeRun()
1669 {
1670 return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
1671 }
1672
1673 void JumpToPositionInSong::run()
1674 {
1675 using Global::wFooter;
1676
1677 const MPD::Song s = myPlaylist->nowPlayingSong();
1678
1679 std::string spos;
1680 {
1681 Statusbar::ScopedLock slock;
1682 Statusbar::put() << "Position to go (in %/m:ss/seconds(s)): ";
1683 spos = wFooter->prompt();
1684 }
1685
1686 boost::regex rx;
1687 boost::smatch what;
1688 if (boost::regex_match(spos, what, rx.assign("([0-9]+):([0-9]{2})"))) // mm:ss
1689 {
1690 auto mins = fromString<unsigned>(what[1]);
1691 auto secs = fromString<unsigned>(what[2]);
1692 boundsCheck(secs, 0u, 60u);
1693 Mpd.Seek(s.getPosition(), mins * 60 + secs);
1694 }
1695 else if (boost::regex_match(spos, what, rx.assign("([0-9]+)s"))) // position in seconds
1696 {
1697 auto secs = fromString<unsigned>(what[1]);
1698 Mpd.Seek(s.getPosition(), secs);
1699 }
1700 else if (boost::regex_match(spos, what, rx.assign("([0-9]+)[%]{0,1}"))) // position in %
1701 {
1702 auto percent = fromString<unsigned>(what[1]);
1703 boundsCheck(percent, 0u, 100u);
1704 int secs = (percent * s.getDuration()) / 100.0;
1705 Mpd.Seek(s.getPosition(), secs);
1706 }
1707 else
1708 Statusbar::print("Invalid format ([m]:[ss], [s]s, [%]%, [%] accepted)");
1709 }
1710
1711 bool SelectItem::canBeRun()
1712 {
1713 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1714 return m_list != nullptr
1715 && !m_list->empty()
1716 && m_list->currentP()->isSelectable();
1717 }
1718
1719 void SelectItem::run()
1720 {
1721 auto current = m_list->currentP();
1722 current->setSelected(!current->isSelected());
1723 }
1724
1725 bool SelectRange::canBeRun()
1726 {
1727 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1728 if (m_list == nullptr)
1729 return false;
1730 m_begin = m_list->beginP();
1731 m_end = m_list->endP();
1732 return findRange(m_begin, m_end);
1733 }
1734
1735 void SelectRange::run()
1736 {
1737 for (; m_begin != m_end; ++m_begin)
1738 m_begin->setSelected(true);
1739 Statusbar::print("Range selected");
1740 }
1741
1742 bool ReverseSelection::canBeRun()
1743 {
1744 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1745 return m_list != nullptr;
1746 }
1747
1748 void ReverseSelection::run()
1749 {
1750 for (auto &p : *m_list)
1751 p.setSelected(!p.isSelected());
1752 Statusbar::print("Selection reversed");
1753 }
1754
1755 bool RemoveSelection::canBeRun()
1756 {
1757 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1758 return m_list != nullptr;
1759 }
1760
1761 void RemoveSelection::run()
1762 {
1763 for (auto &p : *m_list)
1764 p.setSelected(false);
1765 Statusbar::print("Selection removed");
1766 }
1767
1768 bool SelectAlbum::canBeRun()
1769 {
1770 auto *w = myScreen->activeWindow();
1771 if (m_list != static_cast<void *>(w))
1772 m_list = dynamic_cast<NC::List *>(w);
1773 if (m_songs != static_cast<void *>(w))
1774 m_songs = dynamic_cast<SongList *>(w);
1775 return m_list != nullptr && !m_list->empty()
1776 && m_songs != nullptr;
1777 }
1778
1779 void SelectAlbum::run()
1780 {
1781 const auto front = m_songs->beginS(), current = m_songs->currentS(), end = m_songs->endS();
1782 auto *s = current->get<Bit::Song>();
1783 if (s == nullptr)
1784 return;
1785 auto get = &MPD::Song::getAlbum;
1786 const std::string tag = s->getTags(get);
1787 // go up
1788 for (auto it = current; it != front;)
1789 {
1790 --it;
1791 s = it->get<Bit::Song>();
1792 if (s == nullptr || s->getTags(get) != tag)
1793 break;
1794 it->get<Bit::Properties>().setSelected(true);
1795 }
1796 // go down
1797 for (auto it = current;;)
1798 {
1799 it->get<Bit::Properties>().setSelected(true);
1800 if (++it == end)
1801 break;
1802 s = it->get<Bit::Song>();
1803 if (s == nullptr || s->getTags(get) != tag)
1804 break;
1805 }
1806 Statusbar::print("Album around cursor position selected");
1807 }
1808
1809 bool SelectFoundItems::canBeRun()
1810 {
1811 m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1812 if (m_list == nullptr || m_list->empty())
1813 return false;
1814 m_searchable = dynamic_cast<Searchable *>(myScreen);
1815 return m_searchable != nullptr && m_searchable->allowsSearching();
1816 }
1817
1818 void SelectFoundItems::run()
1819 {
1820 auto current_pos = m_list->choice();
1821 myScreen->activeWindow()->scroll(NC::Scroll::Home);
1822 bool found = m_searchable->find(SearchDirection::Forward, false, false);
1823 if (found)
1824 {
1825 Statusbar::print("Searching for items...");
1826 m_list->currentP()->setSelected(true);
1827 while (m_searchable->find(SearchDirection::Forward, false, true))
1828 m_list->currentP()->setSelected(true);
1829 Statusbar::print("Found items selected");
1830 }
1831 m_list->highlight(current_pos);
1832 }
1833
1834 bool AddSelectedItems::canBeRun()
1835 {
1836 return myScreen != mySelectedItemsAdder;
1837 }
1838
1839 void AddSelectedItems::run()
1840 {
1841 mySelectedItemsAdder->switchTo();
1842 }
1843
1844 void CropMainPlaylist::run()
1845 {
1846 auto &w = myPlaylist->main();
1847 // cropping doesn't make sense in this case
1848 if (w.size() <= 1)
1849 return;
1850 if (Config.ask_before_clearing_playlists)
1851 confirmAction("Do you really want to crop main playlist?");
1852 Statusbar::print("Cropping playlist...");
1853 selectCurrentIfNoneSelected(w);
1854 cropPlaylist(w, std::bind(&MPD::Connection::Delete, ph::_1, ph::_2));
1855 Statusbar::print("Playlist cropped");
1856 }
1857
1858 bool CropPlaylist::canBeRun()
1859 {
1860 return myScreen == myPlaylistEditor;
1861 }
1862
1863 void CropPlaylist::run()
1864 {
1865 auto &w = myPlaylistEditor->Content;
1866 // cropping doesn't make sense in this case
1867 if (w.size() <= 1)
1868 return;
1869 assert(!myPlaylistEditor->Playlists.empty());
1870 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
1871 if (Config.ask_before_clearing_playlists)
1872 confirmAction(boost::format("Do you really want to crop playlist \"%1%\"?") % playlist);
1873 selectCurrentIfNoneSelected(w);
1874 Statusbar::printf("Cropping playlist \"%1%\"...", playlist);
1875 cropPlaylist(w, std::bind(&MPD::Connection::PlaylistDelete, ph::_1, playlist, ph::_2));
1876 Statusbar::printf("Playlist \"%1%\" cropped", playlist);
1877 }
1878
1879 void ClearMainPlaylist::run()
1880 {
1881 if (!myPlaylist->main().empty() && Config.ask_before_clearing_playlists)
1882 confirmAction("Do you really want to clear main playlist?");
1883 Mpd.ClearMainPlaylist();
1884 Statusbar::print("Playlist cleared");
1885 myPlaylist->main().reset();
1886 }
1887
1888 bool ClearPlaylist::canBeRun()
1889 {
1890 return myScreen == myPlaylistEditor;
1891 }
1892
1893 void ClearPlaylist::run()
1894 {
1895 if (myPlaylistEditor->Playlists.empty())
1896 return;
1897 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
1898 if (Config.ask_before_clearing_playlists)
1899 confirmAction(boost::format("Do you really want to clear playlist \"%1%\"?") % playlist);
1900 Mpd.ClearPlaylist(playlist);
1901 Statusbar::printf("Playlist \"%1%\" cleared", playlist);
1902 }
1903
1904 bool SortPlaylist::canBeRun()
1905 {
1906 if (myScreen != myPlaylist)
1907 return false;
1908 auto first = myPlaylist->main().begin(), last = myPlaylist->main().end();
1909 return findSelectedRangeAndPrintInfoIfNot(first, last);
1910 }
1911
1912 void SortPlaylist::run()
1913 {
1914 mySortPlaylistDialog->switchTo();
1915 }
1916
1917 bool ReversePlaylist::canBeRun()
1918 {
1919 if (myScreen != myPlaylist)
1920 return false;
1921 m_begin = myPlaylist->main().begin();
1922 m_end = myPlaylist->main().end();
1923 return findSelectedRangeAndPrintInfoIfNot(m_begin, m_end);
1924 }
1925
1926 void ReversePlaylist::run()
1927 {
1928 Statusbar::print("Reversing range...");
1929 Mpd.StartCommandsList();
1930 for (--m_end; m_begin < m_end; ++m_begin, --m_end)
1931 Mpd.Swap(m_begin->value().getPosition(), m_end->value().getPosition());
1932 Mpd.CommitCommandsList();
1933 Statusbar::print("Range reversed");
1934 }
1935
1936 bool Find::canBeRun()
1937 {
1938 return myScreen == myHelp
1939 || myScreen == myLyrics
1940 # ifdef HAVE_CURL_CURL_H
1941 || myScreen == myLastfm
1942 # endif // HAVE_CURL_CURL_H
1943 ;
1944 }
1945
1946 void Find::run()
1947 {
1948 using Global::wFooter;
1949
1950 std::string token;
1951 {
1952 Statusbar::ScopedLock slock;
1953 Statusbar::put() << "Find: ";
1954 token = wFooter->prompt();
1955 }
1956
1957 Statusbar::print("Searching...");
1958 auto s = static_cast<Screen<NC::Scrollpad> *>(myScreen);
1959 s->main().removeProperties();
1960 if (token.empty() || s->main().setProperties(NC::Format::Reverse, token, NC::Format::NoReverse, Config.regex_type))
1961 Statusbar::print("Done");
1962 else
1963 Statusbar::print("No matching patterns found");
1964 s->main().flush();
1965 }
1966
1967 bool FindItemBackward::canBeRun()
1968 {
1969 auto w = dynamic_cast<Searchable *>(myScreen);
1970 return w && w->allowsSearching();
1971 }
1972
1973 void FindItemForward::run()
1974 {
1975 findItem(SearchDirection::Forward);
1976 listsChangeFinisher();
1977 }
1978
1979 bool FindItemForward::canBeRun()
1980 {
1981 auto w = dynamic_cast<Searchable *>(myScreen);
1982 return w && w->allowsSearching();
1983 }
1984
1985 void FindItemBackward::run()
1986 {
1987 findItem(SearchDirection::Backward);
1988 listsChangeFinisher();
1989 }
1990
1991 bool NextFoundItem::canBeRun()
1992 {
1993 return dynamic_cast<Searchable *>(myScreen);
1994 }
1995
1996 void NextFoundItem::run()
1997 {
1998 Searchable *w = dynamic_cast<Searchable *>(myScreen);
1999 assert(w != nullptr);
2000 w->find(SearchDirection::Forward, Config.wrapped_search, true);
2001 listsChangeFinisher();
2002 }
2003
2004 bool PreviousFoundItem::canBeRun()
2005 {
2006 return dynamic_cast<Searchable *>(myScreen);
2007 }
2008
2009 void PreviousFoundItem::run()
2010 {
2011 Searchable *w = dynamic_cast<Searchable *>(myScreen);
2012 assert(w != nullptr);
2013 w->find(SearchDirection::Backward, Config.wrapped_search, true);
2014 listsChangeFinisher();
2015 }
2016
2017 void ToggleFindMode::run()
2018 {
2019 Config.wrapped_search = !Config.wrapped_search;
2020 Statusbar::printf("Search mode: %1%",
2021 Config.wrapped_search ? "Wrapped" : "Normal"
2022 );
2023 }
2024
2025 void ToggleReplayGainMode::run()
2026 {
2027 using Global::wFooter;
2028
2029 char rgm = 0;
2030 {
2031 Statusbar::ScopedLock slock;
2032 Statusbar::put() << "Replay gain mode? "
2033 << "[" << NC::Format::Bold << 'o' << NC::Format::NoBold << "ff"
2034 << "/" << NC::Format::Bold << 't' << NC::Format::NoBold << "rack"
2035 << "/" << NC::Format::Bold << 'a' << NC::Format::NoBold << "lbum"
2036 << "] ";
2037 rgm = Statusbar::Helpers::promptReturnOneOf({"t", "a", "o"})[0];
2038 }
2039 switch (rgm)
2040 {
2041 case 't':
2042 Mpd.SetReplayGainMode(MPD::rgmTrack);
2043 break;
2044 case 'a':
2045 Mpd.SetReplayGainMode(MPD::rgmAlbum);
2046 break;
2047 case 'o':
2048 Mpd.SetReplayGainMode(MPD::rgmOff);
2049 break;
2050 default: // impossible
2051 throw std::runtime_error(
2052 (boost::format("ToggleReplayGainMode: impossible case reached: %1%") % rgm).str()
2053 );
2054 }
2055 Statusbar::printf("Replay gain mode: %1%", Mpd.GetReplayGainMode());
2056 }
2057
2058 void ToggleAddMode::run()
2059 {
2060 std::string mode_desc;
2061 switch (Config.space_add_mode)
2062 {
2063 case SpaceAddMode::AddRemove:
2064 Config.space_add_mode = SpaceAddMode::AlwaysAdd;
2065 mode_desc = "always add an item to playlist";
2066 break;
2067 case SpaceAddMode::AlwaysAdd:
2068 Config.space_add_mode = SpaceAddMode::AddRemove;
2069 mode_desc = "add an item to playlist or remove if already added";
2070 break;
2071 }
2072 Statusbar::printf("Add mode: %1%", mode_desc);
2073 }
2074
2075 void ToggleMouse::run()
2076 {
2077 Config.mouse_support = !Config.mouse_support;
2078 if (Config.mouse_support)
2079 NC::Mouse::enable();
2080 else
2081 NC::Mouse::disable();
2082 Statusbar::printf("Mouse support %1%",
2083 Config.mouse_support ? "enabled" : "disabled"
2084 );
2085 }
2086
2087 void ToggleBitrateVisibility::run()
2088 {
2089 Config.display_bitrate = !Config.display_bitrate;
2090 Statusbar::printf("Bitrate visibility %1%",
2091 Config.display_bitrate ? "enabled" : "disabled"
2092 );
2093 }
2094
2095 void AddRandomItems::run()
2096 {
2097 using Global::wFooter;
2098 char rnd_type = 0;
2099 {
2100 Statusbar::ScopedLock slock;
2101 Statusbar::put() << "Add random? "
2102 << "[" << NC::Format::Bold << 's' << NC::Format::NoBold << "ongs"
2103 << "/" << NC::Format::Bold << 'a' << NC::Format::NoBold << "rtists"
2104 << "/" << "album" << NC::Format::Bold << 'A' << NC::Format::NoBold << "rtists"
2105 << "/" << "al" << NC::Format::Bold << 'b' << NC::Format::NoBold << "ums"
2106 << "] ";
2107 rnd_type = Statusbar::Helpers::promptReturnOneOf({"s", "a", "A", "b"})[0];
2108 }
2109
2110 mpd_tag_type tag_type = MPD_TAG_ARTIST;
2111 std::string tag_type_str ;
2112 if (rnd_type != 's')
2113 {
2114 tag_type = charToTagType(rnd_type);
2115 tag_type_str = boost::locale::to_lower(tagTypeToString(tag_type));
2116 }
2117 else
2118 tag_type_str = "song";
2119
2120 unsigned number;
2121 {
2122 Statusbar::ScopedLock slock;
2123 Statusbar::put() << "Number of random " << tag_type_str << "s: ";
2124 number = fromString<unsigned>(wFooter->prompt());
2125 }
2126 if (number && (rnd_type == 's' ? Mpd.AddRandomSongs(number) : Mpd.AddRandomTag(tag_type, number)))
2127 {
2128 Statusbar::printf("%1% random %2%%3% added to playlist",
2129 number, tag_type_str, number == 1 ? "" : "s"
2130 );
2131 }
2132 }
2133
2134 bool ToggleBrowserSortMode::canBeRun()
2135 {
2136 return myScreen == myBrowser;
2137 }
2138
2139 void ToggleBrowserSortMode::run()
2140 {
2141 switch (Config.browser_sort_mode)
2142 {
2143 case SortMode::Name:
2144 Config.browser_sort_mode = SortMode::ModificationTime;
2145 Statusbar::print("Sort songs by: modification time");
2146 break;
2147 case SortMode::ModificationTime:
2148 Config.browser_sort_mode = SortMode::CustomFormat;
2149 Statusbar::print("Sort songs by: custom format");
2150 break;
2151 case SortMode::CustomFormat:
2152 Config.browser_sort_mode = SortMode::NoOp;
2153 Statusbar::print("Do not sort songs");
2154 break;
2155 case SortMode::NoOp:
2156 Config.browser_sort_mode = SortMode::Name;
2157 Statusbar::print("Sort songs by: name");
2158 }
2159 if (Config.browser_sort_mode != SortMode::NoOp)
2160 {
2161 size_t sort_offset = myBrowser->inRootDirectory() ? 0 : 1;
2162 std::sort(myBrowser->main().begin()+sort_offset, myBrowser->main().end(),
2163 LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode)
2164 );
2165 }
2166 }
2167
2168 bool ToggleLibraryTagType::canBeRun()
2169 {
2170 return (myScreen->isActiveWindow(myLibrary->Tags))
2171 || (myLibrary->Columns() == 2 && myScreen->isActiveWindow(myLibrary->Albums));
2172 }
2173
2174 void ToggleLibraryTagType::run()
2175 {
2176 using Global::wFooter;
2177
2178 char tag_type = 0;
2179 {
2180 Statusbar::ScopedLock slock;
2181 Statusbar::put() << "Tag type? "
2182 << "[" << NC::Format::Bold << 'a' << NC::Format::NoBold << "rtist"
2183 << "/" << "album" << NC::Format::Bold << 'A' << NC::Format::NoBold << "rtist"
2184 << "/" << NC::Format::Bold << 'y' << NC::Format::NoBold << "ear"
2185 << "/" << NC::Format::Bold << 'g' << NC::Format::NoBold << "enre"
2186 << "/" << NC::Format::Bold << 'c' << NC::Format::NoBold << "omposer"
2187 << "/" << NC::Format::Bold << 'p' << NC::Format::NoBold << "erformer"
2188 << "] ";
2189 tag_type = Statusbar::Helpers::promptReturnOneOf({"a", "A", "y", "g", "c", "p"})[0];
2190 }
2191 mpd_tag_type new_tagitem = charToTagType(tag_type);
2192 if (new_tagitem != Config.media_lib_primary_tag)
2193 {
2194 Config.media_lib_primary_tag = new_tagitem;
2195 std::string item_type = tagTypeToString(Config.media_lib_primary_tag);
2196 myLibrary->Tags.setTitle(Config.titles_visibility ? item_type + "s" : "");
2197 myLibrary->Tags.reset();
2198 item_type = boost::locale::to_lower(item_type);
2199 std::string and_mtime = Config.media_library_sort_by_mtime ?
2200 " and mtime" :
2201 "";
2202 if (myLibrary->Columns() == 2)
2203 {
2204 myLibrary->Songs.clear();
2205 myLibrary->Albums.reset();
2206 myLibrary->Albums.clear();
2207 myLibrary->Albums.setTitle(Config.titles_visibility ? "Albums (sorted by " + item_type + and_mtime + ")" : "");
2208 myLibrary->Albums.display();
2209 }
2210 else
2211 {
2212 myLibrary->Tags.clear();
2213 myLibrary->Tags.display();
2214 }
2215 Statusbar::printf("Switched to the list of %1%s", item_type);
2216 }
2217 }
2218
2219 bool ToggleMediaLibrarySortMode::canBeRun()
2220 {
2221 return myScreen == myLibrary;
2222 }
2223
2224 void ToggleMediaLibrarySortMode::run()
2225 {
2226 myLibrary->toggleSortMode();
2227 }
2228
2229 bool RefetchLyrics::canBeRun()
2230 {
2231 # ifdef HAVE_CURL_CURL_H
2232 return myScreen == myLyrics;
2233 # else
2234 return false;
2235 # endif // HAVE_CURL_CURL_H
2236 }
2237
2238 void RefetchLyrics::run()
2239 {
2240 # ifdef HAVE_CURL_CURL_H
2241 myLyrics->Refetch();
2242 # endif // HAVE_CURL_CURL_H
2243 }
2244
2245 bool SetSelectedItemsPriority::canBeRun()
2246 {
2247 if (Mpd.Version() < 17)
2248 {
2249 Statusbar::print("Priorities are supported in MPD >= 0.17.0");
2250 return false;
2251 }
2252 return myScreen == myPlaylist && !myPlaylist->main().empty();
2253 }
2254
2255 void SetSelectedItemsPriority::run()
2256 {
2257 using Global::wFooter;
2258
2259 unsigned prio;
2260 {
2261 Statusbar::ScopedLock slock;
2262 Statusbar::put() << "Set priority [0-255]: ";
2263 prio = fromString<unsigned>(wFooter->prompt());
2264 boundsCheck(prio, 0u, 255u);
2265 }
2266 myPlaylist->setSelectedItemsPriority(prio);
2267 }
2268
2269 bool ToggleOutput::canBeRun()
2270 {
2271 #ifdef ENABLE_OUTPUTS
2272 return myScreen == myOutputs;
2273 #else
2274 return false;
2275 #endif // ENABLE_OUTPUTS
2276 }
2277
2278 void ToggleOutput::run()
2279 {
2280 #ifdef ENABLE_OUTPUTS
2281 myOutputs->toggleOutput();
2282 #endif // ENABLE_OUTPUTS
2283 }
2284
2285 bool ToggleVisualizationType::canBeRun()
2286 {
2287 # ifdef ENABLE_VISUALIZER
2288 return myScreen == myVisualizer;
2289 # else
2290 return false;
2291 # endif // ENABLE_VISUALIZER
2292 }
2293
2294 void ToggleVisualizationType::run()
2295 {
2296 # ifdef ENABLE_VISUALIZER
2297 myVisualizer->ToggleVisualizationType();
2298 # endif // ENABLE_VISUALIZER
2299 }
2300
2301 bool SetVisualizerSampleMultiplier::canBeRun()
2302 {
2303 # ifdef ENABLE_VISUALIZER
2304 return myScreen == myVisualizer;
2305 # else
2306 return false;
2307 # endif // ENABLE_VISUALIZER
2308 }
2309
2310 void SetVisualizerSampleMultiplier::run()
2311 {
2312 # ifdef ENABLE_VISUALIZER
2313 using Global::wFooter;
2314
2315 double multiplier;
2316 {
2317 Statusbar::ScopedLock slock;
2318 Statusbar::put() << "Set visualizer sample multiplier: ";
2319 multiplier = fromString<double>(wFooter->prompt());
2320 lowerBoundCheck(multiplier, 0.0);
2321 Config.visualizer_sample_multiplier = multiplier;
2322 }
2323 Statusbar::printf("Visualizer sample multiplier set to %1%", multiplier);
2324 # endif // ENABLE_VISUALIZER
2325 }
2326
2327 void ShowSongInfo::run()
2328 {
2329 mySongInfo->switchTo();
2330 }
2331
2332 bool ShowArtistInfo::canBeRun()
2333 {
2334 #ifdef HAVE_CURL_CURL_H
2335 return myScreen == myLastfm
2336 || (myScreen->isActiveWindow(myLibrary->Tags)
2337 && !myLibrary->Tags.empty()
2338 && Config.media_lib_primary_tag == MPD_TAG_ARTIST)
2339 || currentSong(myScreen);
2340 # else
2341 return false;
2342 # endif // NOT HAVE_CURL_CURL_H
2343 }
2344
2345 void ShowArtistInfo::run()
2346 {
2347 # ifdef HAVE_CURL_CURL_H
2348 if (myScreen == myLastfm)
2349 {
2350 myLastfm->switchTo();
2351 return;
2352 }
2353
2354 std::string artist;
2355 if (myScreen->isActiveWindow(myLibrary->Tags))
2356 {
2357 assert(!myLibrary->Tags.empty());
2358 assert(Config.media_lib_primary_tag == MPD_TAG_ARTIST);
2359 artist = myLibrary->Tags.current()->value().tag();
2360 }
2361 else
2362 {
2363 auto s = currentSong(myScreen);
2364 assert(s);
2365 artist = s->getArtist();
2366 }
2367
2368 if (!artist.empty())
2369 {
2370 myLastfm->queueJob(new LastFm::ArtistInfo(artist, Config.lastfm_preferred_language));
2371 myLastfm->switchTo();
2372 }
2373 # endif // HAVE_CURL_CURL_H
2374 }
2375
2376 void ShowLyrics::run()
2377 {
2378 myLyrics->switchTo();
2379 }
2380
2381 void Quit::run()
2382 {
2383 ExitMainLoop = true;
2384 }
2385
2386 void NextScreen::run()
2387 {
2388 if (Config.screen_switcher_previous)
2389 {
2390 if (auto tababble = dynamic_cast<Tabbable *>(myScreen))
2391 tababble->switchToPreviousScreen();
2392 }
2393 else if (!Config.screen_sequence.empty())
2394 {
2395 const auto &seq = Config.screen_sequence;
2396 auto screen_type = std::find(seq.begin(), seq.end(), myScreen->type());
2397 if (++screen_type == seq.end())
2398 toScreen(seq.front())->switchTo();
2399 else
2400 toScreen(*screen_type)->switchTo();
2401 }
2402 }
2403
2404 void PreviousScreen::run()
2405 {
2406 if (Config.screen_switcher_previous)
2407 {
2408 if (auto tababble = dynamic_cast<Tabbable *>(myScreen))
2409 tababble->switchToPreviousScreen();
2410 }
2411 else if (!Config.screen_sequence.empty())
2412 {
2413 const auto &seq = Config.screen_sequence;
2414 auto screen_type = std::find(seq.begin(), seq.end(), myScreen->type());
2415 if (screen_type == seq.begin())
2416 toScreen(seq.back())->switchTo();
2417 else
2418 toScreen(*--screen_type)->switchTo();
2419 }
2420 }
2421
2422 bool ShowHelp::canBeRun()
2423 {
2424 return myScreen != myHelp
2425 # ifdef HAVE_TAGLIB_H
2426 && myScreen != myTinyTagEditor
2427 # endif // HAVE_TAGLIB_H
2428 ;
2429 }
2430
2431 void ShowHelp::run()
2432 {
2433 myHelp->switchTo();
2434 }
2435
2436 bool ShowPlaylist::canBeRun()
2437 {
2438 return myScreen != myPlaylist
2439 # ifdef HAVE_TAGLIB_H
2440 && myScreen != myTinyTagEditor
2441 # endif // HAVE_TAGLIB_H
2442 ;
2443 }
2444
2445 void ShowPlaylist::run()
2446 {
2447 myPlaylist->switchTo();
2448 }
2449
2450 bool ShowBrowser::canBeRun()
2451 {
2452 return myScreen != myBrowser
2453 # ifdef HAVE_TAGLIB_H
2454 && myScreen != myTinyTagEditor
2455 # endif // HAVE_TAGLIB_H
2456 ;
2457 }
2458
2459 void ShowBrowser::run()
2460 {
2461 myBrowser->switchTo();
2462 }
2463
2464 bool ChangeBrowseMode::canBeRun()
2465 {
2466 return myScreen == myBrowser;
2467 }
2468
2469 void ChangeBrowseMode::run()
2470 {
2471 myBrowser->changeBrowseMode();
2472 }
2473
2474 bool ShowSearchEngine::canBeRun()
2475 {
2476 return myScreen != mySearcher
2477 # ifdef HAVE_TAGLIB_H
2478 && myScreen != myTinyTagEditor
2479 # endif // HAVE_TAGLIB_H
2480 ;
2481 }
2482
2483 void ShowSearchEngine::run()
2484 {
2485 mySearcher->switchTo();
2486 }
2487
2488 bool ResetSearchEngine::canBeRun()
2489 {
2490 return myScreen == mySearcher;
2491 }
2492
2493 void ResetSearchEngine::run()
2494 {
2495 mySearcher->reset();
2496 }
2497
2498 bool ShowMediaLibrary::canBeRun()
2499 {
2500 return myScreen != myLibrary
2501 # ifdef HAVE_TAGLIB_H
2502 && myScreen != myTinyTagEditor
2503 # endif // HAVE_TAGLIB_H
2504 ;
2505 }
2506
2507 void ShowMediaLibrary::run()
2508 {
2509 myLibrary->switchTo();
2510 }
2511
2512 bool ToggleMediaLibraryColumnsMode::canBeRun()
2513 {
2514 return myScreen == myLibrary;
2515 }
2516
2517 void ToggleMediaLibraryColumnsMode::run()
2518 {
2519 myLibrary->toggleColumnsMode();
2520 myLibrary->refresh();
2521 }
2522
2523 bool ShowPlaylistEditor::canBeRun()
2524 {
2525 return myScreen != myPlaylistEditor
2526 # ifdef HAVE_TAGLIB_H
2527 && myScreen != myTinyTagEditor
2528 # endif // HAVE_TAGLIB_H
2529 ;
2530 }
2531
2532 void ShowPlaylistEditor::run()
2533 {
2534 myPlaylistEditor->switchTo();
2535 }
2536
2537 bool ShowTagEditor::canBeRun()
2538 {
2539 # ifdef HAVE_TAGLIB_H
2540 return myScreen != myTagEditor
2541 && myScreen != myTinyTagEditor;
2542 # else
2543 return false;
2544 # endif // HAVE_TAGLIB_H
2545 }
2546
2547 void ShowTagEditor::run()
2548 {
2549 # ifdef HAVE_TAGLIB_H
2550 if (isMPDMusicDirSet())
2551 myTagEditor->switchTo();
2552 # endif // HAVE_TAGLIB_H
2553 }
2554
2555 bool ShowOutputs::canBeRun()
2556 {
2557 # ifdef ENABLE_OUTPUTS
2558 return myScreen != myOutputs
2559 # ifdef HAVE_TAGLIB_H
2560 && myScreen != myTinyTagEditor
2561 # endif // HAVE_TAGLIB_H
2562 ;
2563 # else
2564 return false;
2565 # endif // ENABLE_OUTPUTS
2566 }
2567
2568 void ShowOutputs::run()
2569 {
2570 # ifdef ENABLE_OUTPUTS
2571 myOutputs->switchTo();
2572 # endif // ENABLE_OUTPUTS
2573 }
2574
2575 bool ShowVisualizer::canBeRun()
2576 {
2577 # ifdef ENABLE_VISUALIZER
2578 return myScreen != myVisualizer
2579 # ifdef HAVE_TAGLIB_H
2580 && myScreen != myTinyTagEditor
2581 # endif // HAVE_TAGLIB_H
2582 ;
2583 # else
2584 return false;
2585 # endif // ENABLE_VISUALIZER
2586 }
2587
2588 void ShowVisualizer::run()
2589 {
2590 # ifdef ENABLE_VISUALIZER
2591 myVisualizer->switchTo();
2592 # endif // ENABLE_VISUALIZER
2593 }
2594
2595 bool ShowClock::canBeRun()
2596 {
2597 # ifdef ENABLE_CLOCK
2598 return myScreen != myClock
2599 # ifdef HAVE_TAGLIB_H
2600 && myScreen != myTinyTagEditor
2601 # endif // HAVE_TAGLIB_H
2602 ;
2603 # else
2604 return false;
2605 # endif // ENABLE_CLOCK
2606 }
2607
2608 void ShowClock::run()
2609 {
2610 # ifdef ENABLE_CLOCK
2611 myClock->switchTo();
2612 # endif // ENABLE_CLOCK
2613 }
2614
2615 #ifdef HAVE_TAGLIB_H
2616 bool ShowServerInfo::canBeRun()
2617 {
2618 return myScreen != myTinyTagEditor;
2619 }
2620 #endif // HAVE_TAGLIB_H
2621
2622 void ShowServerInfo::run()
2623 {
2624 myServerInfo->switchTo();
2625 }
2626
2627 }
2628
2629 namespace {
2630
2631 void populateActions()
2632 {
2633 auto insert_action = [](Actions::BaseAction *a) {
2634 AvailableActions[static_cast<size_t>(a->type())] = a;
2635 };
2636 insert_action(new Actions::Dummy());
2637 insert_action(new Actions::UpdateEnvironment());
2638 insert_action(new Actions::MouseEvent());
2639 insert_action(new Actions::ScrollUp());
2640 insert_action(new Actions::ScrollDown());
2641 insert_action(new Actions::ScrollUpArtist());
2642 insert_action(new Actions::ScrollUpAlbum());
2643 insert_action(new Actions::ScrollDownArtist());
2644 insert_action(new Actions::ScrollDownAlbum());
2645 insert_action(new Actions::PageUp());
2646 insert_action(new Actions::PageDown());
2647 insert_action(new Actions::MoveHome());
2648 insert_action(new Actions::MoveEnd());
2649 insert_action(new Actions::ToggleInterface());
2650 insert_action(new Actions::JumpToParentDirectory());
2651 insert_action(new Actions::RunAction());
2652 insert_action(new Actions::SelectItem());
2653 insert_action(new Actions::SelectRange());
2654 insert_action(new Actions::PreviousColumn());
2655 insert_action(new Actions::NextColumn());
2656 insert_action(new Actions::MasterScreen());
2657 insert_action(new Actions::SlaveScreen());
2658 insert_action(new Actions::VolumeUp());
2659 insert_action(new Actions::VolumeDown());
2660 insert_action(new Actions::AddItemToPlaylist());
2661 insert_action(new Actions::DeletePlaylistItems());
2662 insert_action(new Actions::DeleteStoredPlaylist());
2663 insert_action(new Actions::DeleteBrowserItems());
2664 insert_action(new Actions::ReplaySong());
2665 insert_action(new Actions::PreviousSong());
2666 insert_action(new Actions::NextSong());
2667 insert_action(new Actions::Pause());
2668 insert_action(new Actions::Stop());
2669 insert_action(new Actions::ExecuteCommand());
2670 insert_action(new Actions::SavePlaylist());
2671 insert_action(new Actions::MoveSortOrderUp());
2672 insert_action(new Actions::MoveSortOrderDown());
2673 insert_action(new Actions::MoveSelectedItemsUp());
2674 insert_action(new Actions::MoveSelectedItemsDown());
2675 insert_action(new Actions::MoveSelectedItemsTo());
2676 insert_action(new Actions::Add());
2677 insert_action(new Actions::PlayItem());
2678 insert_action(new Actions::SeekForward());
2679 insert_action(new Actions::SeekBackward());
2680 insert_action(new Actions::ToggleDisplayMode());
2681 insert_action(new Actions::ToggleSeparatorsBetweenAlbums());
2682 insert_action(new Actions::ToggleLyricsUpdateOnSongChange());
2683 insert_action(new Actions::ToggleLyricsFetcher());
2684 insert_action(new Actions::ToggleFetchingLyricsInBackground());
2685 insert_action(new Actions::TogglePlayingSongCentering());
2686 insert_action(new Actions::UpdateDatabase());
2687 insert_action(new Actions::JumpToPlayingSong());
2688 insert_action(new Actions::ToggleRepeat());
2689 insert_action(new Actions::Shuffle());
2690 insert_action(new Actions::ToggleRandom());
2691 insert_action(new Actions::StartSearching());
2692 insert_action(new Actions::SaveTagChanges());
2693 insert_action(new Actions::ToggleSingle());
2694 insert_action(new Actions::ToggleConsume());
2695 insert_action(new Actions::ToggleCrossfade());
2696 insert_action(new Actions::SetCrossfade());
2697 insert_action(new Actions::SetVolume());
2698 insert_action(new Actions::EnterDirectory());
2699 insert_action(new Actions::EditSong());
2700 insert_action(new Actions::EditLibraryTag());
2701 insert_action(new Actions::EditLibraryAlbum());
2702 insert_action(new Actions::EditDirectoryName());
2703 insert_action(new Actions::EditPlaylistName());
2704 insert_action(new Actions::EditLyrics());
2705 insert_action(new Actions::JumpToBrowser());
2706 insert_action(new Actions::JumpToMediaLibrary());
2707 insert_action(new Actions::JumpToPlaylistEditor());
2708 insert_action(new Actions::ToggleScreenLock());
2709 insert_action(new Actions::JumpToTagEditor());
2710 insert_action(new Actions::JumpToPositionInSong());
2711 insert_action(new Actions::ReverseSelection());
2712 insert_action(new Actions::RemoveSelection());
2713 insert_action(new Actions::SelectAlbum());
2714 insert_action(new Actions::SelectFoundItems());
2715 insert_action(new Actions::AddSelectedItems());
2716 insert_action(new Actions::CropMainPlaylist());
2717 insert_action(new Actions::CropPlaylist());
2718 insert_action(new Actions::ClearMainPlaylist());
2719 insert_action(new Actions::ClearPlaylist());
2720 insert_action(new Actions::SortPlaylist());
2721 insert_action(new Actions::ReversePlaylist());
2722 insert_action(new Actions::Find());
2723 insert_action(new Actions::FindItemForward());
2724 insert_action(new Actions::FindItemBackward());
2725 insert_action(new Actions::NextFoundItem());
2726 insert_action(new Actions::PreviousFoundItem());
2727 insert_action(new Actions::ToggleFindMode());
2728 insert_action(new Actions::ToggleReplayGainMode());
2729 insert_action(new Actions::ToggleAddMode());
2730 insert_action(new Actions::ToggleMouse());
2731 insert_action(new Actions::ToggleBitrateVisibility());
2732 insert_action(new Actions::AddRandomItems());
2733 insert_action(new Actions::ToggleBrowserSortMode());
2734 insert_action(new Actions::ToggleLibraryTagType());
2735 insert_action(new Actions::ToggleMediaLibrarySortMode());
2736 insert_action(new Actions::RefetchLyrics());
2737 insert_action(new Actions::SetSelectedItemsPriority());
2738 insert_action(new Actions::ToggleOutput());
2739 insert_action(new Actions::ToggleVisualizationType());
2740 insert_action(new Actions::SetVisualizerSampleMultiplier());
2741 insert_action(new Actions::ShowSongInfo());
2742 insert_action(new Actions::ShowArtistInfo());
2743 insert_action(new Actions::ShowLyrics());
2744 insert_action(new Actions::Quit());
2745 insert_action(new Actions::NextScreen());
2746 insert_action(new Actions::PreviousScreen());
2747 insert_action(new Actions::ShowHelp());
2748 insert_action(new Actions::ShowPlaylist());
2749 insert_action(new Actions::ShowBrowser());
2750 insert_action(new Actions::ChangeBrowseMode());
2751 insert_action(new Actions::ShowSearchEngine());
2752 insert_action(new Actions::ResetSearchEngine());
2753 insert_action(new Actions::ShowMediaLibrary());
2754 insert_action(new Actions::ToggleMediaLibraryColumnsMode());
2755 insert_action(new Actions::ShowPlaylistEditor());
2756 insert_action(new Actions::ShowTagEditor());
2757 insert_action(new Actions::ShowOutputs());
2758 insert_action(new Actions::ShowVisualizer());
2759 insert_action(new Actions::ShowClock());
2760 insert_action(new Actions::ShowServerInfo());
2761 }
2762
2763 bool scrollTagCanBeRun(NC::List *&list, SongList *&songs)
2764 {
2765 auto w = myScreen->activeWindow();
2766 if (list != static_cast<void *>(w))
2767 list = dynamic_cast<NC::List *>(w);
2768 if (songs != static_cast<void *>(w))
2769 songs = dynamic_cast<SongList *>(w);
2770 return list != nullptr && !list->empty()
2771 && songs != nullptr;
2772 }
2773
2774 void scrollTagUpRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get)
2775 {
2776 const auto front = songs->beginS();
2777 auto it = songs->currentS();
2778 if (auto *s = it->get<Bit::Song>())
2779 {
2780 const std::string tag = s->getTags(get);
2781 while (it != front)
2782 {
2783 --it;
2784 s = it->get<Bit::Song>();
2785 if (s == nullptr || s->getTags(get) != tag)
2786 break;
2787 }
2788 list->highlight(it-front);
2789 }
2790 }
2791
2792 void scrollTagDownRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get)
2793 {
2794 const auto front = songs->beginS(), back = --songs->endS();
2795 auto it = songs->currentS();
2796 if (auto *s = it->get<Bit::Song>())
2797 {
2798 const std::string tag = s->getTags(get);
2799 while (it != back)
2800 {
2801 ++it;
2802 s = it->get<Bit::Song>();
2803 if (s == nullptr || s->getTags(get) != tag)
2804 break;
2805 }
2806 list->highlight(it-front);
2807 }
2808 }
2809
2810 void seek()
2811 {
2812 using Global::wHeader;
2813 using Global::wFooter;
2814 using Global::Timer;
2815 using Global::SeekingInProgress;
2816
2817 if (!Status::State::totalTime())
2818 {
2819 Statusbar::print("Unknown item length");
2820 return;
2821 }
2822
2823 Progressbar::ScopedLock progressbar_lock;
2824 Statusbar::ScopedLock statusbar_lock;
2825
2826 unsigned songpos = Status::State::elapsedTime();
2827 auto t = Timer;
2828
2829 int old_timeout = wFooter->getTimeout();
2830 wFooter->setTimeout(BaseScreen::defaultWindowTimeout);
2831
2832 auto seekForward = &Actions::get(Actions::Type::SeekForward);
2833 auto seekBackward = &Actions::get(Actions::Type::SeekBackward);
2834
2835 SeekingInProgress = true;
2836 while (true)
2837 {
2838 Status::trace();
2839
2840 unsigned howmuch = Config.incremental_seeking
2841 ? (Timer-t).total_seconds()/2+Config.seek_time
2842 : Config.seek_time;
2843
2844 NC::Key::Type input = readKey(*wFooter);
2845 auto k = Bindings.get(input);
2846 if (k.first == k.second || !k.first->isSingle()) // no single action?
2847 break;
2848 auto a = k.first->action();
2849 if (a == seekForward)
2850 {
2851 if (songpos < Status::State::totalTime())
2852 songpos = std::min(songpos + howmuch, Status::State::totalTime());
2853 }
2854 else if (a == seekBackward)
2855 {
2856 if (songpos > 0)
2857 {
2858 if (songpos < howmuch)
2859 songpos = 0;
2860 else
2861 songpos -= howmuch;
2862 }
2863 }
2864 else
2865 break;
2866
2867 *wFooter << NC::Format::Bold;
2868 std::string tracklength;
2869 // FIXME: merge this with the code in status.cpp
2870 switch (Config.design)
2871 {
2872 case Design::Classic:
2873 tracklength = " [";
2874 if (Config.display_remaining_time)
2875 {
2876 tracklength += "-";
2877 tracklength += MPD::Song::ShowTime(Status::State::totalTime()-songpos);
2878 }
2879 else
2880 tracklength += MPD::Song::ShowTime(songpos);
2881 tracklength += "/";
2882 tracklength += MPD::Song::ShowTime(Status::State::totalTime());
2883 tracklength += "]";
2884 *wFooter << NC::XY(wFooter->getWidth()-tracklength.length(), 1) << tracklength;
2885 break;
2886 case Design::Alternative:
2887 if (Config.display_remaining_time)
2888 {
2889 tracklength = "-";
2890 tracklength += MPD::Song::ShowTime(Status::State::totalTime()-songpos);
2891 }
2892 else
2893 tracklength = MPD::Song::ShowTime(songpos);
2894 tracklength += "/";
2895 tracklength += MPD::Song::ShowTime(Status::State::totalTime());
2896 *wHeader << NC::XY(0, 0) << tracklength << " ";
2897 wHeader->refresh();
2898 break;
2899 }
2900 *wFooter << NC::Format::NoBold;
2901 Progressbar::draw(songpos, Status::State::totalTime());
2902 wFooter->refresh();
2903 }
2904 SeekingInProgress = false;
2905 Mpd.Seek(Status::State::currentSongPosition(), songpos);
2906
2907 wFooter->setTimeout(old_timeout);
2908 }
2909
2910 void findItem(const SearchDirection direction)
2911 {
2912 using Global::wFooter;
2913
2914 Searchable *w = dynamic_cast<Searchable *>(myScreen);
2915 assert(w != nullptr);
2916 assert(w->allowsSearching());
2917
2918 std::string constraint;
2919 {
2920 Statusbar::ScopedLock slock;
2921 NC::Window::ScopedPromptHook prompt_hook(*wFooter,
2922 Statusbar::Helpers::FindImmediately(w, direction)
2923 );
2924 Statusbar::put() << (boost::format("Find %1%: ") % direction).str();
2925 constraint = wFooter->prompt();
2926 }
2927
2928 try
2929 {
2930 if (constraint.empty())
2931 {
2932 Statusbar::printf("Constraint unset");
2933 w->clearConstraint();
2934 }
2935 else
2936 {
2937 w->setSearchConstraint(constraint);
2938 Statusbar::printf("Using constraint \"%1%\"", constraint);
2939 }
2940 }
2941 catch (boost::bad_expression &e)
2942 {
2943 Statusbar::printf("%1%", e.what());
2944 }
2945 }
2946
2947 void listsChangeFinisher()
2948 {
2949 if (myScreen == myLibrary
2950 || myScreen == myPlaylistEditor
2951 # ifdef HAVE_TAGLIB_H
2952 || myScreen == myTagEditor
2953 # endif // HAVE_TAGLIB_H
2954 )
2955 {
2956 if (myScreen->activeWindow() == &myLibrary->Tags)
2957 {
2958 myLibrary->Albums.clear();
2959 myLibrary->Albums.refresh();
2960 myLibrary->Songs.clear();
2961 myLibrary->Songs.refresh();
2962 myLibrary->updateTimer();
2963 }
2964 else if (myScreen->activeWindow() == &myLibrary->Albums)
2965 {
2966 myLibrary->Songs.clear();
2967 myLibrary->Songs.refresh();
2968 myLibrary->updateTimer();
2969 }
2970 else if (myScreen->isActiveWindow(myPlaylistEditor->Playlists))
2971 {
2972 myPlaylistEditor->Content.clear();
2973 myPlaylistEditor->Content.refresh();
2974 myPlaylistEditor->updateTimer();
2975 }
2976 # ifdef HAVE_TAGLIB_H
2977 else if (myScreen->activeWindow() == myTagEditor->Dirs)
2978 {
2979 myTagEditor->Tags->clear();
2980 }
2981 # endif // HAVE_TAGLIB_H
2982 }
2983 }
2984
2985 }
an ncurses mpd client inspired by ncmpc