src/playlist_editor.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2012 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 <cassert>
  22 #include <algorithm>
  23
  24 #include "charset.h"
  25 #include "display.h"
  26 #include "global.h"
  27 #include "helpers.h"
  28 #include "playlist.h"
  29 #include "playlist_editor.h"
  30 #include "mpdpp.h"
  31 #include "regex_filter.h"
  32 #include "status.h"
  33 #include "statusbar.h"
  34 #include "tag_editor.h"
  35 #include "utility/comparators.h"
  36 #include "title.h"
  37
  38 using namespace std::placeholders;
  39
  40 using Global::MainHeight;
  41 using Global::MainStartY;
  42
  43 PlaylistEditor *myPlaylistEditor = new PlaylistEditor;
  44
  45 namespace {//
  46
  47 size_t LeftColumnStartX;
  48 size_t LeftColumnWidth;
  49 size_t RightColumnStartX;
  50 size_t RightColumnWidth;
  51
  52 std::string SongToString(const MPD::Song &s);
  53 bool PlaylistEntryMatcher(const Regex &rx, const std::string &playlist);
  54 bool SongEntryMatcher(const Regex &rx, const MPD::Song &s);
  55
  56 }
  57
  58 void PlaylistEditor::init()
  59 {
  60         LeftColumnWidth = COLS/3-1;
  61         RightColumnStartX = LeftColumnWidth+1;
  62         RightColumnWidth = COLS-LeftColumnWidth-1;
  63
  64         Playlists = new NC::Menu<std::string>(0, MainStartY, LeftColumnWidth, MainHeight, Config.titles_visibility ? "Playlists" : "", Config.main_color, NC::brNone);
  65         Playlists->setHighlightColor(Config.active_column_color);
  66         Playlists->cyclicScrolling(Config.use_cyclic_scrolling);
  67         Playlists->centeredCursor(Config.centered_cursor);
  68         Playlists->setSelectedPrefix(Config.selected_item_prefix);
  69         Playlists->setSelectedSuffix(Config.selected_item_suffix);
  70         Playlists->setItemDisplayer(Display::Default<std::string>);
  71
  72         Content = new NC::Menu<MPD::Song>(RightColumnStartX, MainStartY, RightColumnWidth, MainHeight, Config.titles_visibility ? "Playlist content" : "", Config.main_color, NC::brNone);
  73         Content->setHighlightColor(Config.main_highlight_color);
  74         Content->cyclicScrolling(Config.use_cyclic_scrolling);
  75         Content->centeredCursor(Config.centered_cursor);
  76         Content->setSelectedPrefix(Config.selected_item_prefix);
  77         Content->setSelectedSuffix(Config.selected_item_suffix);
  78         if (Config.columns_in_playlist_editor)
  79                 Content->setItemDisplayer(std::bind(Display::SongsInColumns, _1, this));
  80         else
  81                 Content->setItemDisplayer(std::bind(Display::Songs, _1, this, Config.song_list_format));
  82
  83         w = Playlists;
  84         isInitialized = 1;
  85 }
  86
  87 void PlaylistEditor::resize()
  88 {
  89         size_t x_offset, width;
  90         getWindowResizeParams(x_offset, width);
  91
  92         LeftColumnStartX = x_offset;
  93         LeftColumnWidth = width/3-1;
  94         RightColumnStartX = LeftColumnStartX+LeftColumnWidth+1;
  95         RightColumnWidth = width-LeftColumnWidth-1;
  96
  97         Playlists->resize(LeftColumnWidth, MainHeight);
  98         Content->resize(RightColumnWidth, MainHeight);
  99
 100         Playlists->moveTo(LeftColumnStartX, MainStartY);
 101         Content->moveTo(RightColumnStartX, MainStartY);
 102
 103         hasToBeResized = 0;
 104 }
 105
 106 std::wstring PlaylistEditor::title()
 107 {
 108         return L"Playlist editor";
 109 }
 110
 111 void PlaylistEditor::refresh()
 112 {
 113         Playlists->display();
 114         mvvline(MainStartY, RightColumnStartX-1, 0, MainHeight);
 115         Content->display();
 116 }
 117
 118 void PlaylistEditor::switchTo()
 119 {
 120         using Global::myScreen;
 121         using Global::myLockedScreen;
 122
 123         if (myScreen == this)
 124                 return;
 125
 126         if (!isInitialized)
 127                 init();
 128
 129         if (myLockedScreen)
 130                 updateInactiveScreen(this);
 131
 132         if (hasToBeResized || myLockedScreen)
 133                 resize();
 134
 135         if (myScreen != this && myScreen->isTabbable())
 136                 Global::myPrevScreen = myScreen;
 137         myScreen = this;
 138         drawHeader();
 139         markSongsInPlaylist(contentProxyList());
 140         refresh();
 141 }
 142
 143 void PlaylistEditor::update()
 144 {
 145         if (Playlists->reallyEmpty() || playlistsUpdateRequested)
 146         {
 147                 playlistsUpdateRequested = false;
 148                 Playlists->clearSearchResults();
 149                 withUnfilteredMenuReapplyFilter(*Playlists, [this]() {
 150                         auto list = Mpd.GetPlaylists();
 151                         std::sort(list.begin(), list.end(),
 152                                 LocaleBasedSorting(std::locale(), Config.ignore_leading_the));
 153                         auto playlist = list.begin();
 154                         if (Playlists->size() > list.size())
 155                                 Playlists->resizeList(list.size());
 156                         for (auto it = Playlists->begin(); it != Playlists->end(); ++it, ++playlist)
 157                                 it->value() = *playlist;
 158                         for (; playlist != list.end(); ++playlist)
 159                                 Playlists->addItem(*playlist);
 160                 });
 161                 Playlists->refresh();
 162         }
 163
 164         if (!Playlists->empty() && (Content->reallyEmpty() || contentUpdateRequested))
 165         {
 166                 contentUpdateRequested = false;
 167                 Content->clearSearchResults();
 168                 withUnfilteredMenuReapplyFilter(*Content, [this]() {
 169                         auto list = Mpd.GetPlaylistContent(Playlists->current().value());
 170                         auto song = list.begin();
 171                         if (Content->size() > list.size())
 172                                 Content->resizeList(list.size());
 173                         for (auto it = Content->begin(); it != Content->end(); ++it, ++song)
 174                         {
 175                                 it->value() = *song;
 176                                 it->setBold(myPlaylist->checkForSong(*song));
 177                         }
 178                         for (; song != list.end(); ++song)
 179                                 Content->addItem(*song, myPlaylist->checkForSong(*song));
 180                         std::string title;
 181                         if (Config.titles_visibility)
 182                         {
 183                                 title = "Playlist content";
 184                                 title += " (";
 185                                 title += unsignedLongIntTo<std::string>::apply(list.size());
 186                                 title += " item";
 187                                 if (list.size() == 1)
 188                                         title += ")";
 189                                 else
 190                                         title += "s)";
 191                                 title.resize(Content->getWidth());
 192                         }
 193                         Content->setTitle(title);
 194                 });
 195                 Content->display();
 196         }
 197
 198         if (w == Content && Content->reallyEmpty())
 199         {
 200                 Content->setHighlightColor(Config.main_highlight_color);
 201                 Playlists->setHighlightColor(Config.active_column_color);
 202                 w = Playlists;
 203         }
 204
 205         if (Playlists->empty() && Content->reallyEmpty())
 206         {
 207                 Content->Window::clear();
 208                 Content->Window::display();
 209         }
 210 }
 211
 212 bool PlaylistEditor::isContentFiltered()
 213 {
 214         if (Content->isFiltered())
 215         {
 216                 Statusbar::msg("Function currently unavailable due to filtered playlist content");
 217                 return true;
 218         }
 219         return false;
 220 }
 221
 222 std::shared_ptr<ProxySongList> PlaylistEditor::contentProxyList()
 223 {
 224         return mkProxySongList(*Content, [](NC::Menu<MPD::Song>::Item &item) {
 225                 return &item.value();
 226         });
 227 }
 228
 229 void PlaylistEditor::AddToPlaylist(bool add_n_play)
 230 {
 231         MPD::SongList list;
 232
 233         if (w == Playlists && !Playlists->empty())
 234         {
 235                 if (Mpd.LoadPlaylist(Playlists->current().value()))
 236                 {
 237                         Statusbar::msg("Playlist \"%s\" loaded", Playlists->current().value().c_str());
 238                         if (add_n_play)
 239                                 myPlaylist->PlayNewlyAddedSongs();
 240                 }
 241         }
 242         else if (w == Content && !Content->empty())
 243                 myPlaylist->Add(Content->current().value(), add_n_play);
 244
 245         if (!add_n_play)
 246                 w->scroll(NC::wDown);
 247 }
 248
 249 void PlaylistEditor::enterPressed()
 250 {
 251         AddToPlaylist(true);
 252 }
 253
 254 void PlaylistEditor::spacePressed()
 255 {
 256         if (Config.space_selects)
 257         {
 258                 if (w == Playlists)
 259                 {
 260                         if (!Playlists->empty())
 261                         {
 262                                 Playlists->current().setSelected(!Playlists->current().isSelected());
 263                                 Playlists->scroll(NC::wDown);
 264                         }
 265                 }
 266                 else if (w == Content)
 267                 {
 268                         if (!Content->empty())
 269                         {
 270                                 Content->current().setSelected(!Content->current().isSelected());
 271                                 Content->scroll(NC::wDown);
 272                         }
 273                 }
 274         }
 275         else
 276                 AddToPlaylist(false);
 277 }
 278
 279 void PlaylistEditor::mouseButtonPressed(MEVENT me)
 280 {
 281         if (!Playlists->empty() && Playlists->hasCoords(me.x, me.y))
 282         {
 283                 if (w != Playlists)
 284                 {
 285                         if (previousColumnAvailable())
 286                                 previousColumn();
 287                         else
 288                                 return;
 289                 }
 290                 if (size_t(me.y) < Playlists->size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 291                 {
 292                         Playlists->Goto(me.y);
 293                         if (me.bstate & BUTTON3_PRESSED)
 294                         {
 295                                 size_t pos = Playlists->choice();
 296                                 spacePressed();
 297                                 if (pos < Playlists->size()-1)
 298                                         Playlists->scroll(NC::wUp);
 299                         }
 300                 }
 301                 else
 302                         Screen<NC::Window>::mouseButtonPressed(me);
 303                 Content->clear();
 304         }
 305         else if (!Content->empty() && Content->hasCoords(me.x, me.y))
 306         {
 307                 if (w != Content)
 308                 {
 309                         if (nextColumnAvailable())
 310                                 nextColumn();
 311                         else
 312                                 return;
 313                 }
 314                 if (size_t(me.y) < Content->size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 315                 {
 316                         Content->Goto(me.y);
 317                         if (me.bstate & BUTTON1_PRESSED)
 318                         {
 319                                 size_t pos = Content->choice();
 320                                 spacePressed();
 321                                 if (pos < Content->size()-1)
 322                                         Content->scroll(NC::wUp);
 323                         }
 324                         else
 325                                 enterPressed();
 326                 }
 327                 else
 328                         Screen<NC::Window>::mouseButtonPressed(me);
 329         }
 330 }
 331
 332 /***********************************************************************/
 333
 334 bool PlaylistEditor::allowsFiltering()
 335 {
 336         return true;
 337 }
 338
 339 std::string PlaylistEditor::currentFilter()
 340 {
 341         std::string filter;
 342         if (w == Playlists)
 343                 filter = RegexFilter<std::string>::currentFilter(*Playlists);
 344         else if (w == Content)
 345                 filter = RegexFilter<MPD::Song>::currentFilter(*Content);
 346         return filter;
 347 }
 348
 349 void PlaylistEditor::applyFilter(const std::string &filter)
 350 {
 351         if (w == Playlists)
 352         {
 353                 Playlists->showAll();
 354                 auto rx = RegexFilter<std::string>(filter, Config.regex_type, PlaylistEntryMatcher);
 355                 Playlists->filter(Playlists->begin(), Playlists->end(), rx);
 356         }
 357         else if (w == Content)
 358         {
 359                 Content->showAll();
 360                 auto rx = RegexFilter<MPD::Song>(filter, Config.regex_type, SongEntryMatcher);
 361                 Content->filter(Content->begin(), Content->end(), rx);
 362         }
 363 }
 364
 365 /***********************************************************************/
 366
 367 bool PlaylistEditor::allowsSearching()
 368 {
 369         return true;
 370 }
 371
 372 bool PlaylistEditor::search(const std::string &constraint)
 373 {
 374         bool result = false;
 375         if (w == Playlists)
 376         {
 377                 auto rx = RegexFilter<std::string>(constraint, Config.regex_type, PlaylistEntryMatcher);
 378                 result = Playlists->search(Playlists->begin(), Playlists->end(), rx);
 379         }
 380         else if (w == Content)
 381         {
 382                 auto rx = RegexFilter<MPD::Song>(constraint, Config.regex_type, SongEntryMatcher);
 383                 result = Content->search(Content->begin(), Content->end(), rx);
 384         }
 385         return result;
 386 }
 387
 388 void PlaylistEditor::nextFound(bool wrap)
 389 {
 390         if (w == Playlists)
 391                 Playlists->nextFound(wrap);
 392         else if (w == Content)
 393                 Content->nextFound(wrap);
 394 }
 395
 396 void PlaylistEditor::prevFound(bool wrap)
 397 {
 398         if (w == Playlists)
 399                 Playlists->prevFound(wrap);
 400         else if (w == Content)
 401                 Content->prevFound(wrap);
 402 }
 403
 404 /***********************************************************************/
 405
 406 std::shared_ptr<ProxySongList> PlaylistEditor::getProxySongList()
 407 {
 408         auto ptr = nullProxySongList();
 409         if (w == Content)
 410                 ptr = contentProxyList();
 411         return ptr;
 412 }
 413
 414 bool PlaylistEditor::allowsSelection()
 415 {
 416         return true;
 417 }
 418
 419 void PlaylistEditor::reverseSelection()
 420 {
 421         if (w == Playlists)
 422                 reverseSelectionHelper(Playlists->begin(), Playlists->end());
 423         else if (w == Content)
 424                 reverseSelectionHelper(Content->begin(), Content->end());
 425 }
 426
 427 MPD::SongList PlaylistEditor::getSelectedSongs()
 428 {
 429         MPD::SongList result;
 430         if (w == Playlists)
 431         {
 432                 bool any_selected = false;
 433                 for (auto it = Playlists->begin(); it != Playlists->end(); ++it)
 434                 {
 435                         if (it->isSelected())
 436                         {
 437                                 any_selected = true;
 438                                 auto songs = Mpd.GetPlaylistContent(it->value());
 439                                 result.insert(result.end(), songs.begin(), songs.end());
 440                         }
 441                 }
 442                 // we don't check for empty result here as it's possible that
 443                 // all selected playlists are empty.
 444                 if (!any_selected && !Content->empty())
 445                 {
 446                         withUnfilteredMenu(*Content, [this, &result]() {
 447                                 result.insert(result.end(), Content->beginV(), Content->endV());
 448                         });
 449                 }
 450         }
 451         else if (w == Content)
 452         {
 453                 for (auto it = Content->begin(); it != Content->end(); ++it)
 454                         if (it->isSelected())
 455                                 result.push_back(it->value());
 456                 // if no item is selected, add current one
 457                 if (result.empty() && !Content->empty())
 458                         result.push_back(Content->current().value());
 459         }
 460         return result;
 461 }
 462
 463 /***********************************************************************/
 464
 465 bool PlaylistEditor::previousColumnAvailable()
 466 {
 467         if (w == Content)
 468         {
 469                 if (!Playlists->reallyEmpty())
 470                         return true;
 471         }
 472         return false;
 473 }
 474
 475 void PlaylistEditor::previousColumn()
 476 {
 477         if (w == Content)
 478         {
 479                 Content->setHighlightColor(Config.main_highlight_color);
 480                 w->refresh();
 481                 w = Playlists;
 482                 Playlists->setHighlightColor(Config.active_column_color);
 483         }
 484 }
 485
 486 bool PlaylistEditor::nextColumnAvailable()
 487 {
 488         if (w == Playlists)
 489         {
 490                 if (!Content->reallyEmpty())
 491                         return true;
 492         }
 493         return false;
 494 }
 495
 496 void PlaylistEditor::nextColumn()
 497 {
 498         if (w == Playlists)
 499         {
 500                 Playlists->setHighlightColor(Config.main_highlight_color);
 501                 w->refresh();
 502                 w = Content;
 503                 Content->setHighlightColor(Config.active_column_color);
 504         }
 505 }
 506
 507 /***********************************************************************/
 508
 509
 510 void PlaylistEditor::Locate(const std::string &name)
 511 {
 512         if (!isInitialized)
 513                 init();
 514         update();
 515         for (size_t i = 0; i < Playlists->size(); ++i)
 516         {
 517                 if (name == (*Playlists)[i].value())
 518                 {
 519                         Playlists->highlight(i);
 520                         Content->clear();
 521                         break;
 522                 }
 523         }
 524         switchTo();
 525 }
 526
 527 namespace {//
 528
 529 std::string SongToString(const MPD::Song &s)
 530 {
 531         std::string result;
 532         if (Config.columns_in_playlist_editor)
 533                 result = s.toString(Config.song_in_columns_to_string_format, Config.tags_separator);
 534         else
 535                 result = s.toString(Config.song_list_format_dollar_free, Config.tags_separator);
 536         return result;
 537 }
 538
 539 bool PlaylistEntryMatcher(const Regex &rx, const std::string &playlist)
 540 {
 541         return rx.match(playlist);
 542 }
 543
 544 bool SongEntryMatcher(const Regex &rx, const MPD::Song &s)
 545 {
 546         return rx.match(SongToString(s));
 547 }
 548
 549 }