src/actions.h

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2012 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 _ACTIONS_H
  22 #define _ACTIONS_H
  23
  24 #include <map>
  25 #include <string>
  26 #include "window.h"
  27
  28 enum ActionType
  29 {
  30         aMacroUtility,
  31         aDummy, aMouseEvent, aScrollUp, aScrollDown, aScrollUpArtist, aScrollUpAlbum, aScrollDownArtist,
  32         aScrollDownAlbum, aPageUp, aPageDown, aMoveHome, aMoveEnd, aToggleInterface, aJumpToParentDir,
  33         aPressEnter, aPressSpace, aPreviousColumn, aNextColumn, aMasterScreen, aSlaveScreen, aVolumeUp,
  34         aVolumeDown, aDelete, aReplaySong, aPreviousSong, aNextSong, aPause, aStop, aSavePlaylist,
  35         aMoveSortOrderUp, aMoveSortOrderDown, aMoveSelectedItemsUp, aMoveSelectedItemsDown,
  36         aMoveSelectedItemsTo, aAdd, aSeekForward, aSeekBackward, aToggleDisplayMode, aToggleSeparatorsBetweenAlbums,
  37         aToggleLyricsFetcher, aToggleFetchingLyricsInBackground, aToggleAutoCenter, aUpdateDatabase,
  38         aJumpToPlayingSong, aToggleRepeat, aShuffle, aToggleRandom, aStartSearching, aSaveTagChanges,
  39         aToggleSingle, aToggleConsume, aToggleCrossfade, aSetCrossfade, aEditSong, aEditLibraryTag,
  40         aEditLibraryAlbum, aEditDirectoryName, aEditPlaylistName, aEditLyrics, aJumpToBrowser,
  41         aJumpToMediaLibrary, aJumpToPlaylistEditor, aToggleScreenLock, aJumpToTagEditor,
  42         aJumpToPositionInSong, aReverseSelection, aRemoveSelection, aSelectAlbum, aAddSelectedItems,
  43         aCropMainPlaylist, aCropPlaylist, aClearMainPlaylist, aClearPlaylist, aSortPlaylist, aReversePlaylist,
  44         aApplyFilter, aFind, aFindItemForward, aFindItemBackward, aNextFoundItem,
  45         aPreviousFoundItem, aToggleFindMode, aToggleReplayGainMode, aToggleSpaceMode, aToggleAddMode,
  46         aToggleMouse, aToggleBitrateVisibility, aAddRandomItems, aToggleBrowserSortMode, aToggleLibraryTagType,
  47         aRefetchLyrics, aRefetchArtistInfo, aSetSelectedItemsPriority, aShowSongInfo, aShowArtistInfo,
  48         aShowLyrics, aQuit, aNextScreen, aPreviousScreen, aShowHelp, aShowPlaylist, aShowBrowser,
  49         aShowSearchEngine, aShowMediaLibrary, aShowPlaylistEditor, aShowTagEditor, aShowOutputs,
  50         aShowVisualizer, aShowClock, aShowServerInfo
  51 };
  52
  53 struct Action
  54 {
  55         enum FindDirection { fdForward, fdBackward };
  56
  57         Action(ActionType type, const char *name) : itsType(type), itsName(name) { }
  58
  59         const char *Name() const { return itsName; }
  60         ActionType Type() const { return itsType; }
  61
  62         virtual bool canBeRun() const { return true; }
  63
  64         bool Execute()
  65         {
  66                 if (canBeRun())
  67                 {
  68                         Run();
  69                         return true;
  70                 }
  71                 return false;
  72         }
  73
  74         static void ValidateScreenSize();
  75         static void SetResizeFlags();
  76         static void ResizeScreen();
  77         static void SetWindowsDimensions();
  78
  79         static bool ConnectToMPD();
  80         static bool AskYesNoQuestion(const std::string &question, void (*callback)());
  81         static bool isMPDMusicDirSet();
  82
  83         static Action *Get(ActionType at);
  84         static Action *Get(const std::string &name);
  85
  86         static bool OriginalStatusbarVisibility;
  87         static bool DesignChanged;
  88         static bool OrderResize;
  89         static bool ExitMainLoop;
  90
  91         static size_t HeaderHeight;
  92         static size_t FooterHeight;
  93         static size_t FooterStartY;
  94
  95 protected:
  96         virtual void Run() = 0;
  97
  98         static void Seek();
  99         static void FindItem(const FindDirection);
 100         static void ListsChangeFinisher();
 101
 102 private:
 103         ActionType itsType;
 104         const char *itsName;
 105 };
 106
 107 struct Dummy : public Action
 108 {
 109         Dummy() : Action(aDummy, "dummy") { }
 110
 111 protected:
 112         virtual void Run() { }
 113 };
 114
 115 struct MouseEvent : public Action
 116 {
 117         MouseEvent() : Action(aMouseEvent, "mouse_event") { }
 118
 119 protected:
 120         virtual bool canBeRun() const;
 121         virtual void Run();
 122
 123         private:
 124                 MEVENT itsMouseEvent;
 125                 MEVENT itsOldMouseEvent;
 126 };
 127
 128 struct ScrollUp : public Action
 129 {
 130         ScrollUp() : Action(aScrollUp, "scroll_up") { }
 131
 132 protected:
 133         virtual void Run();
 134 };
 135
 136 struct ScrollDown : public Action
 137 {
 138         ScrollDown() : Action(aScrollDown, "scroll_down") { }
 139
 140 protected:
 141         virtual void Run();
 142 };
 143
 144 struct ScrollUpArtist : public Action
 145 {
 146         ScrollUpArtist() : Action(aScrollUpArtist, "scroll_up_artist") { }
 147
 148 protected:
 149         virtual bool canBeRun() const;
 150         virtual void Run();
 151 };
 152
 153 struct ScrollUpAlbum : public Action
 154 {
 155         ScrollUpAlbum() : Action(aScrollUpAlbum, "scroll_up_album") { }
 156
 157 protected:
 158         virtual bool canBeRun() const;
 159         virtual void Run();
 160 };
 161
 162 struct ScrollDownArtist : public Action
 163 {
 164         ScrollDownArtist() : Action(aScrollDownArtist, "scroll_down_artist") { }
 165
 166 protected:
 167         virtual bool canBeRun() const;
 168         virtual void Run();
 169 };
 170
 171 struct ScrollDownAlbum : public Action
 172 {
 173         ScrollDownAlbum() : Action(aScrollDownAlbum, "scroll_down_album") { }
 174
 175 protected:
 176         virtual bool canBeRun() const;
 177         virtual void Run();
 178 };
 179
 180 struct PageUp : public Action
 181 {
 182         PageUp() : Action(aPageUp, "page_up") { }
 183
 184 protected:
 185         virtual void Run();
 186 };
 187
 188 struct PageDown : public Action
 189 {
 190         PageDown() : Action(aPageDown, "page_down") { }
 191
 192 protected:
 193         virtual void Run();
 194 };
 195
 196 struct MoveHome : public Action
 197 {
 198         MoveHome() : Action(aMoveHome, "move_home") { }
 199
 200 protected:
 201         virtual void Run();
 202 };
 203
 204 struct MoveEnd : public Action
 205 {
 206         MoveEnd() : Action(aMoveEnd, "move_end") { }
 207
 208 protected:
 209         virtual void Run();
 210 };
 211
 212 struct ToggleInterface : public Action
 213 {
 214         ToggleInterface() : Action(aToggleInterface, "toggle_inferface") { }
 215
 216 protected:
 217         virtual void Run();
 218 };
 219
 220 struct JumpToParentDir : public Action
 221 {
 222         JumpToParentDir() : Action(aJumpToParentDir, "jump_to_parent_dir") { }
 223
 224 protected:
 225         virtual bool canBeRun() const;
 226         virtual void Run();
 227 };
 228
 229 struct PressEnter : public Action
 230 {
 231         PressEnter() : Action(aPressEnter, "press_enter") { }
 232
 233 protected:
 234         virtual void Run();
 235 };
 236
 237 struct PressSpace : public Action
 238 {
 239         PressSpace() : Action(aPressSpace, "press_space") { }
 240
 241 protected:
 242         virtual void Run();
 243 };
 244
 245 struct PreviousColumn : public Action
 246 {
 247         PreviousColumn() : Action(aPreviousColumn, "previous_column") { }
 248
 249 protected:
 250         virtual bool canBeRun() const;
 251         virtual void Run();
 252 };
 253
 254 struct NextColumn : public Action
 255 {
 256         NextColumn() : Action(aNextColumn, "next_column") { }
 257
 258 protected:
 259         virtual bool canBeRun() const;
 260         virtual void Run();
 261 };
 262
 263 struct MasterScreen : public Action
 264 {
 265         MasterScreen() : Action(aMasterScreen, "master_screen") { }
 266
 267 protected:
 268         virtual bool canBeRun() const;
 269         virtual void Run();
 270 };
 271
 272 struct SlaveScreen : public Action
 273 {
 274         SlaveScreen() : Action(aSlaveScreen, "slave_screen") { }
 275
 276 protected:
 277         virtual bool canBeRun() const;
 278         virtual void Run();
 279 };
 280
 281 struct VolumeUp : public Action
 282 {
 283         VolumeUp() : Action(aVolumeUp, "volume_up") { }
 284
 285 protected:
 286         virtual void Run();
 287 };
 288
 289 struct VolumeDown : public Action
 290 {
 291         VolumeDown() : Action(aVolumeDown, "volume_down") { }
 292
 293 protected:
 294         virtual void Run();
 295 };
 296
 297 struct Delete : public Action
 298 {
 299         Delete() : Action(aDelete, "delete") { }
 300
 301 protected:
 302         virtual void Run();
 303 };
 304
 305 struct ReplaySong : public Action
 306 {
 307         ReplaySong() : Action(aReplaySong, "replay_song") { }
 308
 309 protected:
 310         virtual void Run();
 311 };
 312
 313 struct PreviousSong : public Action
 314 {
 315         PreviousSong() : Action(aPreviousSong, "previous") { }
 316
 317 protected:
 318         virtual void Run();
 319 };
 320
 321 struct NextSong : public Action
 322 {
 323         NextSong() : Action(aNextSong, "next") { }
 324
 325 protected:
 326         virtual void Run();
 327 };
 328
 329 struct Pause : public Action
 330 {
 331         Pause() : Action(aPause, "pause") { }
 332
 333 protected:
 334         virtual void Run();
 335 };
 336
 337 struct Stop : public Action
 338 {
 339         Stop() : Action(aStop, "stop") { }
 340
 341 protected:
 342         virtual void Run();
 343 };
 344
 345 struct SavePlaylist : public Action
 346 {
 347         SavePlaylist() : Action(aSavePlaylist, "save_playlist") { }
 348
 349 protected:
 350         virtual void Run();
 351 };
 352
 353 struct MoveSortOrderUp : public Action
 354 {
 355         MoveSortOrderUp() : Action(aMoveSortOrderUp, "move_sort_order_up") { }
 356
 357 protected:
 358         virtual bool canBeRun() const;
 359         virtual void Run();
 360 };
 361
 362 struct MoveSortOrderDown : public Action
 363 {
 364         MoveSortOrderDown() : Action(aMoveSortOrderDown, "move_sort_order_down") { }
 365
 366 protected:
 367         virtual bool canBeRun() const;
 368         virtual void Run();
 369 };
 370
 371 struct MoveSelectedItemsUp : public Action
 372 {
 373         MoveSelectedItemsUp() : Action(aMoveSelectedItemsUp, "move_selected_items_up") { }
 374
 375 protected:
 376         virtual bool canBeRun() const;
 377         virtual void Run();
 378 };
 379
 380 struct MoveSelectedItemsDown : public Action
 381 {
 382         MoveSelectedItemsDown() : Action(aMoveSelectedItemsDown, "move_selected_items_down") { }
 383
 384 protected:
 385         virtual bool canBeRun() const;
 386         virtual void Run();
 387 };
 388
 389 struct MoveSelectedItemsTo : public Action
 390 {
 391         MoveSelectedItemsTo() : Action(aMoveSelectedItemsTo, "move_selected_items_to") { }
 392
 393 protected:
 394         virtual bool canBeRun() const;
 395         virtual void Run();
 396 };
 397
 398 struct Add : public Action
 399 {
 400         Add() : Action(aAdd, "add") { }
 401
 402 protected:
 403         virtual bool canBeRun() const;
 404         virtual void Run();
 405 };
 406
 407 struct SeekForward : public Action
 408 {
 409         SeekForward() : Action(aSeekForward, "seek_forward") { }
 410
 411 protected:
 412         virtual bool canBeRun() const;
 413         virtual void Run();
 414 };
 415
 416 struct SeekBackward : public Action
 417 {
 418         SeekBackward() : Action(aSeekBackward, "seek_backward") { }
 419
 420 protected:
 421         virtual bool canBeRun() const;
 422         virtual void Run();
 423 };
 424
 425 struct ToggleDisplayMode : public Action
 426 {
 427         ToggleDisplayMode() : Action(aToggleDisplayMode, "toggle_display_mode") { }
 428
 429 protected:
 430         virtual bool canBeRun() const;
 431         virtual void Run();
 432 };
 433
 434 struct ToggleSeparatorsBetweenAlbums : public Action
 435 {
 436         ToggleSeparatorsBetweenAlbums()
 437         : Action(aToggleSeparatorsBetweenAlbums, "toggle_separators_between_albums") { }
 438
 439 protected:
 440         virtual bool canBeRun() const;
 441         virtual void Run();
 442 };
 443
 444 struct ToggleLyricsFetcher : public Action
 445 {
 446         ToggleLyricsFetcher() : Action(aToggleLyricsFetcher, "toggle_lyrics_fetcher") { }
 447
 448 protected:
 449 #       ifndef HAVE_CURL_CURL_H
 450         virtual bool canBeRun() const;
 451 #       endif // NOT HAVE_CURL_CURL_H
 452         virtual void Run();
 453 };
 454
 455 struct ToggleFetchingLyricsInBackground : public Action
 456 {
 457         ToggleFetchingLyricsInBackground()
 458         : Action(aToggleFetchingLyricsInBackground, "toggle_fetching_lyrics_in_background") { }
 459
 460 protected:
 461 #       ifndef HAVE_CURL_CURL_H
 462         virtual bool canBeRun() const;
 463 #       endif // NOT HAVE_CURL_CURL_H
 464         virtual void Run();
 465 };
 466
 467 struct ToggleAutoCenter : public Action
 468 {
 469         ToggleAutoCenter() : Action(aToggleAutoCenter, "toggle_autocentering") { }
 470
 471 protected:
 472         virtual void Run();
 473 };
 474
 475 struct UpdateDatabase : public Action
 476 {
 477         UpdateDatabase() : Action(aUpdateDatabase, "update_database") { }
 478
 479 protected:
 480         virtual void Run();
 481 };
 482
 483 struct JumpToPlayingSong : public Action
 484 {
 485         JumpToPlayingSong() : Action(aJumpToPlayingSong, "jump_to_playing_song") { }
 486
 487 protected:
 488         virtual bool canBeRun() const;
 489         virtual void Run();
 490 };
 491
 492 struct ToggleRepeat : public Action
 493 {
 494         ToggleRepeat() : Action(aToggleRepeat, "toggle_repeat") { }
 495
 496 protected:
 497         virtual void Run();
 498 };
 499
 500 struct Shuffle : public Action
 501 {
 502         Shuffle() : Action(aShuffle, "shuffle") { }
 503
 504 protected:
 505         virtual void Run();
 506 };
 507
 508 struct ToggleRandom : public Action
 509 {
 510         ToggleRandom() : Action(aToggleRandom, "toggle_random") { }
 511
 512 protected:
 513         virtual void Run();
 514 };
 515
 516 struct StartSearching : public Action
 517 {
 518         StartSearching() : Action(aStartSearching, "start_searching") { }
 519
 520 protected:
 521         virtual bool canBeRun() const;
 522         virtual void Run();
 523 };
 524
 525 struct SaveTagChanges : public Action
 526 {
 527         SaveTagChanges() : Action(aSaveTagChanges, "save_tag_changes") { }
 528
 529 protected:
 530         virtual bool canBeRun() const;
 531         virtual void Run();
 532 };
 533
 534 struct ToggleSingle : public Action
 535 {
 536         ToggleSingle() : Action(aToggleSingle, "toggle_single") { }
 537
 538 protected:
 539         virtual void Run();
 540 };
 541
 542 struct ToggleConsume : public Action
 543 {
 544         ToggleConsume() : Action(aToggleConsume, "toggle_consume") { }
 545
 546 protected:
 547         virtual void Run();
 548 };
 549
 550 struct ToggleCrossfade : public Action
 551 {
 552         ToggleCrossfade() : Action(aToggleCrossfade, "toggle_crossfade") { }
 553
 554 protected:
 555         virtual void Run();
 556 };
 557
 558 struct SetCrossfade : public Action
 559 {
 560         SetCrossfade() : Action(aSetCrossfade, "set_crossfade") { }
 561
 562 protected:
 563         virtual void Run();
 564 };
 565
 566 struct EditSong : public Action
 567 {
 568         EditSong() : Action(aEditSong, "edit_song") { }
 569
 570 protected:
 571         virtual bool canBeRun() const;
 572         virtual void Run();
 573 };
 574
 575 struct EditLibraryTag : public Action
 576 {
 577         EditLibraryTag() : Action(aEditLibraryTag, "edit_library_tag") { }
 578
 579 protected:
 580         virtual bool canBeRun() const;
 581         virtual void Run();
 582 };
 583
 584 struct EditLibraryAlbum : public Action
 585 {
 586         EditLibraryAlbum() : Action(aEditLibraryAlbum, "edit_library_album") { }
 587
 588 protected:
 589         virtual bool canBeRun() const;
 590         virtual void Run();
 591 };
 592
 593 struct EditDirectoryName : public Action
 594 {
 595         EditDirectoryName() : Action(aEditDirectoryName, "edit_directory_name") { }
 596
 597 protected:
 598         virtual bool canBeRun() const;
 599         virtual void Run();
 600 };
 601
 602 struct EditPlaylistName : public Action
 603 {
 604         EditPlaylistName() : Action(aEditPlaylistName, "edit_playlist_name") { }
 605
 606 protected:
 607         virtual bool canBeRun() const;
 608         virtual void Run();
 609 };
 610
 611 struct EditLyrics : public Action
 612 {
 613         EditLyrics() : Action(aEditLyrics, "edit_lyrics") { }
 614
 615 protected:
 616         virtual bool canBeRun() const;
 617         virtual void Run();
 618 };
 619
 620 struct JumpToBrowser : public Action
 621 {
 622         JumpToBrowser() : Action(aJumpToBrowser, "jump_to_browser") { }
 623
 624 protected:
 625         virtual bool canBeRun() const;
 626         virtual void Run();
 627 };
 628
 629 struct JumpToMediaLibrary : public Action
 630 {
 631         JumpToMediaLibrary() : Action(aJumpToMediaLibrary, "jump_to_media_library") { }
 632
 633 protected:
 634         virtual bool canBeRun() const;
 635         virtual void Run();
 636 };
 637
 638 struct JumpToPlaylistEditor : public Action
 639 {
 640         JumpToPlaylistEditor() : Action(aJumpToPlaylistEditor, "jump_to_playlist_editor") { }
 641
 642 protected:
 643         virtual bool canBeRun() const;
 644         virtual void Run();
 645 };
 646
 647 struct ToggleScreenLock : public Action
 648 {
 649         ToggleScreenLock() : Action(aToggleScreenLock, "toggle_screen_lock") { }
 650
 651 protected:
 652         virtual void Run();
 653 };
 654
 655 struct JumpToTagEditor : public Action
 656 {
 657         JumpToTagEditor() : Action(aJumpToTagEditor, "jump_to_tag_editor") { }
 658
 659 protected:
 660         virtual bool canBeRun() const;
 661         virtual void Run();
 662 };
 663
 664 struct JumpToPositionInSong : public Action
 665 {
 666         JumpToPositionInSong() : Action(aJumpToPositionInSong, "jump_to_position_in_song") { }
 667
 668 protected:
 669         virtual bool canBeRun() const;
 670         virtual void Run();
 671 };
 672
 673 struct ReverseSelection : public Action
 674 {
 675         ReverseSelection() : Action(aReverseSelection, "reverse_selection") { }
 676
 677 protected:
 678         virtual bool canBeRun() const;
 679         virtual void Run();
 680 };
 681
 682 struct RemoveSelection : public Action
 683 {
 684         RemoveSelection() : Action(aRemoveSelection, "remove_selection") { }
 685
 686 protected:
 687         virtual bool canBeRun() const;
 688         virtual void Run();
 689 };
 690
 691 struct SelectAlbum : public Action
 692 {
 693         SelectAlbum() : Action(aSelectAlbum, "select_album") { }
 694
 695 protected:
 696         virtual bool canBeRun() const;
 697         virtual void Run();
 698 };
 699
 700 struct AddSelectedItems : public Action
 701 {
 702         AddSelectedItems() : Action(aAddSelectedItems, "add_selected_items") { }
 703
 704 protected:
 705         virtual void Run();
 706 };
 707
 708 struct CropMainPlaylist : public Action
 709 {
 710         CropMainPlaylist() : Action(aCropMainPlaylist, "crop_main_playlist") { }
 711
 712 protected:
 713         virtual void Run();
 714 };
 715
 716 struct CropPlaylist : public Action
 717 {
 718         CropPlaylist() : Action(aCropPlaylist, "crop_playlist") { }
 719
 720 protected:
 721         virtual bool canBeRun() const;
 722         virtual void Run();
 723 };
 724
 725 struct ClearMainPlaylist : public Action
 726 {
 727         ClearMainPlaylist() : Action(aClearMainPlaylist, "clear_main_playlist") { }
 728
 729 protected:
 730         virtual void Run();
 731 };
 732
 733 struct ClearPlaylist : public Action
 734 {
 735         ClearPlaylist() : Action(aClearPlaylist, "clear_playlist") { }
 736
 737 protected:
 738         virtual bool canBeRun() const;
 739         virtual void Run();
 740 };
 741
 742 struct SortPlaylist : public Action
 743 {
 744         SortPlaylist() : Action(aSortPlaylist, "sort_playlist") { }
 745
 746 protected:
 747         virtual bool canBeRun() const;
 748         virtual void Run();
 749 };
 750
 751 struct ReversePlaylist : public Action
 752 {
 753         ReversePlaylist() : Action(aReversePlaylist, "reverse_playlist") { }
 754
 755 protected:
 756         virtual bool canBeRun() const;
 757         virtual void Run();
 758 };
 759
 760 struct ApplyFilter : public Action
 761 {
 762         ApplyFilter() : Action(aApplyFilter, "apply_filter") { }
 763
 764 protected:
 765         virtual bool canBeRun() const;
 766         virtual void Run();
 767 };
 768
 769 struct Find : public Action
 770 {
 771         Find() : Action(aFind, "find") { }
 772
 773 protected:
 774         virtual bool canBeRun() const;
 775         virtual void Run();
 776 };
 777
 778 struct FindItemForward : public Action
 779 {
 780         FindItemForward() : Action(aFindItemForward, "find_item_forward") { }
 781
 782 protected:
 783         virtual bool canBeRun() const;
 784         virtual void Run();
 785 };
 786
 787 struct FindItemBackward : public Action
 788 {
 789         FindItemBackward() : Action(aFindItemBackward, "find_item_backward") { }
 790
 791 protected:
 792         virtual bool canBeRun() const;
 793         virtual void Run();
 794 };
 795
 796 struct NextFoundItem : public Action
 797 {
 798         NextFoundItem() : Action(aNextFoundItem, "next_found_item") { }
 799
 800 protected:
 801         virtual bool canBeRun() const;
 802         virtual void Run();
 803 };
 804
 805 struct PreviousFoundItem : public Action
 806 {
 807         PreviousFoundItem() : Action(aPreviousFoundItem, "previous_found_item") { }
 808
 809 protected:
 810         virtual bool canBeRun() const;
 811         virtual void Run();
 812 };
 813
 814 struct ToggleFindMode : public Action
 815 {
 816         ToggleFindMode() : Action(aToggleFindMode, "toggle_find_mode") { }
 817
 818 protected:
 819         virtual void Run();
 820 };
 821
 822 struct ToggleReplayGainMode : public Action
 823 {
 824         ToggleReplayGainMode() : Action(aToggleReplayGainMode, "toggle_replay_gain_mode") { }
 825
 826 protected:
 827         virtual bool canBeRun() const;
 828         virtual void Run();
 829 };
 830
 831 struct ToggleSpaceMode : public Action
 832 {
 833         ToggleSpaceMode() : Action(aToggleSpaceMode, "toggle_space_mode") { }
 834
 835 protected:
 836         virtual void Run();
 837 };
 838
 839 struct ToggleAddMode : public Action
 840 {
 841         ToggleAddMode() : Action(aToggleAddMode, "toggle_add_mode") { }
 842
 843 protected:
 844         virtual void Run();
 845 };
 846
 847 struct ToggleMouse : public Action
 848 {
 849         ToggleMouse() : Action(aToggleMouse, "toggle_mouse") { }
 850
 851 protected:
 852         virtual void Run();
 853 };
 854
 855 struct ToggleBitrateVisibility : public Action
 856 {
 857         ToggleBitrateVisibility() : Action(aToggleBitrateVisibility, "toggle_bitrate_visibility") { }
 858
 859 protected:
 860         virtual void Run();
 861 };
 862
 863 struct AddRandomItems : public Action
 864 {
 865         AddRandomItems() : Action(aAddRandomItems, "add_random_items") { }
 866
 867 protected:
 868         virtual void Run();
 869 };
 870
 871 struct ToggleBrowserSortMode : public Action
 872 {
 873         ToggleBrowserSortMode() : Action(aToggleBrowserSortMode, "toggle_browser_sort_mode") { }
 874
 875 protected:
 876         virtual bool canBeRun() const;
 877         virtual void Run();
 878 };
 879
 880 struct ToggleLibraryTagType : public Action
 881 {
 882         ToggleLibraryTagType() : Action(aToggleLibraryTagType, "toggle_library_tag_type") { }
 883
 884 protected:
 885         virtual bool canBeRun() const;
 886         virtual void Run();
 887 };
 888
 889 struct RefetchLyrics : public Action
 890 {
 891         RefetchLyrics() : Action(aRefetchLyrics, "refetch_lyrics") { }
 892
 893 protected:
 894         virtual bool canBeRun() const;
 895         virtual void Run();
 896 };
 897
 898 struct RefetchArtistInfo : public Action
 899 {
 900         RefetchArtistInfo() : Action(aRefetchArtistInfo, "refetch_artist_info") { }
 901
 902 protected:
 903         virtual bool canBeRun() const;
 904         virtual void Run();
 905 };
 906
 907 struct SetSelectedItemsPriority : public Action
 908 {
 909         SetSelectedItemsPriority()
 910         : Action(aSetSelectedItemsPriority, "set_selected_items_priority") { }
 911
 912 protected:
 913         virtual bool canBeRun() const;
 914         virtual void Run();
 915 };
 916
 917 struct ShowSongInfo : public Action
 918 {
 919         ShowSongInfo() : Action(aShowSongInfo, "show_song_info") { }
 920
 921 protected:
 922         virtual void Run();
 923 };
 924
 925 struct ShowArtistInfo : public Action
 926 {
 927         ShowArtistInfo() : Action(aShowArtistInfo, "show_artist_info") { }
 928
 929 protected:
 930         virtual bool canBeRun() const;
 931         virtual void Run();
 932 };
 933
 934 struct ShowLyrics : public Action
 935 {
 936         ShowLyrics() : Action(aShowLyrics, "show_lyrics") { }
 937
 938 protected:
 939         virtual void Run();
 940 };
 941
 942 struct Quit : public Action
 943 {
 944         Quit() : Action(aQuit, "quit") { }
 945
 946 protected:
 947         virtual void Run();
 948 };
 949
 950 struct NextScreen : public Action
 951 {
 952         NextScreen() : Action(aNextScreen, "next_screen") { }
 953
 954 protected:
 955         virtual void Run();
 956 };
 957
 958 struct PreviousScreen : public Action
 959 {
 960         PreviousScreen() : Action(aPreviousScreen, "previous_screen") { }
 961
 962 protected:
 963         virtual void Run();
 964 };
 965
 966 struct ShowHelp : public Action
 967 {
 968         ShowHelp() : Action(aShowHelp, "show_help") { }
 969
 970 protected:
 971 #       ifdef HAVE_TAGLIB_H
 972         virtual bool canBeRun() const;
 973 #       endif // HAVE_TAGLIB_H
 974         virtual void Run();
 975 };
 976
 977 struct ShowPlaylist : public Action
 978 {
 979         ShowPlaylist() : Action(aShowPlaylist, "show_playlist") { }
 980
 981 protected:
 982 #       ifdef HAVE_TAGLIB_H
 983         virtual bool canBeRun() const;
 984 #       endif // HAVE_TAGLIB_H
 985         virtual void Run();
 986 };
 987
 988 struct ShowBrowser : public Action
 989 {
 990         ShowBrowser() : Action(aShowBrowser, "show_browser") { }
 991
 992 protected:
 993 #       ifdef HAVE_TAGLIB_H
 994         virtual bool canBeRun() const;
 995 #       endif // HAVE_TAGLIB_H
 996         virtual void Run();
 997 };
 998
 999 struct ShowSearchEngine : public Action
