src/actions.h

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