menu: generalize filtering, introduce interfaces

src/Makefile.am

@@ -26,6 +26,7 @@ ncmpcpp_SOURCES = \
 	outputs.cpp \
 	playlist.cpp \
 	playlist_editor.cpp \
+	regexes.cpp \
 	screen.cpp \
 	scrollpad.cpp \
 	search_engine.cpp \
@@ -60,6 +61,7 @@ noinst_HEADERS = \
 	global.h \
 	help.h \
 	helpers.h \
+	interfaces.h \
 	lastfm.h \
 	lastfm_service.h \
 	lyrics.h \
@@ -71,6 +73,8 @@ noinst_HEADERS = \
 	mutable_song.h \
 	outputs.h \
 	playlist_editor.h \
+	regex_filter.h \
+	regexes.h \
 	screen.h \
 	scrollpad.h \
 	search_engine.h \

src/actions.cpp

@@ -1991,7 +1991,7 @@ void ReversePlaylist::Run()
 
 bool ApplyFilter::canBeRun() const
 {
-	return myScreen->GetList();
+	return dynamic_cast<Filterable *>(myScreen);
 }
 
 void ApplyFilter::Run()
@@ -1999,20 +1999,21 @@ void ApplyFilter::Run()
 	using Global::RedrawHeader;
 	using Global::wFooter;
 	
-	List *mList = myScreen->GetList();
+	Filterable *f = dynamic_cast<Filterable *>(myScreen);
-	assert(mList);
+	assert(f);
 	
 	LockStatusbar();
 	Statusbar() << fmtBold << "Apply filter: " << fmtBoldEnd;
-	wFooter->SetGetStringHelper(StatusbarApplyFilterImmediately);
+	wFooter->SetGetStringHelper(std::bind(StatusbarApplyFilterImmediately, f, _1));
-	wFooter->GetString(mList->GetFilter());
+	wFooter->GetString(f->currentFilter());
 	wFooter->SetGetStringHelper(StatusbarGetStringHelper);
 	UnlockStatusbar();
 	
-	if (mList->isFiltered())
+	std::string filter = f->currentFilter();
-		ShowMessage("Using filter \"%s\"", mList->GetFilter().c_str());
+ 	if (filter.empty())
-	else
 		ShowMessage("Filtering disabled");
+ 	else
+		ShowMessage("Using filter \"%s\"", filter.c_str());
 	
 	if (myScreen == myPlaylist)
 	{

src/browser.cpp

@@ -319,9 +319,21 @@ void Browser::GetSelectedSongs(MPD::SongList &v)
 	}
 }
 
-void Browser::ApplyFilter(const std::string &s)
+std::string Browser::currentFilter()
 {
-	w->ApplyFilter(s, itsBrowsedDir == "/" ? 0 : 1, REG_ICASE | Config.regex_type);
+	return RegexFilter<MPD::Item>::currentFilter(*w);
+}
+
+void Browser::applyFilter(const std::string &filter)
+{
+	w->ShowAll();
+	auto fun = [](const Regex &rx, Menu<MPD::Item> &menu, const Menu<MPD::Item>::Item &item) {
+		if (item.value().type == MPD::itDirectory && item.value().name == "..")
+			return true;
+		return rx.match(menu.Stringify(item));
+	};
+	auto rx = RegexFilter<MPD::Item>(filter, Config.regex_type, fun);
+	w->Filter(w->Begin(), w->End(), rx);
 }
 
 bool Browser::hasSupportedExtension(const std::string &file)
@@ -485,7 +497,6 @@ void Browser::GetLocalDirectory(MPD::ItemList &v, const std::string &directory,
 			MPD::MutableSong *s = new MPD::MutableSong(mpd_song_begin(&file_pair));
 			new_item.song = std::shared_ptr<MPD::Song>(s);
 #			ifdef HAVE_TAGLIB_H
-			// FIXME
 			if (!recursively)
 				TagEditor::ReadTags(*s);
 #			endif // HAVE_TAGLIB_H

src/browser.h

@@ -21,10 +21,12 @@
 #ifndef _BROWSER_H
 #define _BROWSER_H
 
+#include "interfaces.h"
 #include "ncmpcpp.h"
+#include "regex_filter.h"
 #include "screen.h"
 
-class Browser : public Screen< Menu<MPD::Item> >
+class Browser : public Screen< Menu<MPD::Item> >, public Filterable
 {
 	public:
 		Browser() : itsBrowseLocally(0), itsScrollBeginning(0), itsBrowsedDir("/") { }
@@ -46,7 +48,8 @@ class Browser : public Screen< Menu<MPD::Item> >
 		virtual void ReverseSelection();
 		virtual void GetSelectedSongs(MPD::SongList &);
 		
-		virtual void ApplyFilter(const std::string &);
+		virtual std::string currentFilter();
+		virtual void applyFilter(const std::string &filter);
 		
 		virtual List *GetList() { return w; }
 		

src/interfaces.h

@@ -0,0 +1,33 @@
+/***************************************************************************
+ *   Copyright (C) 2008-2012 by Andrzej Rybczak                            *
+ *   electricityispower@gmail.com                                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
+ ***************************************************************************/
+
+#ifndef _INTERFACES_H
+#define _INTERFACES_H
+
+#include <string>
+#include "gcc.h"
+
+struct Filterable
+{
+	virtual std::string currentFilter() = 0;
+	virtual void applyFilter(const std::string &filter) = 0;
+};
+
+#endif // _INTERFACES_H

src/media_library.cpp

@@ -527,9 +527,43 @@ void MediaLibrary::GetSelectedSongs(MPD::SongList &v)
 	}
 }
 
