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/date_time/posix_time/posix_time.hpp>
  23 #include <sstream>
  24
  25 #include "display.h"
  26 #include "global.h"
  27 #include "helpers.h"
  28 #include "menu_impl.h"
  29 #include "playlist.h"
  30 #include "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::enterPressed()
 135 {
 136         if (!w.empty())
 137                 Mpd.PlayID(w.current()->value().getID());
 138 }
 139
 140 void Playlist::mouseButtonPressed(MEVENT me)
 141 {
 142         if (!w.empty() && w.hasCoords(me.x, me.y))
 143         {
 144                 if (size_t(me.y) < w.size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 145                 {
 146                         w.Goto(me.y);
 147                         if (me.bstate & BUTTON3_PRESSED)
 148                                 enterPressed();
 149                 }
 150                 else
 151                         Screen<WindowType>::mouseButtonPressed(me);
 152         }
 153 }
 154
 155 /***********************************************************************/
 156
 157 bool Playlist::allowsSearching()
 158 {
 159         return true;
 160 }
 161
 162 void Playlist::setSearchConstraint(const std::string &constraint)
 163 {
 164         m_search_predicate = Regex::Filter<MPD::Song>(
 165                 Regex::make(constraint, Config.regex_type), playlistEntryMatcher
 166         );
 167 }
 168
 169 void Playlist::clearConstraint()
 170 {
 171         m_search_predicate.clear();
 172 }
 173
 174 bool Playlist::find(SearchDirection direction, bool wrap, bool skip_current)
 175 {
 176         return search(w, m_search_predicate, direction, wrap, skip_current);
 177 }
 178
 179 /***********************************************************************/
 180
 181 std::vector<MPD::Song> Playlist::getSelectedSongs()
 182 {
 183         return w.getSelectedSongs();
 184 }
 185
 186 /***********************************************************************/
 187
 188 MPD::Song Playlist::nowPlayingSong()
 189 {
 190         MPD::Song s;
 191         if (Status::State::player() != MPD::psUnknown)
 192         {
 193                 auto sp = Status::State::currentSongPosition();
 194                 if (sp >= 0 && size_t(sp) < w.size())
 195                         s = w.at(sp).value();
 196         }
 197         return s;
 198 }
 199
 200 void Playlist::EnableHighlighting()
 201 {
 202         w.setHighlighting(true);
 203         m_timer = Global::Timer;
 204 }
 205
 206 std::string Playlist::getTotalLength()
 207 {
 208         std::ostringstream result;
 209
 210         if (m_reload_total_length)
 211         {
 212                 m_total_length = 0;
 213                 for (const auto &s : w)
 214                         m_total_length += s.value().getDuration();
 215                 m_reload_total_length = false;
 216         }
 217         if (Config.playlist_show_remaining_time && m_reload_remaining)
 218         {
 219                 m_remaining_time = 0;
 220                 for (size_t i = Status::State::currentSongPosition(); i < w.size(); ++i)
 221                         m_remaining_time += w[i].value().getDuration();
 222                 m_reload_remaining = false;
 223         }
 224
 225         result << '(' << w.size() << (w.size() == 1 ? " item" : " items");
 226
 227         if (m_total_length)
 228         {
 229                 result << ", length: ";
 230                 ShowTime(result, m_total_length, Config.playlist_shorten_total_times);
 231         }
 232         if (Config.playlist_show_remaining_time && m_remaining_time && w.size() > 1)
 233         {
 234                 result << " :: remaining: ";
 235                 ShowTime(result, m_remaining_time, Config.playlist_shorten_total_times);
 236         }
 237         result << ')';
 238         return result.str();
 239 }
 240
 241 void Playlist::SetSelectedItemsPriority(int prio)
 242 {
 243         auto list = getSelectedOrCurrent(w.begin(), w.end(), w.current());
 244         Mpd.StartCommandsList();
 245         for (auto it = list.begin(); it != list.end(); ++it)
 246                 Mpd.SetPriority((*it)->value(), prio);
 247         Mpd.CommitCommandsList();
 248         Statusbar::print("Priority set");
 249 }
 250
 251 bool Playlist::checkForSong(const MPD::Song &s)
 252 {
 253         return m_song_refs.find(s) != m_song_refs.end();
 254 }
 255
 256 void Playlist::registerSong(const MPD::Song &s)
 257 {
 258         ++m_song_refs[s];
 259 }
 260
 261 void Playlist::unregisterSong(const MPD::Song &s)
 262 {
 263         auto it = m_song_refs.find(s);
 264         assert(it != m_song_refs.end());
 265         if (it->second == 1)
 266                 m_song_refs.erase(it);
 267         else
 268                 --it->second;
 269 }
 270
 271 namespace {
 272
 273 std::string songToString(const MPD::Song &s)
 274 {
 275         std::string result;
 276         switch (Config.playlist_display_mode)
 277         {
 278                 case DisplayMode::Classic:
 279                         result = Format::stringify<char>(Config.song_list_format, &s);
 280                         break;
 281                 case DisplayMode::Columns:
 282                         result = Format::stringify<char>(Config.song_columns_mode_format, &s);
 283         }
 284         return result;
 285 }
 286
 287 bool playlistEntryMatcher(const Regex::Regex &rx, const MPD::Song &s)
 288 {
 289         return Regex::search(songToString(s), rx);
 290 }
 291
 292 }