src/screens/playlist.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2016 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/date_time/posix_time/posix_time.hpp>
  23 #include <sstream>
  24
  25 #include "curses/menu_impl.h"
  26 #include "display.h"
  27 #include "global.h"
  28 #include "helpers.h"
  29 #include "screens/playlist.h"
  30 #include "screens/screen_switcher.h"
  31 #include "song.h"
  32 #include "status.h"
  33 #include "statusbar.h"
  34 #include "helpers/song_iterator_maker.h"
  35 #include "utility/comparators.h"
  36 #include "utility/functional.h"
  37 #include "title.h"
  38
  39 using Global::MainHeight;
  40 using Global::MainStartY;
  41
  42 namespace ph = std::placeholders;
  43
  44 Playlist *myPlaylist;
  45
  46 namespace {
  47
  48 std::string songToString(const MPD::Song &s);
  49 bool playlistEntryMatcher(const Regex::Regex &rx, const MPD::Song &s);
  50
  51 }
  52
  53 Playlist::Playlist()
  54 : m_total_length(0), m_remaining_time(0), m_scroll_begin(0)
  55 , m_timer(boost::posix_time::from_time_t(0))
  56 , m_reload_total_length(false), m_reload_remaining(false)
  57 {
  58         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());
  59         w.cyclicScrolling(Config.use_cyclic_scrolling);
  60         w.centeredCursor(Config.centered_cursor);
  61         w.setHighlightColor(Config.main_highlight_color);
  62         w.setSelectedPrefix(Config.selected_item_prefix);
  63         w.setSelectedSuffix(Config.selected_item_suffix);
  64         switch (Config.playlist_display_mode)
  65         {
  66                 case DisplayMode::Classic:
  67                         w.setItemDisplayer(std::bind(
  68                                 Display::Songs, ph::_1, std::cref(w), std::cref(Config.song_list_format)
  69                         ));
  70                         break;
  71                 case DisplayMode::Columns:
  72                         w.setItemDisplayer(std::bind(
  73                                 Display::SongsInColumns, ph::_1, std::cref(w)
  74                         ));
  75                         break;
  76         }
  77 }
  78
  79 void Playlist::switchTo()
  80 {
  81         SwitchTo::execute(this);
  82         m_scroll_begin = 0;
  83         drawHeader();
  84 }
  85
  86 void Playlist::resize()
  87 {
  88         size_t x_offset, width;
  89         getWindowResizeParams(x_offset, width);
  90         w.resize(width, MainHeight);
  91         w.moveTo(x_offset, MainStartY);
  92
  93         switch (Config.playlist_display_mode)
  94         {
  95                 case DisplayMode::Columns:
  96                         if (Config.titles_visibility)
  97                         {
  98                                 w.setTitle(Display::Columns(w.getWidth()));
  99                                 break;
 100                         }
 101                 case DisplayMode::Classic:
 102                         w.setTitle("");
 103         }
 104
 105         hasToBeResized = 0;
 106 }
 107
 108 std::wstring Playlist::title()
 109 {
 110         std::wstring result = L"Playlist ";
 111         if (Config.playlist_show_mpd_host)
 112         {
 113                 result += L"on ";
 114                 result += ToWString(Mpd.GetHostname());
 115                 result += L" ";
 116         }
 117         if (m_reload_total_length || m_reload_remaining)
 118                 m_stats = getTotalLength();
 119         result += Scroller(ToWString(m_stats), m_scroll_begin, COLS-result.length()-(Config.design == Design::Alternative ? 2 : Global::VolumeState.length()));
 120         return result;
 121 }
 122
 123 void Playlist::update()
 124 {
 125         if (w.isHighlighted()
 126         &&  Config.playlist_disable_highlight_delay.time_duration::seconds() > 0
 127         &&  Global::Timer - m_timer > Config.playlist_disable_highlight_delay)
 128         {
 129                 w.setHighlighting(false);
 130                 w.refresh();
 131         }
 132 }
 133
 134 void Playlist::mouseButtonPressed(MEVENT me)
 135 {
 136         if (!w.empty() && w.hasCoords(me.x, me.y))
 137         {
 138                 if (size_t(me.y) < w.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 139                 {
 140                         w.Goto(me.y);
 141                         if (me.bstate & BUTTON3_PRESSED)
 142                                 addItemToPlaylist(true);
 143                 }
 144                 else
 145                         Screen<WindowType>::mouseButtonPressed(me);
 146         }
 147 }
 148
 149 /***********************************************************************/
 150
 151 bool Playlist::allowsSearching()
 152 {
 153         return true;
 154 }
 155
 156 const std::string &Playlist::searchConstraint()
 157 {
 158         return m_search_predicate.constraint();
 159 }
 160
 161 void Playlist::setSearchConstraint(const std::string &constraint)
 162 {
 163         m_search_predicate = Regex::Filter<MPD::Song>(
 164                 constraint,
 165                 Config.regex_type,
 166                 playlistEntryMatcher);
 167 }
 168
 169 void Playlist::clearSearchConstraint()
 170 {
 171         m_search_predicate.clear();
 172 }
 173
 174 bool Playlist::search(SearchDirection direction, bool wrap, bool skip_current)
 175 {
 176         return ::search(w, m_search_predicate, direction, wrap, skip_current);
 177 }
 178
 179 /***********************************************************************/
 180
 181 bool Playlist::allowsFiltering()
 182 {
 183         return allowsSearching();
 184 }
 185
 186 std::string Playlist::currentFilter()
 187 {
 188         std::string result;
 189         if (auto pred = w.filterPredicate<Regex::Filter<MPD::Song>>())
 190                 result = pred->constraint();
 191         return result;
 192 }
 193
 194 void Playlist::applyFilter(const std::string &constraint)
 195 {
 196         if (!constraint.empty())
 197         {
 198                 w.applyFilter(Regex::Filter<MPD::Song>(
 199                                       constraint,
 200                                       Config.regex_type,
 201                                       playlistEntryMatcher));
 202         }
 203         else
 204                 w.clearFilter();
 205 }
 206
 207 /***********************************************************************/
 208
 209 bool Playlist::itemAvailable()
 210 {
 211         return !w.empty();
 212 }
 213
 214 bool Playlist::addItemToPlaylist(bool play)
 215 {
 216         if (play)
 217                 Mpd.PlayID(w.currentV()->getID());
 218         return true;
 219 }
 220
 221 std::vector<MPD::Song> Playlist::getSelectedSongs()
 222 {
 223         return w.getSelectedSongs();
 224 }
 225
 226 /***********************************************************************/
 227
 228 MPD::Song Playlist::nowPlayingSong()
 229 {
 230         MPD::Song s;
 231         if (Status::State::player() != MPD::psUnknown)
 232         {
 233                 ScopedUnfilteredMenu<MPD::Song> sunfilter(ReapplyFilter::No, w);
 234                 auto sp = Status::State::currentSongPosition();
 235                 if (sp >= 0 && size_t(sp) < w.size())
 236                         s = w.at(sp).value();
 237         }
 238         return s;
 239 }
 240
 241 void Playlist::locateSong(const MPD::Song &s)
 242 {
 243         if (!w.isFiltered())
 244                 w.highlight(s.getPosition());
 245         else
 246         {
 247                 auto cmp = [](const MPD::Song &a, const MPD::Song &b) {
 248                         return a.getPosition() < b.getPosition();
 249                 };
 250                 auto first = w.beginV(), last = w.endV();
 251                 auto it = std::lower_bound(first, last, s, cmp);
 252                 if (it != last && it->getPosition() == s.getPosition())
 253                         w.highlight(it - first);
 254                 else
 255                         Statusbar::print("Song is filtered out");
 256         }
 257 }
 258
 259 void Playlist::enableHighlighting()
 260 {
 261         w.setHighlighting(true);
 262         m_timer = Global::Timer;
 263 }
 264
 265 std::string Playlist::getTotalLength()
 266 {
 267         std::ostringstream result;
 268
 269         if (m_reload_total_length)
 270         {
 271                 m_total_length = 0;
 272                 for (const auto &s : w)
 273                         m_total_length += s.value().getDuration();
 274                 m_reload_total_length = false;
 275         }
 276         if (Config.playlist_show_remaining_time && m_reload_remaining)
 277         {
 278                 ScopedUnfilteredMenu<MPD::Song> sunfilter(ReapplyFilter::No, w);
 279                 m_remaining_time = 0;
 280                 for (size_t i = Status::State::currentSongPosition(); i < w.size(); ++i)
 281                         m_remaining_time += w[i].value().getDuration();
 282                 m_reload_remaining = false;
 283         }
 284
 285         result << '(' << w.size() << (w.size() == 1 ? " item" : " items");
 286
 287         if (w.isFiltered())
 288         {
 289                 ScopedUnfilteredMenu<MPD::Song> sunfilter(ReapplyFilter::No, w);
 290                 result << " (out of " << w.size() << ")";
 291         }
 292
 293         if (m_total_length)
 294         {
 295                 result << ", length: ";
 296                 ShowTime(result, m_total_length, Config.playlist_shorten_total_times);
 297         }
 298         if (Config.playlist_show_remaining_time && m_remaining_time && w.size() > 1)
 299         {
 300                 result << ", remaining: ";
 301                 ShowTime(result, m_remaining_time, Config.playlist_shorten_total_times);
 302         }
 303         result << ')';
 304         return result.str();
 305 }
 306
 307 void Playlist::setSelectedItemsPriority(int prio)
 308 {
 309         auto list = getSelectedOrCurrent(w.begin(), w.end(), w.current());
 310         Mpd.StartCommandsList();
 311         for (auto it = list.begin(); it != list.end(); ++it)
 312                 Mpd.SetPriority((*it)->value(), prio);
 313         Mpd.CommitCommandsList();
 314         Statusbar::print("Priority set");
 315 }
 316
 317 bool Playlist::checkForSong(const MPD::Song &s)
 318 {
 319         return m_song_refs.find(s) != m_song_refs.end();
 320 }
 321
 322 void Playlist::registerSong(const MPD::Song &s)
 323 {
 324         ++m_song_refs[s];
 325 }
 326
 327 void Playlist::unregisterSong(const MPD::Song &s)
 328 {
 329         auto it = m_song_refs.find(s);
 330         assert(it != m_song_refs.end());
 331         if (it->second == 1)
 332                 m_song_refs.erase(it);
 333         else
 334                 --it->second;
 335 }
 336
 337 namespace {
 338
 339 std::string songToString(const MPD::Song &s)
 340 {
 341         std::string result;
 342         switch (Config.playlist_display_mode)
 343         {
 344                 case DisplayMode::Classic:
 345                         result = Format::stringify<char>(Config.song_list_format, &s);
 346                         break;
 347                 case DisplayMode::Columns:
 348                         result = Format::stringify<char>(Config.song_columns_mode_format, &s);
 349         }
 350         return result;
 351 }
 352
 353 bool playlistEntryMatcher(const Regex::Regex &rx, const MPD::Song &s)
 354 {
 355         return Regex::search(songToString(s), rx);
 356 }
 357
 358 }