-void MediaLibrary::ApplyFilter(const std::string &s)
+std::string MediaLibrary::currentFilter()
 {
-	GetList()->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
+	std::string filter;
+	if (w == Artists)
+		filter = RegexFilter<std::string>::currentFilter(*Artists);
+	else if (w == Albums)
+		filter = RegexFilter<SearchConstraints>::currentFilter(*Albums);
+	else if (w == Songs)
+		filter = RegexFilter<MPD::Song>::currentFilter(*Songs);
+	return filter;
+}
+
+void MediaLibrary::applyFilter(const std::string &filter)
+{
+	if (w == Artists)
+	{
+		Artists->ShowAll();
+		auto rx = RegexFilter<std::string>(filter, Config.regex_type);
+		Artists->Filter(Artists->Begin(), Artists->End(), rx);
+	}
+	else if (w == Albums)
+	{
+		Albums->ShowAll();
+		auto fun = [](const Regex &rx, Menu<SearchConstraints> &menu, const Menu<SearchConstraints>::Item &item) {
+			if (item.isSeparator() || item.value().Date == AllTracksMarker)
+				return true;
+			return rx.match(menu.Stringify(item));
+		};
+		auto rx = RegexFilter<SearchConstraints>(filter, Config.regex_type, fun);
+		Albums->Filter(Albums->Begin(), Albums->End(), rx);
+	}
+	else if (w == Songs)
+	{
+		Songs->ShowAll();
+		auto rx = RegexFilter<MPD::Song>(filter, Config.regex_type);
+		Songs->Filter(Songs->Begin(), Songs->End(), rx);
+	}
 }
 
 bool MediaLibrary::isNextColumnAvailable()
@@ -647,7 +681,7 @@ void MediaLibrary::LocateSong(const MPD::Song &s)
 	
 	if (!hasTwoColumns)
 	{
-		Artists->ApplyFilter("");
+		Artists->ShowAll();
 		if (Artists->Empty())
 			Update();
 		if (primary_tag != Artists->Current().value())
@@ -665,7 +699,7 @@ void MediaLibrary::LocateSong(const MPD::Song &s)
 		}
 	}
 	
-	Albums->ApplyFilter("");
+	Albums->ShowAll();
 	if (Albums->Empty())
 		Update();
 	
@@ -688,7 +722,7 @@ void MediaLibrary::LocateSong(const MPD::Song &s)
 		}
 	}
 	
-	Songs->ApplyFilter("");
+	Songs->ShowAll();
 	if (Songs->Empty())
 		Update();
 	

src/media_library.h

@@ -21,10 +21,12 @@
 #ifndef _H_MEDIA_LIBRARY
 #define _H_MEDIA_LIBRARY
 
+#include "interfaces.h"
 #include "ncmpcpp.h"
+#include "regex_filter.h"
 #include "screen.h"
 
-class MediaLibrary : public Screen<Window>
+class MediaLibrary : public Screen<Window>, public Filterable
 {
 	struct SearchConstraints
 	{
@@ -63,7 +65,8 @@ class MediaLibrary : public Screen<Window>
 		virtual void ReverseSelection();
 		virtual void GetSelectedSongs(MPD::SongList &);
 		
-		virtual void ApplyFilter(const std::string &);
+		virtual std::string currentFilter();
+		virtual void applyFilter(const std::string &filter);
 		
 		virtual List *GetList();
 		

src/menu.cpp

@@ -27,12 +27,22 @@ template <> std::string Menu<std::string>::GetItem(size_t pos)
 	std::string result;
 	if (m_options_ptr->at(pos))
 	{
-		if (m_get_string_helper)
+		if (m_item_stringifier)
-			result = m_get_string_helper((*m_options_ptr)[pos]->value());
+			result = m_item_stringifier((*m_options_ptr)[pos]->value());
 		else
 			result = (*m_options_ptr)[pos]->value();
 	}
 	return result;
 }
 
+template <> std::string Menu<std::string>::Stringify(const Menu<std::string>::Item &item) const
+{
+	std::string result;
+	if (m_item_stringifier)
+		result = m_item_stringifier(item.value());
+	else
+		result = item.value();
+	return result;
+}
+
 }

src/menu.h

@@ -22,14 +22,14 @@
 #define _MENU_H
 
 #include <cassert>
