src/actions.cpp

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