src/playlist_editor.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 "global.h"
  26 #include "helpers.h"
  27 #include "playlist.h"
  28 #include "playlist_editor.h"
  29 #include "mpdpp.h"
  30 #include "status.h"
  31 #include "tag_editor.h"
  32
  33 using Global::MainHeight;
  34 using Global::MainStartY;
  35
  36 PlaylistEditor *myPlaylistEditor = new PlaylistEditor;
  37
  38 size_t PlaylistEditor::LeftColumnWidth;
  39 size_t PlaylistEditor::RightColumnStartX;
  40 size_t PlaylistEditor::RightColumnWidth;
  41
  42 void PlaylistEditor::Init()
  43 {
  44         LeftColumnWidth = COLS/3-1;
  45         RightColumnStartX = LeftColumnWidth+1;
  46         RightColumnWidth = COLS-LeftColumnWidth-1;
  47
  48         Playlists = new Menu<std::string>(0, MainStartY, LeftColumnWidth, MainHeight, "Playlists", Config.main_color, brNone);
  49         Playlists->HighlightColor(Config.active_column_color);
  50         Playlists->CyclicScrolling(Config.use_cyclic_scrolling);
  51         Playlists->CenteredCursor(Config.centered_cursor);
  52         Playlists->SetItemDisplayer(Display::Generic);
  53
  54         Content = new Menu<MPD::Song>(RightColumnStartX, MainStartY, RightColumnWidth, MainHeight, "Playlist's content", Config.main_color, brNone);
  55         Content->HighlightColor(Config.main_highlight_color);
  56         Content->CyclicScrolling(Config.use_cyclic_scrolling);
  57         Content->CenteredCursor(Config.centered_cursor);
  58         Content->SetSelectPrefix(&Config.selected_item_prefix);
  59         Content->SetSelectSuffix(&Config.selected_item_suffix);
  60         Content->SetItemDisplayer(Display::Songs);
  61         Content->SetItemDisplayerUserData(&Config.song_list_format);
  62         Content->SetGetStringFunction(Playlist::SongToString);
  63         Content->SetGetStringFunctionUserData(&Config.song_list_format);
  64
  65         w = Playlists;
  66         isInitialized = 1;
  67 }
  68
  69 void PlaylistEditor::Resize()
  70 {
  71         LeftColumnWidth = COLS/3-1;
  72         RightColumnStartX = LeftColumnWidth+1;
  73         RightColumnWidth = COLS-LeftColumnWidth-1;
  74
  75         Playlists->Resize(LeftColumnWidth, MainHeight);
  76         Content->Resize(RightColumnWidth, MainHeight);
  77
  78         Playlists->MoveTo(0, MainStartY);
  79         Content->MoveTo(RightColumnStartX, MainStartY);
  80
  81         hasToBeResized = 0;
  82 }
  83
  84 std::basic_string<my_char_t> PlaylistEditor::Title()
  85 {
  86         return U("Playlist editor");
  87 }
  88
  89 void PlaylistEditor::Refresh()
  90 {
  91         Playlists->Display();
  92         mvvline(MainStartY, RightColumnStartX-1, 0, MainHeight);
  93         Content->Display();
  94 }
  95
  96 void PlaylistEditor::SwitchTo()
  97 {
  98         using Global::myScreen;
  99
 100         if (myScreen == this)
 101                 return;
 102
 103         if (!isInitialized)
 104                 Init();
 105
 106         if (hasToBeResized)
 107                 Resize();
 108
 109         if (myScreen != this && myScreen->isTabbable())
 110                 Global::myPrevScreen = myScreen;
 111         myScreen = this;
 112         Global::RedrawHeader = 1;
 113         Refresh();
 114         UpdateSongList(Content);
 115 }
 116
 117 void PlaylistEditor::Update()
 118 {
 119         if (Playlists->Empty())
 120         {
 121                 Content->Clear();
 122                 MPD::TagList list;
 123                 Mpd.GetPlaylists(list);
 124                 sort(list.begin(), list.end(), CaseInsensitiveSorting());
 125                 for (MPD::TagList::iterator it = list.begin(); it != list.end(); ++it)
 126                 {
 127                         utf_to_locale(*it);
 128                         Playlists->AddOption(*it);
 129                 }
 130                 Playlists->Window::Clear();
 131                 Playlists->Refresh();
 132         }
 133
 134         if (!Playlists->Empty() && Content->Empty())
 135         {
 136                 Content->Reset();
 137                 MPD::SongList list;
 138                 Mpd.GetPlaylistContent(locale_to_utf_cpy(Playlists->Current()), list);
 139                 if (!list.empty())
 140                         Content->SetTitle("Playlist's content (" + IntoStr(list.size()) + " item" + (list.size() == 1 ? ")" : "s)"));
 141                 else
 142                         Content->SetTitle("Playlist's content");
 143                 bool bold = 0;
 144                 for (MPD::SongList::const_iterator it = list.begin(); it != list.end(); ++it)
 145                 {
 146                         for (size_t j = 0; j < myPlaylist->Items->Size(); ++j)
 147                         {
 148                                 if ((*it)->GetHash() == myPlaylist->Items->at(j).GetHash())
 149                                 {
 150                                         bold = 1;
 151                                         break;
 152                                 }
 153                         }
 154                         Content->AddOption(**it, bold);
 155                         bold = 0;
 156                 }
 157                 MPD::FreeSongList(list);
 158                 Content->Window::Clear();
 159                 Content->Display();
 160         }
 161
 162         if (w == Content && Content->Empty())
 163         {
 164                 Content->HighlightColor(Config.main_highlight_color);
 165                 Playlists->HighlightColor(Config.active_column_color);
 166                 w = Playlists;
 167         }
 168
 169         if (Content->Empty())
 170         {
 171                 *Content << XY(0, 0) << "Playlist is empty.";
 172                 Content->Window::Refresh();
 173         }
 174 }
 175
 176 void PlaylistEditor::NextColumn()
 177 {
 178         if (w == Playlists)
 179         {
 180                 Playlists->HighlightColor(Config.main_highlight_color);
 181                 w->Refresh();
 182                 w = Content;
 183                 Content->HighlightColor(Config.active_column_color);
 184         }
 185 }
 186
 187 void PlaylistEditor::PrevColumn()
 188 {
 189         if (w == Content)
 190         {
 191                 Content->HighlightColor(Config.main_highlight_color);
 192                 w->Refresh();
 193                 w = Playlists;
 194                 Playlists->HighlightColor(Config.active_column_color);
 195         }
 196 }
 197
 198 void PlaylistEditor::AddToPlaylist(bool add_n_play)
 199 {
 200         MPD::SongList list;
 201
 202         if (w == Playlists && !Playlists->Empty())
 203         {
 204                 Mpd.GetPlaylistContent(locale_to_utf_cpy(Playlists->Current()), list);
 205                 if (myPlaylist->Add(list, add_n_play))
 206                         ShowMessage("Loading playlist %s...", Playlists->Current().c_str());
 207         }
 208         else if (w == Content && !Content->Empty())
 209                 Content->Bold(Content->Choice(), myPlaylist->Add(Content->Current(), Content->isBold(), add_n_play));
 210
 211         FreeSongList(list);
 212         if (!add_n_play)
 213                 w->Scroll(wDown);
 214 }
 215
 216 void PlaylistEditor::SpacePressed()
 217 {
 218         if (Config.space_selects && w == Content)
 219         {
 220                 Content->Select(Content->Choice(), !Content->isSelected());
 221                 w->Scroll(wDown);
 222         }
 223         else
 224                 AddToPlaylist(0);
 225 }
 226
 227 void PlaylistEditor::MouseButtonPressed(MEVENT me)
 228 {
 229         if (!Playlists->Empty() && Playlists->hasCoords(me.x, me.y))
 230         {
 231                 if (w != Playlists)
 232                         PrevColumn();
 233                 if (size_t(me.y) < Playlists->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 234                 {
 235                         Playlists->Goto(me.y);
 236                         if (me.bstate & BUTTON3_PRESSED)
 237                         {
 238                                 size_t pos = Playlists->Choice();
 239                                 SpacePressed();
 240                                 if (pos < Playlists->Size()-1)
 241                                         Playlists->Scroll(wUp);
 242                         }
 243                 }
 244                 else
 245                         Screen<Window>::MouseButtonPressed(me);
 246                 Content->Clear();
 247         }
 248         else if (!Content->Empty() && Content->hasCoords(me.x, me.y))
 249         {
 250                 if (w != Content)
 251                         NextColumn();
 252                 if (size_t(me.y) < Content->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
 253                 {
 254                         Content->Goto(me.y);
 255                         if (me.bstate & BUTTON1_PRESSED)
 256                         {
 257                                 size_t pos = Content->Choice();
 258                                 SpacePressed();
 259                                 if (pos < Content->Size()-1)
 260                                         Content->Scroll(wUp);
 261                         }
 262                         else
 263                                 EnterPressed();
 264                 }
 265                 else
 266                         Screen<Window>::MouseButtonPressed(me);
 267         }
 268 }
 269
 270 MPD::Song *PlaylistEditor::CurrentSong()
 271 {
 272         return w == Content && !Content->Empty() ? &Content->Current() : 0;
 273 }
 274
 275 void PlaylistEditor::GetSelectedSongs(MPD::SongList &v)
 276 {
 277         std::vector<size_t> selected;
 278         Content->GetSelected(selected);
 279         if (selected.empty())
 280                 selected.push_back(Content->Choice());
 281         for (std::vector<size_t>::const_iterator it = selected.begin(); it != selected.end(); ++it)
 282         {
 283                 v.push_back(new MPD::Song(Content->at(*it)));
 284         }
 285 }
 286
 287 void PlaylistEditor::ApplyFilter(const std::string &s)
 288 {
 289         GetList()->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
 290 }
 291
 292 List *PlaylistEditor::GetList()
 293 {
 294         if (w == Playlists)
 295                 return Playlists;
 296         else if (w == Content)
 297                 return Content;
 298         else // silence compiler
 299                 return 0;
 300 }
 301