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 ? "Playlist 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         if (Playlists.empty() || m_playlists_update_requested)
 147         {
 148                 m_playlists_update_requested = false;
 149                 size_t idx = 0;
 150                 for (MPD::PlaylistIterator it = Mpd.GetPlaylists(), end; it != end; ++it, ++idx)
 151                 {
 152                         if (idx < Playlists.size())
 153                                 Playlists[idx].value() = std::move(*it);
 154                         else
 155                                 Playlists.addItem(std::move(*it));
 156                 };
 157                 if (idx < Playlists.size())
 158                         Playlists.resizeList(idx);
 159                 std::sort(Playlists.beginV(), Playlists.endV(),
 160                         LocaleBasedSorting(std::locale(), Config.ignore_leading_the));
 161                 Playlists.refresh();
 162         }
 163
 164         if ((Content.empty() && Global::Timer - m_timer > m_fetching_delay)
 165         ||  m_content_update_requested)
 166         {
 167                 m_content_update_requested = false;
 168                 if (Playlists.empty())
 169                         Content.clear();
 170                 else
 171                 {
 172                         size_t idx = 0;
 173                         MPD::SongIterator s = Mpd.GetPlaylistContent(Playlists.current()->value().path()), end;
 174                         for (; s != end; ++s, ++idx)
 175                         {
 176                                 bool in_playlist = myPlaylist->checkForSong(*s);
 177                                 if (idx < Content.size())
 178                                 {
 179                                         Content[idx].setBold(in_playlist);
 180                                         Content[idx].value() = std::move(*s);
 181                                 }
 182                                 else
 183                                 {
 184                                         auto properties = NC::List::Properties::Selectable;
 185                                         if (in_playlist)
 186                                                 properties |= NC::List::Properties::Bold;
 187                                         Content.addItem(std::move(*s), properties);
 188                                 }
 189                         }
 190                         if (idx < Content.size())
 191                                 Content.resizeList(idx);
 192                         std::string wtitle;
 193                         if (Config.titles_visibility)
 194                         {
 195                                 wtitle = (boost::format("Playlist content (%1%) %2%")
 196                                         % boost::lexical_cast<std::string>(Content.size())
 197                                         % (Content.size() == 1 ? "item" : "items")
 198                                         ).str();
 199                                 wtitle.resize(Content.getWidth());
 200                         }
 201                         Content.setTitle(wtitle);
 202                 }
 203                 Content.display();
 204         }
 205
 206         if (isActiveWindow(Content) && Content.empty())
 207         {
 208                 Content.setHighlightColor(Config.main_highlight_color);
 209                 Playlists.setHighlightColor(Config.active_column_color);
 210                 w = &Playlists;
 211         }
 212
 213         if (Playlists.empty() && Content.empty())
 214         {
 215                 Content.Window::clear();
 216                 Content.Window::display();
 217         }
 218 }
 219
 220 int PlaylistEditor::windowTimeout()
 221 {
 222         if (Content.empty())
 223                 return m_window_timeout;
 224         else
 225                 return Screen<WindowType>::windowTimeout();
 226 }
 227
 228 void PlaylistEditor::enterPressed()
 229 {
 230         addItemToPlaylist(true);
 231 }
 232
 233 void PlaylistEditor::mouseButtonPressed(MEVENT me)
 234 {
 235         if (!Playlists.empty() && Playlists.hasCoords(me.x, me.y))
 236         {
 237                 if (!isActiveWindow(Playlists))
 238                 {
 239                         if (previousColumnAvailable())
 240                                 previousColumn();
 241                         else
 242                                 return;
 243                 }
 244                 if (size_t(me.y) < Playlists.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 245                 {
 246                         Playlists.Goto(me.y);
 247                         if (me.bstate & BUTTON3_PRESSED)
 248                                 addItemToPlaylist();
 249                 }
 250                 else
 251                         Screen<WindowType>::mouseButtonPressed(me);
 252                 Content.clear();
 253         }
 254         else if (!Content.empty() && Content.hasCoords(me.x, me.y))
 255         {
 256                 if (!isActiveWindow(Content))
 257                 {
 258                         if (nextColumnAvailable())
 259                                 nextColumn();
 260                         else
 261                                 return;
 262                 }
 263                 if (size_t(me.y) < Content.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 264                 {
 265                         Content.Goto(me.y);
 266                         if (me.bstate & BUTTON1_PRESSED)
 267                                 addItemToPlaylist();
 268                         else
 269                                 enterPressed();
 270                 }
 271                 else
 272                         Screen<WindowType>::mouseButtonPressed(me);
 273         }
 274 }
 275
 276 /***********************************************************************/
 277
 278 bool PlaylistEditor::allowsSearching()
 279 {
 280         return true;
 281 }
 282
 283 void PlaylistEditor::setSearchConstraint(const std::string &constraint)
 284 {
 285         if (isActiveWindow(Playlists))
 286         {
 287                 m_playlists_search_predicate = Regex::Filter<MPD::Playlist>(
 288                         Regex::make(constraint, Config.regex_type),
 289                         PlaylistEntryMatcher
 290                 );
 291         }
 292         else if (isActiveWindow(Content))
 293         {
 294                 m_content_search_predicate = Regex::Filter<MPD::Song>(
 295                         Regex::make(constraint, Config.regex_type),
 296                         SongEntryMatcher
 297                 );
 298         }
 299 }
 300
 301 void PlaylistEditor::clearConstraint()
 302 {
 303         if (isActiveWindow(Playlists))
 304                 m_playlists_search_predicate.clear();
 305         else if (isActiveWindow(Content))
 306                 m_content_search_predicate.clear();
 307 }
 308
 309 bool PlaylistEditor::find(SearchDirection direction, bool wrap, bool skip_current)
 310 {
 311         bool result = false;
 312         if (isActiveWindow(Playlists))
 313                 result = search(Playlists, m_playlists_search_predicate, direction, wrap, skip_current);
 314         else if (isActiveWindow(Content))
 315                 result = search(Content, m_content_search_predicate, direction, wrap, skip_current);
 316         return result;
 317 }
 318
 319 /***********************************************************************/
 320
 321 bool PlaylistEditor::addItemToPlaylist()
 322 {
 323         return addItemToPlaylist(false);
 324 }
 325
 326 std::vector<MPD::Song> PlaylistEditor::getSelectedSongs()
 327 {
 328         std::vector<MPD::Song> result;
 329         if (isActiveWindow(Playlists))
 330         {
 331                 bool any_selected = false;
 332                 for (auto &e : Playlists)
 333                 {
 334                         if (e.isSelected())
 335                         {
 336                                 any_selected = true;
 337                                 std::copy(
 338                                         std::make_move_iterator(Mpd.GetPlaylistContent(e.value().path())),
 339                                         std::make_move_iterator(MPD::SongIterator()),
 340                                         std::back_inserter(result)
 341                                 );
 342                         }
 343                 }
 344                 // if no item is selected, add songs from right column
 345                 if (!any_selected && !Playlists.empty())
 346                 {
 347                         std::copy(
 348                                 std::make_move_iterator(Mpd.GetPlaylistContent(Playlists.current()->value().path())),
 349                                 std::make_move_iterator(MPD::SongIterator()),
 350                                 std::back_inserter(result)
 351                         );
 352                 }
 353         }
 354         else if (isActiveWindow(Content))
 355                 result = Content.getSelectedSongs();
 356         return result;
 357 }
 358
 359 /***********************************************************************/
 360
 361 bool PlaylistEditor::previousColumnAvailable()
 362 {
 363         if (isActiveWindow(Content))
 364         {
 365                 if (!Playlists.empty())
 366                         return true;
 367         }
 368         return false;
 369 }
 370
 371 void PlaylistEditor::previousColumn()
 372 {
 373         if (isActiveWindow(Content))
 374         {
 375                 Content.setHighlightColor(Config.main_highlight_color);
 376                 w->refresh();
 377                 w = &Playlists;
 378                 Playlists.setHighlightColor(Config.active_column_color);
 379         }
 380 }
 381
 382 bool PlaylistEditor::nextColumnAvailable()
 383 {
 384         if (isActiveWindow(Playlists))
 385         {
 386                 if (!Content.empty())
 387                         return true;
 388         }
 389         return false;
 390 }
 391
 392 void PlaylistEditor::nextColumn()
 393 {
 394         if (isActiveWindow(Playlists))
 395         {
 396                 Playlists.setHighlightColor(Config.main_highlight_color);
 397                 w->refresh();
 398                 w = &Content;
 399                 Content.setHighlightColor(Config.active_column_color);
 400         }
 401 }
 402
 403 /***********************************************************************/
 404
 405 void PlaylistEditor::updateTimer()
 406 {
 407         m_timer = Global::Timer;
 408 }
 409
 410 void PlaylistEditor::Locate(const MPD::Playlist &playlist)
 411 {
 412         update();
 413         auto begin = Playlists.beginV(), end = Playlists.endV();
 414         auto it = std::find(begin, end, playlist);
 415         if (it != end)
 416         {
 417                 Playlists.highlight(it-begin);
 418                 Content.clear();
 419                 switchTo();
 420         }
 421 }
 422
 423 bool PlaylistEditor::addItemToPlaylist(bool play)
 424 {
 425         bool result = false;
 426         if (isActiveWindow(Playlists) && !Playlists.empty())
 427         {
 428                 std::vector<MPD::Song> list(
 429                         std::make_move_iterator(Mpd.GetPlaylistContent(Playlists.current()->value().path())),
 430                         std::make_move_iterator(MPD::SongIterator())
 431                 );
 432                 result = addSongsToPlaylist(list.begin(), list.end(), play, -1);
 433                 Statusbar::printf("Playlist \"%1%\" loaded%2%",
 434                         Playlists.current()->value().path(), withErrors(result)
 435                 );
 436         }
 437         else if (isActiveWindow(Content) && !Content.empty())
 438                 result = addSongToPlaylist(Content.current()->value(), play);
 439         return result;
 440 }
 441
 442 namespace {
 443
 444 std::string SongToString(const MPD::Song &s)
 445 {
 446         std::string result;
 447         switch (Config.playlist_display_mode)
 448         {
 449                 case DisplayMode::Classic:
 450                         result = Format::stringify<char>(Config.song_list_format, &s);
 451                         break;
 452                 case DisplayMode::Columns:
 453                         result = Format::stringify<char>(Config.song_columns_mode_format, &s);
 454                         break;
 455         }
 456         return result;
 457 }
 458
 459 bool PlaylistEntryMatcher(const Regex::Regex &rx, const MPD::Playlist &playlist)
 460 {
 461         return Regex::search(playlist.path(), rx);
 462 }
 463
 464 bool SongEntryMatcher(const Regex::Regex &rx, const MPD::Song &s)
 465 {
 466         return Regex::search(SongToString(s), rx);
 467 }
 468
 469 }