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