-#include <regex.h>
 #include <functional>
 #include <iterator>
 #include <set>
 
 #include "error.h"
-#include "window.h"
+#include "regexes.h"
 #include "strbuffer.h"
+#include "window.h"
 
 namespace NCurses {
 
@@ -65,14 +65,6 @@ struct List
 	///
 	virtual void PrevFound(bool wrap) = 0;
 	
-	/// @see Menu::ApplyFilter()
-	///
-	virtual void ApplyFilter(const std::string &filter, size_t beginning = 0, int flags = 0) = 0;
-	
-	/// @see Menu::GetFilter()
-	///
-	virtual const std::string &GetFilter() = 0;
-	
 	/// @see Menu::isFiltered()
 	///
 	virtual bool isFiltered() = 0;
@@ -83,21 +75,6 @@ struct 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.
-	/// @see setItemDisplayer()
-	///
-	typedef std::function<void(Menu<T> &)> ItemDisplayer;
-	
-	/// Function helper prototype used for converting items to strings.
-	/// If not set by SetItemStringifier(), searching and filtering
-	/// won't work (note that Menu<std::string> doesn't need this)
-	/// @see SetItemStringifier()
-	///
-	typedef std::function<std::string(const T &)> ItemStringifier;
-	
-	/// Struct that holds each item in the list and its attributes
-	///
 	struct Item
 	{
 		friend class Menu<T>;
@@ -221,6 +198,21 @@ template <typename T> struct Menu : public Window, public List
 	typedef std::reverse_iterator<ValueIterator> ReverseValueIterator;
 	typedef std::reverse_iterator<ConstValueIterator> ConstReverseValueIterator;
 	
+	/// Function helper prototype used to display each option on the screen.
+	/// If not set by setItemDisplayer(), menu won't display anything.
+	/// @see setItemDisplayer()
+	///
+	typedef std::function<void(Menu<T> &)> ItemDisplayer;
+	
+	/// Function helper prototype used for converting items to strings.
+	/// If not set by SetItemStringifier(), searching and filtering
+	/// won't work (note that Menu<std::string> doesn't need this)
+	/// @see SetItemStringifier()
+	///
+	typedef std::function<std::string(const T &)> ItemStringifier;
+	
+	typedef std::function<bool(Menu<T> &, const Item &)> FilterFunction;
+	
 	/// Constructs an empty menu with given parameters
 	/// @param startx X position of left upper corner of constructed menu
 	/// @param starty Y position of left upper corner of constructed menu
@@ -240,12 +232,12 @@ template <typename T> struct Menu : public Window, public List
 	/// Sets helper function that is responsible for displaying items
 	/// @param ptr function pointer that matches the ItemDisplayer prototype
 	///
-	void setItemDisplayer(ItemDisplayer ptr) { m_item_displayer = ptr; }
+	void setItemDisplayer(const ItemDisplayer &f) { m_item_displayer = f; }
 	
 	/// Sets helper function that is responsible for converting items to strings
 	/// @param f function pointer that matches the ItemStringifier prototype
 	///
-	void SetItemStringifier(ItemStringifier f) { m_get_string_helper = f; }
+	void SetItemStringifier(const ItemStringifier &f) { m_item_stringifier = f; }
 	
 	/// Reserves the size for internal container (this just calls std::vector::reserve())
 	/// @param size requested size
@@ -322,6 +314,8 @@ template <typename T> struct Menu : public Window, public List
 	///
 	size_t Choice() const;
 	
+	template <typename Iterator> void Filter(Iterator first, Iterator last, const FilterFunction &f);
+	
 	/// Searches the list for a given contraint. It uses ItemStringifier to convert stored items
 	/// into strings and then performs pattern matching. Note that this supports regular expressions.
 	/// @param constraint a search constraint to be used
@@ -347,22 +341,15 @@ template <typename T> struct Menu : public Window, public List
 	///
 	virtual void PrevFound(bool wrap);
 	
-	/// Filters the list, showing only the items that matches the pattern. It uses
-	/// ItemStringifier to convert stored items into strings and then performs
-	/// pattern matching. Note that this supports regular expressions.
-	/// @param filter a pattern to be used in pattern matching
-	/// @param beginning beginning of range that has to be filtered
-	/// @param flags regex flags (REG_EXTENDED, REG_ICASE, REG_NOSUB, REG_NEWLINE)
-	///
-	virtual void ApplyFilter(const std::string &filter, size_t beginning = 0, int flags = 0);
-	
 	/// @return const reference to currently used filter
 	///
-	virtual const std::string &GetFilter();
+	//virtual const std::string &GetFilter();
+	
+	const FilterFunction &getFilter() { return m_filter; }
 	
 	/// @return true if list is currently filtered, false otherwise
 	///
-	virtual bool isFiltered() { return m_options_ptr == &m_filtered_options; }
+	bool isFiltered() { return m_options_ptr == &m_filtered_options; }
 	
 	/// Turns off filtering
 	///
@@ -380,6 +367,8 @@ template <typename T> struct Menu : public Window, public List
 	///
 	std::string GetItem(size_t pos);
 	
+	std::string Stringify(const Item &item) const;
+	
 	/// Refreshes the menu window
 	/// @see Window::Refresh()
 	///
@@ -534,7 +523,7 @@ template <typename T> struct Menu : public Window, public List
 private:
 	/// Clears filter, filtered data etc.
 	///
-	void ClearFiltered();
+	void clearFiltered();
 	
 	bool isHighlightable(size_t pos)
 	{
@@ -542,9 +531,9 @@ private:
 	}
 	
 	ItemDisplayer m_item_displayer;
-	ItemStringifier m_get_string_helper;
+	ItemStringifier m_item_stringifier;
 	
-	std::string m_filter;
+	FilterFunction m_filter;
 	std::string m_search_constraint;
 	
 	std::vector<Item *> *m_options_ptr;
@@ -568,10 +557,10 @@ private:
 	Buffer m_selected_suffix;
 };
 
-/// Specialization of Menu<T>::GetItem for T = std::string, it's obvious
+/// Specialization for T = std::string. It's obvious that if strings are stored,
-/// that if strings are stored, we don't need extra function to convert
+/// we don't need extra function to convert them to strings by default
-/// them to strings by default
 template <> std::string Menu<std::string>::GetItem(size_t pos);
+template <> std::string Menu<std::string>::Stringify(const Menu<std::string>::Item &item) const;
 
 template <typename T> Menu<T>::Menu(size_t startx,
 	size_t starty,
@@ -582,7 +571,7 @@ template <typename T> Menu<T>::Menu(size_t startx,
 	Border border)
 	: Window(startx, starty, width, height, title, color, border),
 	m_item_displayer(0),
-	m_get_string_helper(0),
+	m_item_stringifier(0),
 	m_options_ptr(&m_options),
 	m_beginning(0),
 	m_highlight(0),
@@ -667,6 +656,7 @@ template <typename T> void Menu<T>::Refresh()
 	if (m_options_ptr->empty())
 	{
 		Window::Clear();
+		Window::Refresh();
 		return;
 	}
 	
@@ -681,7 +671,7 @@ template <typename T> void Menu<T>::Refresh()
 	if (!isHighlightable(m_highlight))
 	{
 		Scroll(wUp);
-		if (isHighlightable(m_highlight))
+		if (!isHighlightable(m_highlight))
 			Scroll(wDown);
 	}
 	
@@ -822,7 +812,7 @@ template <typename T> void Menu<T>::Reset()
 	m_beginning = 0;
 }
 
-template <typename T> void Menu<T>::ClearFiltered()
+template <typename T> void Menu<T>::clearFiltered()
 {
 	m_filtered_options.clear();
 	m_filtered_positions.clear();
@@ -833,10 +823,9 @@ template <typename T> void Menu<T>::Clear()
 {
 	for (auto it = m_options.begin(); it != m_options.end(); ++it)
 		delete *it;
+	clearFiltered();
 	m_options.clear();
 	m_found_positions.clear();
-	m_filter.clear();
-	ClearFiltered();
 	m_options_ptr = &m_options;
 }
 
@@ -875,6 +864,24 @@ template <typename T> size_t Menu<T>::Choice() const
 	return m_highlight;
 }
 
+template <typename T> template <typename Iterator_>
+void Menu<T>::Filter(Iterator_ first, Iterator_ last, const FilterFunction &f)
+{
+	assert(m_options_ptr != &m_filtered_options);
+	clearFiltered();
+	m_filter = f;
+	for (auto it = first; it != last; ++it)
+	{
+		if (m_filter(*this, *it))
+		{
+			size_t pos = it-Begin();
+			m_filtered_positions.push_back(pos);
+			m_filtered_options.push_back(*it.base());
+		}
+	}
+	m_options_ptr = &m_filtered_options;
+}
+
 template <typename T> void Menu<T>::ReverseSelection(size_t beginning)
 {
 	auto it = m_options_ptr->begin()+beginning;
@@ -889,16 +896,15 @@ template <typename T> bool Menu<T>::Search(const std::string &constraint, size_t
 	if (constraint.empty())
 		return false;
 	m_search_constraint = constraint;
-	regex_t rx;
+	Regex rx;
-	if (regcomp(&rx, m_search_constraint.c_str(), flags) == 0)
+	if (rx.compile(m_search_constraint, flags))
 	{
 		for (size_t i = beginning; i < m_options_ptr->size(); ++i)
 		{
-			if (regexec(&rx, GetItem(i).c_str(), 0, 0, 0) == 0)
+			if (rx.match(GetItem(i)))
 				m_found_positions.insert(i);
 		}
 	}
-	regfree(&rx);
 	return !m_found_positions.empty();
 }
 
@@ -924,44 +930,19 @@ template <typename T> void Menu<T>::PrevFound(bool wrap)
 		Highlight(*m_found_positions.rbegin());
 }
 
-template <typename T> void Menu<T>::ApplyFilter(const std::string &filter, size_t beginning, int flags)
-{
-	m_found_positions.clear();
-	ClearFiltered();
-	m_filter = filter;
-	if (m_filter.empty())
-		return;
-	for (size_t i = 0; i < beginning; ++i)
-	{
-		m_filtered_positions.push_back(i);
-		m_filtered_options.push_back(m_options[i]);
-	}
-	regex_t rx;
-	if (regcomp(&rx, m_filter.c_str(), flags) == 0)
-	{
-		for (size_t i = beginning; i < m_options.size(); ++i)
-		{
-			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]);
-			}
-		}
-	}
-	regfree(&rx);
-	m_options_ptr = &m_filtered_options;
-}
-
-template <typename T> const std::string &Menu<T>::GetFilter()
-{
-	return m_filter;
-}
-
 template <typename T> std::string Menu<T>::GetItem(size_t pos)
 {
 	std::string result;
-	if (m_get_string_helper)
+	if (m_item_stringifier)
-		result = m_get_string_helper((*m_options_ptr)[pos]->value());
+		result = m_item_stringifier((*m_options_ptr)[pos]->value());
+	return result;
+}
+
+template <typename T> std::string Menu<T>::Stringify(const Item &item) const
+{
+	std::string result;
+	if (m_item_stringifier)
+		result = m_item_stringifier(item.value());
 	return result;
 }
 

