src/actions.h

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