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

menu: implement custom iterator

Browse Source
This commit is contained in:
Andrzej Rybczak
2012-08-30 20:17:25 +02:00
parent 7297b8a9ad
commit 7e53654492
12 changed files with 207 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/actions.cpp
View File

@@ -881,7 +881,7 @@ void Delete::Run()
for (std::vector<size_t>::reverse_iterator it = list.rbegin(); it != list.rend(); ++it)
{
Mpd.Delete(playlist, *it);
myPlaylistEditor->Content->DeleteOption(*it);
myPlaylistEditor->Content->DeleteItem(*it);
}
Mpd.CommitCommandsList();
ShowMessage("Selected items deleted from playlist \"%s\"", myPlaylistEditor->Playlists->Current().c_str());
@@ -889,7 +889,7 @@ void Delete::Run()
else
{
if (Mpd.Delete(myPlaylistEditor->Playlists->Current(), myPlaylistEditor->Content->Choice()))
myPlaylistEditor->Content->DeleteOption(myPlaylistEditor->Content->Choice());
myPlaylistEditor->Content->DeleteItem(myPlaylistEditor->Content->Choice());
}
}
}
@@ -2203,7 +2203,7 @@ void ToggleBrowserSortMode::Run()
ShowMessage("Sort songs by: Name");
break;
}
myBrowser->Main()->Sort<CaseInsensitiveSorting>(myBrowser->CurrentDir() != "/");
std::sort(myBrowser->Main()->Begin()+(myBrowser->CurrentDir() != "/"), myBrowser->Main()->End(), CaseInsensitiveSorting());
}
bool ToggleLibraryTagType::canBeRun() const

8
src/browser.cpp
View File

@@ -369,7 +369,7 @@ void Browser::GetDirectory(std::string dir, std::string subdir)
MPD::Item parent;
parent.name = "..";
parent.type = itDirectory;
w->AddOption(parent);
w->AddItem(parent);
}
MPD::ItemList list;
@@ -397,7 +397,7 @@ void Browser::GetDirectory(std::string dir, std::string subdir)
case itPlaylist:
{
utf_to_locale(it->name);
w->AddOption(*it);
w->AddItem(*it);
break;
}
case itDirectory:
@@ -405,7 +405,7 @@ void Browser::GetDirectory(std::string dir, std::string subdir)
utf_to_locale(it->name);
if (it->name == subdir)
highlightme = w->Size();
w->AddOption(*it);
w->AddItem(*it);
break;
}
case itSong:
@@ -419,7 +419,7 @@ void Browser::GetDirectory(std::string dir, std::string subdir)
break;
}
}
w->AddOption(*it, bold);
w->AddItem(*it, bold);
break;
}
}

29
src/media_library.cpp
View File

