1 /***************************************************************************
2 * Copyright (C) 2008-2021 by Andrzej Rybczak *
3 * andrzej@rybczak.net *
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 #ifndef NCMPCPP_ACTIONS_H
22 #define NCMPCPP_ACTIONS_H
23
24 #include <boost/date_time/posix_time/posix_time_types.hpp>
25 #include <boost/format.hpp>
26 #include <map>
27 #include <string>
28 #include "curses/window.h"
29 #include "interfaces.h"
30
31 // forward declarations
32 struct SongList;
33
34 namespace Actions {
35
36 enum class Type
37 {
38 MacroUtility = -1,
39 Dummy,
40 UpdateEnvironment,
41 MouseEvent,
42 ScrollUp,
43 ScrollDown,
44 ScrollUpArtist,
45 ScrollUpAlbum,
46 ScrollDownArtist,
47 ScrollDownAlbum,
48 PageUp,
49 PageDown,
50 MoveHome,
51 MoveEnd,
52 ToggleInterface,
53 JumpToParentDirectory,
54 RunAction,
55 PreviousColumn,
56 NextColumn,
57 MasterScreen,
58 SlaveScreen,
59 VolumeUp,
60 VolumeDown,
61 AddItemToPlaylist,
62 PlayItem,
63 DeletePlaylistItems,
64 DeleteStoredPlaylist,
65 DeleteBrowserItems,
66 ReplaySong,
67 Previous,
68 Next,
69 Pause,
70 Stop,
71 Play,
72 ExecuteCommand,
73 SavePlaylist,
74 MoveSortOrderUp,
75 MoveSortOrderDown,
76 MoveSelectedItemsUp,
77 MoveSelectedItemsDown,
78 MoveSelectedItemsTo,
79 Add,
80 Load,
81 SeekForward,
82 SeekBackward,
83 ToggleDisplayMode,
84 ToggleSeparatorsBetweenAlbums,
85 ToggleLyricsUpdateOnSongChange,
86 ToggleLyricsFetcher,
87 ToggleFetchingLyricsInBackground,
88 TogglePlayingSongCentering,
89 UpdateDatabase,
90 JumpToPlayingSong,
91 ToggleRepeat,
92 Shuffle,
93 ToggleRandom,
94 StartSearching,
95 SaveTagChanges,
96 ToggleSingle,
97 ToggleConsume,
98 ToggleCrossfade,
99 SetCrossfade,
100 SetVolume,
101 EnterDirectory,
102 EditSong,
103 EditLibraryTag,
104 EditLibraryAlbum,
105 EditDirectoryName,
106 EditPlaylistName,
107 EditLyrics,
108 JumpToBrowser,
109 JumpToMediaLibrary,
110 JumpToPlaylistEditor,
111 ToggleScreenLock,
112 JumpToTagEditor,
113 JumpToPositionInSong,
114 SelectItem,
115 SelectRange,
116 ReverseSelection,
117 RemoveSelection,
118 SelectAlbum,
119 SelectFoundItems,
120 AddSelectedItems,
121 CropMainPlaylist,
122 CropPlaylist,
123 ClearMainPlaylist,
124 ClearPlaylist,
125 SortPlaylist,
126 ReversePlaylist,
127 ApplyFilter,
128 Find,
129 FindItemForward,
130 FindItemBackward,
131 NextFoundItem,
132 PreviousFoundItem,
133 ToggleFindMode,
134 ToggleReplayGainMode,
135 ToggleAddMode,
136 ToggleMouse,
137 ToggleBitrateVisibility,
138 AddRandomItems,
139 ToggleBrowserSortMode,
140 ToggleLibraryTagType,
141 ToggleMediaLibrarySortMode,
142 FetchLyricsInBackground,
143 RefetchLyrics,
144 SetSelectedItemsPriority,
145 ToggleOutput,
146 ToggleVisualizationType,
147 ShowSongInfo,
148 ShowArtistInfo,
149 ShowLyrics,
150 Quit,
151 NextScreen,
152 PreviousScreen,
153 ShowHelp,
154 ShowPlaylist,
155 ShowBrowser,
156 ChangeBrowseMode,
157 ShowSearchEngine,
158 ResetSearchEngine,
159 ShowMediaLibrary,
160 ToggleMediaLibraryColumnsMode,
161 ShowPlaylistEditor,
162 ShowTagEditor,
163 ShowOutputs,
164 ShowVisualizer,
165 ShowClock,
166 ShowServerInfo,
167 _numberOfActions // needed to dynamically calculate size of action array
168 };
169
170 void validateScreenSize();
171 void initializeScreens();
172 void setResizeFlags();
173 void resizeScreen(bool reload_main_window);
174 void setWindowsDimensions();
175
176 void confirmAction(const boost::format &description);
confirmAction(const std::string & description)177 inline void confirmAction(const std::string &description)
178 {
179 confirmAction(boost::format(description));
180 }
181
182 bool isMPDMusicDirSet();
183
184 extern bool OriginalStatusbarVisibility;
185 extern bool ExitMainLoop;
186
187 extern size_t HeaderHeight;
188 extern size_t FooterHeight;
189 extern size_t FooterStartY;
190
191 struct BaseAction
192 {
BaseActionBaseAction193 BaseAction(Type type_, const char *name_): m_name(name_), m_type(type_) { }
194
~BaseActionBaseAction195 virtual ~BaseAction() { }
196
nameBaseAction197 const std::string &name() const { return m_name; }
typeBaseAction198 Type type() const { return m_type; }
199
canBeRunBaseAction200 virtual bool canBeRun() { return true; }
201
executeBaseAction202 bool execute()
203 {
204 if (canBeRun())
205 {
206 run();
207 return true;
208 }
209 return false;
210 }
211
212 protected:
213 std::string m_name;
214
215 private:
216 virtual void run() = 0;
217
218 Type m_type;
219 };
220
221 BaseAction &get(Type at);
222
223 std::shared_ptr<BaseAction> get_(Type at);
224 std::shared_ptr<BaseAction> get_(const std::string &name);
225
226 struct Dummy: BaseAction
227 {
DummyDummy228 Dummy(): BaseAction(Type::Dummy, "dummy") { }
229
230 private:
runDummy231 virtual void run() override { }
232 };
233
234 struct UpdateEnvironment: BaseAction
235 {
236 UpdateEnvironment();
237
238 void run(bool update_status, bool refresh_window, bool mpd_sync);
239
240 private:
241 boost::posix_time::ptime m_past;
242
243 virtual void run() override;
244 };
245
246 struct MouseEvent: BaseAction
247 {
MouseEventMouseEvent248 MouseEvent(): BaseAction(Type::MouseEvent, "mouse_event")
249 {
250 m_old_mouse_event.bstate = 0;
251 m_mouse_event.bstate = 0;
252 }
253
254 private:
255 virtual bool canBeRun() override;
256 virtual void run() override;
257
258 MEVENT m_mouse_event;
259 MEVENT m_old_mouse_event;
260 };
261
262 struct ScrollUp: BaseAction
263 {
ScrollUpScrollUp264 ScrollUp(): BaseAction(Type::ScrollUp, "scroll_up") { }
265
266 private:
267 virtual void run() override;
268 };
269
270 struct ScrollDown: BaseAction
271 {
ScrollDownScrollDown272 ScrollDown(): BaseAction(Type::ScrollDown, "scroll_down") { }
273
274 private:
275 virtual void run() override;
276 };
277
278 struct ScrollUpArtist: BaseAction
279 {
ScrollUpArtistScrollUpArtist280 ScrollUpArtist(): BaseAction(Type::ScrollUpArtist, "scroll_up_artist") { }
281
282 private:
283 virtual bool canBeRun() override;
284 virtual void run() override;
285
286 NC::List *m_list;
287 const SongList *m_songs;
288 };
289
290 struct ScrollUpAlbum: BaseAction
291 {
ScrollUpAlbumScrollUpAlbum292 ScrollUpAlbum(): BaseAction(Type::ScrollUpAlbum, "scroll_up_album") { }
293
294 private:
295 virtual bool canBeRun() override;
296 virtual void run() override;
297
298 NC::List *m_list;
299 const SongList *m_songs;
300 };
301
302 struct ScrollDownArtist: BaseAction
303 {
ScrollDownArtistScrollDownArtist304 ScrollDownArtist(): BaseAction(Type::ScrollDownArtist, "scroll_down_artist") { }
305
306 private:
307 virtual bool canBeRun() override;
308 virtual void run() override;
309
310 NC::List *m_list;
311 const SongList *m_songs;
312 };
313
314 struct ScrollDownAlbum: BaseAction
315 {
ScrollDownAlbumScrollDownAlbum316 ScrollDownAlbum(): BaseAction(Type::ScrollDownAlbum, "scroll_down_album") { }
317
318 private:
319 virtual bool canBeRun() override;
320 virtual void run() override;
321
322 NC::List *m_list;
323 const SongList *m_songs;
324 };
325
326 struct PageUp: BaseAction
327 {
PageUpPageUp328 PageUp(): BaseAction(Type::PageUp, "page_up") { }
329
330 private:
331 virtual void run() override;
332 };
333
334 struct PageDown: BaseAction
335 {
PageDownPageDown336 PageDown(): BaseAction(Type::PageDown, "page_down") { }
337
338 private:
339 virtual void run() override;
340 };
341
342 struct MoveHome: BaseAction
343 {
MoveHomeMoveHome344 MoveHome(): BaseAction(Type::MoveHome, "move_home") { }
345
346 private:
347 virtual void run() override;
348 };
349
350 struct MoveEnd: BaseAction
351 {
MoveEndMoveEnd352 MoveEnd(): BaseAction(Type::MoveEnd, "move_end") { }
353
354 private:
355 virtual void run() override;
356 };
357
358 struct ToggleInterface: BaseAction
359 {
ToggleInterfaceToggleInterface360 ToggleInterface(): BaseAction(Type::ToggleInterface, "toggle_interface") { }
361
362 private:
363 virtual void run() override;
364 };
365
366 struct JumpToParentDirectory: BaseAction
367 {
JumpToParentDirectoryJumpToParentDirectory368 JumpToParentDirectory(): BaseAction(Type::JumpToParentDirectory, "jump_to_parent_directory") { }
369
370 private:
371 virtual bool canBeRun() override;
372 virtual void run() override;
373 };
374
375 struct RunAction: BaseAction
376 {
RunActionRunAction377 RunAction(): BaseAction(Type::RunAction, "run_action") { }
378
379 private:
380 virtual bool canBeRun() override;
381 virtual void run() override;
382
383 HasActions *m_ha;
384 };
385
386 struct PreviousColumn: BaseAction
387 {
PreviousColumnPreviousColumn388 PreviousColumn(): BaseAction(Type::PreviousColumn, "previous_column") { }
389
390 private:
391 virtual bool canBeRun() override;
392 virtual void run() override;
393
394 HasColumns *m_hc;
395 };
396
397 struct NextColumn: BaseAction
398 {
NextColumnNextColumn399 NextColumn(): BaseAction(Type::NextColumn, "next_column") { }
400
401 private:
402 virtual bool canBeRun() override;
403 virtual void run() override;
404
405 HasColumns *m_hc;
406 };
407
408 struct MasterScreen: BaseAction
409 {
MasterScreenMasterScreen410 MasterScreen(): BaseAction(Type::MasterScreen, "master_screen") { }
411
412 private:
413 virtual bool canBeRun() override;
414 virtual void run() override;
415 };
416
417 struct SlaveScreen: BaseAction
418 {
SlaveScreenSlaveScreen419 SlaveScreen(): BaseAction(Type::SlaveScreen, "slave_screen") { }
420
421 private:
422 virtual bool canBeRun() override;
423 virtual void run() override;
424 };
425
426 struct VolumeUp: BaseAction
427 {
VolumeUpVolumeUp428 VolumeUp(): BaseAction(Type::VolumeUp, "volume_up") { }
429
430 private:
431 virtual bool canBeRun() override;
432 virtual void run() override;
433 };
434
435 struct VolumeDown: BaseAction
436 {
VolumeDownVolumeDown437 VolumeDown(): BaseAction(Type::VolumeDown, "volume_down") { }
438
439 private:
440 virtual bool canBeRun() override;
441 virtual void run() override;
442 };
443
444 struct AddItemToPlaylist: BaseAction
445 {
AddItemToPlaylistAddItemToPlaylist446 AddItemToPlaylist(): BaseAction(Type::AddItemToPlaylist, "add_item_to_playlist") { }
447
448 private:
449 virtual bool canBeRun() override;
450 virtual void run() override;
451
452 HasSongs *m_hs;
453 };
454
455 struct PlayItem: BaseAction
456 {
PlayItemPlayItem457 PlayItem(): BaseAction(Type::PlayItem, "play_item") { }
458
459 private:
460 virtual bool canBeRun() override;
461 virtual void run() override;
462
463 HasSongs *m_hs;
464 };
465
466 struct DeletePlaylistItems: BaseAction
467 {
DeletePlaylistItemsDeletePlaylistItems468 DeletePlaylistItems(): BaseAction(Type::DeletePlaylistItems, "delete_playlist_items") { }
469
470 private:
471 virtual bool canBeRun() override;
472 virtual void run() override;
473 };
474
475 struct DeleteStoredPlaylist: BaseAction
476 {
DeleteStoredPlaylistDeleteStoredPlaylist477 DeleteStoredPlaylist(): BaseAction(Type::DeleteStoredPlaylist, "delete_stored_playlist") { }
478
479 private:
480 virtual bool canBeRun() override;
481 virtual void run() override;
482 };
483
484 struct DeleteBrowserItems: BaseAction
485 {
DeleteBrowserItemsDeleteBrowserItems486 DeleteBrowserItems(): BaseAction(Type::DeleteBrowserItems, "delete_browser_items") { }
487
488 private:
489 virtual bool canBeRun() override;
490 virtual void run() override;
491 };
492
493 struct ReplaySong: BaseAction
494 {
ReplaySongReplaySong495 ReplaySong(): BaseAction(Type::ReplaySong, "replay_song") { }
496
497 private:
498 virtual bool canBeRun() override;
499 virtual void run() override;
500 };
501
502 struct PreviousSong: BaseAction
503 {
PreviousSongPreviousSong504 PreviousSong(): BaseAction(Type::Previous, "previous") { }
505
506 private:
507 virtual void run() override;
508 };
509
510 struct NextSong: BaseAction
511 {
NextSongNextSong512 NextSong(): BaseAction(Type::Next, "next") { }
513
514 private:
515 virtual void run() override;
516 };
517
518 struct Pause: BaseAction
519 {
PausePause520 Pause(): BaseAction(Type::Pause, "pause") { }
521
522 private:
523 virtual bool canBeRun() override;
524 virtual void run() override;
525 };
526
527 struct Stop: BaseAction
528 {
StopStop529 Stop(): BaseAction(Type::Stop, "stop") { }
530
531 private:
532 virtual void run() override;
533 };
534
535 struct Play: BaseAction
536 {
PlayPlay537 Play(): BaseAction(Type::Play, "play") { }
538
539 private:
540 virtual void run() override;
541 };
542
543 struct ExecuteCommand: BaseAction
544 {
ExecuteCommandExecuteCommand545 ExecuteCommand(): BaseAction(Type::ExecuteCommand, "execute_command") { }
546
547 private:
548 virtual void run() override;
549 };
550
551 struct SavePlaylist: BaseAction
552 {
SavePlaylistSavePlaylist553 SavePlaylist(): BaseAction(Type::SavePlaylist, "save_playlist") { }
554
555 private:
556 virtual void run() override;
557 };
558
559 struct MoveSortOrderUp: BaseAction
560 {
MoveSortOrderUpMoveSortOrderUp561 MoveSortOrderUp(): BaseAction(Type::MoveSortOrderUp, "move_sort_order_up") { }
562
563 private:
564 virtual bool canBeRun() override;
565 virtual void run() override;
566 };
567
568 struct MoveSortOrderDown: BaseAction
569 {
MoveSortOrderDownMoveSortOrderDown570 MoveSortOrderDown(): BaseAction(Type::MoveSortOrderDown, "move_sort_order_down") { }
571
572 private:
573 virtual bool canBeRun() override;
574 virtual void run() override;
575 };
576
577 struct MoveSelectedItemsUp: BaseAction
578 {
MoveSelectedItemsUpMoveSelectedItemsUp579 MoveSelectedItemsUp(): BaseAction(Type::MoveSelectedItemsUp, "move_selected_items_up") { }
580
581 private:
582 virtual bool canBeRun() override;
583 virtual void run() override;
584 };
585
586 struct MoveSelectedItemsDown: BaseAction
587 {
MoveSelectedItemsDownMoveSelectedItemsDown588 MoveSelectedItemsDown(): BaseAction(Type::MoveSelectedItemsDown, "move_selected_items_down") { }
589
590 private:
591 virtual bool canBeRun() override;
592 virtual void run() override;
593 };
594
595 struct MoveSelectedItemsTo: BaseAction
596 {
MoveSelectedItemsToMoveSelectedItemsTo597 MoveSelectedItemsTo(): BaseAction(Type::MoveSelectedItemsTo, "move_selected_items_to") { }
598
599 private:
600 virtual bool canBeRun() override;
601 virtual void run() override;
602 };
603
604 struct Add: BaseAction
605 {
AddAdd606 Add(): BaseAction(Type::Add, "add") { }
607
608 private:
609 virtual bool canBeRun() override;
610 virtual void run() override;
611 };
612
613 struct Load: BaseAction
614 {
LoadLoad615 Load(): BaseAction(Type::Load, "load") { }
616
617 private:
618 virtual bool canBeRun() override;
619 virtual void run() override;
620 };
621
622 struct SeekForward: BaseAction
623 {
SeekForwardSeekForward624 SeekForward(): BaseAction(Type::SeekForward, "seek_forward") { }
625
626 private:
627 virtual bool canBeRun() override;
628 virtual void run() override;
629 };
630
631 struct SeekBackward: BaseAction
632 {
SeekBackwardSeekBackward633 SeekBackward(): BaseAction(Type::SeekBackward, "seek_backward") { }
634
635 private:
636 virtual bool canBeRun() override;
637 virtual void run() override;
638 };
639
640 struct ToggleDisplayMode: BaseAction
641 {
ToggleDisplayModeToggleDisplayMode642 ToggleDisplayMode(): BaseAction(Type::ToggleDisplayMode, "toggle_display_mode") { }
643
644 private:
645 virtual bool canBeRun() override;
646 virtual void run() override;
647 };
648
649 struct ToggleSeparatorsBetweenAlbums: BaseAction
650 {
ToggleSeparatorsBetweenAlbumsToggleSeparatorsBetweenAlbums651 ToggleSeparatorsBetweenAlbums()
652 : BaseAction(Type::ToggleSeparatorsBetweenAlbums, "toggle_separators_between_albums") { }
653
654 private:
655 virtual bool canBeRun() override;
656 virtual void run() override;
657 };
658
659 struct ToggleLyricsUpdateOnSongChange: BaseAction
660 {
ToggleLyricsUpdateOnSongChangeToggleLyricsUpdateOnSongChange661 ToggleLyricsUpdateOnSongChange()
662 : BaseAction(Type::ToggleLyricsUpdateOnSongChange, "toggle_lyrics_update_on_song_change") { }
663
664 private:
665 virtual bool canBeRun() override;
666 virtual void run() override;
667 };
668
669 struct ToggleLyricsFetcher: BaseAction
670 {
ToggleLyricsFetcherToggleLyricsFetcher671 ToggleLyricsFetcher(): BaseAction(Type::ToggleLyricsFetcher, "toggle_lyrics_fetcher") { }
672
673 private:
674 virtual void run() override;
675 };
676
677 struct ToggleFetchingLyricsInBackground: BaseAction
678 {
ToggleFetchingLyricsInBackgroundToggleFetchingLyricsInBackground679 ToggleFetchingLyricsInBackground()
680 : BaseAction(Type::ToggleFetchingLyricsInBackground, "toggle_fetching_lyrics_in_background") { }
681
682 private:
683 virtual void run() override;
684 };
685
686 struct TogglePlayingSongCentering: BaseAction
687 {
TogglePlayingSongCenteringTogglePlayingSongCentering688 TogglePlayingSongCentering()
689 : BaseAction(Type::TogglePlayingSongCentering, "toggle_playing_song_centering") { }
690
691 private:
692 virtual void run() override;
693 };
694
695 struct UpdateDatabase: BaseAction
696 {
UpdateDatabaseUpdateDatabase697 UpdateDatabase(): BaseAction(Type::UpdateDatabase, "update_database") { }
698
699 private:
700 virtual void run() override;
701 };
702
703 struct JumpToPlayingSong: BaseAction
704 {
JumpToPlayingSongJumpToPlayingSong705 JumpToPlayingSong(): BaseAction(Type::JumpToPlayingSong, "jump_to_playing_song") { }
706
707 private:
708 virtual bool canBeRun() override;
709 virtual void run() override;
710
711 MPD::Song m_song;
712 };
713
714 struct ToggleRepeat: BaseAction
715 {
ToggleRepeatToggleRepeat716 ToggleRepeat(): BaseAction(Type::ToggleRepeat, "toggle_repeat") { }
717
718 private:
719 virtual void run() override;
720 };
721
722 struct Shuffle: BaseAction
723 {
ShuffleShuffle724 Shuffle(): BaseAction(Type::Shuffle, "shuffle") { }
725
726 private:
727 virtual bool canBeRun() override;
728 virtual void run() override;
729
730 NC::Menu<MPD::Song>::ConstIterator m_begin;
731 NC::Menu<MPD::Song>::ConstIterator m_end;
732 };
733
734 struct ToggleRandom: BaseAction
735 {
ToggleRandomToggleRandom736 ToggleRandom(): BaseAction(Type::ToggleRandom, "toggle_random") { }
737
738 private:
739 virtual void run() override;
740 };
741
742 struct StartSearching: BaseAction
743 {
StartSearchingStartSearching744 StartSearching(): BaseAction(Type::StartSearching, "start_searching") { }
745
746 private:
747 virtual bool canBeRun() override;
748 virtual void run() override;
749 };
750
751 struct SaveTagChanges: BaseAction
752 {
SaveTagChangesSaveTagChanges753 SaveTagChanges(): BaseAction(Type::SaveTagChanges, "save_tag_changes") { }
754
755 private:
756 virtual bool canBeRun() override;
757 virtual void run() override;
758 };
759
760 struct ToggleSingle: BaseAction
761 {
ToggleSingleToggleSingle762 ToggleSingle(): BaseAction(Type::ToggleSingle, "toggle_single") { }
763
764 private:
765 virtual void run() override;
766 };
767
768 struct ToggleConsume: BaseAction
769 {
ToggleConsumeToggleConsume770 ToggleConsume(): BaseAction(Type::ToggleConsume, "toggle_consume") { }
771
772 private:
773 virtual void run() override;
774 };
775
776 struct ToggleCrossfade: BaseAction
777 {
ToggleCrossfadeToggleCrossfade778 ToggleCrossfade(): BaseAction(Type::ToggleCrossfade, "toggle_crossfade") { }
779
780 private:
781 virtual void run() override;
782 };
783
784 struct SetCrossfade: BaseAction
785 {
SetCrossfadeSetCrossfade786 SetCrossfade(): BaseAction(Type::SetCrossfade, "set_crossfade") { }
787
788 private:
789 virtual void run() override;
790 };
791
792 struct SetVolume: BaseAction
793 {
SetVolumeSetVolume794 SetVolume(): BaseAction(Type::SetVolume, "set_volume") { }
795
796 private:
797 virtual bool canBeRun() override;
798 virtual void run() override;
799 };
800
801 struct EnterDirectory: BaseAction
802 {
EnterDirectoryEnterDirectory803 EnterDirectory(): BaseAction(Type::EnterDirectory, "enter_directory") { }
804
805 private:
806 virtual bool canBeRun() override;
807 virtual void run() override;
808 };
809
810
811 struct EditSong: BaseAction
812 {
EditSongEditSong813 EditSong(): BaseAction(Type::EditSong, "edit_song") { }
814
815 private:
816 virtual bool canBeRun() override;
817 virtual void run() override;
818
819 #ifdef HAVE_TAGLIB_H
820 const MPD::Song *m_song;
821 #endif // HAVE_TAGLIB_H
822 };
823
824 struct EditLibraryTag: BaseAction
825 {
EditLibraryTagEditLibraryTag826 EditLibraryTag(): BaseAction(Type::EditLibraryTag, "edit_library_tag") { }
827
828 private:
829 virtual bool canBeRun() override;
830 virtual void run() override;
831 };
832
833 struct EditLibraryAlbum: BaseAction
834 {
EditLibraryAlbumEditLibraryAlbum835 EditLibraryAlbum(): BaseAction(Type::EditLibraryAlbum, "edit_library_album") { }
836
837 private:
838 virtual bool canBeRun() override;
839 virtual void run() override;
840 };
841
842 struct EditDirectoryName: BaseAction
843 {
EditDirectoryNameEditDirectoryName844 EditDirectoryName(): BaseAction(Type::EditDirectoryName, "edit_directory_name") { }
845
846 private:
847 virtual bool canBeRun() override;
848 virtual void run() override;
849 };
850
851 struct EditPlaylistName: BaseAction
852 {
EditPlaylistNameEditPlaylistName853 EditPlaylistName(): BaseAction(Type::EditPlaylistName, "edit_playlist_name") { }
854
855 private:
856 virtual bool canBeRun() override;
857 virtual void run() override;
858 };
859
860 struct EditLyrics: BaseAction
861 {
EditLyricsEditLyrics862 EditLyrics(): BaseAction(Type::EditLyrics, "edit_lyrics") { }
863
864 private:
865 virtual bool canBeRun() override;
866 virtual void run() override;
867 };
868
869 struct JumpToBrowser: BaseAction
870 {
JumpToBrowserJumpToBrowser871 JumpToBrowser(): BaseAction(Type::JumpToBrowser, "jump_to_browser") { }
872
873 private:
874 virtual bool canBeRun() override;
875 virtual void run() override;
876
877 const MPD::Song *m_song;
878 };
879
880 struct JumpToMediaLibrary: BaseAction
881 {
JumpToMediaLibraryJumpToMediaLibrary882 JumpToMediaLibrary(): BaseAction(Type::JumpToMediaLibrary, "jump_to_media_library") { }
883
884 private:
885 virtual bool canBeRun() override;
886 virtual void run() override;
887
888 const MPD::Song *m_song;
889 };
890
891 struct JumpToPlaylistEditor: BaseAction
892 {
JumpToPlaylistEditorJumpToPlaylistEditor893 JumpToPlaylistEditor(): BaseAction(Type::JumpToPlaylistEditor, "jump_to_playlist_editor") { }
894
895 private:
896 virtual bool canBeRun() override;
897 virtual void run() override;
898 };
899
900 struct ToggleScreenLock: BaseAction
901 {
ToggleScreenLockToggleScreenLock902 ToggleScreenLock(): BaseAction(Type::ToggleScreenLock, "toggle_screen_lock") { }
903
904 private:
905 virtual void run() override;
906 };
907
908 struct JumpToTagEditor: BaseAction
909 {
JumpToTagEditorJumpToTagEditor910 JumpToTagEditor(): BaseAction(Type::JumpToTagEditor, "jump_to_tag_editor") { }
911
912 private:
913 virtual bool canBeRun() override;
914 virtual void run() override;
915
916 #ifdef HAVE_TAGLIB_H
917 const MPD::Song *m_song;
918 #endif // HAVE_TAGLIB_H
919 };
920
921 struct JumpToPositionInSong: BaseAction
922 {
JumpToPositionInSongJumpToPositionInSong923 JumpToPositionInSong(): BaseAction(Type::JumpToPositionInSong, "jump_to_position_in_song") { }
924
925 private:
926 virtual bool canBeRun() override;
927 virtual void run() override;
928 };
929
930 struct SelectItem: BaseAction
931 {
SelectItemSelectItem932 SelectItem(): BaseAction(Type::SelectItem, "select_item") { }
933
934 private:
935 virtual bool canBeRun() override;
936 virtual void run() override;
937
938 NC::List *m_list;
939 };
940
941 struct SelectRange: BaseAction
942 {
SelectRangeSelectRange943 SelectRange(): BaseAction(Type::SelectRange, "select_range") { }
944
945 private:
946 virtual bool canBeRun() override;
947 virtual void run() override;
948
949 NC::List *m_list;
950 NC::List::Iterator m_begin;
951 NC::List::Iterator m_end;
952 };
953
954 struct ReverseSelection: BaseAction
955 {
ReverseSelectionReverseSelection956 ReverseSelection(): BaseAction(Type::ReverseSelection, "reverse_selection") { }
957
958 private:
959 virtual bool canBeRun() override;
960 virtual void run() override;
961
962 NC::List *m_list;
963 };
964
965 struct RemoveSelection: BaseAction
966 {
RemoveSelectionRemoveSelection967 RemoveSelection(): BaseAction(Type::RemoveSelection, "remove_selection") { }
968
969 private:
970 virtual bool canBeRun() override;
971 virtual void run() override;
972
973 NC::List *m_list;
974 };
975
976 struct SelectAlbum: BaseAction
977 {
SelectAlbumSelectAlbum978 SelectAlbum(): BaseAction(Type::SelectAlbum, "select_album") { }
979
980 private:
981 virtual bool canBeRun() override;
982 virtual void run() override;
983
984 NC::List *m_list;
985 SongList *m_songs;
986 };
987
988 struct SelectFoundItems: BaseAction
989 {
SelectFoundItemsSelectFoundItems990 SelectFoundItems(): BaseAction(Type::SelectFoundItems, "select_found_items") { }
991
992 private:
993 virtual bool canBeRun() override;
994 virtual void run() override;
995
996 NC::List *m_list;
997 Searchable *m_searchable;
998 };
999
1000 struct AddSelectedItems: BaseAction
1001 {
AddSelectedItemsAddSelectedItems1002 AddSelectedItems(): BaseAction(Type::AddSelectedItems, "add_selected_items") { }
1003
1004 private:
1005 virtual bool canBeRun() override;
1006 virtual void run() override;
1007 };
1008
1009 struct CropMainPlaylist: BaseAction
1010 {
CropMainPlaylistCropMainPlaylist1011 CropMainPlaylist(): BaseAction(Type::CropMainPlaylist, "crop_main_playlist") { }
1012
1013 private:
1014 virtual void run() override;
1015 };
1016
1017 struct CropPlaylist: BaseAction
1018 {
CropPlaylistCropPlaylist1019 CropPlaylist(): BaseAction(Type::CropPlaylist, "crop_playlist") { }
1020
1021 private:
1022 virtual bool canBeRun() override;
1023 virtual void run() override;
1024 };
1025
1026 struct ClearMainPlaylist: BaseAction
1027 {
ClearMainPlaylistClearMainPlaylist1028 ClearMainPlaylist(): BaseAction(Type::ClearMainPlaylist, "clear_main_playlist") { }
1029
1030 private:
1031 virtual void run() override;
1032 };
1033
1034 struct ClearPlaylist: BaseAction
1035 {
ClearPlaylistClearPlaylist1036 ClearPlaylist(): BaseAction(Type::ClearPlaylist, "clear_playlist") { }
1037
1038 private:
1039 virtual bool canBeRun() override;
1040 virtual void run() override;
1041 };
1042
1043 struct SortPlaylist: BaseAction
1044 {
SortPlaylistSortPlaylist1045 SortPlaylist(): BaseAction(Type::SortPlaylist, "sort_playlist") { }
1046
1047 private:
1048 virtual bool canBeRun() override;
1049 virtual void run() override;
1050 };
1051
1052 struct ReversePlaylist: BaseAction
1053 {
ReversePlaylistReversePlaylist1054 ReversePlaylist(): BaseAction(Type::ReversePlaylist, "reverse_playlist") { }
1055
1056 private:
1057 virtual bool canBeRun() override;
1058 virtual void run() override;
1059
1060 NC::Menu<MPD::Song>::ConstIterator m_begin;
1061 NC::Menu<MPD::Song>::ConstIterator m_end;
1062 };
1063
1064 struct ApplyFilter: public BaseAction
1065 {
ApplyFilterApplyFilter1066 ApplyFilter(): BaseAction(Type::ApplyFilter, "apply_filter") { }
1067
1068 private:
1069 virtual bool canBeRun() override;
1070 virtual void run() override;
1071
1072 Filterable *m_filterable;
1073 };
1074
1075 struct Find: BaseAction
1076 {
FindFind1077 Find(): BaseAction(Type::Find, "find") { }
1078
1079 private:
1080 virtual bool canBeRun() override;
1081 virtual void run() override;
1082 };
1083
1084 struct FindItemForward: BaseAction
1085 {
FindItemForwardFindItemForward1086 FindItemForward(): BaseAction(Type::FindItemForward, "find_item_forward") { }
1087
1088 private:
1089 virtual bool canBeRun() override;
1090 virtual void run() override;
1091 };
1092
1093 struct FindItemBackward: BaseAction
1094 {
FindItemBackwardFindItemBackward1095 FindItemBackward(): BaseAction(Type::FindItemBackward, "find_item_backward") { }
1096
1097 private:
1098 virtual bool canBeRun() override;
1099 virtual void run() override;
1100 };
1101
1102 struct NextFoundItem: BaseAction
1103 {
NextFoundItemNextFoundItem1104 NextFoundItem(): BaseAction(Type::NextFoundItem, "next_found_item") { }
1105
1106 private:
1107 virtual bool canBeRun() override;
1108 virtual void run() override;
1109 };
1110
1111 struct PreviousFoundItem: BaseAction
1112 {
PreviousFoundItemPreviousFoundItem1113 PreviousFoundItem(): BaseAction(Type::PreviousFoundItem, "previous_found_item") { }
1114
1115 private:
1116 virtual bool canBeRun() override;
1117 virtual void run() override;
1118 };
1119
1120 struct ToggleFindMode: BaseAction
1121 {
ToggleFindModeToggleFindMode1122 ToggleFindMode(): BaseAction(Type::ToggleFindMode, "toggle_find_mode") { }
1123
1124 private:
1125 virtual void run() override;
1126 };
1127
1128 struct ToggleReplayGainMode: BaseAction
1129 {
ToggleReplayGainModeToggleReplayGainMode1130 ToggleReplayGainMode(): BaseAction(Type::ToggleReplayGainMode, "toggle_replay_gain_mode") { }
1131
1132 private:
1133 virtual void run() override;
1134 };
1135
1136 struct ToggleAddMode: BaseAction
1137 {
ToggleAddModeToggleAddMode1138 ToggleAddMode(): BaseAction(Type::ToggleAddMode, "toggle_add_mode") { }
1139
1140 private:
1141 virtual void run() override;
1142 };
1143
1144 struct ToggleMouse: BaseAction
1145 {
ToggleMouseToggleMouse1146 ToggleMouse(): BaseAction(Type::ToggleMouse, "toggle_mouse") { }
1147
1148 private:
1149 virtual void run() override;
1150 };
1151
1152 struct ToggleBitrateVisibility: BaseAction
1153 {
ToggleBitrateVisibilityToggleBitrateVisibility1154 ToggleBitrateVisibility(): BaseAction(Type::ToggleBitrateVisibility, "toggle_bitrate_visibility") { }
1155
1156 private:
1157 virtual void run() override;
1158 };
1159
1160 struct AddRandomItems: BaseAction
1161 {
AddRandomItemsAddRandomItems1162 AddRandomItems(): BaseAction(Type::AddRandomItems, "add_random_items") { }
1163
1164 private:
1165 virtual void run() override;
1166 };
1167
1168 struct ToggleBrowserSortMode: BaseAction
1169 {
ToggleBrowserSortModeToggleBrowserSortMode1170 ToggleBrowserSortMode(): BaseAction(Type::ToggleBrowserSortMode, "toggle_browser_sort_mode") { }
1171
1172 private:
1173 virtual bool canBeRun() override;
1174 virtual void run() override;
1175 };
1176
1177 struct ToggleLibraryTagType: BaseAction
1178 {
ToggleLibraryTagTypeToggleLibraryTagType1179 ToggleLibraryTagType(): BaseAction(Type::ToggleLibraryTagType, "toggle_library_tag_type") { }
1180
1181 private:
1182 virtual bool canBeRun() override;
1183 virtual void run() override;
1184 };
1185
1186 struct ToggleMediaLibrarySortMode: BaseAction
1187 {
ToggleMediaLibrarySortModeToggleMediaLibrarySortMode1188 ToggleMediaLibrarySortMode()
1189 : BaseAction(Type::ToggleMediaLibrarySortMode, "toggle_media_library_sort_mode") { }
1190
1191 private:
1192 virtual bool canBeRun() override;
1193 virtual void run() override;
1194 };
1195
1196 struct FetchLyricsInBackground: BaseAction
1197 {
FetchLyricsInBackgroundFetchLyricsInBackground1198 FetchLyricsInBackground()
1199 : BaseAction(Type::FetchLyricsInBackground, "fetch_lyrics_in_background") { }
1200
1201 private:
1202 virtual bool canBeRun() override;
1203 virtual void run() override;
1204
1205 HasSongs *m_hs;
1206 };
1207
1208 struct RefetchLyrics: BaseAction
1209 {
RefetchLyricsRefetchLyrics1210 RefetchLyrics(): BaseAction(Type::RefetchLyrics, "refetch_lyrics") { }
1211
1212 private:
1213 virtual bool canBeRun() override;
1214 virtual void run() override;
1215 };
1216
1217 struct SetSelectedItemsPriority: BaseAction
1218 {
SetSelectedItemsPrioritySetSelectedItemsPriority1219 SetSelectedItemsPriority()
1220 : BaseAction(Type::SetSelectedItemsPriority, "set_selected_items_priority") { }
1221
1222 private:
1223 virtual bool canBeRun() override;
1224 virtual void run() override;
1225 };
1226
1227 struct ToggleOutput: BaseAction
1228 {
ToggleOutputToggleOutput1229 ToggleOutput(): BaseAction(Type::ToggleOutput, "toggle_output") { }
1230
1231 private:
1232 virtual bool canBeRun() override;
1233 virtual void run() override;
1234 };
1235
1236 struct ToggleVisualizationType: BaseAction
1237 {
ToggleVisualizationTypeToggleVisualizationType1238 ToggleVisualizationType()
1239 : BaseAction(Type::ToggleVisualizationType, "toggle_visualization_type") { }
1240
1241 private:
1242
1243 virtual bool canBeRun() override;
1244 virtual void run() override;
1245 };
1246
1247 struct ShowSongInfo: BaseAction
1248 {
ShowSongInfoShowSongInfo1249 ShowSongInfo(): BaseAction(Type::ShowSongInfo, "show_song_info") { }
1250
1251 private:
1252 virtual void run() override;
1253 };
1254
1255 struct ShowArtistInfo: BaseAction
1256 {
ShowArtistInfoShowArtistInfo1257 ShowArtistInfo(): BaseAction(Type::ShowArtistInfo, "show_artist_info") { }
1258
1259 private:
1260 virtual bool canBeRun() override;
1261 virtual void run() override;
1262 };
1263
1264 struct ShowLyrics: BaseAction
1265 {
ShowLyricsShowLyrics1266 ShowLyrics(): BaseAction(Type::ShowLyrics, "show_lyrics") { }
1267
1268 private:
1269 virtual bool canBeRun() override;
1270 virtual void run() override;
1271
1272 const MPD::Song *m_song;
1273 };
1274
1275 struct Quit: BaseAction
1276 {
QuitQuit1277 Quit(): BaseAction(Type::Quit, "quit") { }
1278
1279 private:
1280 virtual void run() override;
1281 };
1282
1283 struct NextScreen: BaseAction
1284 {
NextScreenNextScreen1285 NextScreen(): BaseAction(Type::NextScreen, "next_screen") { }
1286
1287 private:
1288 virtual void run() override;
1289 };
1290
1291 struct PreviousScreen: BaseAction
1292 {
PreviousScreenPreviousScreen1293 PreviousScreen(): BaseAction(Type::PreviousScreen, "previous_screen") { }
1294
1295 private:
1296 virtual void run() override;
1297 };
1298
1299 struct ShowHelp: BaseAction
1300 {
ShowHelpShowHelp1301 ShowHelp(): BaseAction(Type::ShowHelp, "show_help") { }
1302
1303 private:
1304 virtual bool canBeRun() override;
1305 virtual void run() override;
1306 };
1307
1308 struct ShowPlaylist: BaseAction
1309 {
ShowPlaylistShowPlaylist1310 ShowPlaylist(): BaseAction(Type::ShowPlaylist, "show_playlist") { }
1311
1312 private:
1313 virtual bool canBeRun() override;
1314 virtual void run() override;
1315 };
1316
1317 struct ShowBrowser: BaseAction
1318 {
ShowBrowserShowBrowser1319 ShowBrowser(): BaseAction(Type::ShowBrowser, "show_browser") { }
1320
1321 private:
1322 virtual bool canBeRun() override;
1323 virtual void run() override;
1324 };
1325
1326 struct ChangeBrowseMode: BaseAction
1327 {
ChangeBrowseModeChangeBrowseMode1328 ChangeBrowseMode(): BaseAction(Type::ChangeBrowseMode, "change_browse_mode") { }
1329
1330 private:
1331 virtual bool canBeRun() override;
1332 virtual void run() override;
1333 };
1334
1335 struct ShowSearchEngine: BaseAction
1336 {
ShowSearchEngineShowSearchEngine1337 ShowSearchEngine(): BaseAction(Type::ShowSearchEngine, "show_search_engine") { }
1338
1339 private:
1340 virtual bool canBeRun() override;
1341 virtual void run() override;
1342 };
1343
1344 struct ResetSearchEngine: BaseAction
1345 {
ResetSearchEngineResetSearchEngine1346 ResetSearchEngine(): BaseAction(Type::ResetSearchEngine, "reset_search_engine") { }
1347
1348 private:
1349 virtual bool canBeRun() override;
1350 virtual void run() override;
1351 };
1352
1353 struct ShowMediaLibrary: BaseAction
1354 {
ShowMediaLibraryShowMediaLibrary1355 ShowMediaLibrary(): BaseAction(Type::ShowMediaLibrary, "show_media_library") { }
1356
1357 private:
1358 virtual bool canBeRun() override;
1359 virtual void run() override;
1360 };
1361
1362 struct ToggleMediaLibraryColumnsMode: BaseAction
1363 {
ToggleMediaLibraryColumnsModeToggleMediaLibraryColumnsMode1364 ToggleMediaLibraryColumnsMode()
1365 : BaseAction(Type::ToggleMediaLibraryColumnsMode, "toggle_media_library_columns_mode") { }
1366
1367 private:
1368 virtual bool canBeRun() override;
1369 virtual void run() override;
1370 };
1371
1372 struct ShowPlaylistEditor: BaseAction
1373 {
ShowPlaylistEditorShowPlaylistEditor1374 ShowPlaylistEditor(): BaseAction(Type::ShowPlaylistEditor, "show_playlist_editor") { }
1375
1376 private:
1377 virtual bool canBeRun() override;
1378 virtual void run() override;
1379 };
1380
1381 struct ShowTagEditor: BaseAction
1382 {
ShowTagEditorShowTagEditor1383 ShowTagEditor(): BaseAction(Type::ShowTagEditor, "show_tag_editor") { }
1384
1385 private:
1386 virtual bool canBeRun() override;
1387 virtual void run() override;
1388 };
1389
1390 struct ShowOutputs: BaseAction
1391 {
ShowOutputsShowOutputs1392 ShowOutputs(): BaseAction(Type::ShowOutputs, "show_outputs") { }
1393
1394 private:
1395 virtual bool canBeRun() override;
1396 virtual void run() override;
1397 };
1398
1399 struct ShowVisualizer: BaseAction
1400 {
ShowVisualizerShowVisualizer1401 ShowVisualizer(): BaseAction(Type::ShowVisualizer, "show_visualizer") { }
1402
1403 private:
1404 virtual bool canBeRun() override;
1405 virtual void run() override;
1406 };
1407
1408 struct ShowClock: BaseAction
1409 {
ShowClockShowClock1410 ShowClock(): BaseAction(Type::ShowClock, "show_clock") { }
1411
1412 private:
1413 virtual bool canBeRun() override;
1414 virtual void run() override;
1415 };
1416
1417 struct ShowServerInfo: BaseAction
1418 {
ShowServerInfoShowServerInfo1419 ShowServerInfo(): BaseAction(Type::ShowServerInfo, "show_server_info") { }
1420
1421 private:
1422 # ifdef HAVE_TAGLIB_H
1423 virtual bool canBeRun() override;
1424 # endif // HAVE_TAGLIB_H
1425 virtual void run() override;
1426 };
1427
1428 }
1429
1430 #endif // NCMPCPP_ACTIONS_H
1431