src/actions.cpp

   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 #include <cassert>
  22 #include <cerrno>
  23 #include <cstring>
  24 #include <boost/array.hpp>
  25 #include <boost/date_time/posix_time/posix_time.hpp>
  26 #include <boost/filesystem/operations.hpp>
  27 #include <boost/locale/conversion.hpp>
  28 #include <boost/lexical_cast.hpp>
  29 #include <algorithm>
  30 #include <iostream>
  31
  32 #include "actions.h"
  33 #include "charset.h"
  34 #include "config.h"
  35 #include "display.h"
  36 #include "global.h"
  37 #include "mpdpp.h"
  38 #include "helpers.h"
  39 #include "statusbar.h"
  40 #include "utility/comparators.h"
  41 #include "utility/conversion.h"
  42
  43 #include "bindings.h"
  44 #include "browser.h"
  45 #include "clock.h"
  46 #include "help.h"
  47 #include "media_library.h"
  48 #include "menu_impl.h"
  49 #include "lastfm.h"
  50 #include "lyrics.h"
  51 #include "playlist.h"
  52 #include "playlist_editor.h"
  53 #include "sort_playlist.h"
  54 #include "search_engine.h"
  55 #include "sel_items_adder.h"
  56 #include "server_info.h"
  57 #include "song_info.h"
  58 #include "outputs.h"
  59 #include "utility/readline.h"
  60 #include "utility/string.h"
  61 #include "utility/type_conversions.h"
  62 #include "tag_editor.h"
  63 #include "tiny_tag_editor.h"
  64 #include "visualizer.h"
  65 #include "title.h"
  66 #include "tags.h"
  67
  68 #ifdef HAVE_TAGLIB_H
  69 # include "fileref.h"
  70 # include "tag.h"
  71 #endif // HAVE_TAGLIB_H
  72
  73 using Global::myScreen;
  74
  75 namespace ph = std::placeholders;
  76
  77 namespace {
  78
  79 std::vector<std::unique_ptr<Actions::BaseAction>> AvailableActions;
  80
  81 void populateActions();
  82
  83 bool scrollTagCanBeRun(NC::List *&list, SongList *&songs);
  84 void scrollTagUpRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get);
  85 void scrollTagDownRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get);
  86
  87 void seek();
  88 void findItem(const SearchDirection direction);
  89 void listsChangeFinisher();
  90
  91 template <typename Iterator>
  92 bool findSelectedRangeAndPrintInfoIfNot(Iterator &first, Iterator &last)
  93 {
  94         bool success = findSelectedRange(first, last);
  95         if (!success)
  96                 Statusbar::print("No range selected");
  97         return success;
  98 }
  99
 100 }
 101
 102 namespace Actions {
 103
 104 bool OriginalStatusbarVisibility;
 105 bool ExitMainLoop = false;
 106
 107 size_t HeaderHeight;
 108 size_t FooterHeight;
 109 size_t FooterStartY;
 110
 111 void validateScreenSize()
 112 {
 113         using Global::MainHeight;
 114
 115         if (COLS < 30 || MainHeight < 5)
 116         {
 117                 NC::destroyScreen();
 118                 std::cout << "Screen is too small to handle ncmpcpp correctly\n";
 119                 exit(1);
 120         }
 121 }
 122
 123 void initializeScreens()
 124 {
 125         myHelp = new Help;
 126         myPlaylist = new Playlist;
 127         myBrowser = new Browser;
 128         mySearcher = new SearchEngine;
 129         myLibrary = new MediaLibrary;
 130         myPlaylistEditor = new PlaylistEditor;
 131         myLyrics = new Lyrics;
 132         mySelectedItemsAdder = new SelectedItemsAdder;
 133         mySongInfo = new SongInfo;
 134         myServerInfo = new ServerInfo;
 135         mySortPlaylistDialog = new SortPlaylistDialog;
 136         myLastfm = new Lastfm;
 137
 138 #       ifdef HAVE_TAGLIB_H
 139         myTinyTagEditor = new TinyTagEditor;
 140         myTagEditor = new TagEditor;
 141 #       endif // HAVE_TAGLIB_H
 142
 143 #       ifdef ENABLE_VISUALIZER
 144         myVisualizer = new Visualizer;
 145 #       endif // ENABLE_VISUALIZER
 146
 147 #       ifdef ENABLE_OUTPUTS
 148         myOutputs = new Outputs;
 149 #       endif // ENABLE_OUTPUTS
 150
 151 #       ifdef ENABLE_CLOCK
 152         myClock = new Clock;
 153 #       endif // ENABLE_CLOCK
 154
 155 }
 156
 157 void setResizeFlags()
 158 {
 159         myHelp->hasToBeResized = 1;
 160         myPlaylist->hasToBeResized = 1;
 161         myBrowser->hasToBeResized = 1;
 162         mySearcher->hasToBeResized = 1;
 163         myLibrary->hasToBeResized = 1;
 164         myPlaylistEditor->hasToBeResized = 1;
 165         myLyrics->hasToBeResized = 1;
 166         mySelectedItemsAdder->hasToBeResized = 1;
 167         mySongInfo->hasToBeResized = 1;
 168         myServerInfo->hasToBeResized = 1;
 169         mySortPlaylistDialog->hasToBeResized = 1;
 170         myLastfm->hasToBeResized = 1;
 171
 172 #       ifdef HAVE_TAGLIB_H
 173         myTinyTagEditor->hasToBeResized = 1;
 174         myTagEditor->hasToBeResized = 1;
 175 #       endif // HAVE_TAGLIB_H
 176
 177 #       ifdef ENABLE_VISUALIZER
 178         myVisualizer->hasToBeResized = 1;
 179 #       endif // ENABLE_VISUALIZER
 180
 181 #       ifdef ENABLE_OUTPUTS
 182         myOutputs->hasToBeResized = 1;
 183 #       endif // ENABLE_OUTPUTS
 184
 185 #       ifdef ENABLE_CLOCK
 186         myClock->hasToBeResized = 1;
 187 #       endif // ENABLE_CLOCK
 188 }
 189
 190 void resizeScreen(bool reload_main_window)
 191 {
 192         using Global::MainHeight;
 193         using Global::wHeader;
 194         using Global::wFooter;
 195
 196         // update internal screen dimensions
 197         if (reload_main_window)
 198         {
 199                 rl_resize_terminal();
 200                 endwin();
 201                 refresh();
 202         }
 203
 204         MainHeight = LINES-(Config.design == Design::Alternative ? 7 : 4);
 205
 206         validateScreenSize();
 207
 208         if (!Config.header_visibility)
 209                 MainHeight += 2;
 210         if (!Config.statusbar_visibility)
 211                 ++MainHeight;
 212
 213         setResizeFlags();
 214
 215         applyToVisibleWindows(&BaseScreen::resize);
 216
 217         if (Config.header_visibility || Config.design == Design::Alternative)
 218                 wHeader->resize(COLS, HeaderHeight);
 219
 220         FooterStartY = LINES-(Config.statusbar_visibility ? 2 : 1);
 221         wFooter->moveTo(0, FooterStartY);
 222         wFooter->resize(COLS, Config.statusbar_visibility ? 2 : 1);
 223
 224         applyToVisibleWindows(&BaseScreen::refresh);
 225
 226         Status::Changes::elapsedTime(false);
 227         Status::Changes::playerState();
 228         // Note: routines for drawing separator if alternative user
 229         // interface is active and header is hidden are placed in
 230         // NcmpcppStatusChanges.StatusFlags
 231         Status::Changes::flags();
 232         drawHeader();
 233         wFooter->refresh();
 234         refresh();
 235 }
 236
 237 void setWindowsDimensions()
 238 {
 239         using Global::MainStartY;
 240         using Global::MainHeight;
 241
 242         MainStartY = Config.design == Design::Alternative ? 5 : 2;
 243         MainHeight = LINES-(Config.design == Design::Alternative ? 7 : 4);
 244
 245         if (!Config.header_visibility)
 246         {
 247                 MainStartY -= 2;
 248                 MainHeight += 2;
 249         }
 250         if (!Config.statusbar_visibility)
 251                 ++MainHeight;
 252
 253         HeaderHeight = Config.design == Design::Alternative ? (Config.header_visibility ? 5 : 3) : 2;
 254         FooterStartY = LINES-(Config.statusbar_visibility ? 2 : 1);
 255         FooterHeight = Config.statusbar_visibility ? 2 : 1;
 256 }
 257
 258 void confirmAction(const boost::format &description)
 259 {
 260         Statusbar::ScopedLock slock;
 261         Statusbar::put() << description.str()
 262         << " [" << NC::Format::Bold << 'y' << NC::Format::NoBold
 263         << '/' << NC::Format::Bold << 'n' << NC::Format::NoBold
 264         << "] ";
 265         auto answer = Statusbar::Helpers::promptReturnOneOf({"y", "n"});
 266         if (answer == "n")
 267                 throw NC::PromptAborted(std::move(answer));
 268 }
 269
 270 bool isMPDMusicDirSet()
 271 {
 272         if (Config.mpd_music_dir.empty())
 273         {
 274                 Statusbar::print("Proper mpd_music_dir variable has to be set in configuration file");
 275                 return false;
 276         }
 277         return true;
 278 }
 279
 280 BaseAction &get(Actions::Type at)
 281 {
 282         if (AvailableActions.empty())
 283                 populateActions();
 284         BaseAction *action = AvailableActions.at(static_cast<size_t>(at)).get();
 285         // action should be always present if action type in queried
 286         assert(action != nullptr);
 287         return *action;
 288 }
 289
 290 BaseAction *get(const std::string &name)
 291 {
 292         BaseAction *result = nullptr;
 293         if (AvailableActions.empty())
 294                 populateActions();
 295         for (const auto &action : AvailableActions)
 296         {
 297                 if (action->name() == name)
 298                 {
 299                         result = action.get();
 300                         break;
 301                 }
 302         }
 303         return result;
 304 }
 305
 306 UpdateEnvironment::UpdateEnvironment()
 307 : BaseAction(Type::UpdateEnvironment, "update_environment")
 308 , m_past(boost::posix_time::from_time_t(0))
 309 { }
 310
 311 void UpdateEnvironment::run(bool update_timer, bool refresh_window)
 312 {
 313         using Global::Timer;
 314
 315         // update timer, status if necessary etc.
 316         Status::trace(update_timer, true);
 317
 318         // show lyrics consumer notification if appropriate
 319         if (auto message = myLyrics->tryTakeConsumerMessage())
 320                 Statusbar::print(*message);
 321
 322         // header stuff
 323         if ((myScreen == myPlaylist || myScreen == myBrowser || myScreen == myLyrics)
 324         &&  (Timer - m_past > boost::posix_time::milliseconds(500))
 325         )
 326         {
 327                 drawHeader();
 328                 m_past = Timer;
 329         }
 330
 331         if (refresh_window)
 332                 myScreen->refreshWindow();
 333 }
 334
 335 void UpdateEnvironment::run()
 336 {
 337         run(true, true);
 338 }
 339
 340 bool MouseEvent::canBeRun()
 341 {
 342         return Config.mouse_support;
 343 }
 344
 345 void MouseEvent::run()
 346 {
 347         using Global::VolumeState;
 348         using Global::wFooter;
 349
 350         m_old_mouse_event = m_mouse_event;
 351         m_mouse_event = wFooter->getMouseEvent();
 352
 353         //Statusbar::printf("(%1%, %2%, %3%)", m_mouse_event.bstate, m_mouse_event.x, m_mouse_event.y);
 354
 355         if (m_mouse_event.bstate & BUTTON1_PRESSED
 356         &&  m_mouse_event.y == LINES-(Config.statusbar_visibility ? 2 : 1)
 357            ) // progressbar
 358         {
 359                 if (Status::State::player() == MPD::psStop)
 360                         return;
 361                 Mpd.Seek(Status::State::currentSongPosition(),
 362                         Status::State::totalTime()*m_mouse_event.x/double(COLS));
 363         }
 364         else if (m_mouse_event.bstate & BUTTON1_PRESSED
 365              &&  (Config.statusbar_visibility || Config.design == Design::Alternative)
 366              &&  Status::State::player() != MPD::psStop
 367              &&  m_mouse_event.y == (Config.design == Design::Alternative ? 1 : LINES-1)
 368                          &&  m_mouse_event.x < 9
 369                 ) // playing/paused
 370         {
 371                 Mpd.Toggle();
 372         }
 373         else if ((m_mouse_event.bstate & BUTTON5_PRESSED || m_mouse_event.bstate & BUTTON4_PRESSED)
 374              &&  (Config.header_visibility || Config.design == Design::Alternative)
 375              &&  m_mouse_event.y == 0 && size_t(m_mouse_event.x) > COLS-VolumeState.length()
 376         ) // volume
 377         {
 378                 if (m_mouse_event.bstate & BUTTON5_PRESSED)
 379                         get(Type::VolumeDown).execute();
 380                 else
 381                         get(Type::VolumeUp).execute();
 382         }
 383         else if (m_mouse_event.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED | BUTTON4_PRESSED | BUTTON5_PRESSED))
 384                 myScreen->mouseButtonPressed(m_mouse_event);
 385 }
 386
 387 void ScrollUp::run()
 388 {
 389         myScreen->scroll(NC::Scroll::Up);
 390         listsChangeFinisher();
 391 }
 392
 393 void ScrollDown::run()
 394 {
 395         myScreen->scroll(NC::Scroll::Down);
 396         listsChangeFinisher();
 397 }
 398
 399 bool ScrollUpArtist::canBeRun()
 400 {
 401         return scrollTagCanBeRun(m_list, m_songs);
 402 }
 403
 404 void ScrollUpArtist::run()
 405 {
 406         scrollTagUpRun(m_list, m_songs, &MPD::Song::getArtist);
 407 }
 408
 409 bool ScrollUpAlbum::canBeRun()
 410 {
 411         return scrollTagCanBeRun(m_list, m_songs);
 412 }
 413
 414 void ScrollUpAlbum::run()
 415 {
 416         scrollTagUpRun(m_list, m_songs, &MPD::Song::getAlbum);
 417 }
 418
 419 bool ScrollDownArtist::canBeRun()
 420 {
 421         return scrollTagCanBeRun(m_list, m_songs);
 422 }
 423
 424 void ScrollDownArtist::run()
 425 {
 426         scrollTagDownRun(m_list, m_songs, &MPD::Song::getArtist);
 427 }
 428
 429 bool ScrollDownAlbum::canBeRun()
 430 {
 431         return scrollTagCanBeRun(m_list, m_songs);
 432 }
 433
 434 void ScrollDownAlbum::run()
 435 {
 436         scrollTagDownRun(m_list, m_songs, &MPD::Song::getAlbum);
 437 }
 438
 439 void PageUp::run()
 440 {
 441         myScreen->scroll(NC::Scroll::PageUp);
 442         listsChangeFinisher();
 443 }
 444
 445 void PageDown::run()
 446 {
 447         myScreen->scroll(NC::Scroll::PageDown);
 448         listsChangeFinisher();
 449 }
 450
 451 void MoveHome::run()
 452 {
 453         myScreen->scroll(NC::Scroll::Home);
 454         listsChangeFinisher();
 455 }
 456
 457 void MoveEnd::run()
 458 {
 459         myScreen->scroll(NC::Scroll::End);
 460         listsChangeFinisher();
 461 }
 462
 463 void ToggleInterface::run()
 464 {
 465         switch (Config.design)
 466         {
 467                 case Design::Classic:
 468                         Config.design = Design::Alternative;
 469                         Config.statusbar_visibility = false;
 470                         break;
 471                 case Design::Alternative:
 472                         Config.design = Design::Classic;
 473                         Config.statusbar_visibility = OriginalStatusbarVisibility;
 474                         break;
 475         }
 476         setWindowsDimensions();
 477         resizeScreen(false);
 478         // unlock progressbar
 479         Progressbar::ScopedLock();
 480         Status::Changes::mixer();
 481         Status::Changes::elapsedTime(false);
 482         Statusbar::printf("User interface: %1%", Config.design);
 483 }
 484
 485 bool JumpToParentDirectory::canBeRun()
 486 {
 487         return (myScreen == myBrowser)
 488 #       ifdef HAVE_TAGLIB_H
 489             || (myScreen->activeWindow() == myTagEditor->Dirs)
 490 #       endif // HAVE_TAGLIB_H
 491         ;
 492 }
 493
 494 void JumpToParentDirectory::run()
 495 {
 496         if (myScreen == myBrowser)
 497         {
 498                 if (!myBrowser->inRootDirectory())
 499                 {
 500                         myBrowser->main().reset();
 501                         myBrowser->enterDirectory();
 502                 }
 503         }
 504 #       ifdef HAVE_TAGLIB_H
 505         else if (myScreen == myTagEditor)
 506         {
 507                 if (myTagEditor->CurrentDir() != "/")
 508                 {
 509                         myTagEditor->Dirs->reset();
 510                         myTagEditor->enterDirectory();
 511                 }
 512         }
 513 #       endif // HAVE_TAGLIB_H
 514 }
 515
 516 bool RunAction::canBeRun()
 517 {
 518         m_ha = dynamic_cast<HasActions *>(myScreen);
 519         return m_ha != nullptr
 520                 && m_ha->actionRunnable();
 521 }
 522
 523 void RunAction::run()
 524 {
 525         m_ha->runAction();
 526 }
 527
 528 bool PreviousColumn::canBeRun()
 529 {
 530         m_hc = dynamic_cast<HasColumns *>(myScreen);
 531         return m_hc != nullptr
 532                 && m_hc->previousColumnAvailable();
 533 }
 534
 535 void PreviousColumn::run()
 536 {
 537         m_hc->previousColumn();
 538 }
 539
 540 bool NextColumn::canBeRun()
 541 {
 542         m_hc = dynamic_cast<HasColumns *>(myScreen);
 543         return m_hc != nullptr
 544                 && m_hc->nextColumnAvailable();
 545 }
 546
 547 void NextColumn::run()
 548 {
 549         m_hc->nextColumn();
 550 }
 551
 552 bool MasterScreen::canBeRun()
 553 {
 554         using Global::myLockedScreen;
 555         using Global::myInactiveScreen;
 556
 557         return myLockedScreen
 558             && myInactiveScreen
 559             && myLockedScreen != myScreen
 560             && myScreen->isMergable();
 561 }
 562
 563 void MasterScreen::run()
 564 {
 565         using Global::myInactiveScreen;
 566         using Global::myLockedScreen;
 567
 568         myInactiveScreen = myScreen;
 569         myScreen = myLockedScreen;
 570         drawHeader();
 571 }
 572
 573 bool SlaveScreen::canBeRun()
 574 {
 575         using Global::myLockedScreen;
 576         using Global::myInactiveScreen;
 577
 578         return myLockedScreen
 579             && myInactiveScreen
 580             && myLockedScreen == myScreen
 581             && myScreen->isMergable();
 582 }
 583
 584 void SlaveScreen::run()
 585 {
 586         using Global::myInactiveScreen;
 587         using Global::myLockedScreen;
 588
 589         myScreen = myInactiveScreen;
 590         myInactiveScreen = myLockedScreen;
 591         drawHeader();
 592 }
 593
 594 void VolumeUp::run()
 595 {
 596         int volume = std::min(Status::State::volume()+Config.volume_change_step, 100u);
 597         Mpd.SetVolume(volume);
 598 }
 599
 600 void VolumeDown::run()
 601 {
 602         int volume = std::max(int(Status::State::volume()-Config.volume_change_step), 0);
 603         Mpd.SetVolume(volume);
 604 }
 605
 606 bool AddItemToPlaylist::canBeRun()
 607 {
 608         m_hs = dynamic_cast<HasSongs *>(myScreen);
 609         return m_hs != nullptr && m_hs->itemAvailable();
 610 }
 611
 612 void AddItemToPlaylist::run()
 613 {
 614         bool success = m_hs->addItemToPlaylist(false);
 615         if (success)
 616         {
 617                 myScreen->scroll(NC::Scroll::Down);
 618                 listsChangeFinisher();
 619         }
 620 }
 621
 622 bool PlayItem::canBeRun()
 623 {
 624         m_hs = dynamic_cast<HasSongs *>(myScreen);
 625         return m_hs != nullptr && m_hs->itemAvailable();
 626 }
 627
 628 void PlayItem::run()
 629 {
 630         bool success = m_hs->addItemToPlaylist(true);
 631         if (success)
 632                 listsChangeFinisher();
 633 }
 634
 635 bool DeletePlaylistItems::canBeRun()
 636 {
 637         return (myScreen == myPlaylist && !myPlaylist->main().empty())
 638             || (myScreen->isActiveWindow(myPlaylistEditor->Content) && !myPlaylistEditor->Content.empty());
 639 }
 640
 641 void DeletePlaylistItems::run()
 642 {
 643         if (myScreen == myPlaylist)
 644         {
 645                 Statusbar::print("Deleting items...");
 646                 auto delete_fun = std::bind(&MPD::Connection::Delete, ph::_1, ph::_2);
 647                 deleteSelectedSongs(myPlaylist->main(), delete_fun);
 648                 Statusbar::print("Item(s) deleted");
 649         }
 650         else if (myScreen->isActiveWindow(myPlaylistEditor->Content))
 651         {
 652                 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
 653                 auto delete_fun = std::bind(&MPD::Connection::PlaylistDelete, ph::_1, playlist, ph::_2);
 654                 Statusbar::print("Deleting items...");
 655                 deleteSelectedSongs(myPlaylistEditor->Content, delete_fun);
 656                 Statusbar::print("Item(s) deleted");
 657         }
 658 }
 659
 660 bool DeleteBrowserItems::canBeRun()
 661 {
 662         auto check_if_deletion_allowed = []() {
 663                 if (Config.allow_for_physical_item_deletion)
 664                         return true;
 665                 else
 666                 {
 667                         Statusbar::print("Flag \"allow_for_physical_item_deletion\" needs to be enabled in configuration file");
 668                         return false;
 669                 }
 670         };
 671         return myScreen == myBrowser
 672             && !myBrowser->main().empty()
 673             && isMPDMusicDirSet()
 674             && check_if_deletion_allowed();
 675 }
 676
 677 void DeleteBrowserItems::run()
 678 {
 679         auto get_name = [](const MPD::Item &item) -> std::string {
 680                 std::string iname;
 681                 switch (item.type())
 682                 {
 683                         case MPD::Item::Type::Directory:
 684                                 iname = getBasename(item.directory().path());
 685                                 break;
 686                         case MPD::Item::Type::Song:
 687                                 iname = item.song().getName();
 688                                 break;
 689                         case MPD::Item::Type::Playlist:
 690                                 iname = getBasename(item.playlist().path());
 691                                 break;
 692                 }
 693                 return iname;
 694         };
 695
 696         boost::format question;
 697         if (hasSelected(myBrowser->main().begin(), myBrowser->main().end()))
 698                 question = boost::format("Delete selected items?");
 699         else
 700         {
 701                 const auto &item = myBrowser->main().current()->value();
 702                 // parent directories are not accepted (and they
 703                 // can't be selected, so in other cases it's fine).
 704                 if (myBrowser->isParentDirectory(item))
 705                         return;
 706                 const char msg[] = "Delete \"%1%\"?";
 707                 question = boost::format(msg) % wideShorten(
 708                         get_name(item), COLS-const_strlen(msg)-5
 709                 );
 710         }
 711         confirmAction(question);
 712
 713         auto items = getSelectedOrCurrent(
 714                 myBrowser->main().begin(),
 715                 myBrowser->main().end(),
 716                 myBrowser->main().current()
 717         );
 718         for (const auto &item : items)
 719         {
 720                 myBrowser->remove(item->value());
 721                 const char msg[] = "Deleted %1% \"%2%\"";
 722                 Statusbar::printf(msg,
 723                         itemTypeToString(item->value().type()),
 724                         wideShorten(get_name(item->value()), COLS-const_strlen(msg))
 725                 );
 726         }
 727
 728         if (!myBrowser->isLocal())
 729                 Mpd.UpdateDirectory(myBrowser->currentDirectory());
 730         myBrowser->requestUpdate();
 731 }
 732
 733 bool DeleteStoredPlaylist::canBeRun()
 734 {
 735         return myScreen->isActiveWindow(myPlaylistEditor->Playlists);
 736 }
 737
 738 void DeleteStoredPlaylist::run()
 739 {
 740         if (myPlaylistEditor->Playlists.empty())
 741                 return;
 742         boost::format question;
 743         if (hasSelected(myPlaylistEditor->Playlists.begin(), myPlaylistEditor->Playlists.end()))
 744                 question = boost::format("Delete selected playlists?");
 745         else
 746                 question = boost::format("Delete playlist \"%1%\"?")
 747                         % wideShorten(myPlaylistEditor->Playlists.current()->value().path(), COLS-question.size()-10);
 748         confirmAction(question);
 749         auto list = getSelectedOrCurrent(
 750                 myPlaylistEditor->Playlists.begin(),
 751                 myPlaylistEditor->Playlists.end(),
 752                 myPlaylistEditor->Playlists.current()
 753         );
 754         for (const auto &item : list)
 755                 Mpd.DeletePlaylist(item->value().path());
 756         Statusbar::printf("%1% deleted", list.size() == 1 ? "Playlist" : "Playlists");
 757         // force playlists update. this happens automatically, but only after call
 758         // to Key::read, therefore when we call PlaylistEditor::Update, it won't
 759         // yet see it, so let's point that it needs to update it.
 760         myPlaylistEditor->requestPlaylistsUpdate();
 761 }
 762
 763 void ReplaySong::run()
 764 {
 765         if (Status::State::player() != MPD::psStop)
 766                 Mpd.Seek(Status::State::currentSongPosition(), 0);
 767 }
 768
 769 void PreviousSong::run()
 770 {
 771         Mpd.Prev();
 772 }
 773
 774 void NextSong::run()
 775 {
 776         Mpd.Next();
 777 }
 778
 779 void Pause::run()
 780 {
 781         Mpd.Toggle();
 782 }
 783
 784 void SavePlaylist::run()
 785 {
 786         using Global::wFooter;
 787
 788         std::string playlist_name;
 789         {
 790                 Statusbar::ScopedLock slock;
 791                 Statusbar::put() << "Save playlist as: ";
 792                 playlist_name = wFooter->prompt();
 793         }
 794         try
 795         {
 796                 Mpd.SavePlaylist(playlist_name);
 797                 Statusbar::printf("Playlist saved as \"%1%\"", playlist_name);
 798         }
 799         catch (MPD::ServerError &e)
 800         {
 801                 if (e.code() == MPD_SERVER_ERROR_EXIST)
 802                 {
 803                         confirmAction(
 804                                 boost::format("Playlist \"%1%\" already exists, overwrite?") % playlist_name
 805                         );
 806                         Mpd.DeletePlaylist(playlist_name);
 807                         Mpd.SavePlaylist(playlist_name);
 808                         Statusbar::print("Playlist overwritten");
 809                 }
 810                 else
 811                         throw;
 812         }
 813 }
 814
 815 void Stop::run()
 816 {
 817         Mpd.Stop();
 818 }
 819
 820 void ExecuteCommand::run()
 821 {
 822         using Global::wFooter;
 823
 824         std::string cmd_name;
 825         {
 826                 Statusbar::ScopedLock slock;
 827                 NC::Window::ScopedPromptHook helper(*wFooter,
 828                         Statusbar::Helpers::TryExecuteImmediateCommand()
 829                 );
 830                 Statusbar::put() << NC::Format::Bold << ":" << NC::Format::NoBold;
 831                 cmd_name = wFooter->prompt();
 832         }
 833
 834         auto cmd = Bindings.findCommand(cmd_name);
 835         if (cmd)
 836         {
 837                 Statusbar::printf(1, "Executing %1%...", cmd_name);
 838                 bool res = cmd->binding().execute();
 839                 Statusbar::printf("Execution of command \"%1%\" %2%.",
 840                         cmd_name, res ? "successful" : "unsuccessful"
 841                 );
 842         }
 843         else
 844                 Statusbar::printf("No command named \"%1%\"", cmd_name);
 845 }
 846
 847 bool MoveSortOrderUp::canBeRun()
 848 {
 849         return myScreen == mySortPlaylistDialog;
 850 }
 851
 852 void MoveSortOrderUp::run()
 853 {
 854         mySortPlaylistDialog->moveSortOrderUp();
 855 }
 856
 857 bool MoveSortOrderDown::canBeRun()
 858 {
 859         return myScreen == mySortPlaylistDialog;
 860 }
 861
 862 void MoveSortOrderDown::run()
 863 {
 864         mySortPlaylistDialog->moveSortOrderDown();
 865 }
 866
 867 bool MoveSelectedItemsUp::canBeRun()
 868 {
 869         return ((myScreen == myPlaylist
 870             &&  !myPlaylist->main().empty())
 871          ||    (myScreen->isActiveWindow(myPlaylistEditor->Content)
 872             &&  !myPlaylistEditor->Content.empty()));
 873 }
 874
 875 void MoveSelectedItemsUp::run()
 876 {
 877         const char *filteredMsg = "Moving items up is disabled in filtered playlist";
 878         if (myScreen == myPlaylist)
 879         {
 880                 if (myPlaylist->main().isFiltered())
 881                         Statusbar::print(filteredMsg);
 882                 else
 883                         moveSelectedItemsUp(
 884                                 myPlaylist->main(),
 885                                 std::bind(&MPD::Connection::Move, ph::_1, ph::_2, ph::_3));
 886         }
 887         else if (myScreen == myPlaylistEditor)
 888         {
 889                 if (myPlaylistEditor->Content.isFiltered())
 890                         Statusbar::print(filteredMsg);
 891                 else
 892                 {
 893                         auto playlist = myPlaylistEditor->Playlists.current()->value().path();
 894                         moveSelectedItemsUp(
 895                                 myPlaylistEditor->Content,
 896                                 std::bind(&MPD::Connection::PlaylistMove, ph::_1, playlist, ph::_2, ph::_3));
 897                 }
 898         }
 899 }
 900
 901 bool MoveSelectedItemsDown::canBeRun()
 902 {
 903         return ((myScreen == myPlaylist
 904             &&  !myPlaylist->main().empty())
 905          ||    (myScreen->isActiveWindow(myPlaylistEditor->Content)
 906             &&  !myPlaylistEditor->Content.empty()));
 907 }
 908
 909 void MoveSelectedItemsDown::run()
 910 {
 911         const char *filteredMsg = "Moving items down is disabled in filtered playlist";
 912         if (myScreen == myPlaylist)
 913         {
 914                 if (myPlaylist->main().isFiltered())
 915                         Statusbar::print(filteredMsg);
 916                 else
 917                         moveSelectedItemsDown(
 918                                 myPlaylist->main(),
 919                                 std::bind(&MPD::Connection::Move, ph::_1, ph::_2, ph::_3));
 920         }
 921         else if (myScreen == myPlaylistEditor)
 922         {
 923                 if (myPlaylistEditor->Content.isFiltered())
 924                         Statusbar::print(filteredMsg);
 925                 else
 926                 {
 927                         auto playlist = myPlaylistEditor->Playlists.current()->value().path();
 928                         moveSelectedItemsDown(
 929                                 myPlaylistEditor->Content,
 930                                 std::bind(&MPD::Connection::PlaylistMove, ph::_1, playlist, ph::_2, ph::_3));
 931                 }
 932         }
 933 }
 934
 935 bool MoveSelectedItemsTo::canBeRun()
 936 {
 937         return myScreen == myPlaylist
 938             || myScreen->isActiveWindow(myPlaylistEditor->Content);
 939 }
 940
 941 void MoveSelectedItemsTo::run()
 942 {
 943         if (myScreen == myPlaylist)
 944         {
 945                 if (!myPlaylist->main().empty())
 946                         moveSelectedItemsTo(myPlaylist->main(), std::bind(&MPD::Connection::Move, ph::_1, ph::_2, ph::_3));
 947         }
 948         else
 949         {
 950                 assert(!myPlaylistEditor->Playlists.empty());
 951                 std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
 952                 auto move_fun = std::bind(&MPD::Connection::PlaylistMove, ph::_1, playlist, ph::_2, ph::_3);
 953                 moveSelectedItemsTo(myPlaylistEditor->Content, move_fun);
 954         }
 955 }
 956
 957 bool Add::canBeRun()
 958 {
 959         return myScreen != myPlaylistEditor
 960            || !myPlaylistEditor->Playlists.empty();
 961 }
 962
 963 void Add::run()
 964 {
 965         using Global::wFooter;
 966
 967         std::string path;
 968         {
 969                 Statusbar::ScopedLock slock;
 970                 Statusbar::put() << (myScreen == myPlaylistEditor ? "Add to playlist: " : "Add: ");
 971                 path = wFooter->prompt();
 972         }
 973
 974         // confirm when one wants to add the whole database
 975         if (path.empty())
 976                 confirmAction("Are you sure you want to add the whole database?");
 977
 978         Statusbar::put() << "Adding...";
 979         wFooter->refresh();
 980         if (myScreen == myPlaylistEditor)
 981                 Mpd.AddToPlaylist(myPlaylistEditor->Playlists.current()->value().path(), path);
 982         else
 983         {
 984                 try
 985                 {
 986                         Mpd.Add(path);
 987                 }
 988                 catch (MPD::ServerError &err)
 989                 {
 990                         // If a path is not a file or directory, assume it is a playlist.
 991                         if (err.code() == MPD_SERVER_ERROR_NO_EXIST)
 992                                 Mpd.LoadPlaylist(path);
 993                         else
 994                                 throw;
 995                 }
 996         }
 997 }
 998
 999 bool SeekForward::canBeRun()