@@ -207,7 +207,7 @@ void MediaLibrary::Update()
if (it->empty() && !Config.media_library_display_empty_tag)
continue;
utf_to_locale(*it);
Artists->AddOption(*it);
Artists->AddItem(*it);
}
Artists->Window::Clear();
Artists->Refresh();
@@ -237,22 +237,22 @@ void MediaLibrary::Update()
utf_to_locale(*album);
Mpd.CommitSearchTags([this, &album](std::string &&date) {
utf_to_locale(date);
Albums->AddOption(SearchConstraints(*album, date));
Albums->AddItem(SearchConstraints(*album, date));
});
}
else
{
utf_to_locale(*album);
Albums->AddOption(SearchConstraints(*album, ""));
Albums->AddItem(SearchConstraints(*album, ""));
}
}
utf_to_locale(Artists->Current());
if (!Albums->Empty())
Albums->Sort<SearchConstraintsSorting>();
std::sort(Albums->Begin(), Albums->End(), SearchConstraintsSorting());
if (Albums->Size() > 1)
{
Albums->AddSeparator();
Albums->AddOption(SearchConstraints("", AllTracksMarker));
Albums->AddItem(SearchConstraints("", AllTracksMarker));
}
Albums->Refresh();
Mpd.BlockIdle(0);
@@ -286,27 +286,27 @@ void MediaLibrary::Update()
utf_to_locale(*album);
Mpd.CommitSearchTags([this, &artist, &album](std::string &&tag) {
utf_to_locale(tag);
Albums->AddOption(SearchConstraints(*artist, *album, tag));
Albums->AddItem(SearchConstraints(*artist, *album, tag));
});
}
else
{
utf_to_locale(*artist);
utf_to_locale(*album);
Albums->AddOption(SearchConstraints(*artist, *album, *artist));
Albums->AddItem(SearchConstraints(*artist, *album, *artist));
}
}
else
{
utf_to_locale(*artist);
utf_to_locale(*album);
Albums->AddOption(SearchConstraints(*artist, *album, ""));
Albums->AddItem(SearchConstraints(*artist, *album, ""));
}
}
}
Mpd.BlockIdle(0);
if (!Albums->Empty())
Albums->Sort<SearchConstraintsSorting>();
std::sort(Albums->Begin(), Albums->End(), SearchConstraintsSorting());
Albums->Refresh();
}
@@ -320,7 +320,6 @@ void MediaLibrary::Update()
if (!(hasTwoColumns ? Albums->Empty() : Artists->Empty()) && Songs->ReallyEmpty())
{
Songs->Reset();
MPD::SongList list;
Mpd.StartSearch(1);
Mpd.AddSearch(Config.media_lib_primary_tag, locale_to_utf_cpy(hasTwoColumns ? Albums->Current().PrimaryTag : Artists->Current()));
@@ -330,17 +329,15 @@ void MediaLibrary::Update()
if (Config.media_library_display_date)
Mpd.AddSearch(MPD_TAG_DATE, locale_to_utf_cpy(Albums->Current().Date));
}
Mpd.CommitSearchSongs([&list](MPD::Song &&s) {
list.push_back(s);
Mpd.CommitSearchSongs([this](MPD::Song &&s) {
Songs->AddItem(s, myPlaylist->checkForSong(s));
});
if (Albums->Current().Date == AllTracksMarker)
std::sort(list.begin(), list.end(), SortAllTracks);
std::sort(Songs->Begin(), Songs->End(), SortAllTracks);
else
std::sort(list.begin(), list.end(), SortSongsByTrack);
std::sort(Songs->Begin(), Songs->End(), SortSongsByTrack);
for (auto it = list.begin(); it != list.end(); ++it)
Songs->AddOption(*it, myPlaylist->checkForSong(*it));
Songs->Window::Clear();
Songs->Refresh();
}

6
src/menu.cpp
View File

@@ -22,15 +22,15 @@
using namespace NCurses;
template <> std::string Menu<std::string>::GetOption(size_t pos)
template <> std::string Menu<std::string>::GetItem(size_t pos)
{
std::string result;
if (m_options_ptr->at(pos))
{
if (m_get_string_helper)
result = m_get_string_helper((*m_options_ptr)[pos]->Item);
result = m_get_string_helper((*m_options_ptr)[pos]->Value);
else
result = (*m_options_ptr)[pos]->Item;
result = (*m_options_ptr)[pos]->Value;
}
return result;
}

194
src/menu.h
View File

@@ -22,8 +22,8 @@
#define _MENU_H
#include <regex.h>
#include <algorithm>
#include <functional>
#include <iterator>
#include <set>
#include "error.h"
@@ -102,7 +102,7 @@ namespace NCurses
/// This template class is generic menu capable of
/// holding any std::vector compatible values.
///
template <typename T> class Menu : public Window, public List
template <typename T> struct Menu : public Window, public List
{
/// Function helper prototype used to display each option on the screen.
/// If not set by setItemDisplayer(), menu won't display anything.
@@ -119,36 +119,94 @@ namespace NCurses
/// Struct that holds each item in the list and its attributes
///
struct Option
struct Item
{
Option() : isBold(0), isSelected(0), isStatic(0) { }
Option(const T &t, bool is_bold, bool is_static) :
Item(t), isBold(is_bold), isSelected(0), isStatic(is_static) { }
Item() : isBold(0), isSelected(0), isStatic(0) { }
Item(const T &t, bool is_bold, bool is_static) :
Value(t), isBold(is_bold), isSelected(0), isStatic(is_static) { }
T Item;
T Value;
bool isBold;
bool isSelected;
bool isStatic;
};
/// Functor that wraps around the functor passed to Sort()
/// to fit to internal container structure
///
template <typename Comparison> class InternalSorting
template <typename ValueT, typename BaseIterator> class ItemIterator
: public std::iterator<std::random_access_iterator_tag, ValueT>
{
Comparison cmp;
friend class Menu<T>;
public:
bool operator()(Option *a, Option *b)
{
return cmp(a->Item, b->Item);
}
};
BaseIterator m_it;
explicit ItemIterator(BaseIterator it) : m_it(it) { }
typedef typename std::vector<Option *>::iterator option_iterator;
typedef typename std::vector<Option *>::const_iterator option_const_iterator;
static const bool referenceValue = !std::is_same<
ValueT, typename std::remove_pointer<
typename BaseIterator::value_type
>::type
>::value;
template <typename Result, bool referenceValue> struct getObject { };
template <typename Result> struct getObject<Result, true> {
static Result &apply(BaseIterator it) { return (*it)->Value; }
};
template <typename Result> struct getObject<Result, false> {
static Result &apply(BaseIterator it) { return **it; }
};
public:
ItemIterator() { }
ValueT &operator*() const { return getObject<ValueT, referenceValue>::apply(m_it); }
typename BaseIterator::value_type operator->() { return *m_it; }
ItemIterator &operator++() { ++m_it; return *this; }
ItemIterator operator++(int) { return ItemIterator(m_it++); }
ItemIterator &operator--() { --m_it; return *this; }
ItemIterator operator--(int) { return ItemIterator(m_it--); }
ValueT &operator[](ptrdiff_t n) const {
return getObject<ValueT, referenceValue>::apply(&m_it[n]);
}
ItemIterator &operator+=(ptrdiff_t n) { m_it += n; return *this; }
ItemIterator operator+(ptrdiff_t n) const { return ItemIterator(m_it + n); }
ItemIterator &operator-=(ptrdiff_t n) { m_it -= n; return *this; }
ItemIterator operator-(ptrdiff_t n) const { return ItemIterator(m_it - n); }
ptrdiff_t operator-(const ItemIterator &rhs) const { return m_it - rhs.m_it; }
template <typename Iterator>
bool operator==(const Iterator &rhs) const { return m_it == rhs.m_it; }
template <typename Iterator>
bool operator!=(const Iterator &rhs) const { return m_it != rhs.m_it; }
template <typename Iterator>
bool operator<(const Iterator &rhs) const { return m_it < rhs.m_it; }
template <typename Iterator>
bool operator<=(const Iterator &rhs) const { return m_it <= rhs.m_it; }
template <typename Iterator>
bool operator>(const Iterator &rhs) const { return m_it > rhs.m_it; }
template <typename Iterator>
bool operator>=(const Iterator &rhs) const { return m_it >= rhs.m_it; }
/// non-const to const conversion
template <typename Iterator> operator ItemIterator<
typename std::add_const<ValueT>::type, Iterator
>() { return ItemIterator(m_it); }
const BaseIterator &base() { return m_it; }
};
typedef ItemIterator<
T, typename std::vector<Item *>::iterator
> Iterator;
typedef ItemIterator<
typename std::add_const<T>::type, typename std::vector<Item *>::const_iterator
> ConstIterator;
typedef std::reverse_iterator<Iterator> ReverseIterator;
typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;
/// Constructs an empty menu with given parameters
/// @param startx X position of left upper corner of constructed menu
@@ -196,7 +254,7 @@ namespace NCurses
/// @param is_bold defines the initial state of bold attribute
/// @param is_static defines the initial state of static attribute
///
void AddOption(const T &item, bool is_bold = 0, bool is_static = 0);
void AddItem(const T &item, bool is_bold = 0, bool is_static = 0);
/// Adds separator to list
///
@@ -208,7 +266,7 @@ namespace NCurses
/// @param is_bold defines the initial state of bold attribute
/// @param is_static defines the initial state of static attribute
///
void InsertOption(size_t pos, const T &Item, bool is_bold = 0, bool is_static = 0);
void InsertItem(size_t pos, const T &Item, bool is_bold = 0, bool is_static = 0);
/// Inserts separator to list at given position
/// @param pos initial position of inserted separator
@@ -218,7 +276,7 @@ namespace NCurses
/// Deletes item from given position
/// @param pos given position of item to be deleted
///
void DeleteOption(size_t pos);
void DeleteItem(size_t pos);
/// Converts the option into separator
/// @param pos position of item to be converted
@@ -371,7 +429,7 @@ namespace NCurses
/// @return item converted to string
/// @see setItemDisplayer()
///
std::string GetOption(size_t pos);
std::string GetItem(size_t pos);
/// Refreshes the menu window
/// @see Window::Refresh()
@@ -393,18 +451,6 @@ namespace NCurses
///
void Reset();
/// Sorts all items using Comparison object with defined operator()
/// @param beginning beginning of range that has to be sorted
///
template <typename Comparison> void Sort(size_t beginning = 0, size_t end = -1)
{
if (m_options.empty())
return;
sort(m_options.begin()+beginning, end == size_t(-1) ? m_options.end() : m_options.begin()+end, InternalSorting<Comparison>());
if (isFiltered())
ApplyFilter(m_filter);
}
/// Sets prefix, that is put before each selected item to indicate its selection
/// Note that the passed variable is not deleted along with menu object.
/// @param b pointer to buffer that contains the prefix
@@ -510,6 +556,18 @@ namespace NCurses
///
T &operator[](size_t pos);
Iterator Begin() { return Iterator(m_options_ptr->begin()); }
ConstIterator Begin() const { return ConstIterator(m_options_ptr->begin()); }
Iterator End() { return Iterator(m_options_ptr->end()); }
ConstIterator End() const { return ConstIterator(m_options_ptr->end()); }
ReverseIterator Rbegin() { return ReverseIterator(End()); }
ConstReverseIterator Rbegin() const { return ConstReverseIterator(End()); }
ReverseIterator Rend() { return ReverseIterator(Begin()); }
ConstReverseIterator Rend() const { return ConstReverseIterator(Begin()); }
protected:
/// Clears filter, filtered data etc.
///
@@ -521,9 +579,9 @@ namespace NCurses
std::string m_filter;
std::string m_search_constraint;
std::vector<Option *> *m_options_ptr;
std::vector<Option *> m_options;
std::vector<Option *> m_filtered_options;
std::vector<Item *> *m_options_ptr;
std::vector<Item *> m_options;
std::vector<Item *> m_filtered_options;
std::vector<size_t> m_filtered_positions;
std::set<size_t> m_found_positions;
@@ -542,10 +600,10 @@ namespace NCurses
Buffer *m_selected_suffix;
};
/// Specialization of Menu<T>::GetOption for T = std::string, it's obvious
/// Specialization of Menu<T>::GetItem for T = std::string, it's obvious
/// that if strings are stored, we don't need extra function to convert
/// them to strings by default
template <> std::string Menu<std::string>::GetOption(size_t pos);
template <> std::string Menu<std::string>::GetItem(size_t pos);
}
template <typename T> NCurses::Menu<T>::Menu(size_t startx,
@@ -584,13 +642,13 @@ template <typename T> NCurses::Menu<T>::Menu(const Menu &m) : Window(m),
m_selected_suffix(m.m_selected_suffix)
{
m_options.reserve(m.m_options.size());
for (option_const_iterator it = m.m_options.begin(); it != m.m_options.end(); ++it)
m_options.push_back(new Option(**it));
for (auto it = m.m_options.begin(); it != m.m_options.end(); ++it)
m_options.push_back(new Item(**it));
}
template <typename T> NCurses::Menu<T>::~Menu()
{
for (option_iterator it = m_options.begin(); it != m_options.end(); ++it)
for (auto it = m_options.begin(); it != m_options.end(); ++it)
delete *it;
}
@@ -606,7 +664,7 @@ template <typename T> void NCurses::Menu<T>::ResizeList(size_t size)
m_options.resize(size);
for (size_t i = 0; i < size; ++i)
if (!m_options[i])
m_options[i] = new Option();
m_options[i] = new Item();
}
else if (size < m_options.size())
{
@@ -616,19 +674,19 @@ template <typename T> void NCurses::Menu<T>::ResizeList(size_t size)
}
}
template <typename T> void NCurses::Menu<T>::AddOption(const T &item, bool is_bold, bool is_static)
template <typename T> void NCurses::Menu<T>::AddItem(const T &item, bool is_bold, bool is_static)
{
m_options.push_back(new Option(item, is_bold, is_static));
m_options.push_back(new Item(item, is_bold, is_static));
}
template <typename T> void NCurses::Menu<T>::AddSeparator()
{
m_options.push_back(static_cast<Option *>(0));
m_options.push_back(static_cast<Item *>(0));
}
template <typename T> void NCurses::Menu<T>::InsertOption(size_t pos, const T &item, bool is_bold, bool is_static)
template <typename T> void NCurses::Menu<T>::InsertItem(size_t pos, const T &item, bool is_bold, bool is_static)
{
m_options.insert(m_options.begin()+pos, new Option(item, is_bold, is_static));
m_options.insert(m_options.begin()+pos, new Item(item, is_bold, is_static));
}
template <typename T> void NCurses::Menu<T>::InsertSeparator(size_t pos)
@@ -636,7 +694,7 @@ template <typename T> void NCurses::Menu<T>::InsertSeparator(size_t pos)
m_options.insert(m_options.begin()+pos, 0);
}
template <typename T> void NCurses::Menu<T>::DeleteOption(size_t pos)
template <typename T> void NCurses::Menu<T>::DeleteItem(size_t pos)
{
if (m_options_ptr->empty())
return;
@@ -753,7 +811,7 @@ template <typename T> void NCurses::Menu<T>::Refresh()
if ((*m_options_ptr)[i]->isSelected && m_selected_prefix)
*this << *m_selected_prefix;
if (m_item_displayer)
m_item_displayer(*this, (*m_options_ptr)[i]->Item);
m_item_displayer(*this, (*m_options_ptr)[i]->Value);
if ((*m_options_ptr)[i]->isSelected && m_selected_suffix)
*this << *m_selected_suffix;
if (m_highlight_enabled && int(i) == itsHighlight)
@@ -897,7 +955,7 @@ template <typename T> void NCurses::Menu<T>::ClearFiltered()
template <typename T> void NCurses::Menu<T>::Clear()
{
for (option_iterator it = m_options.begin(); it != m_options.end(); ++it)
for (auto it = m_options.begin(); it != m_options.end(); ++it)
delete *it;
m_options.clear();
m_found_positions.clear();
@@ -953,7 +1011,7 @@ template <typename T> bool NCurses::Menu<T>::isSeparator(int pos) const
template <typename T> bool NCurses::Menu<T>::hasSelected() const
{
for (option_const_iterator it = m_options_ptr->begin(); it != m_options_ptr->end(); ++it)
for (auto it = m_options_ptr->begin(); it != m_options_ptr->end(); ++it)
if (*it && (*it)->isSelected)
return true;
return false;
@@ -985,7 +1043,7 @@ template <typename T> size_t NCurses::Menu<T>::Choice() const
template <typename T> size_t NCurses::Menu<T>::RealChoice() const
{
size_t result = 0;
for (option_const_iterator it = m_options_ptr->begin(); it != m_options_ptr->begin()+itsHighlight; ++it)
for (auto it = m_options_ptr->begin(); it != m_options_ptr->begin()+itsHighlight; ++it)
if (*it && !(*it)->isStatic)
result++;
return result;
@@ -993,7 +1051,7 @@ template <typename T> size_t NCurses::Menu<T>::RealChoice() const
template <typename T> void NCurses::Menu<T>::ReverseSelection(size_t beginning)
{
option_iterator it = m_options_ptr->begin()+beginning;
auto it = m_options_ptr->begin()+beginning;
for (size_t i = beginning; i < Size(); ++i, ++it)
if (*it)
(*it)->isSelected = !(*it)->isSelected && !(*it)->isStatic;
@@ -1011,7 +1069,7 @@ template <typename T> bool NCurses::Menu<T>::Search(const std::string &constrain
{
for (size_t i = beginning; i < m_options_ptr->size(); ++i)
{
if (regexec(&rx, GetOption(i).c_str(), 0, 0, 0) == 0)
if (regexec(&rx, GetItem(i).c_str(), 0, 0, 0) == 0)
m_found_positions.insert(i);
}
}
@@ -1058,7 +1116,7 @@ template <typename T> void NCurses::Menu<T>::ApplyFilter(const std::string &filt
{
for (size_t i = beginning; i < m_options.size(); ++i)
{
if (regexec(&rx, GetOption(i).c_str(), 0, 0, 0) == 0)
if (regexec(&rx, GetItem(i).c_str(), 0, 0, 0) == 0)
{
m_filtered_positions.push_back(i);
m_filtered_options.push_back(m_options[i]);
@@ -1076,10 +1134,10 @@ template <typename T> const std::string &NCurses::Menu<T>::GetFilter()
return m_filter;
}
template <typename T> std::string NCurses::Menu<T>::GetOption(size_t pos)
template <typename T> std::string NCurses::Menu<T>::GetItem(size_t pos)
{
if (m_options_ptr->at(pos) && m_get_string_helper)
return m_get_string_helper((*m_options_ptr)[pos]->Item);
return m_get_string_helper((*m_options_ptr)[pos]->Value);
else
return "";
}
@@ -1088,56 +1146,56 @@ template <typename T> T &NCurses::Menu<T>::Back()
{
if (!m_options_ptr->back())
FatalError("Menu::Back() has requested separator!");
return m_options_ptr->back()->Item;
return m_options_ptr->back()->Value;
}
template <typename T> const T &NCurses::Menu<T>::Back() const
{
if (!m_options_ptr->back())
FatalError("Menu::Back() has requested separator!");
return m_options_ptr->back()->Item;
return m_options_ptr->back()->Value;
}
template <typename T> T &NCurses::Menu<T>::Current()
{
if (!m_options_ptr->at(itsHighlight))
FatalError("Menu::Current() has requested separator!");
return (*m_options_ptr)[itsHighlight]->Item;
return (*m_options_ptr)[itsHighlight]->Value;
}
template <typename T> const T &NCurses::Menu<T>::Current() const
{
if (!m_options_ptr->at(itsHighlight))
FatalError("Menu::Current() const has requested separator!");
return (*m_options_ptr)[itsHighlight]->Item;
return (*m_options_ptr)[itsHighlight]->Value;
}
template <typename T> T &NCurses::Menu<T>::at(size_t pos)
{
if (!m_options_ptr->at(pos))
FatalError("Menu::at() has requested separator!");
return (*m_options_ptr)[pos]->Item;
return (*m_options_ptr)[pos]->Value;
}
template <typename T> const T &NCurses::Menu<T>::at(size_t pos) const
{
if (!m_options->at(pos))
FatalError("Menu::at() const has requested separator!");
return (*m_options_ptr)[pos]->Item;
return (*m_options_ptr)[pos]->Value;
}
template <typename T> const T &NCurses::Menu<T>::operator[](size_t pos) const
{
if (!(*m_options_ptr)[pos])
FatalError("Menu::operator[] const has requested separator!");
return (*m_options_ptr)[pos]->Item;
return (*m_options_ptr)[pos]->Value;
}
template <typename T> T &NCurses::Menu<T>::operator[](size_t pos)
{
if (!(*m_options_ptr)[pos])
FatalError("Menu::operator[] has requested separator!");
return (*m_options_ptr)[pos]->Item;
return (*m_options_ptr)[pos]->Value;
}
#endif

2
src/outputs.cpp
View File

@@ -117,7 +117,7 @@ void Outputs::FetchList()
return;
w->Clear();
Mpd.GetOutputs([this](MPD::Output &&o) {
w->AddOption(o, o.isEnabled());
w->AddItem(o, o.isEnabled());
});
if (myScreen == this)
w->Refresh();

26
src/playlist.cpp
View File

@@ -71,19 +71,19 @@ void Playlist::Init()
SortDialog->CenteredCursor(Config.centered_cursor);
SortDialog->setItemDisplayer(Display::Pair<std::string, MPD::Song::GetFunction>);
SortDialog->AddOption(std::make_pair("Artist", &MPD::Song::getArtist));
SortDialog->AddOption(std::make_pair("Album", &MPD::Song::getAlbum));
SortDialog->AddOption(std::make_pair("Disc", &MPD::Song::getDisc));
SortDialog->AddOption(std::make_pair("Track", &MPD::Song::getTrack));
SortDialog->AddOption(std::make_pair("Genre", &MPD::Song::getGenre));
SortDialog->AddOption(std::make_pair("Date", &MPD::Song::getDate));
SortDialog->AddOption(std::make_pair("Composer", &MPD::Song::getComposer));
SortDialog->AddOption(std::make_pair("Performer", &MPD::Song::getPerformer));
SortDialog->AddOption(std::make_pair("Title", &MPD::Song::getTitle));
SortDialog->AddOption(std::make_pair("Filename", &MPD::Song::getURI));
SortDialog->AddItem(std::make_pair("Artist", &MPD::Song::getArtist));
SortDialog->AddItem(std::make_pair("Album", &MPD::Song::getAlbum));
SortDialog->AddItem(std::make_pair("Disc", &MPD::Song::getDisc));
SortDialog->AddItem(std::make_pair("Track", &MPD::Song::getTrack));
SortDialog->AddItem(std::make_pair("Genre", &MPD::Song::getGenre));
SortDialog->AddItem(std::make_pair("Date", &MPD::Song::getDate));
SortDialog->AddItem(std::make_pair("Composer", &MPD::Song::getComposer));
SortDialog->AddItem(std::make_pair("Performer", &MPD::Song::getPerformer));
SortDialog->AddItem(std::make_pair("Title", &MPD::Song::getTitle));
SortDialog->AddItem(std::make_pair("Filename", &MPD::Song::getURI));
SortDialog->AddSeparator();
SortDialog->AddOption(std::make_pair("Sort", static_cast<MPD::Song::GetFunction>(0)));
SortDialog->AddOption(std::make_pair("Cancel", static_cast<MPD::Song::GetFunction>(0)));
SortDialog->AddItem(std::make_pair("Sort", static_cast<MPD::Song::GetFunction>(0)));
SortDialog->AddItem(std::make_pair("Cancel", static_cast<MPD::Song::GetFunction>(0)));
}
w = Items;
@@ -538,7 +538,7 @@ bool Playlist::Add(const MPD::Song &s, bool in_playlist, bool play, int position
if ((*Items)[i].getHash() == hash)
{
Mpd.Delete(i);
Items->DeleteOption(i);
Items->DeleteItem(i);
i--;
}
}

4
src/playlist_editor.cpp
View File

@@ -142,7 +142,7 @@ void PlaylistEditor::Update()
for (MPD::TagList::iterator it = list.begin(); it != list.end(); ++it)
{
utf_to_locale(*it);
Playlists->AddOption(*it);
Playlists->AddItem(*it);
}
Playlists->Window::Clear();
Playlists->Refresh();
@@ -153,7 +153,7 @@ void PlaylistEditor::Update()
Content->Reset();
size_t plsize = 0;
Mpd.GetPlaylistContent(locale_to_utf_cpy(Playlists->Current()), [this, &plsize](MPD::Song &&s) {
Content->AddOption(s, myPlaylist->checkForSong(s));
Content->AddItem(s, myPlaylist->checkForSong(s));
++plsize;
});
if (plsize > 0)

6
src/search_engine.cpp
View File

@@ -167,7 +167,7 @@ void SearchEngine::EnterPressed()
size_t found = w->Size()-SearchEngine::StaticOptions;
found += 3; // don't count options inserted below
w->InsertSeparator(ResetButton+1);
w->InsertOption(ResetButton+2, SEItem(), 1, 1);
w->InsertItem(ResetButton+2, SEItem(), 1, 1);
w->at(ResetButton+2).mkBuffer() << Config.color1 << "Search results: " << Config.color2 << "Found " << found << (found > 1 ? " songs" : " song") << clDefault;
w->InsertSeparator(ResetButton+3);
UpdateFoundList();
@@ -386,7 +386,7 @@ void SearchEngine::Search()
if (!itsConstraints[10].empty())
Mpd.AddSearch(MPD_TAG_COMMENT, itsConstraints[10]);
Mpd.CommitSearchSongs([this](MPD::Song &&s) {
w->AddOption(s);
w->AddItem(s);
});
return;
}
@@ -534,7 +534,7 @@ void SearchEngine::Search()
if (found && any_found)
{
w->AddOption(*it);
w->AddItem(*it);
list[it-list.begin()] = 0;
}
found = 1;

23
src/sel_items_adder.cpp
View File

@@ -18,6 +18,7 @@
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include <algorithm>
#include "charset.h"
#include "browser.h"
#include "display.h"
@@ -49,13 +50,13 @@ void SelectedItemsAdder::Init()
itsPositionSelector->CenteredCursor(Config.centered_cursor);
itsPositionSelector->HighlightColor(Config.main_highlight_color);
itsPositionSelector->setItemDisplayer(Display::Default<std::string>);
itsPositionSelector->AddOption("At the end of playlist");
itsPositionSelector->AddOption("At the beginning of playlist");
itsPositionSelector->AddOption("After current track");
itsPositionSelector->AddOption("After current album");
itsPositionSelector->AddOption("After highlighted item");
itsPositionSelector->AddItem("At the end of playlist");
itsPositionSelector->AddItem("At the beginning of playlist");
itsPositionSelector->AddItem("After current track");
itsPositionSelector->AddItem("After current album");
itsPositionSelector->AddItem("After highlighted item");
itsPositionSelector->AddSeparator();
itsPositionSelector->AddOption("Cancel");
itsPositionSelector->AddItem("Cancel");
w = itsPlaylistSelector;
isInitialized = 1;
@@ -96,20 +97,20 @@ void SelectedItemsAdder::SwitchTo()
w->Clear();
w->Reset();
if (myOldScreen != myPlaylist)
w->AddOption("Current MPD playlist", 0, 0);
w->AddOption("New playlist", 0, playlists_not_active);
w->AddItem("Current MPD playlist", 0, 0);
w->AddItem("New playlist", 0, playlists_not_active);
w->AddSeparator();
MPD::TagList playlists;
Mpd.GetPlaylists(playlists);
sort(playlists.begin(), playlists.end(), CaseInsensitiveSorting());
std::sort(playlists.begin(), playlists.end(), CaseInsensitiveSorting());
for (MPD::TagList::iterator it = playlists.begin(); it != playlists.end(); ++it)
{
utf_to_locale(*it);
w->AddOption(*it, 0, playlists_not_active);
w->AddItem(*it, 0, playlists_not_active);
}
w->AddSeparator();
w->AddOption("Cancel");
w->AddItem("Cancel");
myScreen = this;
w->Window::Clear();

2
src/status.cpp
View File

@@ -243,7 +243,7 @@ void NcmpcppStatusChanged(MPD::Connection *, MPD::StatusChanges changed, void *)
else
{
// otherwise just add it to playlist
myPlaylist->Items->AddOption(s);
myPlaylist->Items->AddItem(s);
}
});

48
src/tag_editor.cpp
View File

@@ -91,18 +91,18 @@ void TagEditor::Init()
TagTypes->setItemDisplayer(Display::Default<std::string>);
for (const SongInfo::Metadata *m = SongInfo::Tags; m->Name; ++m)
TagTypes->AddOption(m->Name);
TagTypes->AddItem(m->Name);
TagTypes->AddSeparator();
TagTypes->AddOption("Filename");
TagTypes->AddItem("Filename");
TagTypes->AddSeparator();
if (Config.titles_visibility)
TagTypes->AddOption("Options", 1, 1);
TagTypes->AddItem("Options", 1, 1);
TagTypes->AddSeparator();
TagTypes->AddOption("Capitalize First Letters");
TagTypes->AddOption("lower all letters");
TagTypes->AddItem("Capitalize First Letters");
TagTypes->AddItem("lower all letters");
TagTypes->AddSeparator();
TagTypes->AddOption("Reset");
TagTypes->AddOption("Save");
TagTypes->AddItem("Reset");
TagTypes->AddItem("Save");
Tags = new Menu<MPD::MutableSong>(RightColumnStartX, MainStartY, RightColumnWidth, MainHeight, Config.titles_visibility ? "Tags" : "", Config.main_color, brNone);
Tags->HighlightColor(Config.main_highlight_color);
@@ -117,10 +117,10 @@ void TagEditor::Init()
FParserDialog->CyclicScrolling(Config.use_cyclic_scrolling);
FParserDialog->CenteredCursor(Config.centered_cursor);
FParserDialog->setItemDisplayer(Display::Default<std::string>);
FParserDialog->AddOption("Get tags from filename");
FParserDialog->AddOption("Rename files");
FParserDialog->AddItem("Get tags from filename");
FParserDialog->AddItem("Rename files");
FParserDialog->AddSeparator();
FParserDialog->AddOption("Cancel");
FParserDialog->AddItem("Cancel");
FParser = new Menu<std::string>((COLS-FParserWidth)/2, (MainHeight-FParserHeight)/2+MainStartY, FParserWidthOne, FParserHeight, "_", Config.main_color, Config.active_window_border);
FParser->CyclicScrolling(Config.use_cyclic_scrolling);
@@ -252,10 +252,10 @@ void TagEditor::Update()
l.push_back(s);
});
if (!l.empty())
Albums->AddOption(std::make_pair(l[0].toString(Config.tag_editor_album_format), *it));
Albums->AddItem(std::make_pair(l[0].toString(Config.tag_editor_album_format), *it));
}
Mpd.BlockIdle(0);
Albums->Sort<CaseInsensitiveSorting>();
std::sort(Albums->Begin(), Albums->End(), CaseInsensitiveSorting());
}
else
{
@@ -266,18 +266,18 @@ void TagEditor::Update()
{
size_t slash = itsBrowsedDir.rfind("/");
std::string parent = slash != std::string::npos ? itsBrowsedDir.substr(0, slash) : "/";
Dirs->AddOption(make_pair("[..]", parent));
Dirs->AddItem(make_pair("[..]", parent));
}
else
{
Dirs->AddOption(std::make_pair(".", "/"));
Dirs->AddItem(std::make_pair(".", "/"));
}
for (MPD::TagList::const_iterator it = list.begin(); it != list.end(); ++it)
{
size_t slash = it->rfind("/");
std::string to_display = slash != std::string::npos ? it->substr(slash+1) : *it;
utf_to_locale(to_display);
Dirs->AddOption(make_pair(to_display, *it));
Dirs->AddItem(make_pair(to_display, *it));
if (*it == itsHighlightedDir)
highlightme = Dirs->Size()-1;
}
@@ -303,7 +303,7 @@ void TagEditor::Update()
});
std::sort(list.begin(), list.end(), CaseInsensitiveSorting());
for (auto it = list.begin(); it != list.end(); ++it)
Tags->AddOption(*it);
Tags->AddItem(*it);
}
}
else
@@ -311,7 +311,7 @@ void TagEditor::Update()
Mpd.GetSongs(Dirs->Current().second, list);
std::sort(list.begin(), list.end(), CaseInsensitiveSorting());
for (auto it = list.begin(); it != list.end(); ++it)
Tags->AddOption(*it);
Tags->AddItem(*it);
}
Tags->Window::Clear();
Tags->Refresh();
@@ -380,19 +380,19 @@ void TagEditor::EnterPressed()
Config.pattern = Patterns.front();
FParser->Clear();
FParser->Reset();
FParser->AddOption("Pattern: " + Config.pattern);
FParser->AddOption("Preview");
FParser->AddOption("Legend");
FParser->AddItem("Pattern: " + Config.pattern);
FParser->AddItem("Preview");
FParser->AddItem("Legend");
FParser->AddSeparator();
FParser->AddOption("Proceed");
FParser->AddOption("Cancel");
FParser->AddItem("Proceed");
FParser->AddItem("Cancel");
if (!Patterns.empty())
{
FParser->AddSeparator();
FParser->AddOption("Recent patterns", 1, 1);
FParser->AddItem("Recent patterns", 1, 1);
FParser->AddSeparator();
for (std::list<std::string>::const_iterator it = Patterns.begin(); it != Patterns.end(); ++it)
FParser->AddOption(*it);
FParser->AddItem(*it);
}
FParser->SetTitle(choice == 0 ? "Get tags from filename" : "Rename files");