src/browser.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2013 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 <dirent.h>
  22 #include <sys/stat.h>
  23 #include <cerrno>
  24 #include <cstring>
  25 #include <boost/locale/conversion.hpp>
  26 #include <algorithm>
  27
  28 #include "browser.h"
  29 #include "charset.h"
  30 #include "display.h"
  31 #include "error.h"
  32 #include "global.h"
  33 #include "helpers.h"
  34 #include "playlist.h"
  35 #include "regex_filter.h"
  36 #include "screen_switcher.h"
  37 #include "settings.h"
  38 #include "status.h"
  39 #include "statusbar.h"
  40 #include "tag_editor.h"
  41 #include "title.h"
  42 #include "tags.h"
  43 #include "utility/comparators.h"
  44 #include "utility/string.h"
  45
  46 using namespace std::placeholders;
  47
  48 using Global::MainHeight;
  49 using Global::MainStartY;
  50 using Global::myScreen;
  51
  52 using MPD::itDirectory;
  53 using MPD::itSong;
  54 using MPD::itPlaylist;
  55
  56 Browser *myBrowser;
  57
  58 namespace {//
  59
  60 std::set<std::string> SupportedExtensions;
  61 bool hasSupportedExtension(const std::string &file);
  62
  63 std::string ItemToString(const MPD::Item &item);
  64 bool BrowserEntryMatcher(const boost::regex &rx, const MPD::Item &item, bool filter);
  65
  66 }
  67
  68 Browser::Browser() : itsBrowseLocally(0), itsScrollBeginning(0), itsBrowsedDir("/")
  69 {
  70         w = NC::Menu<MPD::Item>(0, MainStartY, COLS, MainHeight, Config.columns_in_browser && Config.titles_visibility ? Display::Columns(COLS) : "", Config.main_color, NC::Border::None);
  71         w.setHighlightColor(Config.main_highlight_color);
  72         w.cyclicScrolling(Config.use_cyclic_scrolling);
  73         w.centeredCursor(Config.centered_cursor);
  74         w.setSelectedPrefix(Config.selected_item_prefix);
  75         w.setSelectedSuffix(Config.selected_item_suffix);
  76         w.setItemDisplayer(std::bind(Display::Items, _1, proxySongList()));
  77 }
  78
  79 void Browser::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         w.setTitle(Config.columns_in_browser && Config.titles_visibility ? Display::Columns(w.getWidth()) : "");
  86         hasToBeResized = 0;
  87 }
  88
  89 void Browser::switchTo()
  90 {
  91         SwitchTo::execute(this);
  92
  93         // local browser doesn't support sorting by mtime
  94         if (isLocal() && Config.browser_sort_mode == smMTime)
  95                 Config.browser_sort_mode = smName;
  96
  97         if (w.empty())
  98                 GetDirectory(itsBrowsedDir);
  99         else
 100                 markSongsInPlaylist(proxySongList());
 101
 102         drawHeader();
 103 }
 104
 105 std::wstring Browser::title()
 106 {
 107         std::wstring result = L"Browse: ";
 108         result += Scroller(ToWString(itsBrowsedDir), itsScrollBeginning, COLS-result.length()-(Config.new_design ? 2 : Global::VolumeState.length()));
 109         return result;
 110 }
 111
 112 void Browser::enterPressed()
 113 {
 114         if (w.empty())
 115                 return;
 116
 117         const MPD::Item &item = w.current().value();
 118         switch (item.type)
 119         {
 120                 case itDirectory:
 121                 {
 122                         if (isParentDirectory(item))
 123                                 GetDirectory(getParentDirectory(itsBrowsedDir), itsBrowsedDir);
 124                         else
 125                                 GetDirectory(item.name, itsBrowsedDir);
 126                         drawHeader();
 127                         break;
 128                 }
 129                 case itSong:
 130                 {
 131                         addSongToPlaylist(*item.song, true, -1);
 132                         break;
 133                 }
 134                 case itPlaylist:
 135                 {
 136                         Mpd.LoadPlaylist(item.name);
 137                         Statusbar::msg("Playlist \"%s\" loaded", item.name.c_str());
 138                         myPlaylist->PlayNewlyAddedSongs();
 139                 }
 140         }
 141 }
 142
 143 void Browser::spacePressed()
 144 {
 145         if (w.empty())
 146                 return;
 147
 148         size_t i = itsBrowsedDir != "/" ? 1 : 0;
 149         if (Config.space_selects && w.choice() >= i)
 150         {
 151                 i = w.choice();
 152                 w.at(i).setSelected(!w.at(i).isSelected());
 153                 w.scroll(NC::Scroll::Down);
 154                 return;
 155         }
 156
 157         const MPD::Item &item = w.current().value();
 158
 159         if (isParentDirectory(item))
 160                 return;
 161
 162         switch (item.type)
 163         {
 164                 case itDirectory:
 165                 {
 166 #                       ifndef WIN32
 167                         if (isLocal())
 168                         {
 169                                 MPD::SongList list;
 170                                 MPD::ItemList items;
 171                                 Statusbar::msg("Scanning directory \"%s\"...", item.name.c_str());
 172                                 myBrowser->GetLocalDirectory(items, item.name, 1);
 173                                 list.reserve(items.size());
 174                                 for (MPD::ItemList::const_iterator it = items.begin(); it != items.end(); ++it)
 175                                         list.push_back(*it->song);
 176                                 addSongsToPlaylist(list, false, -1);
 177                         }
 178                         else
 179 #                       endif // !WIN32
 180                                 Mpd.Add(item.name);
 181                         Statusbar::msg("Directory \"%s\" added", item.name.c_str());
 182                         break;
 183                 }
 184                 case itSong:
 185                 {
 186                         addSongToPlaylist(*item.song, false);
 187                         break;
 188                 }
 189                 case itPlaylist:
 190                 {
 191                         Mpd.LoadPlaylist(item.name);
 192                         Statusbar::msg("Playlist \"%s\" loaded", item.name.c_str());
 193                         break;
 194                 }
 195         }
 196         w.scroll(NC::Scroll::Down);
 197 }
 198
 199 void Browser::mouseButtonPressed(MEVENT me)
 200 {
 201         if (w.empty() || !w.hasCoords(me.x, me.y) || size_t(me.y) >= w.size())
 202                 return;
 203         if (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED))
 204         {
 205                 w.Goto(me.y);
 206                 switch (w.current().value().type)
 207                 {
 208                         case itDirectory:
 209                                 if (me.bstate & BUTTON1_PRESSED)
 210                                 {
 211                                         GetDirectory(w.current().value().name);
 212                                         drawHeader();
 213                                 }
 214                                 else
 215                                 {
 216                                         size_t pos = w.choice();
 217                                         spacePressed();
 218                                         if (pos < w.size()-1)
 219                                                 w.scroll(NC::Scroll::Up);
 220                                 }
 221                                 break;
 222                         case itPlaylist:
 223                         case itSong:
 224                                 if (me.bstate & BUTTON1_PRESSED)
 225                                 {
 226                                         size_t pos = w.choice();
 227                                         spacePressed();
 228                                         if (pos < w.size()-1)
 229                                                 w.scroll(NC::Scroll::Up);
 230                                 }
 231                                 else
 232                                         enterPressed();
 233                                 break;
 234                 }
 235         }
 236         else
 237                 Screen<WindowType>::mouseButtonPressed(me);
 238 }
 239
 240 /***********************************************************************/
 241
 242 bool Browser::allowsFiltering()
 243 {
 244         return true;
 245 }
 246
 247 std::string Browser::currentFilter()
 248 {
 249         return RegexFilter<MPD::Item>::currentFilter(w);
 250 }
 251
 252 void Browser::applyFilter(const std::string &filter)
 253 {
 254         try
 255         {
 256                 w.showAll();
 257                 auto fun = std::bind(BrowserEntryMatcher, _1, _2, true);
 258                 auto rx = RegexFilter<MPD::Item>(
 259                         boost::regex(filter, Config.regex_type), fun);
 260                 w.filter(w.begin(), w.end(), rx);
 261         }
 262         catch (boost::bad_expression &) { }
 263 }
 264
 265 /***********************************************************************/
 266
 267 bool Browser::allowsSearching()
 268 {
 269         return true;
 270 }
 271
 272 bool Browser::search(const std::string &constraint)
 273 {
 274         try
 275         {
 276                 auto fun = std::bind(BrowserEntryMatcher, _1, _2, false);
 277                 auto rx = RegexFilter<MPD::Item>(
 278                         boost::regex(constraint, Config.regex_type), fun);
 279                 return w.search(w.begin(), w.end(), rx);
 280         }
 281         catch (boost::bad_expression &)
 282         {
 283                 return false;
 284         }
 285 }
 286
 287 void Browser::nextFound(bool wrap)
 288 {
 289         w.nextFound(wrap);
 290 }
 291
 292 void Browser::prevFound(bool wrap)
 293 {
 294         w.prevFound(wrap);
 295 }
 296
 297 /***********************************************************************/
 298
 299 ProxySongList Browser::proxySongList()
 300 {
 301         return ProxySongList(w, [](NC::Menu<MPD::Item>::Item &item) -> MPD::Song * {
 302                 MPD::Song *ptr = 0;
 303                 if (item.value().type == itSong)
 304                         ptr = item.value().song.get();
 305                 return ptr;
 306         });
 307 }
 308
 309 bool Browser::allowsSelection()
 310 {
 311         return true;
 312 }
 313
 314 void Browser::reverseSelection()
 315 {
 316         reverseSelectionHelper(w.begin()+(itsBrowsedDir == "/" ? 0 : 1), w.end());
 317 }
 318
 319 MPD::SongList Browser::getSelectedSongs()
 320 {
 321         MPD::SongList result;
 322         auto item_handler = [this, &result](const MPD::Item &item) {
 323                 if (item.type == itDirectory)
 324                 {
 325 #                       ifndef WIN32
 326                         if (isLocal())
 327                         {
 328                                 MPD::ItemList list;
 329                                 GetLocalDirectory(list, item.name, true);
 330                                 for (auto it = list.begin(); it != list.end(); ++it)
 331                                         result.push_back(*it->song);
 332                         }
 333                         else
 334 #                       endif // !WIN32
 335                         {
 336                                 Mpd.GetDirectoryRecursive(item.name, [&result](MPD::Song &&s) {
 337                                         result.push_back(s);
 338                                 });
 339                         }
 340                 }
 341                 else if (item.type == itSong)
 342                         result.push_back(*item.song);
 343                 else if (item.type == itPlaylist)
 344                 {
 345                         Mpd.GetPlaylistContent(item.name, [&result](MPD::Song &&s) {
 346                                 result.push_back(s);
 347                         });
 348                 }
 349         };
 350         for (auto it = w.begin(); it != w.end(); ++it)
 351                 if (it->isSelected())
 352                         item_handler(it->value());
 353         // if no item is selected, add current one
 354         if (result.empty() && !w.empty())
 355                 item_handler(w.current().value());
 356         return result;
 357 }
 358
 359 void Browser::fetchSupportedExtensions()
 360 {
 361         SupportedExtensions.clear();
 362         Mpd.GetSupportedExtensions(SupportedExtensions);
 363 }
 364
 365 void Browser::LocateSong(const MPD::Song &s)
 366 {
 367         if (s.getDirectory().empty())
 368                 return;
 369
 370         itsBrowseLocally = !s.isFromDatabase();
 371
 372         if (myScreen != this)
 373                 switchTo();
 374
 375         if (itsBrowsedDir != s.getDirectory())
 376                 GetDirectory(s.getDirectory());
 377         for (size_t i = 0; i < w.size(); ++i)
 378         {
 379                 if (w[i].value().type == itSong && s.getHash() == w[i].value().song->getHash())
 380                 {
 381                         w.highlight(i);
 382                         break;
 383                 }
 384         }
 385         drawHeader();
 386 }
 387
 388 void Browser::GetDirectory(std::string dir, std::string subdir)
 389 {
 390         if (dir.empty())
 391                 dir = "/";
 392
 393         int highlightme = -1;
 394         itsScrollBeginning = 0;
 395         if (itsBrowsedDir != dir)
 396                 w.reset();
 397         itsBrowsedDir = dir;
 398
 399         w.clear();
 400
 401         if (dir != "/")
 402         {
 403                 MPD::Item parent;
 404                 parent.name = "..";
 405                 parent.type = itDirectory;
 406                 w.addItem(parent);
 407         }
 408
 409         MPD::ItemList list;
 410 #       ifndef WIN32
 411         if (isLocal())
 412                 GetLocalDirectory(list);
 413         else
 414                 Mpd.GetDirectory(dir, [&list](MPD::Item &&item) {
 415                         list.push_back(item);
 416                 });
 417 #       else
 418         list = Mpd.GetDirectory(dir);
 419 #       endif // !WIN32
 420         if (!isLocal()) // local directory is already sorted
 421                 std::sort(list.begin(), list.end(),
 422                         LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode));
 423
 424         for (MPD::ItemList::iterator it = list.begin(); it != list.end(); ++it)
 425         {
 426                 switch (it->type)
 427                 {
 428                         case itPlaylist:
 429                         {
 430                                 w.addItem(*it);
 431                                 break;
 432                         }
 433                         case itDirectory:
 434                         {
 435                                 if (it->name == subdir)
 436                                         highlightme = w.size();
 437                                 w.addItem(*it);
 438                                 break;
 439                         }
 440                         case itSong:
 441                         {
 442                                 bool bold = 0;
 443                                 for (size_t i = 0; i < myPlaylist->main().size(); ++i)
 444                                 {
 445                                         if (myPlaylist->main().at(i).value().getHash() == it->song->getHash())
 446                                         {
 447                                                 bold = 1;
 448                                                 break;
 449                                         }
 450                                 }
 451                                 w.addItem(*it, bold);
 452                                 break;
 453                         }
 454                 }
 455         }
 456         if (highlightme >= 0)
 457                 w.highlight(highlightme);
 458 }
 459
 460 #ifndef WIN32
 461 void Browser::GetLocalDirectory(MPD::ItemList &v, const std::string &directory, bool recursively) const
 462 {
 463         DIR *dir = opendir((directory.empty() ? itsBrowsedDir : directory).c_str());
 464
 465         if (!dir)
 466                 return;
 467
 468         dirent *file;
 469
 470         struct stat file_stat;
 471         std::string full_path;
 472
 473         size_t old_size = v.size();
 474         while ((file = readdir(dir)))
 475         {
 476                 // omit . and ..
 477                 if (file->d_name[0] == '.' && (file->d_name[1] == '\0' || (file->d_name[1] == '.' && file->d_name[2] == '\0')))
 478                         continue;
 479
 480                 if (!Config.local_browser_show_hidden_files && file->d_name[0] == '.')
 481                         continue;
 482                 MPD::Item new_item;
 483                 full_path = directory.empty() ? itsBrowsedDir : directory;
 484                 if (itsBrowsedDir != "/")
 485                         full_path += "/";
 486                 full_path += file->d_name;
 487                 stat(full_path.c_str(), &file_stat);
 488                 if (S_ISDIR(file_stat.st_mode))
 489                 {
 490                         if (recursively)
 491                         {
 492                                 GetLocalDirectory(v, full_path, 1);
 493                                 old_size = v.size();
 494                         }
 495                         else
 496                         {
 497                                 new_item.type = itDirectory;
 498                                 new_item.name = full_path;
 499                                 v.push_back(new_item);
 500                         }
 501                 }
 502                 else if (hasSupportedExtension(file->d_name))
 503                 {
 504                         new_item.type = itSong;
 505                         mpd_pair file_pair = { "file", full_path.c_str() };
 506                         MPD::MutableSong *s = new MPD::MutableSong(mpd_song_begin(&file_pair));
 507                         new_item.song = std::shared_ptr<MPD::Song>(s);
 508 #                       ifdef HAVE_TAGLIB_H
 509                         if (!recursively)
 510                                 Tags::read(*s);
 511 #                       endif // HAVE_TAGLIB_H
 512                         v.push_back(new_item);
 513                 }
 514         }
 515         closedir(dir);
 516         std::sort(v.begin()+old_size, v.end(),
 517                 LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode));
 518 }
 519
 520 void Browser::ClearDirectory(const std::string &path) const
 521 {
 522         DIR *dir = opendir(path.c_str());
 523         if (!dir)
 524                 return;
 525
 526         dirent *file;
 527         struct stat file_stat;
 528         std::string full_path;
 529
 530         while ((file = readdir(dir)))
 531         {
 532                 // omit . and ..
 533                 if (file->d_name[0] == '.' && (file->d_name[1] == '\0' || (file->d_name[1] == '.' && file->d_name[2] == '\0')))
 534                         continue;
 535
 536                 full_path = path;
 537                 if (*full_path.rbegin() != '/')
 538                         full_path += '/';
 539                 full_path += file->d_name;
 540                 lstat(full_path.c_str(), &file_stat);
 541                 if (S_ISDIR(file_stat.st_mode))
 542                         ClearDirectory(full_path);
 543                 if (remove(full_path.c_str()) == 0)
 544                 {
 545                         const char msg[] = "Deleting \"%ls\"...";
 546                         Statusbar::msg(msg, wideShorten(ToWString(full_path), COLS-const_strlen(msg)).c_str());
 547                 }
 548                 else
 549                 {
 550                         const char msg[] = "Couldn't remove \"%ls\": %s";
 551                         Statusbar::msg(msg, wideShorten(ToWString(full_path), COLS-const_strlen(msg)-25).c_str(), strerror(errno));
 552                 }
 553         }
 554         closedir(dir);
 555 }
 556
 557 void Browser::ChangeBrowseMode()
 558 {
 559         if (Mpd.GetHostname()[0] != '/')
 560         {
 561                 Statusbar::msg("For browsing local filesystem connection to MPD via UNIX Socket is required");
 562                 return;
 563         }
 564
 565         itsBrowseLocally = !itsBrowseLocally;
 566         Statusbar::msg("Browse mode: %s", itsBrowseLocally ? "Local filesystem" : "MPD database");
 567         itsBrowsedDir = itsBrowseLocally ? Config.GetHomeDirectory() : "/";
 568         if (itsBrowseLocally && *itsBrowsedDir.rbegin() == '/')
 569                 itsBrowsedDir.resize(itsBrowsedDir.length()-1);
 570         w.reset();
 571         GetDirectory(itsBrowsedDir);
 572         drawHeader();
 573 }
 574
 575 bool Browser::deleteItem(const MPD::Item &item)
 576 {
 577         if (isParentDirectory((item)))
 578                 FatalError("Parent directory passed to Browser::deleteItem");
 579
 580         // playlist created by mpd
 581         if (!isLocal() && item.type == itPlaylist && CurrentDir() == "/")
 582                 Mpd.DeletePlaylist(item.name);
 583
 584         std::string path;
 585         if (!isLocal())
 586                 path = Config.mpd_music_dir;
 587         path += item.type == itSong ? item.song->getURI() : item.name;
 588
 589         if (item.type == itDirectory)
 590                 ClearDirectory(path);
 591
 592         return std::remove(path.c_str()) == 0;
 593 }
 594 #endif // !WIN32
 595
 596 namespace {//
 597
 598 bool hasSupportedExtension(const std::string &file)
 599 {
 600         size_t last_dot = file.rfind(".");
 601         if (last_dot > file.length())
 602                 return false;
 603
 604         std::string ext = boost::locale::to_lower(file.substr(last_dot+1));
 605         return SupportedExtensions.find(ext) != SupportedExtensions.end();
 606 }
 607
 608 std::string ItemToString(const MPD::Item &item)
 609 {
 610         std::string result;
 611         switch (item.type)
 612         {
 613                 case MPD::itDirectory:
 614                         result = "[" + getBasename(item.name) + "]";
 615                         break;
 616                 case MPD::itSong:
 617                         if (Config.columns_in_browser)
 618                                 result = item.song->toString(Config.song_in_columns_to_string_format, Config.tags_separator);
 619                         else
 620                                 result = item.song->toString(Config.song_list_format_dollar_free, Config.tags_separator);
 621                         break;
 622                 case MPD::itPlaylist:
 623                         result = Config.browser_playlist_prefix.str() + getBasename(item.name);
 624                         break;
 625         }
 626         return result;
 627 }
 628
 629 bool BrowserEntryMatcher(const boost::regex &rx, const MPD::Item &item, bool filter)
 630 {
 631         if (Browser::isParentDirectory(item))
 632                 return filter;
 633         return boost::regex_search(ItemToString(item), rx);
 634 }
 635
 636 }