src/screens/playlist_editor.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2017 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <algorithm>
  22 #include <boost/lambda/bind.hpp>
  23 #include <boost/optional.hpp>
  24 #include <boost/date_time/posix_time/posix_time.hpp>
  25 #include <cassert>
  26
  27 #include "curses/menu_impl.h"
  28 #include "charset.h"
  29 #include "display.h"
  30 #include "global.h"
  31 #include "helpers.h"
  32 #include "screens/playlist.h"
  33 #include "screens/playlist_editor.h"
  34 #include "mpdpp.h"
  35 #include "status.h"
  36 #include "statusbar.h"
  37 #include "screens/tag_editor.h"
  38 #include "helpers/song_iterator_maker.h"
  39 #include "utility/functional.h"
  40 #include "utility/comparators.h"
  41 #include "title.h"
  42 #include "screens/screen_switcher.h"
  43
  44 using Global::MainHeight;
  45 using Global::MainStartY;
  46
  47 namespace ph = std::placeholders;
  48
  49 PlaylistEditor *myPlaylistEditor;
  50
  51 namespace {
  52
  53 size_t LeftColumnStartX;
  54 size_t LeftColumnWidth;
  55 size_t RightColumnStartX;
  56 size_t RightColumnWidth;
  57
  58 std::string SongToString(const MPD::Song &s);
  59 bool PlaylistEntryMatcher(const Regex::Regex &rx, const MPD::Playlist &playlist);
  60 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s);
  61 boost::optional<size_t> GetSongIndexInPlaylist(MPD::Playlist playlist, const MPD::Song &song);
  62 }
  63
  64 PlaylistEditor::PlaylistEditor()
  65 : m_timer(boost::posix_time::from_time_t(0))
  66 , m_window_timeout(Config.data_fetching_delay ? 250 : BaseScreen::defaultWindowTimeout)
  67 , m_fetching_delay(boost::posix_time::milliseconds(Config.data_fetching_delay ? 250 : -1))
  68 {
  69         LeftColumnWidth = COLS/3-1;
  70         RightColumnStartX = LeftColumnWidth+1;
  71         RightColumnWidth = COLS-LeftColumnWidth-1;
  72
  73         Playlists = NC::Menu<MPD::Playlist>(0, MainStartY, LeftColumnWidth, MainHeight, Config.titles_visibility ? "Playlists" : "", Config.main_color, NC::Border());
  74         Playlists.setHighlightColor(Config.active_column_color);
  75         Playlists.cyclicScrolling(Config.use_cyclic_scrolling);
  76         Playlists.centeredCursor(Config.centered_cursor);
  77         Playlists.setSelectedPrefix(Config.selected_item_prefix);
  78         Playlists.setSelectedSuffix(Config.selected_item_suffix);
  79         Playlists.setItemDisplayer([](NC::Menu<MPD::Playlist> &menu) {
  80                 menu << Charset::utf8ToLocale(menu.drawn()->value().path());
  81         });
  82
  83         Content = NC::Menu<MPD::Song>(RightColumnStartX, MainStartY, RightColumnWidth, MainHeight, Config.titles_visibility ? "Content" : "", Config.main_color, NC::Border());
  84         Content.setHighlightColor(Config.main_highlight_color);
  85         Content.cyclicScrolling(Config.use_cyclic_scrolling);
  86         Content.centeredCursor(Config.centered_cursor);
  87         Content.setSelectedPrefix(Config.selected_item_prefix);
  88         Content.setSelectedSuffix(Config.selected_item_suffix);
  89         switch (Config.playlist_editor_display_mode)
  90         {
  91                 case DisplayMode::Classic:
  92                         Content.setItemDisplayer(std::bind(
  93                                 Display::Songs, ph::_1, std::cref(Content), std::cref(Config.song_list_format)
  94                         ));
  95                         break;
  96                 case DisplayMode::Columns:
  97                         Content.setItemDisplayer(std::bind(
  98                                 Display::SongsInColumns, ph::_1, std::cref(Content)
  99                         ));
 100                         break;
 101         }
 102
 103         w = &Playlists;
 104 }
 105
 106 void PlaylistEditor::resize()
 107 {
 108         size_t x_offset, width;
 109         getWindowResizeParams(x_offset, width);
 110
 111         LeftColumnStartX = x_offset;
 112         LeftColumnWidth = width/3-1;
 113         RightColumnStartX = LeftColumnStartX+LeftColumnWidth+1;
 114         RightColumnWidth = width-LeftColumnWidth-1;
 115
 116         Playlists.resize(LeftColumnWidth, MainHeight);
 117         Content.resize(RightColumnWidth, MainHeight);
 118
 119         Playlists.moveTo(LeftColumnStartX, MainStartY);
 120         Content.moveTo(RightColumnStartX, MainStartY);
 121
 122         hasToBeResized = 0;
 123 }
 124
 125 std::wstring PlaylistEditor::title()
 126 {
 127         return L"Playlist editor";
 128 }
 129
 130 void PlaylistEditor::refresh()
 131 {
 132         Playlists.display();
 133         drawSeparator(RightColumnStartX-1);
 134         Content.display();
 135 }
 136
 137 void PlaylistEditor::switchTo()
 138 {
 139         SwitchTo::execute(this);
 140         drawHeader();
 141         refresh();
 142 }
 143
 144 void PlaylistEditor::update()
 145 {
 146         {
 147                 ScopedUnfilteredMenu<MPD::Playlist> sunfilter_playlists(ReapplyFilter::No, Playlists);
 148                 if (Playlists.empty() || m_playlists_update_requested)
 149                 {
 150                         m_playlists_update_requested = false;
 151                         sunfilter_playlists.set(ReapplyFilter::Yes, true);
 152                         size_t idx = 0;
 153                         try
 154                         {
 155                                 for (MPD::PlaylistIterator it = Mpd.GetPlaylists(), end; it != end; ++it, ++idx)
 156                                 {
 157                                         if (idx < Playlists.size())
 158                                                 Playlists[idx].value() = std::move(*it);
 159                                         else
 160                                                 Playlists.addItem(std::move(*it));
 161                                 };
 162                         }
 163                         catch (MPD::ServerError &e)
 164                         {
 165                                 if (e.code() == MPD_SERVER_ERROR_SYSTEM) // no playlists directory
 166                                         Statusbar::print(e.what());
 167                                 else
 168                                         throw;
 169                         }
 170                         if (idx < Playlists.size())
 171                                 Playlists.resizeList(idx);
 172                         std::sort(Playlists.beginV(), Playlists.endV(),
 173                                   LocaleBasedSorting(std::locale(), Config.ignore_leading_the));
 174                 }
 175         }
 176
 177         {
 178                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 179                 if (!Playlists.empty()
 180                     && ((Content.empty() && Global::Timer - m_timer > m_fetching_delay)
 181                         || m_content_update_requested))
 182                 {
 183                         m_content_update_requested = false;
 184                         sunfilter_content.set(ReapplyFilter::Yes, true);
 185                         size_t idx = 0;
 186                         MPD::SongIterator s = Mpd.GetPlaylistContent(Playlists.current()->value().path()), end;
 187                         for (; s != end; ++s, ++idx)
 188                         {
 189                                 if (idx < Content.size())
 190                                         Content[idx].value() = std::move(*s);
 191                                 else
 192                                         Content.addItem(std::move(*s));
 193                         }
 194                         if (idx < Content.size())
 195                                 Content.resizeList(idx);
 196                         std::string wtitle;
 197                         if (Config.titles_visibility)
 198                         {
 199                                 wtitle = (boost::format("Content (%1% %2%)")
 200                                           % boost::lexical_cast<std::string>(Content.size())
 201                                           % (Content.size() == 1 ? "item" : "items")).str();
 202                                 wtitle.resize(Content.getWidth());
 203                         }
 204                         Content.setTitle(wtitle);
 205                         Content.refreshBorder();
 206                 }
 207         }
 208 }
 209
 210 int PlaylistEditor::windowTimeout()
 211 {
 212         ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 213         if (Content.empty())
 214                 return m_window_timeout;
 215         else
 216                 return Screen<WindowType>::windowTimeout();
 217 }
 218
 219 void PlaylistEditor::mouseButtonPressed(MEVENT me)
 220 {
 221         if (Playlists.hasCoords(me.x, me.y))
 222         {
 223                 if (!isActiveWindow(Playlists))
 224                 {
 225                         if (previousColumnAvailable())
 226                                 previousColumn();
 227                         else
 228                                 return;
 229                 }
 230                 if (size_t(me.y) < Playlists.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 231                 {
 232                         Playlists.Goto(me.y);
 233                         if (me.bstate & BUTTON3_PRESSED)
 234                                 addItemToPlaylist(false);
 235                 }
 236                 else
 237                         Screen<WindowType>::mouseButtonPressed(me);
 238                 Content.clear();
 239         }
 240         else if (Content.hasCoords(me.x, me.y))
 241         {
 242                 if (!isActiveWindow(Content))
 243                 {
 244                         if (nextColumnAvailable())
 245                                 nextColumn();
 246                         else
 247                                 return;
 248                 }
 249                 if (size_t(me.y) < Content.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 250                 {
 251                         Content.Goto(me.y);
 252                         bool play = me.bstate & BUTTON3_PRESSED;
 253                         addItemToPlaylist(play);
 254                 }
 255                 else
 256                         Screen<WindowType>::mouseButtonPressed(me);
 257         }
 258 }
 259
 260 /***********************************************************************/
 261
 262 bool PlaylistEditor::allowsSearching()
 263 {
 264         return true;
 265 }
 266
 267 const std::string &PlaylistEditor::searchConstraint()
 268 {
 269         if (isActiveWindow(Playlists))
 270                 return m_playlists_search_predicate.constraint();
 271         else if (isActiveWindow(Content))
 272                 return m_content_search_predicate.constraint();
 273         throw std::runtime_error("no active window");
 274 }
 275
 276 void PlaylistEditor::setSearchConstraint(const std::string &constraint)
 277 {
 278         if (isActiveWindow(Playlists))
 279         {
 280                 m_playlists_search_predicate = Regex::Filter<MPD::Playlist>(
 281                         constraint,
 282                         Config.regex_type,
 283                         PlaylistEntryMatcher);
 284         }
 285         else if (isActiveWindow(Content))
 286         {
 287                 m_content_search_predicate = Regex::Filter<MPD::Song>(
 288                         constraint,
 289                         Config.regex_type,
 290                         SongEntryMatcher);
 291         }
 292 }
 293
 294 void PlaylistEditor::clearSearchConstraint()
 295 {
 296         if (isActiveWindow(Playlists))
 297                 m_playlists_search_predicate.clear();
 298         else if (isActiveWindow(Content))
 299                 m_content_search_predicate.clear();
 300 }
 301
 302 bool PlaylistEditor::search(SearchDirection direction, bool wrap, bool skip_current)
 303 {
 304         bool result = false;
 305         if (isActiveWindow(Playlists))
 306                 result = ::search(Playlists, m_playlists_search_predicate, direction, wrap, skip_current);
 307         else if (isActiveWindow(Content))
 308                 result = ::search(Content, m_content_search_predicate, direction, wrap, skip_current);
 309         return result;
 310 }
 311
 312 /***********************************************************************/
 313
 314 bool PlaylistEditor::allowsFiltering()
 315 {
 316         return allowsSearching();
 317 }
 318
 319 std::string PlaylistEditor::currentFilter()
 320 {
 321         std::string result;
 322         if (isActiveWindow(Playlists))
 323         {
 324                 if (auto pred = Playlists.filterPredicate<Regex::Filter<MPD::Playlist>>())
 325                         result = pred->constraint();
 326         }
 327         else if (isActiveWindow(Content))
 328         {
 329                 if (auto pred = Content.filterPredicate<Regex::Filter<MPD::Song>>())
 330                         result = pred->constraint();
 331         }
 332         return result;
 333 }
 334
 335 void PlaylistEditor::applyFilter(const std::string &constraint)
 336 {
 337         if (isActiveWindow(Playlists))
 338         {
 339                 if (!constraint.empty())
 340                 {
 341                         Playlists.applyFilter(Regex::Filter<MPD::Playlist>(
 342                                                       constraint,
 343                                                       Config.regex_type,
 344                                                       PlaylistEntryMatcher));
 345                 }
 346                 else
 347                         Playlists.clearFilter();
 348         }
 349         else if (isActiveWindow(Content))
 350         {
 351                 if (!constraint.empty())
 352                 {
 353                         Content.applyFilter(Regex::Filter<MPD::Song>(
 354                                                     constraint,
 355                                                     Config.regex_type,
 356                                                     SongEntryMatcher));
 357                 }
 358                 else
 359                         Content.clearFilter();
 360         }
 361 }
 362
 363
 364 /***********************************************************************/
 365
 366 bool PlaylistEditor::itemAvailable()
 367 {
 368         if (isActiveWindow(Playlists))
 369                 return !Playlists.empty();
 370         if (isActiveWindow(Content))
 371                 return !Content.empty();
 372         return false;
 373 }
 374
 375 bool PlaylistEditor::addItemToPlaylist(bool play)
 376 {
 377         bool result = false;
 378         if (isActiveWindow(Playlists))
 379         {
 380                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 381                 result = addSongsToPlaylist(Content.beginV(), Content.endV(), play, -1);
 382                 Statusbar::printf("Playlist \"%1%\" loaded%2%",
 383                                   Playlists.current()->value().path(), withErrors(result));
 384         }
 385         else if (isActiveWindow(Content))
 386                 result = addSongToPlaylist(Content.current()->value(), play);
 387         return result;
 388 }
 389
 390 std::vector<MPD::Song> PlaylistEditor::getSelectedSongs()
 391 {
 392         std::vector<MPD::Song> result;
 393         if (isActiveWindow(Playlists))
 394         {
 395                 bool any_selected = false;
 396                 for (auto &e : Playlists)
 397                 {
 398                         if (e.isSelected())
 399                         {
 400                                 any_selected = true;
 401                                 std::copy(
 402                                         std::make_move_iterator(Mpd.GetPlaylistContent(e.value().path())),
 403                                         std::make_move_iterator(MPD::SongIterator()),
 404                                         std::back_inserter(result));
 405                         }
 406                 }
 407                 // if no item is selected, add songs from right column
 408                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 409                 if (!any_selected && !Playlists.empty())
 410                         std::copy(Content.beginV(), Content.endV(), std::back_inserter(result));
 411         }
 412         else if (isActiveWindow(Content))
 413                 result = Content.getSelectedSongs();
 414         return result;
 415 }
 416
 417 /***********************************************************************/
 418
 419 bool PlaylistEditor::previousColumnAvailable()
 420 {
 421         if (isActiveWindow(Content))
 422         {
 423                 ScopedUnfilteredMenu<MPD::Playlist> sunfilter_playlists(ReapplyFilter::No, Playlists);
 424                 if (!Playlists.empty())
 425                         return true;
 426         }
 427         return false;
 428 }
 429
 430 void PlaylistEditor::previousColumn()
 431 {
 432         if (isActiveWindow(Content))
 433         {
 434                 Content.setHighlightColor(Config.main_highlight_color);
 435                 w->refresh();
 436                 w = &Playlists;
 437                 Playlists.setHighlightColor(Config.active_column_color);
 438         }
 439 }
 440
 441 bool PlaylistEditor::nextColumnAvailable()
 442 {
 443         if (isActiveWindow(Playlists))
 444         {
 445                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 446                 if (!Content.empty())
 447                         return true;
 448         }
 449         return false;
 450 }
 451
 452 void PlaylistEditor::nextColumn()
 453 {
 454         if (isActiveWindow(Playlists))
 455         {
 456                 Playlists.setHighlightColor(Config.main_highlight_color);
 457                 w->refresh();
 458                 w = &Content;
 459                 Content.setHighlightColor(Config.active_column_color);
 460         }
 461 }
 462
 463 /***********************************************************************/
 464
 465 void PlaylistEditor::updateTimer()
 466 {
 467         m_timer = Global::Timer;
 468 }
 469
 470 void PlaylistEditor::locatePlaylist(const MPD::Playlist &playlist)
 471 {
 472         update();
 473         Playlists.clearFilter();
 474         auto first = Playlists.beginV(), last = Playlists.endV();
 475         auto it = std::find(first, last, playlist);
 476         if (it != last)
 477         {
 478                 Playlists.highlight(it - first);
 479                 Content.clear();
 480                 Content.clearFilter();
 481                 switchTo();
 482         }
 483 }
 484
 485 void PlaylistEditor::locateSong(const MPD::Song &s)
 486 {
 487         if (Playlists.empty())
 488                 return;
 489
 490         Content.clearFilter();
 491         Playlists.clearFilter();
 492
 493         auto locate_song_in_current_playlist = [this, &s](auto front, auto back) {
 494                 if (!Content.empty())
 495                 {
 496                         auto it = std::find(front, back, s);
 497                         if (it != back)
 498                         {
 499                                 Content.highlight(it - Content.beginV());
 500                                 nextColumn();
 501                                 return true;
 502                         }
 503                 }
 504                 return false;
 505         };
 506         auto locate_song_in_playlists = [this, &s](auto front, auto back) {
 507                 for (auto it = front; it != back; ++it)
 508                 {
 509                         if (auto song_index = GetSongIndexInPlaylist(*it, s))
 510                         {
 511                                 Playlists.highlight(it - Playlists.beginV());
 512                                 Playlists.refresh();
 513
 514                                 requestContentUpdate();
 515                                 update();
 516                                 Content.highlight(*song_index);
 517                                 nextColumn();
 518
 519                                 return true;
 520                         }
 521                 }
 522                 return false;
 523         };
 524
 525
 526         if (locate_song_in_current_playlist(Content.currentV() + 1, Content.endV()))
 527                 return;
 528         Statusbar::print("Jumping to song...");
 529         if (locate_song_in_playlists(Playlists.currentV() + 1, Playlists.endV()))
 530                 return;
 531         if (locate_song_in_playlists(Playlists.beginV(), Playlists.currentV()))
 532                 return;
 533         if (locate_song_in_current_playlist(Content.beginV(), Content.currentV()))
 534                 return;
 535
 536         // Highlighted song was skipped, so if that's the one we're looking for, we're
 537         // good.
 538         if (Content.empty() || *Content.currentV() != s)
 539                 Statusbar::print("Song was not found in playlists");
 540 }
 541
 542 namespace {
 543
 544 std::string SongToString(const MPD::Song &s)
 545 {
 546         std::string result;
 547         switch (Config.playlist_display_mode)
 548         {
 549                 case DisplayMode::Classic:
 550                         result = Format::stringify<char>(Config.song_list_format, &s);
 551                         break;
 552                 case DisplayMode::Columns:
 553                         result = Format::stringify<char>(Config.song_columns_mode_format, &s);
 554                         break;
 555         }
 556         return result;
 557 }
 558
 559 bool PlaylistEntryMatcher(const Regex::Regex &rx, const MPD::Playlist &playlist)
 560 {
 561         return Regex::search(playlist.path(), rx);
 562 }
 563
 564 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s)
 565 {
 566         return Regex::search(SongToString(s), rx);
 567 }
 568
 569 boost::optional<size_t> GetSongIndexInPlaylist(MPD::Playlist playlist, const MPD::Song &song)
 570 {
 571         size_t index = 0;
 572         MPD::SongIterator it = Mpd.GetPlaylistContentNoInfo(playlist.path()), end;
 573
 574         for (;;)
 575         {
 576                 if (it == end)
 577                         return boost::none;
 578                 if (*it == song)
 579                         return index;
 580
 581                 ++it, ++index;
 582         }
 583 }
 584
 585 }