1000 {
1001         return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
1002 }
1003
1004 void SeekForward::run()
1005 {
1006         seek();
1007 }
1008
1009 bool SeekBackward::canBeRun()
1010 {
1011         return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
1012 }
1013
1014 void SeekBackward::run()
1015 {
1016         seek();
1017 }
1018
1019 bool ToggleDisplayMode::canBeRun()
1020 {
1021         return myScreen == myPlaylist
1022             || myScreen == myBrowser
1023             || myScreen == mySearcher
1024             || myScreen->isActiveWindow(myPlaylistEditor->Content);
1025 }
1026
1027 void ToggleDisplayMode::run()
1028 {
1029         if (myScreen == myPlaylist)
1030         {
1031                 switch (Config.playlist_display_mode)
1032                 {
1033                         case DisplayMode::Classic:
1034                                 Config.playlist_display_mode = DisplayMode::Columns;
1035                                 myPlaylist->main().setItemDisplayer(std::bind(
1036                                         Display::SongsInColumns, ph::_1, std::cref(myPlaylist->main())
1037                                 ));
1038                                 if (Config.titles_visibility)
1039                                         myPlaylist->main().setTitle(Display::Columns(myPlaylist->main().getWidth()));
1040                                 else
1041                                         myPlaylist->main().setTitle("");
1042                                 break;
1043                         case DisplayMode::Columns:
1044                                 Config.playlist_display_mode = DisplayMode::Classic;
1045                                 myPlaylist->main().setItemDisplayer(std::bind(
1046                                         Display::Songs, ph::_1, std::cref(myPlaylist->main()), std::cref(Config.song_list_format)
1047                                 ));
1048                                 myPlaylist->main().setTitle("");
1049                 }
1050                 Statusbar::printf("Playlist display mode: %1%", Config.playlist_display_mode);
1051         }
1052         else if (myScreen == myBrowser)
1053         {
1054                 switch (Config.browser_display_mode)
1055                 {
1056                         case DisplayMode::Classic:
1057                                 Config.browser_display_mode = DisplayMode::Columns;
1058                                 if (Config.titles_visibility)
1059                                         myBrowser->main().setTitle(Display::Columns(myBrowser->main().getWidth()));
1060                                 else
1061                                         myBrowser->main().setTitle("");
1062                                 break;
1063                         case DisplayMode::Columns:
1064                                 Config.browser_display_mode = DisplayMode::Classic;
1065                                 myBrowser->main().setTitle("");
1066                                 break;
1067                 }
1068                 Statusbar::printf("Browser display mode: %1%", Config.browser_display_mode);
1069         }
1070         else if (myScreen == mySearcher)
1071         {
1072                 switch (Config.search_engine_display_mode)
1073                 {
1074                         case DisplayMode::Classic:
1075                                 Config.search_engine_display_mode = DisplayMode::Columns;
1076                                 break;
1077                         case DisplayMode::Columns:
1078                                 Config.search_engine_display_mode = DisplayMode::Classic;
1079                                 break;
1080                 }
1081                 Statusbar::printf("Search engine display mode: %1%", Config.search_engine_display_mode);
1082                 if (mySearcher->main().size() > SearchEngine::StaticOptions)
1083                         mySearcher->main().setTitle(
1084                                    Config.search_engine_display_mode == DisplayMode::Columns
1085                                 && Config.titles_visibility
1086                                 ? Display::Columns(mySearcher->main().getWidth())
1087                                 : ""
1088                         );
1089         }
1090         else if (myScreen->isActiveWindow(myPlaylistEditor->Content))
1091         {
1092                 switch (Config.playlist_editor_display_mode)
1093                 {
1094                         case DisplayMode::Classic:
1095                                 Config.playlist_editor_display_mode = DisplayMode::Columns;
1096                                 myPlaylistEditor->Content.setItemDisplayer(std::bind(
1097                                         Display::SongsInColumns, ph::_1, std::cref(myPlaylistEditor->Content)
1098                                 ));
1099                                 break;
1100                         case DisplayMode::Columns:
1101                                 Config.playlist_editor_display_mode = DisplayMode::Classic;
1102                                 myPlaylistEditor->Content.setItemDisplayer(std::bind(
1103                                         Display::Songs, ph::_1, std::cref(myPlaylistEditor->Content), std::cref(Config.song_list_format)
1104                                 ));
1105                                 break;
1106                 }
1107                 Statusbar::printf("Playlist editor display mode: %1%", Config.playlist_editor_display_mode);
1108         }
1109 }
1110
1111 bool ToggleSeparatorsBetweenAlbums::canBeRun()
1112 {
1113         return true;
1114 }
1115
1116 void ToggleSeparatorsBetweenAlbums::run()
1117 {
1118         Config.playlist_separate_albums = !Config.playlist_separate_albums;
1119         Statusbar::printf("Separators between albums: %1%",
1120                 Config.playlist_separate_albums ? "on" : "off"
1121         );
1122 }
1123
1124 bool ToggleLyricsUpdateOnSongChange::canBeRun()
1125 {
1126         return myScreen == myLyrics;
1127 }
1128
1129 void ToggleLyricsUpdateOnSongChange::run()
1130 {
1131         Config.now_playing_lyrics = !Config.now_playing_lyrics;
1132         Statusbar::printf("Update lyrics if song changes: %1%",
1133                 Config.now_playing_lyrics ? "on" : "off"
1134         );
1135 }
1136
1137 void ToggleLyricsFetcher::run()
1138 {
1139         myLyrics->toggleFetcher();
1140 }
1141
1142 void ToggleFetchingLyricsInBackground::run()
1143 {
1144         Config.fetch_lyrics_in_background = !Config.fetch_lyrics_in_background;
1145         Statusbar::printf("Fetching lyrics for playing songs in background: %1%",
1146                           Config.fetch_lyrics_in_background ? "on" : "off");
1147 }
1148
1149 void TogglePlayingSongCentering::run()
1150 {
1151         Config.autocenter_mode = !Config.autocenter_mode;
1152         Statusbar::printf("Centering playing song: %1%",
1153                 Config.autocenter_mode ? "on" : "off"
1154         );
1155         if (Config.autocenter_mode)
1156         {
1157                 auto s = myPlaylist->nowPlayingSong();
1158                 if (!s.empty())
1159                         myPlaylist->locateSong(s);
1160         }
1161 }
1162
1163 void UpdateDatabase::run()
1164 {
1165         if (myScreen == myBrowser)
1166                 Mpd.UpdateDirectory(myBrowser->currentDirectory());
1167 #       ifdef HAVE_TAGLIB_H
1168         else if (myScreen == myTagEditor)
1169                 Mpd.UpdateDirectory(myTagEditor->CurrentDir());
1170 #       endif // HAVE_TAGLIB_H
1171         else
1172                 Mpd.UpdateDirectory("/");
1173 }
1174
1175 bool JumpToPlayingSong::canBeRun()
1176 {
1177         return myScreen == myPlaylist
1178             || myScreen == myBrowser
1179             || myScreen == myLibrary;
1180 }
1181
1182 void JumpToPlayingSong::run()
1183 {
1184         auto s = myPlaylist->nowPlayingSong();
1185         if (s.empty())
1186                 return;
1187         if (myScreen == myPlaylist)
1188         {
1189                 myPlaylist->locateSong(s);
1190         }
1191         else if (myScreen == myBrowser)
1192         {
1193                 myBrowser->locateSong(s);
1194         }
1195         else if (myScreen == myLibrary)
1196         {
1197                 myLibrary->locateSong(s);
1198         }
1199 }
1200
1201 void ToggleRepeat::run()
1202 {
1203         Mpd.SetRepeat(!Status::State::repeat());
1204 }
1205
1206 bool Shuffle::canBeRun()
1207 {
1208         if (myScreen != myPlaylist)
1209                 return false;
1210         m_begin = myPlaylist->main().begin();
1211         m_end = myPlaylist->main().end();
1212         return findSelectedRangeAndPrintInfoIfNot(m_begin, m_end);
1213 }
1214
1215 void Shuffle::run()
1216 {
1217         if (Config.ask_before_shuffling_playlists)
1218                 confirmAction("Do you really want to shuffle selected range?");
1219         auto begin = myPlaylist->main().begin();
1220         Mpd.ShuffleRange(m_begin-begin, m_end-begin);
1221         Statusbar::print("Range shuffled");
1222 }
1223
1224 void ToggleRandom::run()
1225 {
1226         Mpd.SetRandom(!Status::State::random());
1227 }
1228
1229 bool StartSearching::canBeRun()
1230 {
1231         return myScreen == mySearcher && !mySearcher->main()[0].isInactive();
1232 }
1233
1234 void StartSearching::run()
1235 {
1236         mySearcher->main().highlight(SearchEngine::SearchButton);
1237         mySearcher->main().setHighlighting(0);
1238         mySearcher->main().refresh();
1239         mySearcher->main().setHighlighting(1);
1240         mySearcher->runAction();
1241 }
1242
1243 bool SaveTagChanges::canBeRun()
1244 {
1245 #       ifdef HAVE_TAGLIB_H
1246         return myScreen == myTinyTagEditor
1247             || myScreen->activeWindow() == myTagEditor->TagTypes;
1248 #       else
1249         return false;
1250 #       endif // HAVE_TAGLIB_H
1251 }
1252
1253 void SaveTagChanges::run()
1254 {
1255 #       ifdef HAVE_TAGLIB_H
1256         if (myScreen == myTinyTagEditor)
1257         {
1258                 myTinyTagEditor->main().highlight(myTinyTagEditor->main().size()-2); // Save
1259                 myTinyTagEditor->runAction();
1260         }
1261         else if (myScreen->activeWindow() == myTagEditor->TagTypes)
1262         {
1263                 myTagEditor->TagTypes->highlight(myTagEditor->TagTypes->size()-1); // Save
1264                 myTagEditor->runAction();
1265         }
1266 #       endif // HAVE_TAGLIB_H
1267 }
1268
1269 void ToggleSingle::run()
1270 {
1271         Mpd.SetSingle(!Status::State::single());
1272 }
1273
1274 void ToggleConsume::run()
1275 {
1276         Mpd.SetConsume(!Status::State::consume());
1277 }
1278
1279 void ToggleCrossfade::run()
1280 {
1281         Mpd.SetCrossfade(Status::State::crossfade() ? 0 : Config.crossfade_time);
1282 }
1283
1284 void SetCrossfade::run()
1285 {
1286         using Global::wFooter;
1287
1288         Statusbar::ScopedLock slock;
1289         Statusbar::put() << "Set crossfade to: ";
1290         auto crossfade = fromString<unsigned>(wFooter->prompt());
1291         lowerBoundCheck(crossfade, 0u);
1292         Config.crossfade_time = crossfade;
1293         Mpd.SetCrossfade(crossfade);
1294 }
1295
1296 void SetVolume::run()
1297 {
1298         using Global::wFooter;
1299
1300         unsigned volume;
1301         {
1302                 Statusbar::ScopedLock slock;
1303                 Statusbar::put() << "Set volume to: ";
1304                 volume = fromString<unsigned>(wFooter->prompt());
1305                 boundsCheck(volume, 0u, 100u);
1306                 Mpd.SetVolume(volume);
1307         }
1308         Statusbar::printf("Volume set to %1%%%", volume);
1309 }
1310
1311 bool EnterDirectory::canBeRun()
1312 {
1313         bool result = false;
1314         if (myScreen == myBrowser && !myBrowser->main().empty())
1315         {
1316                 result = myBrowser->main().current()->value().type()
1317                         == MPD::Item::Type::Directory;
1318         }
1319 #ifdef HAVE_TAGLIB_H
1320         else if (myScreen->activeWindow() == myTagEditor->Dirs)
1321                 result = true;
1322 #endif // HAVE_TAGLIB_H
1323         return result;
1324 }
1325
1326 void EnterDirectory::run()
1327 {
1328         if (myScreen == myBrowser)
1329                 myBrowser->enterDirectory();
1330 #ifdef HAVE_TAGLIB_H
1331         else if (myScreen->activeWindow() == myTagEditor->Dirs)
1332         {
1333                 if (!myTagEditor->enterDirectory())
1334                         Statusbar::print("No subdirectories found");
1335         }
1336 #endif // HAVE_TAGLIB_H
1337 }
1338
1339 bool EditSong::canBeRun()
1340 {
1341 #       ifdef HAVE_TAGLIB_H
1342         m_song = currentSong(myScreen);
1343         return m_song != nullptr && isMPDMusicDirSet();
1344 #       else
1345         return false;
1346 #       endif // HAVE_TAGLIB_H
1347 }
1348
1349 void EditSong::run()
1350 {
1351 #       ifdef HAVE_TAGLIB_H
1352         myTinyTagEditor->SetEdited(*m_song);
1353         myTinyTagEditor->switchTo();
1354 #       endif // HAVE_TAGLIB_H
1355 }
1356
1357 bool EditLibraryTag::canBeRun()
1358 {
1359 #       ifdef HAVE_TAGLIB_H
1360         return myScreen->isActiveWindow(myLibrary->Tags)
1361             && !myLibrary->Tags.empty()
1362             && isMPDMusicDirSet();
1363 #       else
1364         return false;
1365 #       endif // HAVE_TAGLIB_H
1366 }
1367
1368 void EditLibraryTag::run()
1369 {
1370 #       ifdef HAVE_TAGLIB_H
1371         using Global::wFooter;
1372
1373         std::string new_tag;
1374         {
1375                 Statusbar::ScopedLock slock;
1376                 Statusbar::put() << NC::Format::Bold << tagTypeToString(Config.media_lib_primary_tag) << NC::Format::NoBold << ": ";
1377                 new_tag = wFooter->prompt(myLibrary->Tags.current()->value().tag());
1378         }
1379         if (!new_tag.empty() && new_tag != myLibrary->Tags.current()->value().tag())
1380         {
1381                 Statusbar::print("Updating tags...");
1382                 Mpd.StartSearch(true);
1383                 Mpd.AddSearch(Config.media_lib_primary_tag, myLibrary->Tags.current()->value().tag());
1384                 MPD::MutableSong::SetFunction set = tagTypeToSetFunction(Config.media_lib_primary_tag);
1385                 assert(set);
1386                 bool success = true;
1387                 std::string dir_to_update;
1388                 for (MPD::SongIterator s = Mpd.CommitSearchSongs(), end; s != end; ++s)
1389                 {
1390                         MPD::MutableSong ms = std::move(*s);
1391                         ms.setTags(set, new_tag);
1392                         Statusbar::printf("Updating tags in \"%1%\"...", ms.getName());
1393                         std::string path = Config.mpd_music_dir + ms.getURI();
1394                         if (!Tags::write(ms))
1395                         {
1396                                 success = false;
1397                                 Statusbar::printf("Error while writing tags to \"%1%\": %2%",
1398                                                   ms.getName(), strerror(errno));
1399                                 s.finish();
1400                                 break;
1401                         }
1402                         if (dir_to_update.empty())
1403                                 dir_to_update = ms.getURI();
1404                         else
1405                                 dir_to_update = getSharedDirectory(dir_to_update, ms.getURI());
1406                 };
1407                 if (success)
1408                 {
1409                         Mpd.UpdateDirectory(dir_to_update);
1410                         Statusbar::print("Tags updated successfully");
1411                 }
1412         }
1413 #       endif // HAVE_TAGLIB_H
1414 }
1415
1416 bool EditLibraryAlbum::canBeRun()
1417 {
1418 #       ifdef HAVE_TAGLIB_H
1419         return myScreen->isActiveWindow(myLibrary->Albums)
1420             && !myLibrary->Albums.empty()
1421                 && isMPDMusicDirSet();
1422 #       else
1423         return false;
1424 #       endif // HAVE_TAGLIB_H
1425 }
1426
1427 void EditLibraryAlbum::run()
1428 {
1429 #       ifdef HAVE_TAGLIB_H
1430         using Global::wFooter;
1431         // FIXME: merge this and EditLibraryTag. also, prompt on failure if user wants to continue
1432         std::string new_album;
1433         {
1434                 Statusbar::ScopedLock slock;
1435                 Statusbar::put() << NC::Format::Bold << "Album: " << NC::Format::NoBold;
1436                 new_album = wFooter->prompt(myLibrary->Albums.current()->value().entry().album());
1437         }
1438         if (!new_album.empty() && new_album != myLibrary->Albums.current()->value().entry().album())
1439         {
1440                 bool success = 1;
1441                 Statusbar::print("Updating tags...");
1442                 for (size_t i = 0;  i < myLibrary->Songs.size(); ++i)
1443                 {
1444                         Statusbar::printf("Updating tags in \"%1%\"...", myLibrary->Songs[i].value().getName());
1445                         std::string path = Config.mpd_music_dir + myLibrary->Songs[i].value().getURI();
1446                         TagLib::FileRef f(path.c_str());
1447                         if (f.isNull())
1448                         {
1449                                 const char msg[] = "Error while opening file \"%1%\"";
1450                                 Statusbar::printf(msg, wideShorten(myLibrary->Songs[i].value().getURI(), COLS-const_strlen(msg)));
1451                                 success = 0;
1452                                 break;
1453                         }
1454                         f.tag()->setAlbum(ToWString(new_album));
1455                         if (!f.save())
1456                         {
1457                                 const char msg[] = "Error while writing tags in \"%1%\"";
1458                                 Statusbar::printf(msg, wideShorten(myLibrary->Songs[i].value().getURI(), COLS-const_strlen(msg)));
1459                                 success = 0;
1460                                 break;
1461                         }
1462                 }
1463                 if (success)
1464                 {
1465                         Mpd.UpdateDirectory(getSharedDirectory(myLibrary->Songs.beginV(), myLibrary->Songs.endV()));
1466                         Statusbar::print("Tags updated successfully");
1467                 }
1468         }
1469 #       endif // HAVE_TAGLIB_H
1470 }
1471
1472 bool EditDirectoryName::canBeRun()
1473 {
1474         return  ((myScreen == myBrowser
1475               && !myBrowser->main().empty()
1476               && myBrowser->main().current()->value().type() == MPD::Item::Type::Directory)
1477 #       ifdef HAVE_TAGLIB_H
1478             ||   (myScreen->activeWindow() == myTagEditor->Dirs
1479               && !myTagEditor->Dirs->empty()
1480               && myTagEditor->Dirs->choice() > 0)
1481 #       endif // HAVE_TAGLIB_H
1482         ) &&     isMPDMusicDirSet();
1483 }
1484
1485 void EditDirectoryName::run()
1486 {
1487         using Global::wFooter;
1488         if (myScreen == myBrowser)
1489         {
1490                 std::string old_dir = myBrowser->main().current()->value().directory().path();
1491                 std::string new_dir;
1492                 {
1493                         Statusbar::ScopedLock slock;
1494                         Statusbar::put() << NC::Format::Bold << "Directory: " << NC::Format::NoBold;
1495                         new_dir = wFooter->prompt(old_dir);
1496                 }
1497                 if (!new_dir.empty() && new_dir != old_dir)
1498                 {
1499                         std::string full_old_dir;
1500                         if (!myBrowser->isLocal())
1501                                 full_old_dir += Config.mpd_music_dir;
1502                         full_old_dir += old_dir;
1503                         std::string full_new_dir;
1504                         if (!myBrowser->isLocal())
1505                                 full_new_dir += Config.mpd_music_dir;
1506                         full_new_dir += new_dir;
1507                         boost::filesystem::rename(full_old_dir, full_new_dir);
1508                         const char msg[] = "Directory renamed to \"%1%\"";
1509                         Statusbar::printf(msg, wideShorten(new_dir, COLS-const_strlen(msg)));
1510                         if (!myBrowser->isLocal())
1511                                 Mpd.UpdateDirectory(getSharedDirectory(old_dir, new_dir));
1512                         myBrowser->requestUpdate();
1513                 }
1514         }
1515 #       ifdef HAVE_TAGLIB_H
1516         else if (myScreen->activeWindow() == myTagEditor->Dirs)
1517         {
1518                 std::string old_dir = myTagEditor->Dirs->current()->value().first, new_dir;
1519                 {
1520                         Statusbar::ScopedLock slock;
1521                         Statusbar::put() << NC::Format::Bold << "Directory: " << NC::Format::NoBold;
1522                         new_dir = wFooter->prompt(old_dir);
1523                 }
1524                 if (!new_dir.empty() && new_dir != old_dir)
1525                 {
1526                         std::string full_old_dir = Config.mpd_music_dir + myTagEditor->CurrentDir() + "/" + old_dir;
1527                         std::string full_new_dir = Config.mpd_music_dir + myTagEditor->CurrentDir() + "/" + new_dir;
1528                         if (rename(full_old_dir.c_str(), full_new_dir.c_str()) == 0)
1529                         {
1530                                 const char msg[] = "Directory renamed to \"%1%\"";
1531                                 Statusbar::printf(msg, wideShorten(new_dir, COLS-const_strlen(msg)));
1532                                 Mpd.UpdateDirectory(myTagEditor->CurrentDir());
1533                         }
1534                         else
1535                         {
1536                                 const char msg[] = "Couldn't rename \"%1%\": %2%";
1537                                 Statusbar::printf(msg, wideShorten(old_dir, COLS-const_strlen(msg)-25), strerror(errno));
1538                         }
1539                 }
1540         }
1541 #       endif // HAVE_TAGLIB_H
1542 }
1543
1544 bool EditPlaylistName::canBeRun()
1545 {
1546         return   (myScreen->isActiveWindow(myPlaylistEditor->Playlists)
1547               && !myPlaylistEditor->Playlists.empty())
1548             ||   (myScreen == myBrowser
1549               && !myBrowser->main().empty()
1550                   && myBrowser->main().current()->value().type() == MPD::Item::Type::Playlist);
1551 }
1552
1553 void EditPlaylistName::run()
1554 {
1555         using Global::wFooter;
1556         std::string old_name, new_name;
1557         if (myScreen->isActiveWindow(myPlaylistEditor->Playlists))
1558                 old_name = myPlaylistEditor->Playlists.current()->value().path();
1559         else
1560                 old_name = myBrowser->main().current()->value().playlist().path();
1561         {
1562                 Statusbar::ScopedLock slock;
1563                 Statusbar::put() << NC::Format::Bold << "Playlist: " << NC::Format::NoBold;
1564                 new_name = wFooter->prompt(old_name);
1565         }
1566         if (!new_name.empty() && new_name != old_name)
1567         {
1568                 Mpd.Rename(old_name, new_name);
1569                 const char msg[] = "Playlist renamed to \"%1%\"";
1570                 Statusbar::printf(msg, wideShorten(new_name, COLS-const_strlen(msg)));
1571         }
1572 }
1573
1574 bool EditLyrics::canBeRun()
1575 {
1576         return myScreen == myLyrics;
1577 }
1578
1579 void EditLyrics::run()
1580 {
1581         myLyrics->edit();
1582 }
1583
1584 bool JumpToBrowser::canBeRun()
1585 {
1586         m_song = currentSong(myScreen);
1587         return m_song != nullptr;
1588 }
1589
1590 void JumpToBrowser::run()
1591 {
1592         myBrowser->locateSong(*m_song);
1593 }
1594
1595 bool JumpToMediaLibrary::canBeRun()
1596 {
1597         m_song = currentSong(myScreen);
1598         return m_song != nullptr;
1599 }
1600
1601 void JumpToMediaLibrary::run()
1602 {
1603         myLibrary->locateSong(*m_song);
1604 }
1605
1606 bool JumpToPlaylistEditor::canBeRun()
1607 {
1608         return myScreen == myBrowser
1609             && myBrowser->main().current()->value().type() == MPD::Item::Type::Playlist;
1610 }
1611
1612 void JumpToPlaylistEditor::run()
1613 {
1614         myPlaylistEditor->locatePlaylist(myBrowser->main().current()->value().playlist());
1615 }
1616
1617 void ToggleScreenLock::run()
1618 {
1619         using Global::wFooter;
1620         using Global::myLockedScreen;
1621         const char *msg_unlockable_screen = "Current screen can't be locked";
1622         if (myLockedScreen != nullptr)
1623         {
1624                 BaseScreen::unlock();
1625                 Actions::setResizeFlags();
1626                 myScreen->resize();
1627                 Statusbar::print("Screen unlocked");
1628         }
1629         else if (!myScreen->isLockable())
1630         {
1631                 Statusbar::print(msg_unlockable_screen);
1632         }
1633         else
1634         {
1635                 unsigned part = Config.locked_screen_width_part*100;
1636                 if (Config.ask_for_locked_screen_width_part)
1637                 {
1638                         Statusbar::ScopedLock slock;
1639                         Statusbar::put() << "% of the locked screen's width to be reserved (20-80): ";
1640                         part = fromString<unsigned>(wFooter->prompt(boost::lexical_cast<std::string>(part)));
1641                 }
1642                 boundsCheck(part, 20u, 80u);
1643                 Config.locked_screen_width_part = part/100.0;
1644                 if (myScreen->lock())
1645                         Statusbar::printf("Screen locked (with %1%%% width)", part);
1646                 else
1647                         Statusbar::print(msg_unlockable_screen);
1648         }
1649 }
1650
1651 bool JumpToTagEditor::canBeRun()
1652 {
1653 #       ifdef HAVE_TAGLIB_H
1654         m_song = currentSong(myScreen);
1655         return m_song != nullptr && isMPDMusicDirSet();
1656 #       else
1657         return false;
1658 #       endif // HAVE_TAGLIB_H
1659 }
1660
1661 void JumpToTagEditor::run()
1662 {
1663 #       ifdef HAVE_TAGLIB_H
1664         myTagEditor->LocateSong(*m_song);
1665 #       endif // HAVE_TAGLIB_H
1666 }
1667
1668 bool JumpToPositionInSong::canBeRun()
1669 {
1670         return Status::State::player() != MPD::psStop && Status::State::totalTime() > 0;
1671 }
1672
1673 void JumpToPositionInSong::run()
1674 {
1675         using Global::wFooter;
1676
1677         const MPD::Song s = myPlaylist->nowPlayingSong();
1678
1679         std::string spos;
1680         {
1681                 Statusbar::ScopedLock slock;
1682                 Statusbar::put() << "Position to go (in %/m:ss/seconds(s)): ";
1683                 spos = wFooter->prompt();
1684         }
1685
1686         boost::regex rx;
1687         boost::smatch what;
1688         if (boost::regex_match(spos, what, rx.assign("([0-9]+):([0-9]{2})"))) // mm:ss
1689         {
1690                 auto mins = fromString<unsigned>(what[1]);
1691                 auto secs = fromString<unsigned>(what[2]);
1692                 boundsCheck(secs, 0u, 60u);
1693                 Mpd.Seek(s.getPosition(), mins * 60 + secs);
1694         }
1695         else if (boost::regex_match(spos, what, rx.assign("([0-9]+)s"))) // position in seconds
1696         {
1697                 auto secs = fromString<unsigned>(what[1]);
1698                 Mpd.Seek(s.getPosition(), secs);
1699         }
1700         else if (boost::regex_match(spos, what, rx.assign("([0-9]+)[%]{0,1}"))) // position in %
1701         {
1702                 auto percent = fromString<unsigned>(what[1]);
1703                 boundsCheck(percent, 0u, 100u);
1704                 int secs = (percent * s.getDuration()) / 100.0;
1705                 Mpd.Seek(s.getPosition(), secs);
1706         }
1707         else
1708                 Statusbar::print("Invalid format ([m]:[ss], [s]s, [%]%, [%] accepted)");
1709 }
1710
1711 bool SelectItem::canBeRun()
1712 {
1713         m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1714         return m_list != nullptr
1715             && !m_list->empty()
1716             && m_list->currentP()->isSelectable();
1717 }
1718
1719 void SelectItem::run()
1720 {
1721         auto current = m_list->currentP();
1722         current->setSelected(!current->isSelected());
1723 }
1724
1725 bool SelectRange::canBeRun()
1726 {
1727         m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1728         if (m_list == nullptr)
1729                 return false;
1730         m_begin = m_list->beginP();
1731         m_end = m_list->endP();
1732         return findRange(m_begin, m_end);
1733 }
1734
1735 void SelectRange::run()
1736 {
1737         for (; m_begin != m_end; ++m_begin)
1738                 m_begin->setSelected(true);
1739         Statusbar::print("Range selected");
1740 }
1741
1742 bool ReverseSelection::canBeRun()
1743 {
1744         m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1745         return m_list != nullptr;
1746 }
1747
1748 void ReverseSelection::run()
1749 {
1750         for (auto &p : *m_list)
1751                 p.setSelected(!p.isSelected());
1752         Statusbar::print("Selection reversed");
1753 }
1754
1755 bool RemoveSelection::canBeRun()
1756 {
1757         m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1758         return m_list != nullptr;
1759 }
1760
1761 void RemoveSelection::run()
1762 {
1763         for (auto &p : *m_list)
1764                 p.setSelected(false);
1765         Statusbar::print("Selection removed");
1766 }
1767
1768 bool SelectAlbum::canBeRun()
1769 {
1770         auto *w = myScreen->activeWindow();
1771         if (m_list != static_cast<void *>(w))
1772                 m_list = dynamic_cast<NC::List *>(w);
1773         if (m_songs != static_cast<void *>(w))
1774                 m_songs = dynamic_cast<SongList *>(w);
1775         return m_list != nullptr && !m_list->empty()
1776             && m_songs != nullptr;
1777 }
1778
1779 void SelectAlbum::run()
1780 {
1781         const auto front = m_songs->beginS(), current = m_songs->currentS(), end = m_songs->endS();
1782         auto *s = current->get<Bit::Song>();
1783         if (s == nullptr)
1784                 return;
1785         auto get = &MPD::Song::getAlbum;
1786         const std::string tag = s->getTags(get);
1787         // go up
1788         for (auto it = current; it != front;)
1789         {
1790                 --it;
1791                 s = it->get<Bit::Song>();
1792                 if (s == nullptr || s->getTags(get) != tag)
1793                         break;
1794                 it->get<Bit::Properties>().setSelected(true);
1795         }
1796         // go down
1797         for (auto it = current;;)
1798         {
1799                 it->get<Bit::Properties>().setSelected(true);
1800                 if (++it == end)
1801                         break;
1802                 s = it->get<Bit::Song>();
1803                 if (s == nullptr || s->getTags(get) != tag)
1804                         break;
1805         }
1806         Statusbar::print("Album around cursor position selected");
1807 }
1808
1809 bool SelectFoundItems::canBeRun()
1810 {
1811         m_list = dynamic_cast<NC::List *>(myScreen->activeWindow());
1812         if (m_list == nullptr || m_list->empty())
1813                 return false;
1814         m_searchable = dynamic_cast<Searchable *>(myScreen);
1815         return m_searchable != nullptr && m_searchable->allowsSearching();
1816 }
1817
1818 void SelectFoundItems::run()
1819 {
1820         auto current_pos = m_list->choice();
1821         myScreen->activeWindow()->scroll(NC::Scroll::Home);
1822         bool found = m_searchable->search(SearchDirection::Forward, false, false);
1823         if (found)
1824         {
1825                 Statusbar::print("Searching for items...");
1826                 m_list->currentP()->setSelected(true);
1827                 while (m_searchable->search(SearchDirection::Forward, false, true))
1828                         m_list->currentP()->setSelected(true);
1829                 Statusbar::print("Found items selected");
1830         }
1831         m_list->highlight(current_pos);
1832 }
1833
1834 bool AddSelectedItems::canBeRun()
1835 {
1836         return myScreen != mySelectedItemsAdder;
1837 }
1838
1839 void AddSelectedItems::run()
1840 {
1841         mySelectedItemsAdder->switchTo();
1842 }
1843
1844 void CropMainPlaylist::run()
1845 {
1846         auto &w = myPlaylist->main();
1847         // cropping doesn't make sense in this case
1848         if (w.size() <= 1)
1849                 return;
1850         if (Config.ask_before_clearing_playlists)
1851                 confirmAction("Do you really want to crop main playlist?");
1852         Statusbar::print("Cropping playlist...");
1853         selectCurrentIfNoneSelected(w);
1854         cropPlaylist(w, std::bind(&MPD::Connection::Delete, ph::_1, ph::_2));
1855         Statusbar::print("Playlist cropped");
1856 }
1857
1858 bool CropPlaylist::canBeRun()
1859 {
1860         return myScreen == myPlaylistEditor;
1861 }
1862
1863 void CropPlaylist::run()
1864 {
1865         auto &w = myPlaylistEditor->Content;
1866         // cropping doesn't make sense in this case
1867         if (w.size() <= 1)
1868                 return;
1869         assert(!myPlaylistEditor->Playlists.empty());
1870         std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
1871         if (Config.ask_before_clearing_playlists)
1872                 confirmAction(boost::format("Do you really want to crop playlist \"%1%\"?") % playlist);
1873         selectCurrentIfNoneSelected(w);
1874         Statusbar::printf("Cropping playlist \"%1%\"...", playlist);
1875         cropPlaylist(w, std::bind(&MPD::Connection::PlaylistDelete, ph::_1, playlist, ph::_2));
1876         Statusbar::printf("Playlist \"%1%\" cropped", playlist);
1877 }
1878
1879 void ClearMainPlaylist::run()
1880 {
1881         if (!myPlaylist->main().empty() && Config.ask_before_clearing_playlists)
1882                 confirmAction("Do you really want to clear main playlist?");
1883         Mpd.ClearMainPlaylist();
1884         Statusbar::print("Playlist cleared");
1885         myPlaylist->main().reset();
1886 }
1887
1888 bool ClearPlaylist::canBeRun()
1889 {
1890         return myScreen == myPlaylistEditor;
1891 }
1892
1893 void ClearPlaylist::run()
1894 {
1895         if (myPlaylistEditor->Playlists.empty())
1896                 return;
1897         std::string playlist = myPlaylistEditor->Playlists.current()->value().path();
1898         if (Config.ask_before_clearing_playlists)
1899                 confirmAction(boost::format("Do you really want to clear playlist \"%1%\"?") % playlist);
1900         Mpd.ClearPlaylist(playlist);
1901         Statusbar::printf("Playlist \"%1%\" cleared", playlist);
1902 }
1903
1904 bool SortPlaylist::canBeRun()
1905 {
1906         if (myScreen != myPlaylist)
1907                 return false;
1908         auto first = myPlaylist->main().begin(), last = myPlaylist->main().end();
1909         return findSelectedRangeAndPrintInfoIfNot(first, last);
1910 }
1911
1912 void SortPlaylist::run()
1913 {
1914         mySortPlaylistDialog->switchTo();
1915 }
1916
1917 bool ReversePlaylist::canBeRun()
1918 {
1919         if (myScreen != myPlaylist)
1920                 return false;
1921         m_begin = myPlaylist->main().begin();
1922         m_end = myPlaylist->main().end();
1923         return findSelectedRangeAndPrintInfoIfNot(m_begin, m_end);
1924 }
1925
1926 void ReversePlaylist::run()
1927 {
1928         Statusbar::print("Reversing range...");
1929         Mpd.StartCommandsList();
1930         for (--m_end; m_begin < m_end; ++m_begin, --m_end)
1931                 Mpd.Swap(m_begin->value().getPosition(), m_end->value().getPosition());
1932         Mpd.CommitCommandsList();
1933         Statusbar::print("Range reversed");
1934 }
1935
1936 bool ApplyFilter::canBeRun()
1937 {
1938         m_filterable = dynamic_cast<Filterable *>(myScreen);
1939         return m_filterable != nullptr
1940                 && m_filterable->allowsFiltering();
1941 }
1942
1943 void ApplyFilter::run()
1944 {
1945         using Global::wFooter;
1946
1947         std::string filter = m_filterable->currentFilter();
1948         if (!filter.empty())
1949         {
1950                 m_filterable->applyFilter(filter);
1951                 myScreen->refreshWindow();
1952         }
1953
1954         try
1955         {
1956                 Statusbar::ScopedLock slock;
1957                 NC::Window::ScopedPromptHook helper(
1958                         *wFooter,
1959                         Statusbar::Helpers::ApplyFilterImmediately(m_filterable));
1960                 Statusbar::put() << "Apply filter: ";
1961                 filter = wFooter->prompt(filter);
1962         }
1963         catch (NC::PromptAborted &)
1964         {
1965                 m_filterable->applyFilter(filter);
1966                 throw;
1967         }
1968
1969         if (filter.empty())
1970                 Statusbar::printf("Filtering disabled");
1971         else
1972                 Statusbar::printf("Using filter \"%1%\"", filter);
1973
1974         if (myScreen == myPlaylist)
1975                 myPlaylist->reloadTotalLength();
1976
1977         listsChangeFinisher();
1978 }
1979
1980 bool Find::canBeRun()
1981 {
1982         return myScreen == myHelp
1983                 || myScreen == myLyrics
1984                 || myScreen == myLastfm;
1985 }
1986
1987 void Find::run()
1988 {
1989         using Global::wFooter;
1990
1991         std::string token;
1992         {
1993                 Statusbar::ScopedLock slock;
1994                 Statusbar::put() << "Find: ";
1995                 token = wFooter->prompt();
1996         }
1997
1998         Statusbar::print("Searching...");
1999         auto s = static_cast<Screen<NC::Scrollpad> *>(myScreen);
2000         s->main().removeProperties();
2001         if (token.empty() || s->main().setProperties(NC::Format::Reverse, token, NC::Format::NoReverse, Config.regex_type))
2002                 Statusbar::print("Done");
2003         else
2004                 Statusbar::print("No matching patterns found");
2005         s->main().flush();
2006 }
2007
2008 bool FindItemBackward::canBeRun()
2009 {
2010         auto w = dynamic_cast<Searchable *>(myScreen);
2011         return w && w->allowsSearching();
2012 }
2013
2014 void FindItemForward::run()
2015 {
2016         findItem(SearchDirection::Forward);
2017         listsChangeFinisher();
2018 }
2019
2020 bool FindItemForward::canBeRun()
2021 {
2022         auto w = dynamic_cast<Searchable *>(myScreen);
2023         return w && w->allowsSearching();
2024 }
2025
2026 void FindItemBackward::run()
2027 {
2028         findItem(SearchDirection::Backward);
2029         listsChangeFinisher();
2030 }
2031
2032 bool NextFoundItem::canBeRun()
2033 {
2034         return dynamic_cast<Searchable *>(myScreen);
2035 }
2036
2037 void NextFoundItem::run()
2038 {
2039         Searchable *w = dynamic_cast<Searchable *>(myScreen);
2040         assert(w != nullptr);
2041         w->search(SearchDirection::Forward, Config.wrapped_search, true);
2042         listsChangeFinisher();
2043 }
2044
2045 bool PreviousFoundItem::canBeRun()
2046 {
2047         return dynamic_cast<Searchable *>(myScreen);
2048 }
2049
2050 void PreviousFoundItem::run()
2051 {
2052         Searchable *w = dynamic_cast<Searchable *>(myScreen);
2053         assert(w != nullptr);
2054         w->search(SearchDirection::Backward, Config.wrapped_search, true);
2055         listsChangeFinisher();
2056 }
2057
2058 void ToggleFindMode::run()
2059 {
2060         Config.wrapped_search = !Config.wrapped_search;
2061         Statusbar::printf("Search mode: %1%",
2062                 Config.wrapped_search ? "Wrapped" : "Normal"
2063         );
2064 }
2065
2066 void ToggleReplayGainMode::run()
2067 {
2068         using Global::wFooter;
2069
2070         char rgm = 0;
2071         {
2072                 Statusbar::ScopedLock slock;
2073                 Statusbar::put() << "Replay gain mode? "
2074                 << "[" << NC::Format::Bold << 'o' << NC::Format::NoBold << "ff"
2075                 << "/" << NC::Format::Bold << 't' << NC::Format::NoBold << "rack"
2076                 << "/" << NC::Format::Bold << 'a' << NC::Format::NoBold << "lbum"
2077                 << "] ";
2078                 rgm = Statusbar::Helpers::promptReturnOneOf({"t", "a", "o"})[0];
2079         }
2080         switch (rgm)
2081         {
2082                 case 't':
2083                         Mpd.SetReplayGainMode(MPD::rgmTrack);
2084                         break;
2085                 case 'a':
2086                         Mpd.SetReplayGainMode(MPD::rgmAlbum);
2087                         break;
2088                 case 'o':
2089                         Mpd.SetReplayGainMode(MPD::rgmOff);
2090                         break;
2091                 default: // impossible
2092                         throw std::runtime_error(
2093                                 (boost::format("ToggleReplayGainMode: impossible case reached: %1%") % rgm).str()
2094                         );
2095         }
2096         Statusbar::printf("Replay gain mode: %1%", Mpd.GetReplayGainMode());
2097 }
2098
2099 void ToggleAddMode::run()
2100 {
2101         std::string mode_desc;
2102         switch (Config.space_add_mode)
2103         {
2104                 case SpaceAddMode::AddRemove:
2105                         Config.space_add_mode = SpaceAddMode::AlwaysAdd;
2106                         mode_desc = "always add an item to playlist";
2107                         break;
2108                 case SpaceAddMode::AlwaysAdd:
2109                         Config.space_add_mode = SpaceAddMode::AddRemove;
2110                         mode_desc = "add an item to playlist or remove if already added";
2111                         break;
2112         }
2113         Statusbar::printf("Add mode: %1%", mode_desc);
2114 }
2115
2116 void ToggleMouse::run()
2117 {
2118         Config.mouse_support = !Config.mouse_support;
2119         if (Config.mouse_support)
2120                 NC::Mouse::enable();
2121         else
2122                 NC::Mouse::disable();
2123         Statusbar::printf("Mouse support %1%",
2124                 Config.mouse_support ? "enabled" : "disabled"
2125         );
2126 }
2127
2128 void ToggleBitrateVisibility::run()
2129 {
2130         Config.display_bitrate = !Config.display_bitrate;
2131         Statusbar::printf("Bitrate visibility %1%",
2132                 Config.display_bitrate ? "enabled" : "disabled"
2133         );
2134 }
2135
2136 void AddRandomItems::run()
2137 {
2138         using Global::wFooter;
2139         char rnd_type = 0;
2140         {
2141                 Statusbar::ScopedLock slock;
2142                 Statusbar::put() << "Add random? "
2143                 << "[" << NC::Format::Bold << 's' << NC::Format::NoBold << "ongs"
2144                 << "/" << NC::Format::Bold << 'a' << NC::Format::NoBold << "rtists"
2145                 << "/" << "album" << NC::Format::Bold << 'A' << NC::Format::NoBold << "rtists"
2146                 << "/" << "al" << NC::Format::Bold << 'b' << NC::Format::NoBold << "ums"
2147                 << "] ";
2148                 rnd_type = Statusbar::Helpers::promptReturnOneOf({"s", "a", "A", "b"})[0];
2149         }
2150
2151         mpd_tag_type tag_type = MPD_TAG_ARTIST;
2152         std::string tag_type_str ;
2153         if (rnd_type != 's')
2154         {
2155                 tag_type = charToTagType(rnd_type);
2156                 tag_type_str = boost::locale::to_lower(tagTypeToString(tag_type));
2157         }
2158         else
2159                 tag_type_str = "song";
2160
2161         unsigned number;
2162         {
2163                 Statusbar::ScopedLock slock;
2164                 Statusbar::put() << "Number of random " << tag_type_str << "s: ";
2165                 number = fromString<unsigned>(wFooter->prompt());
2166         }
2167         if (number > 0)
2168         {
2169                 bool success;
2170                 if (rnd_type == 's')
2171                         success = Mpd.AddRandomSongs(number, Global::RNG);
2172                 else
2173                         success = Mpd.AddRandomTag(tag_type, number, Global::RNG);
2174                 if (success)
2175                         Statusbar::printf("%1% random %2%%3% added to playlist", number, tag_type_str, number == 1 ? "" : "s");
2176         }
2177 }
2178
2179 bool ToggleBrowserSortMode::canBeRun()
2180 {
2181         return myScreen == myBrowser;
2182 }
2183
2184 void ToggleBrowserSortMode::run()
2185 {
2186         switch (Config.browser_sort_mode)
2187         {
2188                 case SortMode::Name:
2189                         Config.browser_sort_mode = SortMode::ModificationTime;
2190                         Statusbar::print("Sort songs by: modification time");
2191                         break;
2192                 case SortMode::ModificationTime:
2193                         Config.browser_sort_mode = SortMode::CustomFormat;
2194                         Statusbar::print("Sort songs by: custom format");
2195                         break;
2196                 case SortMode::CustomFormat:
2197                         Config.browser_sort_mode = SortMode::NoOp;
2198                         Statusbar::print("Do not sort songs");
2199                         break;
2200                 case SortMode::NoOp:
2201                         Config.browser_sort_mode = SortMode::Name;
2202                         Statusbar::print("Sort songs by: name");
2203         }
2204         if (Config.browser_sort_mode != SortMode::NoOp)
2205         {
2206                 size_t sort_offset = myBrowser->inRootDirectory() ? 0 : 1;
2207                 std::sort(myBrowser->main().begin()+sort_offset, myBrowser->main().end(),
2208                         LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode)
2209                 );
2210         }
2211 }
2212
2213 bool ToggleLibraryTagType::canBeRun()
2214 {
2215         return (myScreen->isActiveWindow(myLibrary->Tags))
2216             || (myLibrary->columns() == 2 && myScreen->isActiveWindow(myLibrary->Albums));
2217 }
2218
2219 void ToggleLibraryTagType::run()
2220 {
2221         using Global::wFooter;
2222
2223         char tag_type = 0;
2224         {
2225                 Statusbar::ScopedLock slock;
2226                 Statusbar::put() << "Tag type? "
2227                 << "[" << NC::Format::Bold << 'a' << NC::Format::NoBold << "rtist"
2228                 << "/" << "album" << NC::Format::Bold << 'A' << NC::Format::NoBold << "rtist"
2229                 << "/" << NC::Format::Bold << 'y' << NC::Format::NoBold << "ear"
2230                 << "/" << NC::Format::Bold << 'g' << NC::Format::NoBold << "enre"
2231                 << "/" << NC::Format::Bold << 'c' << NC::Format::NoBold << "omposer"
2232                 << "/" << NC::Format::Bold << 'p' << NC::Format::NoBold << "erformer"
2233                 << "] ";
2234                 tag_type = Statusbar::Helpers::promptReturnOneOf({"a", "A", "y", "g", "c", "p"})[0];
2235         }
2236         mpd_tag_type new_tagitem = charToTagType(tag_type);
2237         if (new_tagitem != Config.media_lib_primary_tag)
2238         {
2239                 Config.media_lib_primary_tag = new_tagitem;
2240                 std::string item_type = tagTypeToString(Config.media_lib_primary_tag);
2241                 myLibrary->Tags.setTitle(Config.titles_visibility ? item_type + "s" : "");
2242                 myLibrary->Tags.reset();
2243                 item_type = boost::locale::to_lower(item_type);
2244                 std::string and_mtime = Config.media_library_sort_by_mtime ?
2245                                         " and mtime" :
2246                                         "";
2247                 if (myLibrary->columns() == 2)
2248                 {
2249                         myLibrary->Songs.clear();
2250                         myLibrary->Albums.reset();
2251                         myLibrary->Albums.clear();
2252                         myLibrary->Albums.setTitle(Config.titles_visibility ? "Albums (sorted by " + item_type + and_mtime + ")" : "");
2253                         myLibrary->Albums.display();
2254                 }
2255                 else
2256                 {
2257                         myLibrary->Tags.clear();
2258                         myLibrary->Tags.display();
2259                 }
2260                 Statusbar::printf("Switched to the list of %1%s", item_type);
2261         }
2262 }
2263
2264 bool ToggleMediaLibrarySortMode::canBeRun()
2265 {
2266         return myScreen == myLibrary;
2267 }
2268
2269 void ToggleMediaLibrarySortMode::run()
2270 {
2271         myLibrary->toggleSortMode();
2272 }
2273
2274 bool FetchLyricsInBackground::canBeRun()
2275 {
2276         m_hs = dynamic_cast<HasSongs *>(myScreen);
2277         return m_hs != nullptr && m_hs->itemAvailable();
2278 }
2279
2280 void FetchLyricsInBackground::run()
2281 {
2282         auto songs = m_hs->getSelectedSongs();
2283         for (const auto &s : songs)
2284                 myLyrics->fetchInBackground(s, true);
2285         Statusbar::print("Selected songs queued for lyrics fetching");
2286 }
2287
2288 bool RefetchLyrics::canBeRun()
2289 {
2290         return myScreen == myLyrics;
2291 }
2292
2293 void RefetchLyrics::run()
2294 {
2295         myLyrics->refetchCurrent();
2296 }
2297
2298 bool SetSelectedItemsPriority::canBeRun()
2299 {
2300         if (Mpd.Version() < 17)
2301         {
2302                 Statusbar::print("Priorities are supported in MPD >= 0.17.0");
2303                 return false;
2304         }
2305         return myScreen == myPlaylist && !myPlaylist->main().empty();
2306 }
2307
2308 void SetSelectedItemsPriority::run()
2309 {
2310         using Global::wFooter;
2311
2312         unsigned prio;
2313         {
2314                 Statusbar::ScopedLock slock;
2315                 Statusbar::put() << "Set priority [0-255]: ";
2316                 prio = fromString<unsigned>(wFooter->prompt());
2317                 boundsCheck(prio, 0u, 255u);
2318         }
2319         myPlaylist->setSelectedItemsPriority(prio);
2320 }
2321
2322 bool ToggleOutput::canBeRun()
2323 {
2324 #ifdef ENABLE_OUTPUTS
2325         return myScreen == myOutputs;
2326 #else
2327         return false;
2328 #endif // ENABLE_OUTPUTS
2329 }
2330
2331 void ToggleOutput::run()
2332 {
2333 #ifdef ENABLE_OUTPUTS
2334         myOutputs->toggleOutput();
2335 #endif // ENABLE_OUTPUTS
2336 }
2337
2338 bool ToggleVisualizationType::canBeRun()
2339 {
2340 #       ifdef ENABLE_VISUALIZER
2341         return myScreen == myVisualizer;
2342 #       else
2343         return false;
2344 #       endif // ENABLE_VISUALIZER
2345 }
2346
2347 void ToggleVisualizationType::run()
2348 {
2349 #       ifdef ENABLE_VISUALIZER
2350         myVisualizer->ToggleVisualizationType();
2351 #       endif // ENABLE_VISUALIZER
2352 }
2353
2354 bool SetVisualizerSampleMultiplier::canBeRun()
2355 {
2356 #       ifdef ENABLE_VISUALIZER
2357         return myScreen == myVisualizer;
2358 #       else
2359         return false;
2360 #       endif // ENABLE_VISUALIZER
2361 }
2362
2363 void SetVisualizerSampleMultiplier::run()
2364 {
2365 #       ifdef ENABLE_VISUALIZER
2366         using Global::wFooter;
2367
2368         double multiplier;
2369         {
2370                 Statusbar::ScopedLock slock;
2371                 Statusbar::put() << "Set visualizer sample multiplier: ";
2372                 multiplier = fromString<double>(wFooter->prompt());
2373                 lowerBoundCheck(multiplier, 0.0);
2374                 Config.visualizer_sample_multiplier = multiplier;
2375         }
2376         Statusbar::printf("Visualizer sample multiplier set to %1%", multiplier);
2377 #       endif // ENABLE_VISUALIZER
2378 }
2379
2380 void ShowSongInfo::run()
2381 {
2382         mySongInfo->switchTo();
2383 }
2384
2385 bool ShowArtistInfo::canBeRun()
2386 {
2387         return myScreen == myLastfm
2388                 || (myScreen->isActiveWindow(myLibrary->Tags)
2389                     && !myLibrary->Tags.empty()
2390                     && Config.media_lib_primary_tag == MPD_TAG_ARTIST)
2391                 || currentSong(myScreen);
2392 }
2393
2394 void ShowArtistInfo::run()
2395 {
2396         if (myScreen == myLastfm)
2397         {
2398                 myLastfm->switchTo();
2399                 return;
2400         }
2401
2402         std::string artist;
2403         if (myScreen->isActiveWindow(myLibrary->Tags))
2404         {
2405                 assert(!myLibrary->Tags.empty());
2406                 assert(Config.media_lib_primary_tag == MPD_TAG_ARTIST);
2407                 artist = myLibrary->Tags.current()->value().tag();
2408         }
2409         else
2410         {
2411                 auto s = currentSong(myScreen);
2412                 assert(s);
2413                 artist = s->getArtist();
2414         }
2415
2416         if (!artist.empty())
2417         {
2418                 myLastfm->queueJob(new LastFm::ArtistInfo(artist, Config.lastfm_preferred_language));
2419                 myLastfm->switchTo();
2420         }
2421 }
2422
2423 bool ShowLyrics::canBeRun()
2424 {
2425         if (myScreen == myLyrics)
2426         {
2427                 m_song = nullptr;
2428                 return true;
2429         }
2430         else
2431         {
2432                 m_song = currentSong(myScreen);
2433                 return m_song != nullptr;
2434         }
2435 }
2436
2437 void ShowLyrics::run()
2438 {
2439         if (m_song != nullptr)
2440                 myLyrics->fetch(*m_song);
2441         myLyrics->switchTo();
2442 }
2443
2444 void Quit::run()
2445 {
2446         ExitMainLoop = true;
2447 }
2448
2449 void NextScreen::run()
2450 {
2451         if (Config.screen_switcher_previous)
2452         {
2453                 if (auto tababble = dynamic_cast<Tabbable *>(myScreen))
2454                         tababble->switchToPreviousScreen();
2455         }
2456         else if (!Config.screen_sequence.empty())
2457         {
2458                 const auto &seq = Config.screen_sequence;
2459                 auto screen_type = std::find(seq.begin(), seq.end(), myScreen->type());
2460                 if (++screen_type == seq.end())
2461                         toScreen(seq.front())->switchTo();
2462                 else
2463                         toScreen(*screen_type)->switchTo();
2464         }
2465 }
2466
2467 void PreviousScreen::run()
2468 {
2469         if (Config.screen_switcher_previous)
2470         {
2471                 if (auto tababble = dynamic_cast<Tabbable *>(myScreen))
2472                         tababble->switchToPreviousScreen();
2473         }
2474         else if (!Config.screen_sequence.empty())
2475         {
2476                 const auto &seq = Config.screen_sequence;
2477                 auto screen_type = std::find(seq.begin(), seq.end(), myScreen->type());
2478                 if (screen_type == seq.begin())
2479                         toScreen(seq.back())->switchTo();
2480                 else
2481                         toScreen(*--screen_type)->switchTo();
2482         }
2483 }
2484
2485 bool ShowHelp::canBeRun()
2486 {
2487         return myScreen != myHelp
2488 #       ifdef HAVE_TAGLIB_H
2489             && myScreen != myTinyTagEditor
2490 #       endif // HAVE_TAGLIB_H
2491         ;
2492 }
2493
2494 void ShowHelp::run()
2495 {
2496         myHelp->switchTo();
2497 }
2498
2499 bool ShowPlaylist::canBeRun()
2500 {
2501         return myScreen != myPlaylist
2502 #       ifdef HAVE_TAGLIB_H
2503             && myScreen != myTinyTagEditor
2504 #       endif // HAVE_TAGLIB_H
2505         ;
2506 }
2507
2508 void ShowPlaylist::run()
2509 {
2510         myPlaylist->switchTo();
2511 }
2512
2513 bool ShowBrowser::canBeRun()
2514 {
2515         return myScreen != myBrowser
2516 #       ifdef HAVE_TAGLIB_H
2517             && myScreen != myTinyTagEditor
2518 #       endif // HAVE_TAGLIB_H
2519         ;
2520 }
2521
2522 void ShowBrowser::run()
2523 {
2524         myBrowser->switchTo();
2525 }
2526
2527 bool ChangeBrowseMode::canBeRun()
2528 {
2529         return myScreen == myBrowser;
2530 }
2531
2532 void ChangeBrowseMode::run()
2533 {
2534         myBrowser->changeBrowseMode();
2535 }
2536
2537 bool ShowSearchEngine::canBeRun()
2538 {
2539         return myScreen != mySearcher
2540 #       ifdef HAVE_TAGLIB_H
2541             && myScreen != myTinyTagEditor
2542 #       endif // HAVE_TAGLIB_H
2543         ;
2544 }
2545
2546 void ShowSearchEngine::run()
2547 {
2548         mySearcher->switchTo();
2549 }
2550
2551 bool ResetSearchEngine::canBeRun()
2552 {
2553         return myScreen == mySearcher;
2554 }
2555
2556 void ResetSearchEngine::run()
2557 {
2558         mySearcher->reset();
2559 }
2560
2561 bool ShowMediaLibrary::canBeRun()
2562 {
2563         return myScreen != myLibrary
2564 #       ifdef HAVE_TAGLIB_H
2565             && myScreen != myTinyTagEditor
2566 #       endif // HAVE_TAGLIB_H
2567         ;
2568 }
2569
2570 void ShowMediaLibrary::run()
2571 {
2572         myLibrary->switchTo();
2573 }
2574
2575 bool ToggleMediaLibraryColumnsMode::canBeRun()
2576 {
2577         return myScreen == myLibrary;
2578 }
2579
2580 void ToggleMediaLibraryColumnsMode::run()
2581 {
2582         myLibrary->toggleColumnsMode();
2583         myLibrary->refresh();
2584 }
2585
2586 bool ShowPlaylistEditor::canBeRun()
2587 {
2588         return myScreen != myPlaylistEditor
2589 #       ifdef HAVE_TAGLIB_H
2590             && myScreen != myTinyTagEditor
2591 #       endif // HAVE_TAGLIB_H
2592         ;
2593 }
2594
2595 void ShowPlaylistEditor::run()
2596 {
2597         myPlaylistEditor->switchTo();
2598 }
2599
2600 bool ShowTagEditor::canBeRun()
2601 {
2602 #       ifdef HAVE_TAGLIB_H
2603         return myScreen != myTagEditor
2604             && myScreen != myTinyTagEditor;
2605 #       else
2606         return false;
2607 #       endif // HAVE_TAGLIB_H
2608 }
2609
2610 void ShowTagEditor::run()
2611 {
2612 #       ifdef HAVE_TAGLIB_H
2613         if (isMPDMusicDirSet())
2614                 myTagEditor->switchTo();
2615 #       endif // HAVE_TAGLIB_H
2616 }
2617
2618 bool ShowOutputs::canBeRun()
2619 {
2620 #       ifdef ENABLE_OUTPUTS
2621         return myScreen != myOutputs
2622 #       ifdef HAVE_TAGLIB_H
2623             && myScreen != myTinyTagEditor
2624 #       endif // HAVE_TAGLIB_H
2625         ;
2626 #       else
2627         return false;
2628 #       endif // ENABLE_OUTPUTS
2629 }
2630
2631 void ShowOutputs::run()
2632 {
2633 #       ifdef ENABLE_OUTPUTS
2634         myOutputs->switchTo();
2635 #       endif // ENABLE_OUTPUTS
2636 }
2637
2638 bool ShowVisualizer::canBeRun()
2639 {
2640 #       ifdef ENABLE_VISUALIZER
2641         return myScreen != myVisualizer
2642 #       ifdef HAVE_TAGLIB_H
2643             && myScreen != myTinyTagEditor
2644 #       endif // HAVE_TAGLIB_H
2645         ;
2646 #       else
2647         return false;
2648 #       endif // ENABLE_VISUALIZER
2649 }
2650
2651 void ShowVisualizer::run()
2652 {
2653 #       ifdef ENABLE_VISUALIZER
2654         myVisualizer->switchTo();
2655 #       endif // ENABLE_VISUALIZER
2656 }
2657
2658 bool ShowClock::canBeRun()
2659 {
2660 #       ifdef ENABLE_CLOCK
2661         return myScreen != myClock
2662 #       ifdef HAVE_TAGLIB_H
2663             && myScreen != myTinyTagEditor
2664 #       endif // HAVE_TAGLIB_H
2665         ;
2666 #       else
2667         return false;
2668 #       endif // ENABLE_CLOCK
2669 }
2670
2671 void ShowClock::run()
2672 {
2673 #       ifdef ENABLE_CLOCK
2674         myClock->switchTo();
2675 #       endif // ENABLE_CLOCK
2676 }
2677
2678 #ifdef HAVE_TAGLIB_H
2679 bool ShowServerInfo::canBeRun()
2680 {
2681         return myScreen != myTinyTagEditor;
2682 }
2683 #endif // HAVE_TAGLIB_H
2684
2685 void ShowServerInfo::run()
2686 {
2687         myServerInfo->switchTo();
2688 }
2689
2690 }
2691
2692 namespace {
2693
2694 void populateActions()
2695 {
2696         AvailableActions.resize(static_cast<size_t>(Actions::Type::_numberOfActions));
2697         auto insert_action = [](Actions::BaseAction *a) {
2698                 AvailableActions.at(static_cast<size_t>(a->type())).reset(a);
2699         };
2700         insert_action(new Actions::Dummy());
2701         insert_action(new Actions::UpdateEnvironment());
2702         insert_action(new Actions::MouseEvent());
2703         insert_action(new Actions::ScrollUp());
2704         insert_action(new Actions::ScrollDown());
2705         insert_action(new Actions::ScrollUpArtist());
2706         insert_action(new Actions::ScrollUpAlbum());
2707         insert_action(new Actions::ScrollDownArtist());
2708         insert_action(new Actions::ScrollDownAlbum());
2709         insert_action(new Actions::PageUp());
2710         insert_action(new Actions::PageDown());
2711         insert_action(new Actions::MoveHome());
2712         insert_action(new Actions::MoveEnd());
2713         insert_action(new Actions::ToggleInterface());
2714         insert_action(new Actions::JumpToParentDirectory());
2715         insert_action(new Actions::RunAction());
2716         insert_action(new Actions::SelectItem());
2717         insert_action(new Actions::SelectRange());
2718         insert_action(new Actions::PreviousColumn());
2719         insert_action(new Actions::NextColumn());
2720         insert_action(new Actions::MasterScreen());
2721         insert_action(new Actions::SlaveScreen());
2722         insert_action(new Actions::VolumeUp());
2723         insert_action(new Actions::VolumeDown());
2724         insert_action(new Actions::AddItemToPlaylist());
2725         insert_action(new Actions::DeletePlaylistItems());
2726         insert_action(new Actions::DeleteStoredPlaylist());
2727         insert_action(new Actions::DeleteBrowserItems());
2728         insert_action(new Actions::ReplaySong());
2729         insert_action(new Actions::PreviousSong());
2730         insert_action(new Actions::NextSong());
2731         insert_action(new Actions::Pause());
2732         insert_action(new Actions::Stop());
2733         insert_action(new Actions::ExecuteCommand());
2734         insert_action(new Actions::SavePlaylist());
2735         insert_action(new Actions::MoveSortOrderUp());
2736         insert_action(new Actions::MoveSortOrderDown());
2737         insert_action(new Actions::MoveSelectedItemsUp());
2738         insert_action(new Actions::MoveSelectedItemsDown());
2739         insert_action(new Actions::MoveSelectedItemsTo());
2740         insert_action(new Actions::Add());
2741         insert_action(new Actions::PlayItem());
2742         insert_action(new Actions::SeekForward());
2743         insert_action(new Actions::SeekBackward());
2744         insert_action(new Actions::ToggleDisplayMode());
2745         insert_action(new Actions::ToggleSeparatorsBetweenAlbums());
2746         insert_action(new Actions::ToggleLyricsUpdateOnSongChange());
2747         insert_action(new Actions::ToggleLyricsFetcher());
2748         insert_action(new Actions::ToggleFetchingLyricsInBackground());
2749         insert_action(new Actions::TogglePlayingSongCentering());
2750         insert_action(new Actions::UpdateDatabase());
2751         insert_action(new Actions::JumpToPlayingSong());
2752         insert_action(new Actions::ToggleRepeat());
2753         insert_action(new Actions::Shuffle());
2754         insert_action(new Actions::ToggleRandom());
2755         insert_action(new Actions::StartSearching());
2756         insert_action(new Actions::SaveTagChanges());
2757         insert_action(new Actions::ToggleSingle());
2758         insert_action(new Actions::ToggleConsume());
2759         insert_action(new Actions::ToggleCrossfade());
2760         insert_action(new Actions::SetCrossfade());
2761         insert_action(new Actions::SetVolume());
2762         insert_action(new Actions::EnterDirectory());
2763         insert_action(new Actions::EditSong());
2764         insert_action(new Actions::EditLibraryTag());
2765         insert_action(new Actions::EditLibraryAlbum());
2766         insert_action(new Actions::EditDirectoryName());
2767         insert_action(new Actions::EditPlaylistName());
2768         insert_action(new Actions::EditLyrics());
2769         insert_action(new Actions::JumpToBrowser());
2770         insert_action(new Actions::JumpToMediaLibrary());
2771         insert_action(new Actions::JumpToPlaylistEditor());
2772         insert_action(new Actions::ToggleScreenLock());
2773         insert_action(new Actions::JumpToTagEditor());
2774         insert_action(new Actions::JumpToPositionInSong());
2775         insert_action(new Actions::ReverseSelection());
2776         insert_action(new Actions::RemoveSelection());
2777         insert_action(new Actions::SelectAlbum());
2778         insert_action(new Actions::SelectFoundItems());
2779         insert_action(new Actions::AddSelectedItems());
2780         insert_action(new Actions::CropMainPlaylist());
2781         insert_action(new Actions::CropPlaylist());
2782         insert_action(new Actions::ClearMainPlaylist());
2783         insert_action(new Actions::ClearPlaylist());
2784         insert_action(new Actions::SortPlaylist());
2785         insert_action(new Actions::ReversePlaylist());
2786         insert_action(new Actions::ApplyFilter());
2787         insert_action(new Actions::Find());
2788         insert_action(new Actions::FindItemForward());
2789         insert_action(new Actions::FindItemBackward());
2790         insert_action(new Actions::NextFoundItem());
2791         insert_action(new Actions::PreviousFoundItem());
2792         insert_action(new Actions::ToggleFindMode());
2793         insert_action(new Actions::ToggleReplayGainMode());
2794         insert_action(new Actions::ToggleAddMode());
2795         insert_action(new Actions::ToggleMouse());
2796         insert_action(new Actions::ToggleBitrateVisibility());
2797         insert_action(new Actions::AddRandomItems());
2798         insert_action(new Actions::ToggleBrowserSortMode());
2799         insert_action(new Actions::ToggleLibraryTagType());
2800         insert_action(new Actions::ToggleMediaLibrarySortMode());
2801         insert_action(new Actions::FetchLyricsInBackground());
2802         insert_action(new Actions::RefetchLyrics());
2803         insert_action(new Actions::SetSelectedItemsPriority());
2804         insert_action(new Actions::ToggleOutput());
2805         insert_action(new Actions::ToggleVisualizationType());
2806         insert_action(new Actions::SetVisualizerSampleMultiplier());
2807         insert_action(new Actions::ShowSongInfo());
2808         insert_action(new Actions::ShowArtistInfo());
2809         insert_action(new Actions::ShowLyrics());
2810         insert_action(new Actions::Quit());
2811         insert_action(new Actions::NextScreen());
2812         insert_action(new Actions::PreviousScreen());
2813         insert_action(new Actions::ShowHelp());
2814         insert_action(new Actions::ShowPlaylist());
2815         insert_action(new Actions::ShowBrowser());
2816         insert_action(new Actions::ChangeBrowseMode());
2817         insert_action(new Actions::ShowSearchEngine());
2818         insert_action(new Actions::ResetSearchEngine());
2819         insert_action(new Actions::ShowMediaLibrary());
2820         insert_action(new Actions::ToggleMediaLibraryColumnsMode());
2821         insert_action(new Actions::ShowPlaylistEditor());
2822         insert_action(new Actions::ShowTagEditor());
2823         insert_action(new Actions::ShowOutputs());
2824         insert_action(new Actions::ShowVisualizer());
2825         insert_action(new Actions::ShowClock());
2826         insert_action(new Actions::ShowServerInfo());
2827         for (size_t i = 0; i < AvailableActions.size(); ++i)
2828         {
2829                 if (AvailableActions[i] == nullptr)
2830                         throw std::logic_error("undefined action at position "
2831                                                + boost::lexical_cast<std::string>(i));
2832         }
2833 }
2834
2835 bool scrollTagCanBeRun(NC::List *&list, SongList *&songs)
2836 {
2837         auto w = myScreen->activeWindow();
2838         if (list != static_cast<void *>(w))
2839                 list = dynamic_cast<NC::List *>(w);
2840         if (songs != static_cast<void *>(w))
2841                 songs = dynamic_cast<SongList *>(w);
2842         return list != nullptr && !list->empty()
2843             && songs != nullptr;
2844 }
2845
2846 void scrollTagUpRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get)
2847 {
2848         const auto front = songs->beginS();
2849         auto it = songs->currentS();
2850         if (auto *s = it->get<Bit::Song>())
2851         {
2852                 const std::string tag = s->getTags(get);
2853                 while (it != front)
2854                 {
2855                         --it;
2856                         s = it->get<Bit::Song>();
2857                         if (s == nullptr || s->getTags(get) != tag)
2858                                 break;
2859                 }
2860                 list->highlight(it-front);
2861         }
2862 }
2863
2864 void scrollTagDownRun(NC::List *list, SongList *songs, MPD::Song::GetFunction get)
2865 {
2866         const auto front = songs->beginS(), back = --songs->endS();
2867         auto it = songs->currentS();
2868         if (auto *s = it->get<Bit::Song>())
2869         {
2870                 const std::string tag = s->getTags(get);
2871                 while (it != back)
2872                 {
2873                         ++it;
2874                         s = it->get<Bit::Song>();
2875                         if (s == nullptr || s->getTags(get) != tag)
2876                                 break;
2877                 }
2878                 list->highlight(it-front);
2879         }
2880 }
2881
2882 void seek()
2883 {
2884         using Global::wHeader;
2885         using Global::wFooter;
2886         using Global::Timer;
2887         using Global::SeekingInProgress;
2888
2889         if (!Status::State::totalTime())
2890         {
2891                 Statusbar::print("Unknown item length");
2892                 return;
2893         }
2894
2895         Progressbar::ScopedLock progressbar_lock;
2896         Statusbar::ScopedLock statusbar_lock;
2897
2898         unsigned songpos = Status::State::elapsedTime();
2899         auto t = Timer;
2900
2901         int old_timeout = wFooter->getTimeout();
2902         wFooter->setTimeout(BaseScreen::defaultWindowTimeout);
2903
2904         // Accept single action of a given type or action chain for which all actions
2905         // can be run and one of them is of the given type. This will still not work
2906         // in some contrived cases, but allows for more flexibility than accepting
2907         // single actions only.
2908         auto hasRunnableAction = [](BindingsConfiguration::BindingIteratorPair &bindings, Actions::Type type) {
2909                 bool success = false;
2910                 for (auto binding = bindings.first; binding != bindings.second; ++binding)
2911                 {
2912                         auto &actions = binding->actions();
2913                         for (const auto &action : actions)
2914                         {
2915                                 if (action->canBeRun())
2916                                 {
2917                                         if (action->type() == type)
2918                                                 success = true;
2919                                 }
2920                                 else
2921                                 {
2922                                         success = false;
2923                                         break;
2924                                 }
2925                         }
2926                         if (success)
2927                                 break;
2928                 }
2929                 return success;
2930         };
2931
2932         SeekingInProgress = true;
2933         while (true)
2934         {
2935                 Status::trace();
2936
2937                 unsigned howmuch = Config.incremental_seeking
2938                                  ? (Timer-t).total_seconds()/2+Config.seek_time
2939                                  : Config.seek_time;
2940
2941                 NC::Key::Type input = readKey(*wFooter);
2942
2943                 auto k = Bindings.get(input);
2944                 if (hasRunnableAction(k, Actions::Type::SeekForward))
2945                 {
2946                         if (songpos < Status::State::totalTime())
2947                                 songpos = std::min(songpos + howmuch, Status::State::totalTime());
2948                 }
2949                 else if (hasRunnableAction(k, Actions::Type::SeekBackward))
2950                 {
2951                         if (songpos > 0)
2952                         {
2953                                 if (songpos < howmuch)
2954                                         songpos = 0;
2955                                 else
2956                                         songpos -= howmuch;
2957                         }
2958                 }
2959                 else
2960                         break;
2961
2962                 *wFooter << NC::Format::Bold;
2963                 std::string tracklength;
2964                 // FIXME: merge this with the code in status.cpp
2965                 switch (Config.design)
2966                 {
2967                         case Design::Classic:
2968                                 tracklength = " [";
2969                                 if (Config.display_remaining_time)
2970                                 {
2971                                         tracklength += "-";
2972                                         tracklength += MPD::Song::ShowTime(Status::State::totalTime()-songpos);
2973                                 }
2974                                 else
2975                                         tracklength += MPD::Song::ShowTime(songpos);
2976                                 tracklength += "/";
2977                                 tracklength += MPD::Song::ShowTime(Status::State::totalTime());
2978                                 tracklength += "]";
2979                                 *wFooter << NC::XY(wFooter->getWidth()-tracklength.length(), 1) << tracklength;
2980                                 break;
2981                         case Design::Alternative:
2982                                 if (Config.display_remaining_time)
2983                                 {
2984                                         tracklength = "-";
2985                                         tracklength += MPD::Song::ShowTime(Status::State::totalTime()-songpos);
2986                                 }
2987                                 else
2988                                         tracklength = MPD::Song::ShowTime(songpos);
2989                                 tracklength += "/";
2990                                 tracklength += MPD::Song::ShowTime(Status::State::totalTime());
2991                                 *wHeader << NC::XY(0, 0) << tracklength << " ";
2992                                 wHeader->refresh();
2993                                 break;
2994                 }
2995                 *wFooter << NC::Format::NoBold;
2996                 Progressbar::draw(songpos, Status::State::totalTime());
2997                 wFooter->refresh();
2998         }
2999         SeekingInProgress = false;
3000         Mpd.Seek(Status::State::currentSongPosition(), songpos);
3001
3002         wFooter->setTimeout(old_timeout);
3003 }
3004
3005 void findItem(const SearchDirection direction)
3006 {
3007         using Global::wFooter;
3008
3009         Searchable *w = dynamic_cast<Searchable *>(myScreen);
3010         assert(w != nullptr);
3011         assert(w->allowsSearching());
3012
3013         std::string constraint = w->searchConstraint();
3014         try
3015         {
3016                 Statusbar::ScopedLock slock;
3017                 NC::Window::ScopedPromptHook prompt_hook(
3018                         *wFooter,
3019                         Statusbar::Helpers::FindImmediately(w, direction));
3020                 Statusbar::put() << (boost::format("Find %1%: ") % direction).str();
3021                 constraint = wFooter->prompt(constraint);
3022         }
3023         catch (NC::PromptAborted &)
3024         {
3025                 w->setSearchConstraint(constraint);
3026                 w->search(direction, Config.wrapped_search, false);
3027                 throw;
3028         }
3029
3030         if (constraint.empty())
3031         {
3032                 Statusbar::printf("Constraint unset");
3033                 w->clearSearchConstraint();
3034         }
3035         else
3036                 Statusbar::printf("Using constraint \"%1%\"", constraint);
3037 }
3038
3039 void listsChangeFinisher()
3040 {
3041         if (myScreen == myLibrary
3042         ||  myScreen == myPlaylistEditor
3043 #       ifdef HAVE_TAGLIB_H
3044         ||  myScreen == myTagEditor
3045 #       endif // HAVE_TAGLIB_H
3046            )
3047         {
3048                 if (myScreen->activeWindow() == &myLibrary->Tags)
3049                 {
3050                         myLibrary->Albums.clear();
3051                         myLibrary->Albums.refresh();
3052                         myLibrary->Songs.clear();
3053                         myLibrary->Songs.refresh();
3054                         myLibrary->updateTimer();
3055                 }
3056                 else if (myScreen->activeWindow() == &myLibrary->Albums)
3057                 {
3058                         myLibrary->Songs.clear();
3059                         myLibrary->Songs.refresh();
3060                         myLibrary->updateTimer();
3061                 }
3062                 else if (myScreen->isActiveWindow(myPlaylistEditor->Playlists))
3063                 {
3064                         myPlaylistEditor->Content.clear();
3065                         myPlaylistEditor->Content.refresh();
3066                         myPlaylistEditor->updateTimer();
3067                 }
3068 #               ifdef HAVE_TAGLIB_H
3069                 else if (myScreen->activeWindow() == myTagEditor->Dirs)
3070                 {
3071                         myTagEditor->Tags->clear();
3072                 }
3073 #               endif // HAVE_TAGLIB_H
3074         }
3075 }
3076
3077 }