src/playlist.cpp

@@ -19,6 +19,7 @@
  ***************************************************************************/
 
 #include <algorithm>
+#include <sstream>
 
 #include "display.h"
 #include "global.h"
@@ -283,10 +284,22 @@ void Playlist::GetSelectedSongs(MPD::SongList &v)
 		v.push_back(Items->at(*it).value());
 }
 
-void Playlist::ApplyFilter(const std::string &s)
+std::string Playlist::currentFilter()
+{
+	std::string filter;
+	if (w == Items)
+		filter = RegexFilter<MPD::Song>::currentFilter(*Items);
+	return filter;
+}
+
+void Playlist::applyFilter(const std::string &filter)
 {
 	if (w == Items)
-		Items->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
+	{
+		Items->ShowAll();
+		auto rx = RegexFilter<MPD::Song>(filter, Config.regex_type);
+		Items->Filter(Items->Begin(), Items->End(), rx);
+	}
 }
 
 bool Playlist::isFiltered()

src/playlist.h

@@ -21,13 +21,12 @@
 #ifndef _PLAYLIST_H
 #define _PLAYLIST_H
 
-#include <sstream>
+#include "interfaces.h"
-
 #include "ncmpcpp.h"
 #include "screen.h"
 #include "song.h"
 
-class Playlist : public Screen<Window>
+class Playlist : public Screen<Window>, public Filterable
 {
 	public:
 		enum Movement { mUp, mDown };
@@ -52,7 +51,8 @@ class Playlist : public Screen<Window>
 		virtual void ReverseSelection() { Items->ReverseSelection(); }
 		virtual void GetSelectedSongs(MPD::SongList &);
 		
-		virtual void ApplyFilter(const std::string &);
+		virtual std::string currentFilter();
+		virtual void applyFilter(const std::string &filter);
 		
 		virtual List *GetList() { return w == Items ? Items : 0; }
 		

src/playlist_editor.cpp

@@ -416,9 +416,30 @@ void PlaylistEditor::GetSelectedSongs(MPD::SongList &v)
 		v.push_back(Content->at(*it).value());
 }
 
