Salastil/ncmpcpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pass ProxySongList around since it already has shared_ptr inside

Browse Source
This commit is contained in:
Andrzej Rybczak
2012-09-16 07:13:54 +02:00
parent ddd18681ba
commit 48cf01f084
19 changed files with 83 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
src/actions.cpp
View File

@@ -539,93 +539,93 @@ void ScrollDown::Run()
bool ScrollUpArtist::canBeRun() const bool ScrollUpArtist::canBeRun() const
{ {
return proxySongList(myScreen).get(); return proxySongList(myScreen);
} }
void ScrollUpArtist::Run() void ScrollUpArtist::Run()
{ {
auto pl = proxySongList(myScreen); auto pl = proxySongList(myScreen);
assert(pl); assert(pl);
size_t pos = pl->choice(); size_t pos = pl.choice();
if (MPD::Song *s = pl->getSong(pos)) if (MPD::Song *s = pl.getSong(pos))
{ {
std::string artist = s->getArtist(); std::string artist = s->getArtist();
while (pos > 0) while (pos > 0)
{ {
s = pl->getSong(--pos); s = pl.getSong(--pos);
if (!s || s->getArtist() != artist) if (!s || s->getArtist() != artist)
break; break;
} }
pl->highlight(pos); pl.highlight(pos);
} }
} }
bool ScrollUpAlbum::canBeRun() const bool ScrollUpAlbum::canBeRun() const
{ {
return proxySongList(myScreen).get(); return proxySongList(myScreen);
} }
void ScrollUpAlbum::Run() void ScrollUpAlbum::Run()
{ {
auto pl = proxySongList(myScreen); auto pl = proxySongList(myScreen);
assert(pl); assert(pl);
size_t pos = pl->choice(); size_t pos = pl.choice();
if (MPD::Song *s = pl->getSong(pos)) if (MPD::Song *s = pl.getSong(pos))
{ {
std::string album = s->getAlbum(); std::string album = s->getAlbum();
while (pos > 0) while (pos > 0)
{ {
s = pl->getSong(--pos); s = pl.getSong(--pos);
if (!s || s->getAlbum() != album) if (!s || s->getAlbum() != album)
break; break;
} }
pl->highlight(pos); pl.highlight(pos);
} }
} }
bool ScrollDownArtist::canBeRun() const bool ScrollDownArtist::canBeRun() const
{ {
return proxySongList(myScreen).get(); return proxySongList(myScreen);
} }
void ScrollDownArtist::Run() void ScrollDownArtist::Run()
{ {
auto pl = proxySongList(myScreen); auto pl = proxySongList(myScreen);
assert(pl); assert(pl);
size_t pos = pl->choice(); size_t pos = pl.choice();
if (MPD::Song *s = pl->getSong(pos)) if (MPD::Song *s = pl.getSong(pos))
{ {
std::string artist = s->getArtist(); std::string artist = s->getArtist();
while (pos < pl->size() - 1) while (pos < pl.size() - 1)
{ {
s = pl->getSong(++pos); s = pl.getSong(++pos);
if (!s || s->getArtist() != artist) if (!s || s->getArtist() != artist)
break; break;
} }
pl->highlight(pos); pl.highlight(pos);
} }
} }
bool ScrollDownAlbum::canBeRun() const bool ScrollDownAlbum::canBeRun() const
{ {
return proxySongList(myScreen).get(); return proxySongList(myScreen);
} }
void ScrollDownAlbum::Run() void ScrollDownAlbum::Run()
{ {
auto pl = proxySongList(myScreen); auto pl = proxySongList(myScreen);
assert(pl); assert(pl);
size_t pos = pl->choice(); size_t pos = pl.choice();
if (MPD::Song *s = pl->getSong(pos)) if (MPD::Song *s = pl.getSong(pos))
{ {
std::string album = s->getAlbum(); std::string album = s->getAlbum();
while (pos < pl->size() - 1) while (pos < pl.size() - 1)
{ {
s = pl->getSong(++pos); s = pl.getSong(++pos);
if (!s || s->getAlbum() != album) if (!s || s->getAlbum() != album)
break; break;
} }
pl->highlight(pos); pl.highlight(pos);
} }
} }
@@ -1720,50 +1720,50 @@ void ReverseSelection::Run()
bool RemoveSelection::canBeRun() const bool RemoveSelection::canBeRun() const
{ {
return proxySongList(myScreen).get(); return proxySongList(myScreen);
} }
void RemoveSelection::Run() void RemoveSelection::Run()
{ {
auto pl = proxySongList(myScreen); auto pl = proxySongList(myScreen);
for (size_t i = 0; i < pl->size(); ++i) for (size_t i = 0; i < pl.size(); ++i)
pl->setSelected(i, false); pl.setSelected(i, false);
Statusbar::msg("Selection removed"); Statusbar::msg("Selection removed");
} }
bool SelectAlbum::canBeRun() const bool SelectAlbum::canBeRun() const
{ {
auto w = hasSongs(myScreen); auto w = hasSongs(myScreen);
return w && w->allowsSelection() && w->getProxySongList().get(); return w && w->allowsSelection() && w->proxySongList();
} }
void SelectAlbum::Run() void SelectAlbum::Run()
{ {
auto pl = proxySongList(myScreen); auto pl = proxySongList(myScreen);
size_t pos = pl->choice(); size_t pos = pl.choice();
if (MPD::Song *s = pl->getSong(pos)) if (MPD::Song *s = pl.getSong(pos))
{ {
std::string album = s->getAlbum(); std::string album = s->getAlbum();
// select song under cursor // select song under cursor
pl->setSelected(pos, true); pl.setSelected(pos, true);
// go up // go up
while (pos > 0) while (pos > 0)
{ {
s = pl->getSong(--pos); s = pl.getSong(--pos);
if (!s || s->getAlbum() != album) if (!s || s->getAlbum() != album)
break; break;
else else
pl->setSelected(pos, true); pl.setSelected(pos, true);
} }
// go down // go down
pos = pl->choice(); pos = pl.choice();
while (pos < pl->size() - 1) while (pos < pl.size() - 1)
{ {
s = pl->getSong(++pos); s = pl.getSong(++pos);
if (!s || s->getAlbum() != album) if (!s || s->getAlbum() != album)
break; break;
else else
pl->setSelected(pos, true); pl.setSelected(pos, true);
} }
Statusbar::msg("Album around cursor position selected"); Statusbar::msg("Album around cursor position selected");
} }

6
src/browser.cpp
View File

@@ -97,7 +97,7 @@ void Browser::switchTo()
if (w.empty()) if (w.empty())
GetDirectory(itsBrowsedDir); GetDirectory(itsBrowsedDir);
else else
markSongsInPlaylist(getProxySongList()); markSongsInPlaylist(proxySongList());
drawHeader(); drawHeader();
} }
@@ -287,9 +287,9 @@ void Browser::prevFound(bool wrap)
/***********************************************************************/ /***********************************************************************/
std::shared_ptr<ProxySongList> Browser::getProxySongList() ProxySongList Browser::proxySongList()
{ {
return mkProxySongList(w, [](NC::Menu<MPD::Item>::Item &item) -> MPD::Song * { return ProxySongList(w, [](NC::Menu<MPD::Item>::Item &item) -> MPD::Song * {
MPD::Song *ptr = 0; MPD::Song *ptr = 0;
if (item.value().type == itSong) if (item.value().type == itSong)
ptr = item.value().song.get(); ptr = item.value().song.get();

2
src/browser.h
View File

@@ -56,7 +56,7 @@ struct Browser: Screen<NC::Menu<MPD::Item>>, Filterable, HasSongs, Searchable, T
virtual void prevFound(bool wrap) OVERRIDE; virtual void prevFound(bool wrap) OVERRIDE;
// HasSongs implementation // HasSongs implementation
virtual std::shared_ptr<ProxySongList> getProxySongList() OVERRIDE; virtual ProxySongList proxySongList() OVERRIDE;
virtual bool allowsSelection() OVERRIDE; virtual bool allowsSelection() OVERRIDE;
virtual void reverseSelection() OVERRIDE; virtual void reverseSelection() OVERRIDE;

4
src/display.cpp
View File

@@ -80,9 +80,9 @@ void setProperties(NC::Menu<T> &menu, const MPD::Song &s, HasSongs &screen, bool
separate_albums = false; separate_albums = false;
if (Config.playlist_separate_albums) if (Config.playlist_separate_albums)
{ {
auto pl = screen.getProxySongList(); auto pl = screen.proxySongList();
assert(pl); assert(pl);
auto next = pl->getSong(drawn_pos+1); auto next = pl.getSong(drawn_pos+1);
if (next && next->getAlbum() != s.getAlbum()) if (next && next->getAlbum() != s.getAlbum())
separate_albums = true; separate_albums = true;
} }

8
src/helpers.cpp
View File

@@ -90,12 +90,12 @@ std::string Timestamp(time_t t)
return result; return result;
} }
void markSongsInPlaylist(std::shared_ptr<ProxySongList> pl) void markSongsInPlaylist(ProxySongList pl)
{ {
size_t list_size = pl->size(); size_t list_size = pl.size();
for (size_t i = 0; i < list_size; ++i) for (size_t i = 0; i < list_size; ++i)
if (auto s = pl->getSong(i)) if (auto s = pl.getSong(i))
pl->setBold(i, myPlaylist->checkForSong(*s)); pl.setBold(i, myPlaylist->checkForSong(*s));
} }
std::wstring Scroller(const std::wstring &str, size_t &pos, size_t width) std::wstring Scroller(const std::wstring &str, size_t &pos, size_t width)

12
src/helpers.h
View File

@@ -38,13 +38,13 @@ inline HasSongs *hasSongs(BaseScreen *screen)
return dynamic_cast<HasSongs *>(screen); return dynamic_cast<HasSongs *>(screen);
} }
inline std::shared_ptr<ProxySongList> proxySongList(BaseScreen *screen) inline ProxySongList proxySongList(BaseScreen *screen)
{ {
auto ptr = nullProxySongList(); auto pl = ProxySongList();
auto hs = hasSongs(screen); auto hs = hasSongs(screen);
if (hs) if (hs)
ptr = hs->getProxySongList(); pl = hs->proxySongList();
return ptr; return pl;
} }
inline MPD::Song *currentSong(BaseScreen *screen) inline MPD::Song *currentSong(BaseScreen *screen)
@@ -52,7 +52,7 @@ inline MPD::Song *currentSong(BaseScreen *screen)
MPD::Song *ptr = 0; MPD::Song *ptr = 0;
auto pl = proxySongList(screen); auto pl = proxySongList(screen);
if (pl) if (pl)
ptr = pl->currentSong(); ptr = pl.currentSong();
return ptr; return ptr;
} }
@@ -471,7 +471,7 @@ bool addSongsToPlaylist(const MPD::SongList &list, bool play, size_t position =
std::string Timestamp(time_t t); std::string Timestamp(time_t t);
void markSongsInPlaylist(std::shared_ptr<ProxySongList> pl); void markSongsInPlaylist(ProxySongList pl);
std::wstring Scroller(const std::wstring &str, size_t &pos, size_t width); std::wstring Scroller(const std::wstring &str, size_t &pos, size_t width);

2
src/interfaces.h
View File

@@ -44,7 +44,7 @@ struct Searchable
struct HasSongs struct HasSongs
{ {
virtual std::shared_ptr<ProxySongList> getProxySongList() = 0; virtual ProxySongList proxySongList() = 0;
virtual bool allowsSelection() = 0; virtual bool allowsSelection() = 0;
virtual void reverseSelection() = 0; virtual void reverseSelection() = 0;

8
src/media_library.cpp
View File

@@ -553,9 +553,9 @@ void MediaLibrary::prevFound(bool wrap)
/***********************************************************************/ /***********************************************************************/
std::shared_ptr<ProxySongList> MediaLibrary::getProxySongList() ProxySongList MediaLibrary::proxySongList()
{ {
auto ptr = nullProxySongList(); auto ptr = ProxySongList();
if (isActiveWindow(Songs)) if (isActiveWindow(Songs))
ptr = songsProxyList(); ptr = songsProxyList();
return ptr; return ptr;
@@ -744,9 +744,9 @@ int MediaLibrary::Columns()
return 3; return 3;
} }
std::shared_ptr<ProxySongList> MediaLibrary::songsProxyList() ProxySongList MediaLibrary::songsProxyList()
{ {
return mkProxySongList(Songs, [](NC::Menu<MPD::Song>::Item &item) { return ProxySongList(Songs, [](NC::Menu<MPD::Song>::Item &item) {
return &item.value(); return &item.value();
}); });
} }

4
src/media_library.h
View File

@@ -55,7 +55,7 @@ struct MediaLibrary: Screen<NC::Window *>, Filterable, HasColumns, HasSongs, Sea
virtual void prevFound(bool wrap) OVERRIDE; virtual void prevFound(bool wrap) OVERRIDE;
// HasSongs implementation // HasSongs implementation
virtual std::shared_ptr<ProxySongList> getProxySongList() OVERRIDE; virtual ProxySongList proxySongList() OVERRIDE;
virtual bool allowsSelection() OVERRIDE; virtual bool allowsSelection() OVERRIDE;
virtual void reverseSelection() OVERRIDE; virtual void reverseSelection() OVERRIDE;
@@ -72,7 +72,7 @@ struct MediaLibrary: Screen<NC::Window *>, Filterable, HasColumns, HasSongs, Sea
void toggleColumnsMode(); void toggleColumnsMode();
int Columns(); int Columns();
void LocateSong(const MPD::Song &); void LocateSong(const MPD::Song &);
std::shared_ptr<ProxySongList> songsProxyList(); ProxySongList songsProxyList();
struct SearchConstraints struct SearchConstraints
{ {

4
src/playlist.cpp
View File

@@ -171,9 +171,9 @@ void Playlist::prevFound(bool wrap)
/***********************************************************************/ /***********************************************************************/
std::shared_ptr<ProxySongList> Playlist::getProxySongList() ProxySongList Playlist::proxySongList()
{ {
return mkProxySongList(w, [](NC::Menu<MPD::Song>::Item &item) { return ProxySongList(w, [](NC::Menu<MPD::Song>::Item &item) {
return &item.value(); return &item.value();
}); });
} }

2
src/playlist.h
View File

@@ -58,7 +58,7 @@ struct Playlist: Screen<NC::Menu<MPD::Song>>, Filterable, HasSongs, Searchable,
virtual void prevFound(bool wrap) OVERRIDE; virtual void prevFound(bool wrap) OVERRIDE;
// HasSongs implementation // HasSongs implementation
virtual std::shared_ptr<ProxySongList> getProxySongList() OVERRIDE; virtual ProxySongList proxySongList() OVERRIDE;
virtual bool allowsSelection() OVERRIDE; virtual bool allowsSelection() OVERRIDE;
virtual void reverseSelection() OVERRIDE; virtual void reverseSelection() OVERRIDE;

8
src/playlist_editor.cpp
View File

@@ -202,9 +202,9 @@ bool PlaylistEditor::isContentFiltered()
return false; return false;
} }
std::shared_ptr<ProxySongList> PlaylistEditor::contentProxyList() ProxySongList PlaylistEditor::contentProxyList()
{ {
return mkProxySongList(Content, [](NC::Menu<MPD::Song>::Item &item) { return ProxySongList(Content, [](NC::Menu<MPD::Song>::Item &item) {
return &item.value(); return &item.value();
}); });
} }
@@ -386,9 +386,9 @@ void PlaylistEditor::prevFound(bool wrap)
/***********************************************************************/ /***********************************************************************/
std::shared_ptr<ProxySongList> PlaylistEditor::getProxySongList() ProxySongList PlaylistEditor::proxySongList()
{ {
auto ptr = nullProxySongList(); auto ptr = ProxySongList();
if (isActiveWindow(Content)) if (isActiveWindow(Content))
ptr = contentProxyList(); ptr = contentProxyList();
return ptr; return ptr;

4
src/playlist_editor.h
View File

@@ -55,7 +55,7 @@ struct PlaylistEditor: Screen<NC::Window *>, Filterable, HasColumns, HasSongs, S
virtual void prevFound(bool wrap) OVERRIDE; virtual void prevFound(bool wrap) OVERRIDE;
// HasSongs implementation // HasSongs implementation
virtual std::shared_ptr<ProxySongList> getProxySongList() OVERRIDE; virtual ProxySongList proxySongList() OVERRIDE;
virtual bool allowsSelection() OVERRIDE; virtual bool allowsSelection() OVERRIDE;
virtual void reverseSelection() OVERRIDE; virtual void reverseSelection() OVERRIDE;
@@ -74,7 +74,7 @@ struct PlaylistEditor: Screen<NC::Window *>, Filterable, HasColumns, HasSongs, S
virtual void Locate(const std::string &); virtual void Locate(const std::string &);
bool isContentFiltered(); bool isContentFiltered();
std::shared_ptr<ProxySongList> contentProxyList(); ProxySongList contentProxyList();
NC::Menu<std::string> Playlists; NC::Menu<std::string> Playlists;
NC::Menu<MPD::Song> Content; NC::Menu<MPD::Song> Content;

16
src/proxy_song_list.h
View File

@@ -99,6 +99,8 @@ class ProxySongList
std::shared_ptr<Interface> m_impl; std::shared_ptr<Interface> m_impl;
public: public:
ProxySongList() { }
template <typename T, typename F> template <typename T, typename F>
ProxySongList(typename NC::Menu<T> &menu, F f) : m_impl(new Impl<T, F>(menu, f)) { } ProxySongList(typename NC::Menu<T> &menu, F f) : m_impl(new Impl<T, F>(menu, f)) { }
@@ -115,17 +117,9 @@ public:
MPD::Song *getSong(size_t pos) { return m_impl->getSong(pos); } MPD::Song *getSong(size_t pos) { return m_impl->getSong(pos); }
MPD::Song *currentSong() { return m_impl->currentSong(); } MPD::Song *currentSong() { return m_impl->currentSong(); }
/// @return true if there is no underlying menu object, false otherwise
operator bool() const { return m_impl.get() != 0; }
}; };
template <typename T, typename F>
std::shared_ptr<ProxySongList> mkProxySongList(typename NC::Menu<T> &menu, F f)
{
return std::make_shared<ProxySongList>(ProxySongList(menu, f));
}
inline std::shared_ptr<ProxySongList> nullProxySongList()
{
return std::shared_ptr<ProxySongList>();
}
#endif #endif

8
src/search_engine.cpp
View File

@@ -129,7 +129,7 @@ void SearchEngine::switchTo()
SwitchTo::execute(this); SwitchTo::execute(this);
if (w.empty()) if (w.empty())
Prepare(); Prepare();
markSongsInPlaylist(getProxySongList()); markSongsInPlaylist(proxySongList());
drawHeader(); drawHeader();
} }
@@ -184,7 +184,7 @@ void SearchEngine::enterPressed()
w.insertItem(ResetButton+2, SEItem(), 1, 1); w.insertItem(ResetButton+2, SEItem(), 1, 1);
w.at(ResetButton+2).value().mkBuffer() << Config.color1 << "Search results: " << Config.color2 << "Found " << found << (found > 1 ? " songs" : " song") << NC::clDefault; w.at(ResetButton+2).value().mkBuffer() << Config.color1 << "Search results: " << Config.color2 << "Found " << found << (found > 1 ? " songs" : " song") << NC::clDefault;
w.insertSeparator(ResetButton+3); w.insertSeparator(ResetButton+3);
markSongsInPlaylist(getProxySongList()); markSongsInPlaylist(proxySongList());
Statusbar::msg("Searching finished"); Statusbar::msg("Searching finished");
if (Config.block_search_constraints_change) if (Config.block_search_constraints_change)
for (size_t i = 0; i < StaticOptions-4; ++i) for (size_t i = 0; i < StaticOptions-4; ++i)
@@ -296,9 +296,9 @@ void SearchEngine::prevFound(bool wrap)
/***********************************************************************/ /***********************************************************************/
std::shared_ptr< ProxySongList > SearchEngine::getProxySongList() ProxySongList SearchEngine::proxySongList()
{ {
return mkProxySongList(w, [](NC::Menu<SEItem>::Item &item) -> MPD::Song * { return ProxySongList(w, [](NC::Menu<SEItem>::Item &item) -> MPD::Song * {
MPD::Song *ptr = 0; MPD::Song *ptr = 0;
if (!item.isSeparator() && item.value().isSong()) if (!item.isSeparator() && item.value().isSong())
ptr = &item.value().song(); ptr = &item.value().song();

2
src/search_engine.h
View File

@@ -104,7 +104,7 @@ struct SearchEngine: Screen<NC::Menu<SEItem>>, Filterable, HasSongs, Searchable,
virtual void prevFound(bool wrap) OVERRIDE; virtual void prevFound(bool wrap) OVERRIDE;
// HasSongs implementation // HasSongs implementation
virtual std::shared_ptr<ProxySongList> getProxySongList() OVERRIDE; virtual ProxySongList proxySongList() OVERRIDE;
virtual bool allowsSelection() OVERRIDE; virtual bool allowsSelection() OVERRIDE;
virtual void reverseSelection() OVERRIDE; virtual void reverseSelection() OVERRIDE;

4
src/status.cpp
View File

@@ -165,9 +165,9 @@ void Status::Changes::playlist()
Playlist::ReloadRemaining = true; Playlist::ReloadRemaining = true;
if (isVisible(myBrowser)) if (isVisible(myBrowser))
markSongsInPlaylist(myBrowser->getProxySongList()); markSongsInPlaylist(myBrowser->proxySongList());
if (isVisible(mySearcher)) if (isVisible(mySearcher))
markSongsInPlaylist(mySearcher->getProxySongList()); markSongsInPlaylist(mySearcher->proxySongList());
if (isVisible(myLibrary)) if (isVisible(myLibrary))
markSongsInPlaylist(myLibrary->songsProxyList()); markSongsInPlaylist(myLibrary->songsProxyList());
if (isVisible(myPlaylistEditor)) if (isVisible(myPlaylistEditor))

6
src/tag_editor.cpp
View File

@@ -796,11 +796,11 @@ void TagEditor::prevFound(bool wrap)
/***********************************************************************/ /***********************************************************************/
std::shared_ptr<ProxySongList> TagEditor::getProxySongList() ProxySongList TagEditor::proxySongList()
{ {
auto ptr = nullProxySongList(); auto ptr = ProxySongList();
if (w == Tags) if (w == Tags)
ptr = mkProxySongList(*Tags, [](NC::Menu<MPD::MutableSong>::Item &item) { ptr = ProxySongList(*Tags, [](NC::Menu<MPD::MutableSong>::Item &item) {
return &item.value(); return &item.value();
}); });
return ptr; return ptr;

2
src/tag_editor.h
View File

@@ -63,7 +63,7 @@ struct TagEditor: Screen<NC::Window *>, Filterable, HasColumns, HasSongs, Search
virtual void prevFound(bool wrap) OVERRIDE; virtual void prevFound(bool wrap) OVERRIDE;
// HasSongs implementation // HasSongs implementation
virtual std::shared_ptr<ProxySongList> getProxySongList() OVERRIDE; virtual ProxySongList proxySongList() OVERRIDE;
virtual bool allowsSelection() OVERRIDE; virtual bool allowsSelection() OVERRIDE;
virtual void reverseSelection() OVERRIDE; virtual void reverseSelection() OVERRIDE;