src/playlist.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/bind.hpp>
  23 #include <sstream>
  24
  25 #include "display.h"
  26 #include "global.h"
  27 #include "helpers.h"
  28 #include "menu.h"
  29 #include "playlist.h"
  30 #include "regex_filter.h"
  31 #include "screen_switcher.h"
  32 #include "song.h"
  33 #include "status.h"
  34 #include "statusbar.h"
  35 #include "utility/comparators.h"
  36 #include "title.h"
  37
  38 using Global::MainHeight;
  39 using Global::MainStartY;
  40
  41 Playlist *myPlaylist;
  42
  43 namespace {
  44
  45 std::string songToString(const MPD::Song &s);
  46 bool playlistEntryMatcher(const boost::regex &rx, const MPD::Song &s);
  47
  48 }
  49
  50 Playlist::Playlist()
  51 : m_total_length(0), m_remaining_time(0), m_scroll_begin(0)
  52 , m_reload_total_length(false), m_reload_remaining(false)
  53 {
  54         w = NC::Menu<MPD::Song>(0, MainStartY, COLS, MainHeight, Config.playlist_display_mode == DisplayMode::Columns && Config.titles_visibility ? Display::Columns(COLS) : "", Config.main_color, NC::Border::None);
  55         w.cyclicScrolling(Config.use_cyclic_scrolling);
  56         w.centeredCursor(Config.centered_cursor);
  57         w.setHighlightColor(Config.main_highlight_color);
  58         w.setSelectedPrefix(Config.selected_item_prefix);
  59         w.setSelectedSuffix(Config.selected_item_suffix);
  60         switch (Config.playlist_display_mode)
  61         {
  62                 case DisplayMode::Classic:
  63                         w.setItemDisplayer(boost::bind(Display::Songs, _1, proxySongList(), Config.song_list_format));
  64                         break;
  65                 case DisplayMode::Columns:
  66                         w.setItemDisplayer(boost::bind(Display::SongsInColumns, _1, proxySongList()));
  67                         break;
  68         }
  69 }
  70
  71 void Playlist::switchTo()
  72 {
  73         SwitchTo::execute(this);
  74         m_scroll_begin = 0;
  75         EnableHighlighting();
  76         drawHeader();
  77 }
  78
  79 void Playlist::resize()
  80 {
  81         size_t x_offset, width;
  82         getWindowResizeParams(x_offset, width);
  83         w.resize(width, MainHeight);
  84         w.moveTo(x_offset, MainStartY);
  85
  86         switch (Config.playlist_display_mode)
  87         {
  88                 case DisplayMode::Columns:
  89                         if (Config.titles_visibility)
  90                         {
  91                                 w.setTitle(Display::Columns(w.getWidth()));
  92                                 break;
  93                         }
  94                 case DisplayMode::Classic:
  95                         w.setTitle("");
  96         }
  97
  98         hasToBeResized = 0;
  99 }
 100
 101 std::wstring Playlist::title()
 102 {
 103         std::wstring result = L"Playlist ";
 104         if (m_reload_total_length || m_reload_remaining)
 105                 m_stats = getTotalLength();
 106         result += Scroller(ToWString(m_stats), m_scroll_begin, COLS-result.length()-(Config.design == Design::Alternative ? 2 : Global::VolumeState.length()));
 107         return result;
 108 }
 109
 110 void Playlist::update()
 111 {
 112         if (w.isHighlighted()
 113         &&  Config.playlist_disable_highlight_delay.time_duration::seconds() > 0
 114         &&  Global::Timer - m_timer > Config.playlist_disable_highlight_delay)
 115         {
 116                 w.setHighlighting(false);
 117                 w.refresh();
 118         }
 119 }
 120
 121 void Playlist::enterPressed()
 122 {
 123         if (!w.empty())
 124                 Mpd.PlayID(w.current().value().getID());
 125 }
 126
 127 void Playlist::spacePressed()
 128 {
 129         if (!w.empty())
 130         {
 131                 w.current().setSelected(!w.current().isSelected());
 132                 w.scroll(NC::Scroll::Down);
 133         }
 134 }
 135
 136 void Playlist::mouseButtonPressed(MEVENT me)
 137 {
 138         if (!w.empty() && w.hasCoords(me.x, me.y))
 139         {
 140                 if (size_t(me.y) < w.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 141                 {
 142                         w.Goto(me.y);
 143                         if (me.bstate & BUTTON3_PRESSED)
 144                                 enterPressed();
 145                 }
 146                 else
 147                         Screen<WindowType>::mouseButtonPressed(me);
 148         }
 149 }
 150
 151 /***********************************************************************/
 152
 153 bool Playlist::allowsFiltering()
 154 {
 155         return true;
 156 }
 157
 158 std::string Playlist::currentFilter()
 159 {
 160         return RegexFilter<MPD::Song>::currentFilter(w);
 161 }
 162
 163 void Playlist::applyFilter(const std::string &filter)
 164 {
 165         if (filter.empty())
 166         {
 167                 w.clearFilter();
 168                 w.clearFilterResults();
 169                 return;
 170         }
 171         try
 172         {
 173                 w.showAll();
 174                 auto rx = RegexFilter<MPD::Song>(
 175                         boost::regex(filter, Config.regex_type), playlistEntryMatcher);
 176                 w.filter(w.begin(), w.end(), rx);
 177         }
 178         catch (boost::bad_expression &) { }
 179 }
 180
 181 /***********************************************************************/
 182
 183 bool Playlist::allowsSearching()
 184 {
 185         return true;
 186 }
 187
 188 bool Playlist::search(const std::string &constraint)
 189 {
 190         if (constraint.empty())
 191         {
 192                 w.clearSearchResults();
 193                 return false;
 194         }
 195         try
 196         {
 197                 auto rx = RegexFilter<MPD::Song>(
 198                         boost::regex(constraint, Config.regex_type), playlistEntryMatcher);
 199                 return w.search(w.begin(), w.end(), rx);
 200         }
 201         catch (boost::bad_expression &)
 202         {
 203                 return false;
 204         }
 205 }
 206
 207 void Playlist::nextFound(bool wrap)
 208 {
 209         w.nextFound(wrap);
 210 }
 211
 212 void Playlist::prevFound(bool wrap)
 213 {
 214         w.prevFound(wrap);
 215 }
 216
 217 /***********************************************************************/
 218
 219 ProxySongList Playlist::proxySongList()
 220 {
 221         return ProxySongList(w, [](NC::Menu<MPD::Song>::Item &item) {
 222                 return &item.value();
 223         });
 224 }
 225
 226 bool Playlist::allowsSelection()
 227 {
 228         return true;
 229 }
 230
 231 void Playlist::reverseSelection()
 232 {
 233         reverseSelectionHelper(w.begin(), w.end());
 234 }
 235
 236 MPD::SongList Playlist::getSelectedSongs()
 237 {
 238         MPD::SongList result;
 239         for (auto it = w.begin(); it != w.end(); ++it)
 240                 if (it->isSelected())
 241                         result.push_back(it->value());
 242         if (result.empty() && !w.empty())
 243                 result.push_back(w.current().value());
 244         return result;
 245 }
 246
 247 /***********************************************************************/
 248
 249 MPD::Song Playlist::nowPlayingSong()
 250 {
 251         MPD::Song s;
 252         if (Status::get().playerState() != MPD::psStop)
 253                 withUnfilteredMenu(w, [this, &s]() {
 254                         s = w.at(Status::get().currentSongPosition()).value();
 255                 });
 256         return s;
 257 }
 258
 259 bool Playlist::isFiltered()
 260 {
 261         if (w.isFiltered())
 262         {
 263                 Statusbar::print("Function currently unavailable due to filtered playlist");
 264                 return true;
 265         }
 266         return false;
 267 }
 268
 269 void Playlist::Reverse()
 270 {
 271         Statusbar::print("Reversing playlist order...");
 272         auto begin = w.begin(), end = w.end();
 273         std::tie(begin, end) = getSelectedRange(begin, end);
 274         Mpd.StartCommandsList();
 275         for (--end; begin < end; ++begin, --end)
 276                 Mpd.Swap(begin->value().getPosition(), end->value().getPosition());
 277         Mpd.CommitCommandsList();
 278         Statusbar::print("Playlist reversed");
 279 }
 280
 281 void Playlist::EnableHighlighting()
 282 {
 283         w.setHighlighting(true);
 284         m_timer = Global::Timer;
 285 }
 286
 287 std::string Playlist::getTotalLength()
 288 {
 289         std::ostringstream result;
 290
 291         if (m_reload_total_length)
 292         {
 293                 m_total_length = 0;
 294                 for (const auto &s : w)
 295                         m_total_length += s.value().getDuration();
 296                 m_reload_total_length = false;
 297         }
 298         if (Config.playlist_show_remaining_time && m_reload_remaining && !w.isFiltered())
 299         {
 300                 m_remaining_time = 0;
 301                 for (size_t i = Status::get().currentSongPosition(); i < w.size(); ++i)
 302                         m_remaining_time += w[i].value().getDuration();
 303                 m_reload_remaining = false;
 304         }
 305
 306         result << '(' << w.size() << (w.size() == 1 ? " item" : " items");
 307
 308         if (w.isFiltered())
 309         {
 310                 w.showAll();
 311                 size_t real_size = w.size();
 312                 w.showFiltered();
 313                 if (w.size() != real_size)
 314                         result << " (out of " << real_size << ")";
 315         }
 316
 317         if (m_total_length)
 318         {
 319                 result << ", length: ";
 320                 ShowTime(result, m_total_length, Config.playlist_shorten_total_times);
 321         }
 322         if (Config.playlist_show_remaining_time && m_remaining_time && !w.isFiltered() && w.size() > 1)
 323         {
 324                 result << " :: remaining: ";
 325                 ShowTime(result, m_remaining_time, Config.playlist_shorten_total_times);
 326         }
 327         result << ')';
 328         return result.str();
 329 }
 330
 331 void Playlist::SetSelectedItemsPriority(int prio)
 332 {
 333         auto list = getSelectedOrCurrent(w.begin(), w.end(), w.currentI());
 334         Mpd.StartCommandsList();
 335         for (auto it = list.begin(); it != list.end(); ++it)
 336                 Mpd.SetPriority((*it)->value(), prio);
 337         Mpd.CommitCommandsList();
 338         Statusbar::print("Priority set");
 339 }
 340
 341 bool Playlist::checkForSong(const MPD::Song &s)
 342 {
 343         return m_song_refs.find(s) != m_song_refs.end();
 344 }
 345
 346 void Playlist::registerSong(const MPD::Song &s)
 347 {
 348         ++m_song_refs[s];
 349 }
 350
 351 void Playlist::unregisterSong(const MPD::Song &s)
 352 {
 353         auto it = m_song_refs.find(s);
 354         assert(it != m_song_refs.end());
 355         if (it->second == 1)
 356                 m_song_refs.erase(it);
 357         else
 358                 --it->second;
 359 }
 360
 361 namespace {//
 362
 363 std::string songToString(const MPD::Song &s)
 364 {
 365         std::string result;
 366         switch (Config.playlist_display_mode)
 367         {
 368                 case DisplayMode::Classic:
 369                         result = s.toString(Config.song_list_format_dollar_free, Config.tags_separator);
 370                         break;
 371                 case DisplayMode::Columns:
 372                         result = s.toString(Config.song_in_columns_to_string_format, Config.tags_separator);
 373         }
 374         return result;
 375 }
 376
 377 bool playlistEntryMatcher(const boost::regex &rx, const MPD::Song &s)
 378 {
 379         return boost::regex_search(songToString(s), rx);
 380 }
 381
 382 }