-void PlaylistEditor::ApplyFilter(const std::string &s)
+std::string PlaylistEditor::currentFilter()
 {
-	GetList()->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
+	std::string filter;
+	if (w == Playlists)
+		filter = RegexFilter<std::string>::currentFilter(*Playlists);
+	else if (w == Content)
+		filter = RegexFilter<MPD::Song>::currentFilter(*Content);
+	return filter;
+}
+
+void PlaylistEditor::applyFilter(const std::string &filter)
+{
+	if (w == Playlists)
+	{
+		Playlists->ShowAll();
+		auto rx = RegexFilter<std::string>(filter, Config.regex_type);
+		Playlists->Filter(Playlists->Begin(), Playlists->End(), rx);
+	}
+	else if (w == Content)
+	{
+		Content->ShowAll();
+		auto rx = RegexFilter<MPD::Song>(filter, Config.regex_type);
+		Content->Filter(Content->Begin(), Content->End(), rx);
+	}
 }
 
 void PlaylistEditor::Locate(const std::string &name)

src/playlist_editor.h

@@ -24,7 +24,7 @@
 #include "playlist.h"
 #include "ncmpcpp.h"
 
-class PlaylistEditor : public Screen<Window>
+class PlaylistEditor : public Screen<Window>, public Filterable
 {
 	public:
 		virtual void SwitchTo();
@@ -47,7 +47,8 @@ class PlaylistEditor : public Screen<Window>
 		virtual void ReverseSelection() { Content->ReverseSelection(); }
 		virtual void GetSelectedSongs(MPD::SongList &);
 		
-		virtual void ApplyFilter(const std::string &);
+		virtual std::string currentFilter();
+		virtual void applyFilter(const std::string &filter);
 
 		virtual void Locate(const std::string &);
 		

src/regex_filter.h

@@ -0,0 +1,61 @@
+/***************************************************************************
+ *   Copyright (C) 2008-2012 by Andrzej Rybczak                            *
+ *   electricityispower@gmail.com                                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
+ ***************************************************************************/
+
+#ifndef _REGEX_FILTER
+#define _REGEX_FILTER
+
+#include "menu.h"
+
+template <typename T> struct RegexFilter
+{
+	typedef NCurses::Menu<T> MenuT;
+	typedef typename NCurses::Menu<T>::Item MenuItem;
+	typedef std::function<bool(const Regex &, MenuT &menu, const MenuItem &)> FilterFunction;
+	
+	RegexFilter(const std::string &regex_, int cflags, FilterFunction custom_filter = 0)
+	: m_rx(regex_, cflags), m_custom_filter(custom_filter) { }
+	
+	bool operator()(MenuT &menu, const MenuItem &item) {
+		if (m_rx.regex().empty())
+			return true;
+		if (!m_rx.error().empty())
+			return false;
+		if (m_custom_filter)
+			return m_custom_filter(m_rx, menu, item);
+		return m_rx.match(menu.Stringify(item));
+	}
+	
+	static std::string currentFilter(NCurses::Menu<T> &menu)
+	{
+		std::string filter;
+		auto rf = menu.getFilter().template target< RegexFilter<T> >();
+		if (rf)
+			filter = rf->m_rx.regex();
+		return filter;
+	}
+	
+private:
+	Regex m_rx;
+	FilterFunction m_custom_filter;
+};
+
+
+
+#endif

src/regexes.cpp

@@ -0,0 +1,87 @@
+/***************************************************************************
+ *   Copyright (C) 2008-2012 by Andrzej Rybczak                            *
+ *   electricityispower@gmail.com                                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
+ ***************************************************************************/
+
+#include <cassert>
+#include "regexes.h"
+
+Regex::Regex() : m_cflags(0), m_compiled(false) { }
+
+Regex::Regex(const std::string &regex_, int cflags)
+: m_regex(regex_), m_cflags(cflags), m_compiled(false)
+{
+	compile();
+}
+
+Regex::Regex (const Regex &rhs)
+: m_regex(rhs.m_regex), m_cflags(rhs.m_cflags), m_compiled(false)
+{
+	if (rhs.m_compiled)
+		compile();
+}
+
+Regex::~Regex()
+{
+	if (m_compiled)
+		regfree(&m_rx);
+}
+
+bool Regex::compile()
+{
+	if (m_compiled)
+	{
+		m_error.clear();
+		regfree(&m_rx);
+	}
+	int comp_res = regcomp(&m_rx, m_regex.c_str(), m_cflags);
+	bool result = true;
+	if (comp_res != 0)
+	{
+		char buf[256];
+		regerror(comp_res, &m_rx, buf, sizeof(buf));
+		m_error = buf;
+		result = false;
+	}
+	m_compiled = result;
+	return result;
+}
+
+bool Regex::compile(const std::string &regex_, int cflags)
+{
+	m_regex = regex_;
+	m_cflags = cflags;
+	return compile();
+}
+
+bool Regex::match(const std::string &s) const
+{
+	assert(m_compiled);
+	return regexec(&m_rx, s.c_str(), 0, 0, 0) == 0;
+}
+
+Regex &Regex::operator=(const Regex &rhs)
+{
+	if (this == &rhs)
+		return *this;
+	m_regex = rhs.m_regex;
+	m_cflags = rhs.m_cflags;
+	if (rhs.m_compiled)
+		compile();
+	return *this;
+}

src/regexes.h

@@ -0,0 +1,62 @@
+/***************************************************************************
+ *   Copyright (C) 2008-2012 by Andrzej Rybczak                            *
+ *   electricityispower@gmail.com                                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
+ ***************************************************************************/
+
+#ifndef _REGEXES_H
+#define _REGEXES_H
+
+#include <regex.h>
+#include <string>
+
+struct Regex
+{
+	Regex();
+	Regex(const std::string &regex, int cflags);
+	Regex(const Regex &rhs);
+	virtual ~Regex();
+	
+	/// @return regular expression
+	const std::string &regex() const { return m_regex; }
+	
+	/// @return compilation error (if there was any)
+	const std::string &error() const { return m_error; }
+	
+	/// compiles regular expression
+	/// @result true if compilation was successful, false otherwise
+	bool compile();
+	
+	/// compiles regular expression
+	/// @result true if compilation was successful, false otherwise
+	bool compile(const std::string &regex, int cflags);
+	
+	/// tries to match compiled regex with given string
+	/// @return true if string was matched, false otherwise
+	bool match(const std::string &s) const;
+	
+	Regex &operator=(const Regex &rhs);
+	
+private:
+	std::string m_regex;
+	std::string m_error;
+	regex_t m_rx;
+	int m_cflags;
+	bool m_compiled;
+};
+
+#endif // _REGEXES_H

src/screen.h

@@ -116,9 +116,6 @@ class BasicScreen
 		///
 		virtual void GetSelectedSongs(GNUC_UNUSED MPD::SongList &v) { }
 		
-		/// Applies a filter to the screen
-		virtual void ApplyFilter(GNUC_UNUSED const std::string &filter) { }
-		
 		/// @return pointer to instantiation of Menu template class
 		/// cast to List if available or null pointer otherwise
 		///

src/search_engine.cpp

@@ -156,6 +156,7 @@ void SearchEngine::EnterPressed()
 	}
 	else if (option == SearchButton)
 	{
+		w->ShowAll();
 		ShowMessage("Searching...");
 		if (w->Size() > StaticOptions)
 			Prepare();
@@ -260,9 +261,21 @@ void SearchEngine::GetSelectedSongs(MPD::SongList &v)
 	}
 }
 