1000 {
1001         ShowSearchEngine() : Action(aShowSearchEngine, "show_search_engine") { }
1002
1003 protected:
1004 #       ifdef HAVE_TAGLIB_H
1005         virtual bool canBeRun() const;
1006 #       endif // HAVE_TAGLIB_H
1007         virtual void Run();
1008 };
1009
1010 struct ShowMediaLibrary : public Action
1011 {
1012         ShowMediaLibrary() : Action(aShowMediaLibrary, "show_media_library") { }
1013
1014 protected:
1015 #       ifdef HAVE_TAGLIB_H
1016         virtual bool canBeRun() const;
1017 #       endif // HAVE_TAGLIB_H
1018         virtual void Run();
1019 };
1020
1021 struct ShowPlaylistEditor : public Action
1022 {
1023         ShowPlaylistEditor() : Action(aShowPlaylistEditor, "show_playlist_editor") { }
1024
1025 protected:
1026 #       ifdef HAVE_TAGLIB_H
1027         virtual bool canBeRun() const;
1028 #       endif // HAVE_TAGLIB_H
1029         virtual void Run();
1030 };
1031
1032 struct ShowTagEditor : public Action
1033 {
1034         ShowTagEditor() : Action(aShowTagEditor, "show_tag_editor") { }
1035
1036 protected:
1037         virtual bool canBeRun() const;
1038         virtual void Run();
1039 };
1040
1041 struct ShowOutputs : public Action
1042 {
1043         ShowOutputs() : Action(aShowOutputs, "show_outputs") { }
1044
1045 protected:
1046         virtual bool canBeRun() const;
1047         virtual void Run();
1048 };
1049
1050 struct ShowVisualizer : public Action
1051 {
1052         ShowVisualizer() : Action(aShowVisualizer, "show_visualizer") { }
1053
1054 protected:
1055         virtual bool canBeRun() const;
1056         virtual void Run();
1057 };
1058
1059 struct ShowClock : public Action
1060 {
1061         ShowClock() : Action(aShowClock, "show_clock") { }
1062
1063 protected:
1064         virtual bool canBeRun() const;
1065         virtual void Run();
1066 };
1067
1068 struct ShowServerInfo : public Action
1069 {
1070         ShowServerInfo() : Action(aShowServerInfo, "show_server_info") { }
1071
1072 protected:
1073 #       ifdef HAVE_TAGLIB_H
1074         virtual bool canBeRun() const;
1075 #       endif // HAVE_TAGLIB_H
1076         virtual void Run();
1077 };
1078
1079 #endif // _ACTIONS_H