src/media_library.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2010 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
  23 #include "charset.h"
  24 #include "display.h"
  25 #include "helpers.h"
  26 #include "global.h"
  27 #include "media_library.h"
  28 #include "mpdpp.h"
  29 #include "playlist.h"
  30 #include "status.h"
  31
  32 using Global::MainHeight;
  33 using Global::MainStartY;
  34 using Global::myScreen;
  35
  36 MediaLibrary *myLibrary = new MediaLibrary;
  37
  38 bool MediaLibrary::hasTwoColumns;
  39 size_t MediaLibrary::itsLeftColWidth;
  40 size_t MediaLibrary::itsMiddleColWidth;
  41 size_t MediaLibrary::itsMiddleColStartX;
  42 size_t MediaLibrary::itsRightColWidth;
  43 size_t MediaLibrary::itsRightColStartX;
  44
  45 void MediaLibrary::Init()
  46 {
  47         hasTwoColumns = 0;
  48         itsLeftColWidth = COLS/3-1;
  49         itsMiddleColWidth = COLS/3;
  50         itsMiddleColStartX = itsLeftColWidth+1;
  51         itsRightColWidth = COLS-COLS/3*2-1;
  52         itsRightColStartX = itsLeftColWidth+itsMiddleColWidth+2;
  53
  54         Artists = new Menu<std::string>(0, MainStartY, itsLeftColWidth, MainHeight, IntoStr(Config.media_lib_primary_tag) + "s", Config.main_color, brNone);
  55         Artists->HighlightColor(Config.active_column_color);
  56         Artists->CyclicScrolling(Config.use_cyclic_scrolling);
  57         Artists->SetSelectPrefix(&Config.selected_item_prefix);
  58         Artists->SetSelectSuffix(&Config.selected_item_suffix);
  59         Artists->SetItemDisplayer(Display::Generic);
  60
  61         Albums = new Menu<SearchConstraints>(itsMiddleColStartX, MainStartY, itsMiddleColWidth, MainHeight, "Albums", Config.main_color, brNone);
  62         Albums->HighlightColor(Config.main_highlight_color);
  63         Albums->CyclicScrolling(Config.use_cyclic_scrolling);
  64         Albums->SetSelectPrefix(&Config.selected_item_prefix);
  65         Albums->SetSelectSuffix(&Config.selected_item_suffix);
  66         Albums->SetItemDisplayer(DisplayAlbums);
  67         Albums->SetGetStringFunction(AlbumToString);
  68         Albums->SetGetStringFunctionUserData(this);
  69
  70         Songs = new Menu<MPD::Song>(itsRightColStartX, MainStartY, itsRightColWidth, MainHeight, "Songs", Config.main_color, brNone);
  71         Songs->HighlightColor(Config.main_highlight_color);
  72         Songs->CyclicScrolling(Config.use_cyclic_scrolling);
  73         Songs->SetSelectPrefix(&Config.selected_item_prefix);
  74         Songs->SetSelectSuffix(&Config.selected_item_suffix);
  75         Songs->SetItemDisplayer(Display::Songs);
  76         Songs->SetItemDisplayerUserData(&Config.song_library_format);
  77         Songs->SetGetStringFunction(SongToString);
  78
  79         w = Artists;
  80         isInitialized = 1;
  81 }
  82
  83 void MediaLibrary::Resize()
  84 {
  85         if (!hasTwoColumns)
  86         {
  87                 itsLeftColWidth = COLS/3-1;
  88                 itsMiddleColStartX = itsLeftColWidth+1;
  89                 itsMiddleColWidth = COLS/3;
  90                 itsRightColStartX = itsLeftColWidth+itsMiddleColWidth+2;
  91                 itsRightColWidth = COLS-COLS/3*2-1;
  92         }
  93         else
  94         {
  95                 itsMiddleColStartX = 0;
  96                 itsMiddleColWidth = COLS/2;
  97                 itsRightColStartX = itsMiddleColWidth+1;
  98                 itsRightColWidth = COLS-itsMiddleColWidth-1;
  99         }
 100
 101         Artists->Resize(itsLeftColWidth, MainHeight);
 102         Albums->Resize(itsMiddleColWidth, MainHeight);
 103         Songs->Resize(itsRightColWidth, MainHeight);
 104
 105         Artists->MoveTo(0, MainStartY);
 106         Albums->MoveTo(itsMiddleColStartX, MainStartY);
 107         Songs->MoveTo(itsRightColStartX, MainStartY);
 108
 109         hasToBeResized = 0;
 110 }
 111
 112 void MediaLibrary::Refresh()
 113 {
 114         Artists->Display();
 115         mvvline(MainStartY, itsMiddleColStartX-1, 0, MainHeight);
 116         Albums->Display();
 117         mvvline(MainStartY, itsRightColStartX-1, 0, MainHeight);
 118         Songs->Display();
 119         if (Albums->Empty())
 120         {
 121                 *Albums << XY(0, 0) << "No albums found.";
 122                 Albums->Window::Refresh();
 123         }
 124 }
 125
 126 void MediaLibrary::SwitchTo()
 127 {
 128         if (myScreen == this)
 129         {
 130                 if (Config.media_library_disable_two_column_mode)
 131                         return;
 132                 else
 133                 {
 134                         hasTwoColumns = !hasTwoColumns;
 135                         hasToBeResized = 1;
 136                         Artists->Clear();
 137                         Albums->Clear();
 138                         Albums->Reset();
 139                         Songs->Clear();
 140                         if (hasTwoColumns)
 141                         {
 142                                 if (w == Artists)
 143                                         NextColumn();
 144                                 std::string item_type = IntoStr(Config.media_lib_primary_tag);
 145                                 ToLower(item_type);
 146                                 Albums->SetTitle("Albums (sorted by " + item_type + ")");
 147                         }
 148                         else
 149                                 Albums->SetTitle("Albums");
 150                 }
 151         }
 152
 153         if (!isInitialized)
 154                 Init();
 155
 156         if (hasToBeResized)
 157                 Resize();
 158
 159         if (myScreen != this && myScreen->isTabbable())
 160                 Global::myPrevScreen = myScreen;
 161         myScreen = this;
 162         Global::RedrawHeader = 1;
 163         Refresh();
 164         UpdateSongList(Songs);
 165 }
 166
 167 std::basic_string<my_char_t> MediaLibrary::Title()
 168 {
 169         return U("Media library");
 170 }
 171
 172 void MediaLibrary::Update()
 173 {
 174         if (!hasTwoColumns && Artists->Empty())
 175         {
 176                 MPD::TagList list;
 177                 Albums->Clear();
 178                 Mpd.GetList(list, Config.media_lib_primary_tag);
 179                 sort(list.begin(), list.end(), CaseInsensitiveSorting());
 180                 for (MPD::TagList::iterator it = list.begin(); it != list.end(); ++it)
 181                 {
 182                         if (!it->empty())
 183                         {
 184                                 utf_to_locale(*it);
 185                                 Artists->AddOption(*it);
 186                         }
 187                 }
 188                 Artists->Window::Clear();
 189                 Artists->Refresh();
 190         }
 191
 192         if (!hasTwoColumns && !Artists->Empty() && Albums->Empty())
 193         {
 194                 Songs->Clear();
 195                 Albums->Reset();
 196                 MPD::TagList list;
 197                 locale_to_utf(Artists->Current());
 198                 Mpd.StartFieldSearch(MPD_TAG_ALBUM);
 199                 Mpd.AddSearch(Config.media_lib_primary_tag, Artists->Current());
 200                 Mpd.CommitSearch(list);
 201
 202                 for (MPD::TagList::iterator it = list.begin(); it != list.end(); ++it)
 203                 {
 204                         if (Config.media_library_display_date)
 205                         {
 206                                 MPD::TagList l;
 207                                 Mpd.StartFieldSearch(MPD_TAG_DATE);
 208                                 Mpd.AddSearch(Config.media_lib_primary_tag, Artists->Current());
 209                                 Mpd.AddSearch(MPD_TAG_ALBUM, *it);
 210                                 Mpd.CommitSearch(l);
 211                                 utf_to_locale(*it);
 212                                 for (MPD::TagList::iterator j = l.begin(); j != l.end(); ++j)
 213                                 {
 214                                         utf_to_locale(*j);
 215                                         Albums->AddOption(SearchConstraints(*it, *j));
 216                                 }
 217                         }
 218                         else
 219                         {
 220                                 utf_to_locale(*it);
 221                                 Albums->AddOption(SearchConstraints(*it, ""));
 222                         }
 223                 }
 224                 utf_to_locale(Artists->Current());
 225                 if (!Albums->Empty())
 226                         Albums->Sort<SearchConstraintsSorting>();
 227                 Albums->Refresh();
 228         }
 229         else if (hasTwoColumns && Albums->Empty())
 230         {
 231                 Songs->Clear();
 232                 MPD::TagList artists;
 233                 *Albums << XY(0, 0) << "Fetching albums...";
 234                 Albums->Window::Refresh();
 235                 Mpd.GetList(artists, Config.media_lib_primary_tag);
 236                 for (MPD::TagList::iterator i = artists.begin(); i != artists.end(); ++i)
 237                 {
 238                         if (i->empty())
 239                                 continue;
 240                         MPD::TagList albums;
 241                         Mpd.StartFieldSearch(MPD_TAG_ALBUM);
 242                         Mpd.AddSearch(Config.media_lib_primary_tag, *i);
 243                         Mpd.CommitSearch(albums);
 244                         for (MPD::TagList::iterator j = albums.begin(); j != albums.end(); ++j)
 245                         {
 246                                 if (Config.media_library_display_date)
 247                                 {
 248                                         if (Config.media_lib_primary_tag != MPD_TAG_DATE)
 249                                         {
 250                                                 MPD::TagList years;
 251                                                 Mpd.StartFieldSearch(MPD_TAG_DATE);
 252                                                 Mpd.AddSearch(Config.media_lib_primary_tag, *i);
 253                                                 Mpd.AddSearch(MPD_TAG_ALBUM, *j);
 254                                                 Mpd.CommitSearch(years);
 255                                                 utf_to_locale(*i);
 256                                                 utf_to_locale(*j);
 257                                                 for (MPD::TagList::iterator k = years.begin(); k != years.end(); ++k)
 258                                                 {
 259                                                         utf_to_locale(*k);
 260                                                         Albums->AddOption(SearchConstraints(*i, *j, *k));
 261                                                 }
 262                                         }
 263                                         else
 264                                         {
 265                                                 utf_to_locale(*i);
 266                                                 utf_to_locale(*j);
 267                                                 Albums->AddOption(SearchConstraints(*i, *j, *i));
 268                                         }
 269                                 }
 270                                 else
 271                                 {
 272                                         utf_to_locale(*i);
 273                                         utf_to_locale(*j);
 274                                         Albums->AddOption(SearchConstraints(*i, *j, ""));
 275                                 }
 276                         }
 277                 }
 278                 if (!Albums->Empty())
 279                         Albums->Sort<SearchConstraintsSorting>();
 280                 Albums->Refresh();
 281         }
 282
 283         if (!hasTwoColumns && !Artists->Empty() && w == Albums && Albums->Empty())
 284         {
 285                 Albums->HighlightColor(Config.main_highlight_color);
 286                 Artists->HighlightColor(Config.active_column_color);
 287                 w = Artists;
 288         }
 289
 290         if ((hasTwoColumns || !Artists->Empty()) && Songs->Empty())
 291         {
 292                 Songs->Reset();
 293                 MPD::SongList list;
 294
 295                 Mpd.StartSearch(1);
 296                 Mpd.AddSearch(Config.media_lib_primary_tag, locale_to_utf_cpy(hasTwoColumns ? Albums->Current().Artist : Artists->Current()));
 297                 if (Albums->Empty()) // left for compatibility with <mpd-0.14
 298                 {
 299                         *Albums << XY(0, 0) << "No albums found.";
 300                         Albums->Window::Refresh();
 301                 }
 302                 else
 303                 {
 304                         Mpd.AddSearch(MPD_TAG_ALBUM, locale_to_utf_cpy(Albums->Current().Album));
 305                         if (Config.media_library_display_date)
 306                                 Mpd.AddSearch(MPD_TAG_DATE, locale_to_utf_cpy(Albums->Current().Year));
 307                 }
 308                 Mpd.CommitSearch(list);
 309
 310                 sort(list.begin(), list.end(), SortSongsByTrack);
 311                 bool bold = 0;
 312
 313                 for (MPD::SongList::const_iterator it = list.begin(); it != list.end(); ++it)
 314                 {
 315                         for (size_t j = 0; j < myPlaylist->Items->Size(); ++j)
 316                         {
 317                                 if ((*it)->GetHash() == myPlaylist->Items->at(j).GetHash())
 318                                 {
 319                                         bold = 1;
 320                                         break;
 321                                 }
 322                         }
 323                         Songs->AddOption(**it, bold);
 324                         bold = 0;
 325                 }
 326                 FreeSongList(list);
 327                 Songs->Window::Clear();
 328                 Songs->Refresh();
 329         }
 330 }
 331
 332 void MediaLibrary::SpacePressed()
 333 {
 334         if (Config.space_selects)
 335         {
 336                 if (w == Artists)
 337                 {
 338                         Artists->Select(Artists->Choice(), !Artists->isSelected());
 339                         Albums->Clear();
 340                 }
 341                 else if (w == Albums)
 342                 {
 343                         Albums->Select(Albums->Choice(), !Albums->isSelected());
 344                         Songs->Clear();
 345                 }
 346                 else if (w == Songs)
 347                         Songs->Select(Songs->Choice(), !Songs->isSelected());
 348                 w->Scroll(wDown);
 349         }
 350         else
 351                 AddToPlaylist(0);
 352 }
 353
 354 void MediaLibrary::MouseButtonPressed(MEVENT me)
 355 {
 356         if (!Artists->Empty() && Artists->hasCoords(me.x, me.y))
 357         {
 358                 if (w != Artists)
 359                 {
 360                         PrevColumn();
 361                         PrevColumn();
 362                 }
 363                 if (size_t(me.y) < Artists->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 364                 {
 365                         Artists->Goto(me.y);
 366                         if (me.bstate & BUTTON3_PRESSED)
 367                         {
 368                                 size_t pos = Artists->Choice();
 369                                 SpacePressed();
 370                                 if (pos < Artists->Size()-1)
 371                                         Artists->Scroll(wUp);
 372                         }
 373                 }
 374                 else
 375                         Screen<Window>::MouseButtonPressed(me);
 376                 Albums->Clear();
 377                 Songs->Clear();
 378         }
 379         else if (!Albums->Empty() && Albums->hasCoords(me.x, me.y))
 380         {
 381                 if (w != Albums)
 382                         w == Artists ? NextColumn() : PrevColumn();
 383                 if (size_t(me.y) < Albums->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 384                 {
 385                         Albums->Goto(me.y);
 386                         if (me.bstate & BUTTON3_PRESSED)
 387                         {
 388                                 size_t pos = Albums->Choice();
 389                                 SpacePressed();
 390                                 if (pos < Albums->Size()-1)
 391                                         Albums->Scroll(wUp);
 392                         }
 393                 }
 394                 else
 395                         Screen<Window>::MouseButtonPressed(me);
 396                 Songs->Clear();
 397         }
 398         else if (!Songs->Empty() && Songs->hasCoords(me.x, me.y))
 399         {
 400                 if (w != Songs)
 401                 {
 402                         NextColumn();
 403                         NextColumn();
 404                 }
 405                 if (size_t(me.y) < Songs->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 406                 {
 407                         Songs->Goto(me.y);
 408                         if (me.bstate & BUTTON1_PRESSED)
 409                         {
 410                                 size_t pos = Songs->Choice();
 411                                 SpacePressed();
 412                                 if (pos < Songs->Size()-1)
 413                                         Songs->Scroll(wUp);
 414                         }
 415                         else
 416                                 EnterPressed();
 417                 }
 418                 else
 419                         Screen<Window>::MouseButtonPressed(me);
 420         }
 421 }
 422
 423 MPD::Song *MediaLibrary::CurrentSong()
 424 {
 425         return w == Songs && !Songs->Empty() ? &Songs->Current() : 0;
 426 }
 427
 428 List *MediaLibrary::GetList()
 429 {
 430         if (w == Artists)
 431                 return Artists;
 432         else if (w == Albums)
 433                 return Albums;
 434         else if (w == Songs)
 435                 return Songs;
 436         else // silence compiler
 437                 return 0;
 438 }
 439
 440 void MediaLibrary::ReverseSelection()
 441 {
 442         if (w == Artists)
 443                 Artists->ReverseSelection();
 444         else if (w == Albums)
 445                 Albums->ReverseSelection();
 446         else if (w == Songs)
 447                 Songs->ReverseSelection();
 448 }
 449
 450 void MediaLibrary::GetSelectedSongs(MPD::SongList &v)
 451 {
 452         std::vector<size_t> selected;
 453         if (w == Artists && !Artists->Empty())
 454         {
 455                 Artists->GetSelected(selected);
 456                 if (selected.empty())
 457                         selected.push_back(Artists->Choice());
 458                 for (std::vector<size_t>::const_iterator it = selected.begin(); it != selected.end(); ++it)
 459                 {
 460                         MPD::SongList list;
 461                         Mpd.StartSearch(1);
 462                         Mpd.AddSearch(Config.media_lib_primary_tag, locale_to_utf_cpy(Artists->at(*it)));
 463                         Mpd.CommitSearch(list);
 464                         for (MPD::SongList::const_iterator sIt = list.begin(); sIt != list.end(); ++sIt)
 465                                 v.push_back(new MPD::Song(**sIt));
 466                         FreeSongList(list);
 467                 }
 468         }
 469         else if (w == Albums && !Albums->Empty())
 470         {
 471                 Albums->GetSelected(selected);
 472                 if (selected.empty())
 473                 {
 474                         // shortcut via the existing song list in right column
 475                         if (v.empty())
 476                                 v.reserve(Songs->Size());
 477                         for (size_t i = 0; i < Songs->Size(); ++i)
 478                                 v.push_back(new MPD::Song((*Songs)[i]));
 479                 }
 480                 else
 481                 {
 482                         for (std::vector<size_t>::const_iterator it = selected.begin(); it != selected.end(); ++it)
 483                         {
 484                                 MPD::SongList list;
 485                                 Mpd.StartSearch(1);
 486                                 Mpd.AddSearch(Config.media_lib_primary_tag, hasTwoColumns
 487                                                 ?  Albums->at(*it).Artist
 488                                                 : locale_to_utf_cpy(Artists->Current()));
 489                                 Mpd.AddSearch(MPD_TAG_ALBUM, Albums->at(*it).Album);
 490                                 Mpd.AddSearch(MPD_TAG_DATE, Albums->at(*it).Year);
 491                                 Mpd.CommitSearch(list);
 492                                 for (MPD::SongList::const_iterator sIt = list.begin(); sIt != list.end(); ++sIt)
 493                                         v.push_back(new MPD::Song(**sIt));
 494                                 FreeSongList(list);
 495                         }
 496                 }
 497         }
 498         else if (w == Songs && !Songs->Empty())
 499         {
 500                 Songs->GetSelected(selected);
 501                 if (selected.empty())
 502                         selected.push_back(Songs->Choice());
 503                 for (std::vector<size_t>::const_iterator it = selected.begin(); it != selected.end(); ++it)
 504                         v.push_back(new MPD::Song(Songs->at(*it)));
 505         }
 506 }
 507
 508 void MediaLibrary::ApplyFilter(const std::string &s)
 509 {
 510         GetList()->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
 511 }
 512
 513 void MediaLibrary::NextColumn()
 514 {
 515         if (w == Artists)
 516         {
 517                 if (!hasTwoColumns && Songs->Empty())
 518                         return;
 519                 Artists->HighlightColor(Config.main_highlight_color);
 520                 w->Refresh();
 521                 w = Albums;
 522                 Albums->HighlightColor(Config.active_column_color);
 523                 if (!Albums->Empty())
 524                         return;
 525         }
 526         if (w == Albums && !Songs->Empty())
 527         {
 528                 Albums->HighlightColor(Config.main_highlight_color);
 529                 w->Refresh();
 530                 w = Songs;
 531                 Songs->HighlightColor(Config.active_column_color);
 532         }
 533 }
 534
 535 void MediaLibrary::PrevColumn()
 536 {
 537         if (w == Songs)
 538         {
 539                 Songs->HighlightColor(Config.main_highlight_color);
 540                 w->Refresh();
 541                 w = Albums;
 542                 Albums->HighlightColor(Config.active_column_color);
 543                 if (!Albums->Empty())
 544                         return;
 545         }
 546         if (w == Albums && !hasTwoColumns)
 547         {
 548                 Albums->HighlightColor(Config.main_highlight_color);
 549                 w->Refresh();
 550                 w = Artists;
 551                 Artists->HighlightColor(Config.active_column_color);
 552         }
 553 }
 554
 555 void MediaLibrary::LocateSong(const MPD::Song &s)
 556 {
 557         std::string primary_tag;
 558         switch (Config.media_lib_primary_tag)
 559         {
 560                 case MPD_TAG_ARTIST:
 561                         primary_tag = s.GetArtist();
 562                         break;
 563                 case MPD_TAG_DATE:
 564                         primary_tag = s.GetDate();
 565                         break;
 566                 case MPD_TAG_GENRE:
 567                         primary_tag = s.GetGenre();
 568                         break;
 569                 case MPD_TAG_COMPOSER:
 570                         primary_tag = s.GetComposer();
 571                         break;
 572                 case MPD_TAG_PERFORMER:
 573                         primary_tag = s.GetPerformer();
 574                         break;
 575                 default:
 576                         ShowMessage("Invalid tag type in left column of the media library");
 577                         return;
 578         }
 579         if (primary_tag.empty())
 580         {
 581                 std::string item_type = IntoStr(Config.media_lib_primary_tag);
 582                 ToLower(item_type);
 583                 ShowMessage("Can't jump to media library because the song has no %s tag set.", item_type.c_str());
 584                 return;
 585         }
 586
 587         if (myScreen != this)
 588                 SwitchTo();
 589         Statusbar() << "Jumping to song...";
 590         Global::wFooter->Refresh();
 591
 592         if (!hasTwoColumns)
 593         {
 594                 if (Artists->Empty())
 595                         Update();
 596                 if (primary_tag != Artists->Current())
 597                 {
 598                         for (size_t i = 0; i < Artists->Size(); ++i)
 599                         {
 600                                 if (primary_tag == (*Artists)[i])
 601                                 {
 602                                         Artists->Highlight(i);
 603                                         Albums->Clear();
 604                                         break;
 605                                 }
 606                         }
 607                 }
 608         }
 609
 610         if (Albums->Empty())
 611                 Update();
 612
 613         std::string album = s.GetAlbum();
 614         std::string date = s.GetDate();
 615         if ((hasTwoColumns && Albums->Current().Artist != primary_tag)
 616         ||  album != Albums->Current().Album
 617         ||  date != Albums->Current().Year)
 618         {
 619                 for (size_t i = 0; i < Albums->Size(); ++i)
 620                 {
 621                         if ((!hasTwoColumns || (*Albums)[i].Artist == primary_tag)
 622                         &&   album == (*Albums)[i].Album
 623                         &&   date == (*Albums)[i].Year)
 624                         {
 625                                 Albums->Highlight(i);
 626                                 Songs->Clear();
 627                                 break;
 628                         }
 629                 }
 630         }
 631
 632         if (Songs->Empty())
 633                 Update();
 634
 635         std::string song = s.GetTitle();
 636         if (song != Songs->Current().GetTitle())
 637         {
 638                 for (size_t i = 0; i < Songs->Size(); ++i)
 639                 {
 640                         if (song == (*Songs)[i].GetTitle())
 641                         {
 642                                 Songs->Highlight(i);
 643                                 break;
 644                         }
 645                 }
 646         }
 647
 648         Artists->HighlightColor(Config.main_highlight_color);
 649         Albums->HighlightColor(Config.main_highlight_color);
 650         Songs->HighlightColor(Config.active_column_color);
 651         w = Songs;
 652         Refresh();
 653 }
 654
 655 void MediaLibrary::AddToPlaylist(bool add_n_play)
 656 {
 657         if (w == Songs && !Songs->Empty())
 658                 Songs->Bold(Songs->Choice(), myPlaylist->Add(Songs->Current(), Songs->isBold(), add_n_play));
 659         else
 660         {
 661                 MPD::SongList list;
 662                 GetSelectedSongs(list);
 663
 664                 if (myPlaylist->Add(list, add_n_play))
 665                 {
 666                         if (!Artists->Empty() && w == Artists)
 667                         {
 668                                 std::string tag_type = IntoStr(Config.media_lib_primary_tag);
 669                                 ToLower(tag_type);
 670                                 ShowMessage("Adding songs of %s \"%s\"", tag_type.c_str(), Artists->Current().c_str());
 671                         }
 672                         else if (w == Albums)
 673                                 ShowMessage("Adding songs from album \"%s\"", Albums->Current().Album.c_str());
 674                 }
 675         }
 676
 677         if (!add_n_play)
 678         {
 679                 w->Scroll(wDown);
 680                 if (w == Artists)
 681                 {
 682                         Albums->Clear();
 683                         Songs->Clear();
 684                 }
 685                 else if (w == Albums)
 686                         Songs->Clear();
 687         }
 688 }
 689
 690 std::string MediaLibrary::SongToString(const MPD::Song &s, void *)
 691 {
 692         return s.toString(Config.song_library_format);
 693 }
 694
 695 std::string MediaLibrary::AlbumToString(const SearchConstraints &sc, void *ptr)
 696 {
 697         std::string result;
 698         if (!sc.Artist.empty())
 699                 (result += sc.Artist) += " - ";
 700         if ((!static_cast<MediaLibrary *>(ptr)->hasTwoColumns || Config.media_lib_primary_tag != MPD_TAG_DATE) && !sc.Year.empty())
 701                 ((result += "(") += sc.Year) += ") ";
 702         result += sc.Album.empty() ? "<no album>" : sc.Album;
 703         return result;
 704 }
 705
 706 void MediaLibrary::DisplayAlbums(const SearchConstraints &sc, void *, Menu<SearchConstraints> *menu)
 707 {
 708         *menu << AlbumToString(sc, 0);
 709 }
 710
 711 bool MediaLibrary::SearchConstraintsSorting::operator()(const SearchConstraints &a, const SearchConstraints &b) const
 712 {
 713         int result;
 714         CaseInsensitiveStringComparison cmp;
 715         if (!a.Artist.empty() || b.Artist.empty())
 716         {
 717                 result = cmp(a.Artist, b.Artist);
 718                 if (result != 0)
 719                         return result < 0;
 720         }
 721         result = cmp(a.Year, b.Year);
 722         return (result == 0 ? cmp(a.Album, b.Album) : result) < 0;
 723 }
 724
 725 bool MediaLibrary::SortSongsByTrack(MPD::Song *a, MPD::Song *b)
 726 {
 727         if (a->GetDisc() == b->GetDisc())
 728                 return StrToInt(a->GetTrack()) < StrToInt(b->GetTrack());
 729         else
 730                 return StrToInt(a->GetDisc()) < StrToInt(b->GetDisc());
 731 }
 732