-void SearchEngine::ApplyFilter(const std::string &s)
+std::string SearchEngine::currentFilter()
 {
-	w->ApplyFilter(s, StaticOptions, REG_ICASE | Config.regex_type);
+	return RegexFilter<SEItem>::currentFilter(*w);
+}
+
+void SearchEngine::applyFilter(const std::string &filter)
+{
+	w->ShowAll();
+	auto fun = [](const Regex &rx, Menu<SEItem> &menu, const Menu<SEItem>::Item &item) {
+		if (item.isSeparator() || !item.value().isSong())
+			return true;
+		return rx.match(menu.Stringify(item));
+	};
+	auto rx = RegexFilter<SEItem>(filter, Config.regex_type, fun);
+	w->Filter(w->Begin(), w->End(), rx);
 }
 
 void SearchEngine::UpdateFoundList()
@@ -515,7 +528,7 @@ void SearchEngine::Search()
 std::string SearchEngine::SearchEngineOptionToString(const SEItem &ei)
 {
 	std::string result;
-	if (!ei.isSong())
+	if (ei.isSong())
 	{
 		if (Config.columns_in_search_engine)
 			result = Playlist::SongInColumnsToString(ei.song());

src/search_engine.h

@@ -23,6 +23,8 @@
 
 #include <cassert>
 
+#include "regex_filter.h"
+#include "interfaces.h"
 #include "mpdpp.h"
 #include "ncmpcpp.h"
 
@@ -72,7 +74,7 @@ struct SEItem
 		MPD::Song itsSong;
 };
 
-class SearchEngine : public Screen< Menu<SEItem> >
+class SearchEngine : public Screen< Menu<SEItem> >, public Filterable
 {
 	public:
 		virtual void Resize();
@@ -92,7 +94,8 @@ class SearchEngine : public Screen< Menu<SEItem> >
 		virtual void ReverseSelection() { w->ReverseSelection(StaticOptions); }
 		virtual void GetSelectedSongs(MPD::SongList &);
 		
-		virtual void ApplyFilter(const std::string &);
+		virtual std::string currentFilter();
+		virtual void applyFilter(const std::string &filter);
 		
 		virtual List *GetList() { return w->Size() >= StaticOptions ? w : 0; }
 		

src/settings.cpp

@@ -392,7 +392,7 @@ void Configuration::SetDefaults()
 	playlist_disable_highlight_delay = 5;
 	message_delay_time = 4;
 	lyrics_db = 0;
-	regex_type = 0;
+	regex_type = REG_ICASE;
 	lines_scrolled = 2;
 	search_engine_default_search_mode = 0;
 	visualizer_sync_interval = 30;
@@ -953,7 +953,8 @@ void Configuration::Read()
 			}
 			else if (name == "regular_expressions")
 			{
-				regex_type = REG_EXTENDED * (v != "basic");
+				if (v != "basic")
+					regex_type |= REG_EXTENDED;
 			}
 			else if (name == "lines_scrolled")
 			{

src/status.cpp

@@ -78,12 +78,13 @@ void StatusbarGetStringHelper(const std::wstring &)
 	TraceMpdStatus();
 }
 
-void StatusbarApplyFilterImmediately(const std::wstring &ws)
+void StatusbarApplyFilterImmediately(Filterable *f, const std::wstring &ws)
 {
 	static std::wstring cmp;
 	if (cmp != ws)
 	{
-		myScreen->ApplyFilter(ToString((cmp = ws)));
+		cmp = ws;
+		f->applyFilter(ToString(cmp));
 		myScreen->RefreshWindow();
 	}
 	TraceMpdStatus();
@@ -249,7 +250,7 @@ void NcmpcppStatusChanged(MPD::Connection *, MPD::StatusChanges changed, void *)
 		
 		if (is_filtered)
 		{
-			myPlaylist->ApplyFilter(myPlaylist->Items->GetFilter());
+			myPlaylist->applyFilter(myPlaylist->currentFilter());
 			if (myPlaylist->Items->Empty())
 				myPlaylist->Items->ShowAll();
 		}

src/status.h

@@ -21,6 +21,7 @@
 #ifndef _STATUS_CHECKER_H
 #define _STATUS_CHECKER_H
 
+#include "interfaces.h"
 #include "mpdpp.h"
 #include "ncmpcpp.h"
 
@@ -46,7 +47,7 @@ void ShowMessage(const char *, ...) GNUC_PRINTF(1, 2);
 
 void StatusbarMPDCallback();
 void StatusbarGetStringHelper(const std::wstring &);
-void StatusbarApplyFilterImmediately(const std::wstring &);
+void StatusbarApplyFilterImmediately(Filterable *f, const std::wstring &ws);
 
 #endif
 

src/tag_editor.cpp

@@ -23,6 +23,7 @@
 #ifdef HAVE_TAGLIB_H
 
 #include <fstream>
+#include <sstream>
 #include <stdexcept>
 
 // taglib includes
@@ -266,7 +267,7 @@ void TagEditor::Update()
 			{
 				size_t slash = itsBrowsedDir.rfind("/");
 				std::string parent = slash != std::string::npos ? itsBrowsedDir.substr(0, slash) : "/";
-				Dirs->AddItem(make_pair("[..]", parent));
+				Dirs->AddItem(make_pair("..", parent));
 			}
 			else
 			{
@@ -771,14 +772,43 @@ void TagEditor::GetSelectedSongs(MPD::SongList &v)
 		v.push_back(static_cast<MPD::Song>((*Tags)[*it].value()));
 }
 
-void TagEditor::ApplyFilter(const std::string &s)
+std::string TagEditor::currentFilter()
+{
+	std::string filter;
+	if (w == Dirs)
+		filter = RegexFilter<string_pair>::currentFilter(*Dirs);
+	else if (w == Albums)
+		filter = RegexFilter<string_pair>::currentFilter(*Albums);
+	else if (w == Tags)
+		filter = RegexFilter<MPD::MutableSong>::currentFilter(*Tags);
+	return filter;
+}
+
+void TagEditor::applyFilter(const std::string &filter)
 {
 	if (w == Dirs)
-		Dirs->ApplyFilter(s, 1, REG_ICASE | Config.regex_type);
+	{
+		Dirs->ShowAll();
+		auto fun = [](const Regex &rx, Menu<string_pair> &menu, const Menu<string_pair>::Item &item) {
+			if (item.value().first == "." || item.value().first == "..")
+				return true;
+			return rx.match(menu.Stringify(item));
+		};
+		auto rx = RegexFilter<string_pair>(filter, Config.regex_type, fun);
+		Dirs->Filter(Dirs->Begin(), Dirs->End(), rx);
+	}
 	else if (w == Albums)
-		Albums->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
+	{
+		Albums->ShowAll();
+		auto rx = RegexFilter<string_pair>(filter, Config.regex_type);
+		Albums->Filter(Albums->Begin(), Albums->End(), rx);
+	}
 	else if (w == Tags)
-		Tags->ApplyFilter(s, 0, REG_ICASE | Config.regex_type);
+	{
+		Tags->ShowAll();
+		auto rx = RegexFilter<MPD::MutableSong>(filter, Config.regex_type);
+		Tags->Filter(Tags->Begin(), Tags->End(), rx);
+	}
 }
 
 List *TagEditor::GetList()

src/tag_editor.h

@@ -34,9 +34,10 @@
 
 #include "mpdpp.h"
 #include "mutable_song.h"
+#include "regex_filter.h"
 #include "screen.h"
 
-class TagEditor : public Screen<Window>
+class TagEditor : public Screen<Window>, public Filterable
 {
 	public:
 		TagEditor() : FParser(0), FParserHelper(0), FParserLegend(0), FParserPreview(0), itsBrowsedDir("/") { }
@@ -61,7 +62,8 @@ class TagEditor : public Screen<Window>
 		virtual void ReverseSelection() { Tags->ReverseSelection(); }
 		virtual void GetSelectedSongs(MPD::SongList &);
 		
-		virtual void ApplyFilter(const std::string &);
+		virtual std::string currentFilter();
+		virtual void applyFilter(const std::string &filter);
 		
 		virtual List *GetList();
 		

src/window.h

@@ -32,6 +32,7 @@
 #include "curses.h"
 #include "gcc.h"
 
+#include <functional>
 #include <list>
 #include <stack>
 #include <vector>
@@ -148,7 +149,7 @@ namespace NCurses
 	/// to obtain string from Window::GetString() function
 	/// @see Window::GetString()
 	///
-	typedef void (*GetStringHelper)(const std::wstring &);
+	typedef std::function<void(const std::wstring &)> GetStringHelper;
 	
 	/// Initializes curses screen and sets some additional attributes
 	/// @param window_title title of the window (has an effect only if pdcurses lib is used)