src/playlist_editor.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 <algorithm>
  22 #include <boost/lambda/bind.hpp>
  23 #include <boost/date_time/posix_time/posix_time.hpp>
  24 #include <cassert>
  25
  26 #include "charset.h"
  27 #include "display.h"
  28 #include "global.h"
  29 #include "helpers.h"
  30 #include "playlist.h"
  31 #include "playlist_editor.h"
  32 #include "menu_impl.h"
  33 #include "mpdpp.h"
  34 #include "status.h"
  35 #include "statusbar.h"
  36 #include "tag_editor.h"
  37 #include "helpers/song_iterator_maker.h"
  38 #include "utility/functional.h"
  39 #include "utility/comparators.h"
  40 #include "title.h"
  41 #include "screen_switcher.h"
  42
  43 using Global::MainHeight;
  44 using Global::MainStartY;
  45
  46 namespace ph = std::placeholders;
  47
  48 PlaylistEditor *myPlaylistEditor;
  49
  50 namespace {
  51
  52 size_t LeftColumnStartX;
  53 size_t LeftColumnWidth;
  54 size_t RightColumnStartX;
  55 size_t RightColumnWidth;
  56
  57 std::string SongToString(const MPD::Song &s);
  58 bool PlaylistEntryMatcher(const Regex::Regex &rx, const MPD::Playlist &playlist);
  59 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s);
  60
  61 }
  62
  63 PlaylistEditor::PlaylistEditor()
  64 : m_timer(boost::posix_time::from_time_t(0))
  65 , m_window_timeout(Config.data_fetching_delay ? 250 : BaseScreen::defaultWindowTimeout)
  66 , m_fetching_delay(boost::posix_time::milliseconds(Config.data_fetching_delay ? 250 : -1))
  67 {
  68         LeftColumnWidth = COLS/3-1;
  69         RightColumnStartX = LeftColumnWidth+1;
  70         RightColumnWidth = COLS-LeftColumnWidth-1;
  71
  72         Playlists = NC::Menu<MPD::Playlist>(0, MainStartY, LeftColumnWidth, MainHeight, Config.titles_visibility ? "Playlists" : "", Config.main_color, NC::Border());
  73         Playlists.setHighlightColor(Config.active_column_color);
  74         Playlists.cyclicScrolling(Config.use_cyclic_scrolling);
  75         Playlists.centeredCursor(Config.centered_cursor);
  76         Playlists.setSelectedPrefix(Config.selected_item_prefix);
  77         Playlists.setSelectedSuffix(Config.selected_item_suffix);
  78         Playlists.setItemDisplayer([](NC::Menu<MPD::Playlist> &menu) {
  79                 menu << Charset::utf8ToLocale(menu.drawn()->value().path());
  80         });
  81
  82         Content = NC::Menu<MPD::Song>(RightColumnStartX, MainStartY, RightColumnWidth, MainHeight, Config.titles_visibility ? "Content" : "", Config.main_color, NC::Border());
  83         Content.setHighlightColor(Config.main_highlight_color);
  84         Content.cyclicScrolling(Config.use_cyclic_scrolling);
  85         Content.centeredCursor(Config.centered_cursor);
  86         Content.setSelectedPrefix(Config.selected_item_prefix);
  87         Content.setSelectedSuffix(Config.selected_item_suffix);
  88         switch (Config.playlist_editor_display_mode)
  89         {
  90                 case DisplayMode::Classic:
  91                         Content.setItemDisplayer(std::bind(
  92                                 Display::Songs, ph::_1, std::cref(Content), std::cref(Config.song_list_format)
  93                         ));
  94                         break;
  95                 case DisplayMode::Columns:
  96                         Content.setItemDisplayer(std::bind(
  97                                 Display::SongsInColumns, ph::_1, std::cref(Content)
  98                         ));
  99                         break;
 100         }
 101
 102         w = &Playlists;
 103 }
 104
 105 void PlaylistEditor::resize()
 106 {
 107         size_t x_offset, width;
 108         getWindowResizeParams(x_offset, width);
 109
 110         LeftColumnStartX = x_offset;
 111         LeftColumnWidth = width/3-1;
 112         RightColumnStartX = LeftColumnStartX+LeftColumnWidth+1;
 113         RightColumnWidth = width-LeftColumnWidth-1;
 114
 115         Playlists.resize(LeftColumnWidth, MainHeight);
 116         Content.resize(RightColumnWidth, MainHeight);
 117
 118         Playlists.moveTo(LeftColumnStartX, MainStartY);
 119         Content.moveTo(RightColumnStartX, MainStartY);
 120
 121         hasToBeResized = 0;
 122 }
 123
 124 std::wstring PlaylistEditor::title()
 125 {
 126         return L"Playlist editor";
 127 }
 128
 129 void PlaylistEditor::refresh()
 130 {
 131         Playlists.display();
 132         drawSeparator(RightColumnStartX-1);
 133         Content.display();
 134 }
 135
 136 void PlaylistEditor::switchTo()
 137 {
 138         SwitchTo::execute(this);
 139         markSongsInPlaylist(Content);
 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                                 bool in_playlist = myPlaylist->checkForSong(*s);
 190                                 if (idx < Content.size())
 191                                 {
 192                                         Content[idx].setBold(in_playlist);
 193                                         Content[idx].value() = std::move(*s);
 194                                 }
 195                                 else
 196                                 {
 197                                         auto properties = NC::List::Properties::Selectable;
 198                                         if (in_playlist)
 199                                                 properties |= NC::List::Properties::Bold;
 200                                         Content.addItem(std::move(*s), properties);
 201                                 }
 202                         }
 203                         if (idx < Content.size())
 204                                 Content.resizeList(idx);
 205                         std::string wtitle;
 206                         if (Config.titles_visibility)
 207                         {
 208                                 wtitle = (boost::format("Content (%1% %2%)")
 209                                           % boost::lexical_cast<std::string>(Content.size())
 210                                           % (Content.size() == 1 ? "item" : "items")).str();
 211                                 wtitle.resize(Content.getWidth());
 212                         }
 213                         Content.setTitle(wtitle);
 214                         Content.refreshBorder();
 215                 }
 216         }
 217 }
 218
 219 int PlaylistEditor::windowTimeout()
 220 {
 221         ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 222         if (Content.empty())
 223                 return m_window_timeout;
 224         else
 225                 return Screen<WindowType>::windowTimeout();
 226 }
 227
 228 void PlaylistEditor::mouseButtonPressed(MEVENT me)
 229 {
 230         if (!Playlists.empty() && Playlists.hasCoords(me.x, me.y))
 231         {
 232                 if (!isActiveWindow(Playlists))
 233                 {
 234                         if (previousColumnAvailable())
 235                                 previousColumn();
 236                         else
 237                                 return;
 238                 }
 239                 if (size_t(me.y) < Playlists.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 240                 {
 241                         Playlists.Goto(me.y);
 242                         if (me.bstate & BUTTON3_PRESSED)
 243                                 addItemToPlaylist(false);
 244                 }
 245                 else
 246                         Screen<WindowType>::mouseButtonPressed(me);
 247                 Content.clear();
 248         }
 249         else if (!Content.empty() && Content.hasCoords(me.x, me.y))
 250         {
 251                 if (!isActiveWindow(Content))
 252                 {
 253                         if (nextColumnAvailable())
 254                                 nextColumn();
 255                         else
 256                                 return;
 257                 }
 258                 if (size_t(me.y) < Content.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 259                 {
 260                         Content.Goto(me.y);
 261                         bool play = me.bstate & BUTTON3_PRESSED;
 262                         addItemToPlaylist(play);
 263                 }
 264                 else
 265                         Screen<WindowType>::mouseButtonPressed(me);
 266         }
 267 }
 268
 269 /***********************************************************************/
 270
 271 bool PlaylistEditor::allowsSearching()
 272 {
 273         return true;
 274 }
 275
 276 const std::string &PlaylistEditor::searchConstraint()
 277 {
 278         if (isActiveWindow(Playlists))
 279                 return m_playlists_search_predicate.constraint();
 280         else if (isActiveWindow(Content))
 281                 return m_content_search_predicate.constraint();
 282         throw std::runtime_error("no active window");
 283 }
 284
 285 void PlaylistEditor::setSearchConstraint(const std::string &constraint)
 286 {
 287         if (isActiveWindow(Playlists))
 288         {
 289                 m_playlists_search_predicate = Regex::Filter<MPD::Playlist>(
 290                         constraint,
 291                         Config.regex_type,
 292                         PlaylistEntryMatcher);
 293         }
 294         else if (isActiveWindow(Content))
 295         {
 296                 m_content_search_predicate = Regex::Filter<MPD::Song>(
 297                         constraint,
 298                         Config.regex_type,
 299                         SongEntryMatcher);
 300         }
 301 }
 302
 303 void PlaylistEditor::clearSearchConstraint()
 304 {
 305         if (isActiveWindow(Playlists))
 306                 m_playlists_search_predicate.clear();
 307         else if (isActiveWindow(Content))
 308                 m_content_search_predicate.clear();
 309 }
 310
 311 bool PlaylistEditor::search(SearchDirection direction, bool wrap, bool skip_current)
 312 {
 313         bool result = false;
 314         if (isActiveWindow(Playlists))
 315                 result = ::search(Playlists, m_playlists_search_predicate, direction, wrap, skip_current);
 316         else if (isActiveWindow(Content))
 317                 result = ::search(Content, m_content_search_predicate, direction, wrap, skip_current);
 318         return result;
 319 }
 320
 321 std::string PlaylistEditor::currentFilter()
 322 {
 323         std::string result;
 324         if (isActiveWindow(Playlists))
 325         {
 326                 if (auto pred = Playlists.filterPredicate<Regex::Filter<MPD::Playlist>>())
 327                         result = pred->constraint();
 328         }
 329         else if (isActiveWindow(Content))
 330         {
 331                 if (auto pred = Content.filterPredicate<Regex::Filter<MPD::Song>>())
 332                         result = pred->constraint();
 333         }
 334         return result;
 335 }
 336
 337 void PlaylistEditor::applyFilter(const std::string &constraint)
 338 {
 339         if (isActiveWindow(Playlists))
 340         {
 341                 if (!constraint.empty())
 342                 {
 343                         Playlists.applyFilter(Regex::Filter<MPD::Playlist>(
 344                                                       constraint,
 345                                                       Config.regex_type,
 346                                                       PlaylistEntryMatcher));
 347                 }
 348                 else
 349                         Playlists.clearFilter();
 350         }
 351         else if (isActiveWindow(Content))
 352         {
 353                 if (!constraint.empty())
 354                 {
 355                         Content.applyFilter(Regex::Filter<MPD::Song>(
 356                                                     constraint,
 357                                                     Config.regex_type,
 358                                                     SongEntryMatcher));
 359                 }
 360                 else
 361                         Content.clearFilter();
 362         }
 363 }
 364
 365
 366 /***********************************************************************/
 367
 368 bool PlaylistEditor::itemAvailable()
 369 {
 370         if (isActiveWindow(Playlists))
 371                 return !Playlists.empty();
 372         if (isActiveWindow(Content))
 373                 return !Content.empty();
 374         return false;
 375 }
 376
 377 bool PlaylistEditor::addItemToPlaylist(bool play)
 378 {
 379         bool result = false;
 380         if (isActiveWindow(Playlists))
 381         {
 382                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 383                 result = addSongsToPlaylist(Content.beginV(), Content.endV(), play, -1);
 384                 Statusbar::printf("Playlist \"%1%\" loaded%2%",
 385                                   Playlists.current()->value().path(), withErrors(result));
 386         }
 387         else if (isActiveWindow(Content))
 388                 result = addSongToPlaylist(Content.current()->value(), play);
 389         return result;
 390 }
 391
 392 std::vector<MPD::Song> PlaylistEditor::getSelectedSongs()
 393 {
 394         std::vector<MPD::Song> result;
 395         if (isActiveWindow(Playlists))
 396         {
 397                 bool any_selected = false;
 398                 for (auto &e : Playlists)
 399                 {
 400                         if (e.isSelected())
 401                         {
 402                                 any_selected = true;
 403                                 std::copy(
 404                                         std::make_move_iterator(Mpd.GetPlaylistContent(e.value().path())),
 405                                         std::make_move_iterator(MPD::SongIterator()),
 406                                         std::back_inserter(result));
 407                         }
 408                 }
 409                 // if no item is selected, add songs from right column
 410                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 411                 if (!any_selected && !Playlists.empty())
 412                         std::copy(Content.beginV(), Content.endV(), std::back_inserter(result));
 413         }
 414         else if (isActiveWindow(Content))
 415                 result = Content.getSelectedSongs();
 416         return result;
 417 }
 418
 419 /***********************************************************************/
 420
 421 bool PlaylistEditor::previousColumnAvailable()
 422 {
 423         if (isActiveWindow(Content))
 424         {
 425                 ScopedUnfilteredMenu<MPD::Playlist> sunfilter_playlists(ReapplyFilter::No, Playlists);
 426                 if (!Playlists.empty())
 427                         return true;
 428         }
 429         return false;
 430 }
 431
 432 void PlaylistEditor::previousColumn()
 433 {
 434         if (isActiveWindow(Content))
 435         {
 436                 Content.setHighlightColor(Config.main_highlight_color);
 437                 w->refresh();
 438                 w = &Playlists;
 439                 Playlists.setHighlightColor(Config.active_column_color);
 440         }
 441 }
 442
 443 bool PlaylistEditor::nextColumnAvailable()
 444 {
 445         if (isActiveWindow(Playlists))
 446         {
 447                 ScopedUnfilteredMenu<MPD::Song> sunfilter_content(ReapplyFilter::No, Content);
 448                 if (!Content.empty())
 449                         return true;
 450         }
 451         return false;
 452 }
 453
 454 void PlaylistEditor::nextColumn()
 455 {
 456         if (isActiveWindow(Playlists))
 457         {
 458                 Playlists.setHighlightColor(Config.main_highlight_color);
 459                 w->refresh();
 460                 w = &Content;
 461                 Content.setHighlightColor(Config.active_column_color);
 462         }
 463 }
 464
 465 /***********************************************************************/
 466
 467 void PlaylistEditor::updateTimer()
 468 {
 469         m_timer = Global::Timer;
 470 }
 471
 472 void PlaylistEditor::locatePlaylist(const MPD::Playlist &playlist)
 473 {
 474         update();
 475         Playlists.clearFilter();
 476         auto first = Playlists.beginV(), last = Playlists.endV();
 477         auto it = std::find(first, last, playlist);
 478         if (it != last)
 479         {
 480                 Playlists.highlight(it - first);
 481                 Content.clear();
 482                 Content.clearFilter();
 483                 switchTo();
 484         }
 485 }
 486
 487 namespace {
 488
 489 std::string SongToString(const MPD::Song &s)
 490 {
 491         std::string result;
 492         switch (Config.playlist_display_mode)
 493         {
 494                 case DisplayMode::Classic:
 495                         result = Format::stringify<char>(Config.song_list_format, &s);
 496                         break;
 497                 case DisplayMode::Columns:
 498                         result = Format::stringify<char>(Config.song_columns_mode_format, &s);
 499                         break;
 500         }
 501         return result;
 502 }
 503
 504 bool PlaylistEntryMatcher(const Regex::Regex &rx, const MPD::Playlist &playlist)
 505 {
 506         return Regex::search(playlist.path(), rx);
 507 }
 508
 509 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s)
 510 {
 511         return Regex::search(SongToString(s), rx);
 512 }
 513
 514 }