Initial import from SVN

ui/audio/AudioDatabaseWidget.cpp

@@ -0,0 +1,108 @@
+#include <boost/foreach.hpp>
+
+#include <Wt/WModelIndex>
+#include <Wt/WBreak>	// TODO
+
+#include "AudioDatabaseWidget.hpp"
+
+#include "TableFilterWidget.hpp"
+#include "SearchFilterWidget.hpp"
+#include "TrackWidget.hpp"
+
+AudioDatabaseWidget::AudioDatabaseWidget( Wt::WContainerWidget *parent)
+: Wt::WContainerWidget(parent),
+ _db("test.db"),	// TODO
+_refreshingFilters(false)
+{
+	std::size_t idFilter (0);
+	{
+		SearchFilterWidget* search = new SearchFilterWidget(this);
+		_filters.push_back( search );
+		search->update().connect( boost::bind(&AudioDatabaseWidget::handleFilterUpdated, this, idFilter++) );
+	}
+
+	{
+		TableFilterWidget* filterTable = new TableFilterWidget(_db, "genre", "name", this);
+		_filters.push_back( filterTable );
+		filterTable->update().connect( boost::bind(&AudioDatabaseWidget::handleFilterUpdated, this, idFilter++) );
+	}
+	{
+		TableFilterWidget* filterTable = new TableFilterWidget(_db, "artist", "name", this);
+		_filters.push_back( filterTable );
+		filterTable->update().connect( boost::bind(&AudioDatabaseWidget::handleFilterUpdated, this, idFilter++) );
+	}
+	{
+		TableFilterWidget* filterTable = new TableFilterWidget(_db, "release", "name", this);
+		_filters.push_back( filterTable );
+		filterTable->update().connect( boost::bind(&AudioDatabaseWidget::handleFilterUpdated, this, idFilter++) );
+	}
+
+	{
+		TrackWidget* track = new TrackWidget(_db, this);
+		_filters.push_back( track );
+		track->trackSelected().connect(this, &AudioDatabaseWidget::handleTrackSelected);
+	}
+
+}
+
+void
+AudioDatabaseWidget::search(const std::string& text)
+{
+	SearchFilterWidget* searchWidget ( dynamic_cast<SearchFilterWidget*>(_filters.front() ) );
+
+	searchWidget->setText(text);
+}
+
+
+void
+AudioDatabaseWidget::handleTrackSelected(boost::filesystem::path p)
+{
+	_trackSelected.emit(p);
+}
+
+void
+AudioDatabaseWidget::handleFilterUpdated(std::size_t idFilterUpdated)
+{
+	// TODO disconnect from event!
+	if (_refreshingFilters)
+		return;
+
+	_refreshingFilters = true;
+
+	std::cout << "FILTER " << idFilterUpdated << " has been UPDATED!" << std::endl;
+
+	FilterWidget::Constraint currentConstraint;
+
+	currentConstraint.where.And( WhereClause( "track.artist_id = artist.id and track.release_id = release.id and track_genre.track_id = track.id and genre.id = track_genre.genre_id"));
+
+	for (std::size_t idFilter = 0; idFilter < _filters.size(); ++idFilter)
+	{
+		std::cout << "Processing Filter INDEX " << idFilter << std::endl;
+		FilterWidget* filter = _filters.at(idFilter);
+
+		// Apply contraints created by previous filters
+		if (idFilter > idFilterUpdated) {
+			filter->refresh(currentConstraint);
+		}
+
+		// Get constraints generated by this filter
+		// (Note: adding accross successive calls)
+		filter->getConstraint(currentConstraint);
+	}
+
+	_refreshingFilters = false;
+
+}
+
+void
+AudioDatabaseWidget::selectNextTrack(void)
+{
+	std::cout << "Wants to select next track!" << std::endl;
+
+	TrackWidget* trackWidget ( dynamic_cast<TrackWidget*>(_filters.back() ) );
+
+	trackWidget->selectNextTrack();
+}
+
+
+

ui/audio/AudioDatabaseWidget.hpp

@@ -0,0 +1,42 @@
+#ifndef AUDIO_DB_WIDGET_HPP
+#define AUDIO_DB_WIDGET_HPP
+
+#include <boost/filesystem/path.hpp>
+
+#include <Wt/WContainerWidget>
+#include <Wt/WSignal>
+
+#include "database/DatabaseHandler.hpp"
+
+#include "FilterWidget.hpp"
+
+class AudioDatabaseWidget : public Wt::WContainerWidget
+{
+	public:
+		AudioDatabaseWidget( Wt::WContainerWidget *parent = 0);
+
+		void search(const std::string& text);
+
+		void selectNextTrack(void);				// Will later emit the next selected track
+
+		// Signals
+		Wt::Signal< boost::filesystem::path >& trackSelected() { return _trackSelected; }
+
+	private:
+
+		DatabaseHandler	_db;
+
+		Wt::Signal< boost::filesystem::path > _trackSelected;
+
+		void handleTrackSelected(boost::filesystem::path p);
+		void handleFilterUpdated(std::size_t idFilter);
+
+		std::vector<FilterWidget*>	_filters;	// Free Search, Genre, Artist, Release, etc.
+
+		bool _refreshingFilters;
+
+};
+
+
+#endif
+

ui/audio/AudioMediaPlayerWidget.cpp

@@ -0,0 +1,157 @@
+
+#include <Wt/WMediaPlayer>
+#include <Wt/WProgressBar>
+
+#include "AudioMediaPlayerWidget.hpp"
+
+
+AudioMediaPlayerWidget::AudioMediaPlayerWidget( Wt::WContainerWidget *parent)
+	: Wt::WContainerWidget(parent),
+	_mediaResource(nullptr)
+{
+	_mediaPlayer = new Wt::WMediaPlayer( Wt::WMediaPlayer::Audio, this );
+//	_mediaPlayer->setAlternativeContent (new Wt::WText("You don't have HTML5 audio support!"));
+//	_mediaPlayer->setOptions( Wt::WMediaPlayer::Autoplay );
+	_mediaPlayer->addSource( Wt::WMediaPlayer::OGA, "" );
+
+	_mediaPlayer->ended().connect(this, &AudioMediaPlayerWidget::handleTrackEnded);
+
+	{
+		Wt::WContainerWidget *container = new Wt::WContainerWidget(this);
+
+		_prevBtn = new Wt::WPushButton("<<", container );
+		_playBtn = new Wt::WPushButton("Play", container );
+		_pauseBtn = new Wt::WPushButton("Pause", container );
+		_nextBtn = new Wt::WPushButton(">>", container );
+
+		_curTime = new Wt::WText(container);
+		_timeSlider = new Wt::WSlider( container );
+		_duration = new Wt::WText(container);
+
+		_volumeSlider = new Wt::WSlider( container );
+		_volumeSlider->setRange(0,100);
+		_volumeSlider->setValue(_mediaPlayer->volume() * 100);
+
+		_mediaPlayer->setControlsWidget( container );
+		_mediaPlayer->setButton(Wt::WMediaPlayer::Play, _playBtn);
+		_mediaPlayer->setButton(Wt::WMediaPlayer::Pause, _pauseBtn);
+
+		_mediaPlayer->setText( Wt::WMediaPlayer::CurrentTime, _curTime);
+		_mediaPlayer->setText( Wt::WMediaPlayer::Duration, _duration);
+
+		_mediaPlayer->timeUpdated().connect(this, &AudioMediaPlayerWidget::handleTimeUpdated);
+	}
+
+	_timeSlider->valueChanged().connect(this, &AudioMediaPlayerWidget::handlePlayOffset);
+	_timeSlider->sliderMoved().connect(this, &AudioMediaPlayerWidget::handleSliderMoved);
+	_timeSlider->setDisabled(true);
+
+	_volumeSlider->sliderMoved().connect(this, &AudioMediaPlayerWidget::handleVolumeSliderMoved);
+
+	_nextBtn->clicked().connect(this, &AudioMediaPlayerWidget::handlePlayNext);
+	_prevBtn->clicked().connect(this, &AudioMediaPlayerWidget::handlePlayPrev);
+
+}
+
+
+void
+AudioMediaPlayerWidget::loadPlayer(void)
+{
+	_mediaPlayer->clearSources();
+
+	_mediaInternalLink.setResource( nullptr );
+	if (_mediaResource)
+		delete _mediaResource;
+
+	assert( _currentParameters );
+	_mediaResource = new AvConvTranscodeStreamResource( *_currentParameters, this );
+	_mediaInternalLink.setResource( _mediaResource );
+
+	_mediaPlayer->addSource( Wt::WMediaPlayer::OGA, _mediaInternalLink );
+}
+
+void
+AudioMediaPlayerWidget::load(const Transcode::Parameters& parameters)
+{
+	_timeSlider->setDisabled(false);
+
+	_currentParameters = std::make_shared<Transcode::Parameters>( parameters );
+
+	loadPlayer();
+
+	_timeSlider->setRange(0, parameters.getInputMediaFile().getDuration().total_seconds() );
+	_timeSlider->setValue(0);
+
+	_duration->setText( boost::posix_time::to_simple_string( parameters.getInputMediaFile().getDuration() ));
+
+	_mediaPlayer->play();
+}
+
+void
+AudioMediaPlayerWidget::handlePlayOffset(int offsetSecs)
+{
+	if (!_currentParameters)
+		return;
+
+	std::cout << "Want to play at offset " << offsetSecs << std::endl;;
+
+	_currentParameters->setOffset( boost::posix_time::seconds(offsetSecs) );
+
+	loadPlayer();
+
+	_mediaPlayer->play();
+}
+
+
+void
+AudioMediaPlayerWidget::handlePlayNext(void)
+{
+	std::cout << "Want to play next!" << std::endl;
+}
+
+void
+AudioMediaPlayerWidget::handlePlayPrev(void)
+{
+	std::cout << "Want to play prev!" << std::endl;
+}
+
+
+void
+AudioMediaPlayerWidget::handleTrackEnded(void)
+{
+	std::cout << "Track playback ended!" << std::endl;
+	_playbackEnded.emit();
+}
+
+void
+AudioMediaPlayerWidget::handleValueChanged(double value)
+{
+	std::cout << "Value changed!" << std::endl;
+
+}
+
+void
+AudioMediaPlayerWidget::handleSliderMoved(int value)
+{
+	std::cout << "Slider moved to " << value << std::endl;
+}
+
+void
+AudioMediaPlayerWidget::handleTimeUpdated(void)
+{
+	std::cout << "Time updated to " << _mediaPlayer->currentTime() << std::endl;
+
+	if (!_currentParameters)
+		return;
+
+	boost::posix_time::time_duration currentTime ( boost::posix_time::seconds( _mediaPlayer->currentTime() + _currentParameters->getOffset().total_seconds()));
+
+	_timeSlider->setValue( currentTime.total_seconds() );
+	_curTime->setText( boost::posix_time::to_simple_string( currentTime) );
+}
+
+void
+AudioMediaPlayerWidget::handleVolumeSliderMoved(int value)
+{
+	_mediaPlayer->setVolume( value / 100. );
+}

ui/audio/AudioMediaPlayerWidget.hpp

@@ -0,0 +1,68 @@
+#ifndef __MEDIA_PLAYER_WIDGET_HPP
+#define __MEDIA_PLAYER_WIDGET_HPP
+
+#include <memory>
+
+#include <Wt/WSlider>
+#include <Wt/WPushButton>
+#include <Wt/WContainerWidget>
+#include <Wt/WMediaPlayer>
+#include <Wt/WLink>
+#include <Wt/WText>
+
+
+#include "transcode/Parameters.hpp"
+#include "resource/AvConvTranscodeStreamResource.hpp"
+
+class AudioMediaPlayerWidget : public Wt::WContainerWidget
+{
+	public:
+
+		AudioMediaPlayerWidget( Wt::WContainerWidget *parent = 0);
+
+		void load(const Transcode::Parameters& parameters);
+
+		// Signal slot Next
+		Wt::Signal<void>&	playbackEnded() {return _playbackEnded;}
+		// Signal Slot Previous
+		// Signal slot Ended
+
+	private:
+
+		void handlePlayOffset(int offsetSecs);
+		void handlePlayNext(void);
+		void handlePlayPrev(void);
+		void handleTrackEnded(void);
+
+		void handleValueChanged(double);
+		void handleTimeUpdated(void);
+		void handleSliderMoved(int value);
+
+		void handleVolumeSliderMoved(int value);
+
+		void loadPlayer(void);
+
+		// Signals
+		Wt::Signal<void>	_playbackEnded;
+
+		// Core
+		Wt::WMediaPlayer*		_mediaPlayer;
+		AvConvTranscodeStreamResource*	_mediaResource;
+		Wt::WLink			_mediaInternalLink;
+
+		// Controls
+		std::shared_ptr<Transcode::Parameters>	_currentParameters;
+		Wt::WPushButton* 	_playBtn;
+		Wt::WPushButton* 	_pauseBtn;
+		Wt::WPushButton* 	_nextBtn;
+		Wt::WPushButton*	_prevBtn;
+		Wt::WSlider*		_timeSlider;
+		Wt::WSlider*		_volumeSlider;
+		Wt::WText*		_curTime;
+		Wt::WText*		_duration;
+
+};
+
+
+#endif
+

ui/audio/AudioWidget.cpp

@@ -0,0 +1,83 @@
+#include <Wt/WBreak>
+
+#include "AudioWidget.hpp"
+
+#include "metadata/Extractor.hpp"
+
+
+AudioWidget::AudioWidget(Wt::WContainerWidget* parent)
+: Wt::WContainerWidget(parent),
+_audioDbWidget(nullptr),
+_mediaPlayer(nullptr),
+_imgResource(nullptr),
+_img(nullptr)
+{
+	_audioDbWidget = new AudioDatabaseWidget(this);
+
+	_audioDbWidget->trackSelected().connect(this, &AudioWidget::playTrack);
+
+	_mediaPlayer = new AudioMediaPlayerWidget(this);
+	_mediaPlayer->playbackEnded().connect(this, &AudioWidget::handleTrackEnded);
+	this->addWidget(new Wt::WBreak());
+
+	// Image
+	_imgResource = new Wt::WMemoryResource(this);
+	_imgLink.setResource( _imgResource);
+	_img = new Wt::WImage(_imgLink, this);
+
+}
+
+void
+AudioWidget::search(const std::string& searchText)
+{
+	_audioDbWidget->search(searchText);
+}
+
+
+void
+AudioWidget::playTrack(boost::filesystem::path p)
+{
+	std::cout << "play track '" << p << "'" << std::endl;
+	try {
+		// TODO get user's encoding preference
+
+		Transcode::InputMediaFile inputFile(p);
+
+		Transcode::Parameters parameters(inputFile, Transcode::Format::get(Transcode::Format::OGA), 128000);
+
+		_mediaPlayer->load( parameters );
+
+		// Refresh cover
+		{
+			MetaData::Extractor parser;
+			MetaData::GenericData cover;
+			if (parser.parseCover( p, cover)) {
+				std::cout << "Cover parsed!" << std::endl;
+				std::cout << "mime type = " << cover.mimeType << ", size = " << cover.data.size();
+
+				_imgResource->setMimeType(cover.mimeType);
+				_imgResource->setData(cover.data);
+
+			}
+			else {
+				std::cout << "No cover found!" << std::endl;
+				_imgResource->setData( std::vector<unsigned char>());
+			}
+
+			_imgResource->setChanged();
+		}
+	}
+	catch( std::exception &e)
+	{
+		std::cerr <<"Caught exception while loading '" << p << "': " << e.what() << std::endl;
+	}
+}
+
+	void
+AudioWidget::handleTrackEnded(void)
+{
+	std::cout << "Track playback ended!" << std::endl;
+	_audioDbWidget->selectNextTrack();
+}
+
+

ui/audio/AudioWidget.hpp

@@ -0,0 +1,43 @@
+#ifndef AUDIO_WIDGET_HPP
+#define AUDIO_WIDGET_HPP
+
+#include <string>
+
+#include <Wt/WLink>
+#include <Wt/WImage>
+#include <Wt/WContainerWidget>
+#include <Wt/WMemoryResource>
+
+#include "audio/AudioMediaPlayerWidget.hpp"
+#include "audio/AudioDatabaseWidget.hpp"
+
+class AudioWidget : public Wt::WContainerWidget
+{
+
+	public:
+
+		AudioWidget(Wt::WContainerWidget* parent = 0);
+
+		void search(const std::string& searchText);
+
+	private:
+
+		void playTrack(boost::filesystem::path p);
+
+		void handleTrackEnded(void);
+
+		AudioDatabaseWidget*	_audioDbWidget;
+
+		AudioMediaPlayerWidget*	_mediaPlayer;
+
+		// Image
+		Wt::WMemoryResource	*_imgResource;
+		Wt::WLink		_imgLink;
+		Wt::WImage		*_img;
+
+
+
+};
+
+#endif
+

ui/audio/FilterWidget.hpp

@@ -0,0 +1,46 @@
+#ifndef FILTER_WIDGET_HPP
+#define FILTER_WIDGET_HPP
+
+#include <boost/foreach.hpp>
+#include <string>
+#include <list>
+
+#include <Wt/WSignal>
+#include <Wt/WContainerWidget>
+
+#include "database/SqlQuery.hpp"
+
+class FilterWidget : public Wt::WContainerWidget {
+
+	public:
+
+		struct Constraint {
+			WhereClause	where;		// WHERE SQL clause
+		};
+
+		FilterWidget(Wt::WContainerWidget* parent = 0) : Wt::WContainerWidget(parent) {}
+		virtual ~FilterWidget() {}
+
+		// Refresh filter Widget using constraints created by parent filters
+		virtual void refresh(const Constraint& constraint) = 0;
+
+		// Update constraints for child filters
+		virtual void getConstraint(Constraint& constraint) = 0;
+
+		// Emitted when a constraint has changed
+		Wt::Signal<void>& update() { return _update; };
+
+	protected:
+
+		void emitUpdate()	{ _update.emit(); }
+
+	private:
+
+		Wt::Signal<void> _update;
+};
+
+
+
+
+
+#endif

ui/audio/SearchFilterWidget.cpp

@@ -0,0 +1,33 @@
+#include <Wt/WLabel>
+
+#include "SearchFilterWidget.hpp"
+
+
+SearchFilterWidget::SearchFilterWidget(Wt::WContainerWidget* parent)
+: FilterWidget( parent )
+{
+}
+
+void
+SearchFilterWidget::setText(const std::string& text)
+{
+	if (text != _lastEmittedText) {
+		_lastEmittedText = text;
+		emitUpdate();
+	}
+}
+
+// Get constraints created by this filter
+void
+SearchFilterWidget::getConstraint(Constraint& constraint)
+{
+	// No active search means no constaint!
+	if (!_lastEmittedText.empty()) {
+		const std::string bindText ("%%" + _lastEmittedText + "%%");
+		constraint.where.And( WhereClause("(track.name like ? or release.name like ? or artist.name like ?)").bind(bindText).bind(bindText).bind(bindText));
+	}
+
+	// else no constraint!
+}
+
+

ui/audio/SearchFilterWidget.hpp

@@ -0,0 +1,32 @@
+#ifndef SEARCH_FILTER_WIDGET_PP
+#define SEARCH_FILTER_WIDGET_PP
+
+#include <Wt/WLineEdit>
+
+#include "FilterWidget.hpp"
+
+class SearchFilterWidget : public FilterWidget {
+	public:
+		SearchFilterWidget(Wt::WContainerWidget* parent = 0);
+
+		void setText(const std::string& text);
+
+		// Set constraint on this filter
+		void refresh(const Constraint& constraint) {}
+
+		// Get constraints created by this filter
+		void getConstraint(Constraint& constraint);
+
+	private:
+
+		void handleKeyWentUp(void);
+
+		std::string	 _lastEmittedText;
+};
+
+
+
+
+
+#endif
+

ui/audio/TableFilterWidget.cpp

@@ -0,0 +1,90 @@
+#include <boost/foreach.hpp>
+
+#include "TableFilterWidget.hpp"
+
+TableFilterWidget::TableFilterWidget(DatabaseHandler& db, std::string table, std::string field, Wt::WContainerWidget* parent)
+: FilterWidget( parent ),
+_db(db),
+_table(table),
+_field(field),
+_tableView(nullptr)
+{
+	_queryModel.setQuery( _db.getSession().query< ResultType >("select " + _table + "." + _field + ",count(DISTINCT track.id),0 as ORDERBY from track,artist,release,genre,track_genre WHERE track.artist_id = artist.id and track.release_id = release.id and track_genre.track_id = track.id and genre.id = track_genre.genre_id GROUP BY " + _table + "." + _field + " UNION select '<All>',0,1 AS ORDERBY").orderBy("ORDERBY DESC," + _table + "." + _field));
+	_queryModel.addColumn( _table + "." + _field, table);
+	_queryModel.addColumn( "count(DISTINCT track.id)", "Tracks");
+
+	_tableView = new Wt::WTableView( this );
+	_tableView->resize(250, 200);	// TODO
+	_tableView->setSelectionMode(Wt::ExtendedSelection);
+	_tableView->setSortingEnabled(false);
+	_tableView->setAlternatingRowColors(true);
+	_tableView->setModel(&_queryModel);
+
+	_tableView->selectionChanged().connect(this, &TableFilterWidget::emitUpdate);
+	_tableView->selectionChanged().connect(this, &TableFilterWidget::emitUpdate);
+
+	_queryModel.setBatchSize(100);
+}
+
+// Set constraints on this filter
+void
+TableFilterWidget::refresh(const Constraint& constraint)
+{
+	SqlQuery sqlQuery;
+
+	sqlQuery.select().And( _table + "." + _field + ",count(DISTINCT track.id),0 as ORDERBY");
+	sqlQuery.from().And( FromClause("artist,release,track,genre,track_genre")) ;
+	sqlQuery.where().And(constraint.where);	// Add constraint made by other filters
+	sqlQuery.groupBy().And( _table + "." + _field);	// Add constraint made by other filters
+
+	SqlQuery AllSqlQuery;
+	AllSqlQuery.select().And( SelectStatement("'<All>',0,1 AS ORDERBY") );
+
+	std::cout << _table << ", generated query = '" << sqlQuery.get() + " UNION " + AllSqlQuery.get() << "'" << std::endl;
+
+	Wt::Dbo::Query<ResultType> query = _db.getSession().query<ResultType>( sqlQuery.get() + " UNION " + AllSqlQuery.get() );
+
+	query.orderBy("ORDERBY DESC," + _table + "." + _field);
+
+	BOOST_FOREACH(const std::string& bindArg, sqlQuery.where().getBindArgs()) {
+		std::cout << "Binding value '" << bindArg << "'" << std::endl;
+		query.bind(bindArg);
+	}
+
+	_queryModel.setQuery( query, true /* Keep columns */);
+
+	std::cout << "Finish !" << std::endl;
+}
+
+// Get constraint created by this filter
+void
+TableFilterWidget::getConstraint(Constraint& constraint)
+{
+	Wt::WModelIndexSet indexSet = _tableView->selectedIndexes();
+
+	// WHERE statement
+	WhereClause clause;
+
+	BOOST_FOREACH(Wt::WModelIndex index, indexSet) {
+
+		if (!index.isValid())
+			continue;
+
+		ResultType result = _queryModel.resultRow( index.row() );
+
+		// Get the track part
+		std::string	name( result.get<0>() );
+		bool		isAll( result.get<2>() ) ;
+
+		if (isAll) {
+			// no constraint, just return
+			return;
+		}
+
+		clause.Or(_table + "." + _field + " = ?").bind(name);
+	}
+
+	// Adding our WHERE clause
+	constraint.where.And( clause );
+}
+

ui/audio/TableFilterWidget.hpp

@@ -0,0 +1,38 @@
+#ifndef TABLE_VIEW_FILTER_WIDGET_HPP
+#define TABLE_VIEW_FILTER_WIDGET_HPP
+
+
+#include <Wt/Dbo/QueryModel>
+#include <Wt/WTableView>
+
+#include "FilterWidget.hpp"
+#include "database/DatabaseHandler.hpp"
+
+class TableFilterWidget : public FilterWidget
+{
+
+	public:
+		TableFilterWidget(DatabaseHandler& db, std::string table, std::string field, Wt::WContainerWidget* parent = 0);
+
+		// Set constraints on this filter
+		virtual void refresh(const Constraint& constraint);
+
+		// Get constraints created by this filter
+		virtual void getConstraint(Constraint& constraint);
+
+	protected:
+
+		DatabaseHandler&			_db;
+		const std::string			_table;
+		const std::string			_field;
+
+		typedef boost::tuple<std::string, int, int>  ResultType;
+		Wt::Dbo::QueryModel< ResultType >	_queryModel;
+
+		Wt::WTableView*				_tableView;
+};
+
+
+
+#endif
+

ui/audio/TrackWidget.cpp

@@ -0,0 +1,134 @@
+
+#include <boost/foreach.hpp>
+
+#include <Wt/WItemDelegate>
+#include <Wt/WBreak>
+
+#include "TrackWidget.hpp"
+
+TrackWidget::TrackWidget( DatabaseHandler& db, Wt::WContainerWidget* parent)
+: FilterWidget( parent ),
+_db(db),
+_tableView(nullptr),
+_trackStats(nullptr)
+{
+
+	// ----- TRACK -----
+	_queryModel.setQuery(_db.getSession().query<ResultType>("select track,release,artist from track,release,artist where track.release_id = release.id and track.artist_id = artist.id" ).orderBy("artist.name,release.name,track.disc_number,track.track_number"));
+	_queryModel.addColumn( "artist.name", "Artist" );
+	_queryModel.addColumn( "release.name", "Album" );
+	_queryModel.addColumn( "track.disc_number", "Disc #" );
+	_queryModel.addColumn( "track.track_number", "Track #" );
+	_queryModel.addColumn( "track.name", "Track" );
+	_queryModel.addColumn( "track.duration", "Duration" );
+	_queryModel.addColumn( "track.creation_time", "Date" );
+	_queryModel.addColumn( "track.genre_list", "Genres" );
+
+	_queryModel.setBatchSize(1000);
+
+	_tableView = new Wt::WTableView( this );
+	_tableView->resize(Wt::WLength::Auto, 400);
+
+	_tableView->setSortingEnabled(true);
+	_tableView->setSelectionMode(Wt::SingleSelection);
+	_tableView->setAlternatingRowColors(true);
+	_tableView->setModel(&_queryModel);
+
+	{
+		Wt::WItemDelegate *delegate = new Wt::WItemDelegate(this);
+		delegate->setTextFormat("yyyy");
+		_tableView->setItemDelegateForColumn(6, delegate);
+	}
+	{
+		// TODO better handle 1 hour+ files!
+		Wt::WItemDelegate *delegate = new Wt::WItemDelegate(this);
+		delegate->setTextFormat("mm:ss");
+		_tableView->setItemDelegateForColumn(5, delegate);
+	}
+
+	// TODO other event!
+	_tableView->selectionChanged().connect(this, &TrackWidget::handleTrackSelected);
+
+	new Wt::WBreak(this);
+	_trackStats = new Wt::WText(this);
+
+	updateStats();
+}
+
+void
+TrackWidget::updateStats(void)
+{
+	std::ostringstream oss; oss <<  "Files :" << _tableView->model()->rowCount();
+	// TODO from UTF-8 ?
+	_trackStats->setText(oss.str());
+}
+
+// Set constraints created by parent filters
+void
+TrackWidget::refresh(const Constraint& constraint)
+{
+
+	SqlQuery sqlQuery;
+
+	sqlQuery.select().And( SelectStatement( "track,release,artist" ) );
+	sqlQuery.from().And( FromClause("artist,release,track,genre,track_genre"));
+	sqlQuery.where().And(constraint.where);
+
+	std::cout << "TRACK REQ = '" << sqlQuery.get() << "'" << std::endl;
+
+	Wt::Dbo::Query<ResultType> query = _db.getSession().query<ResultType>( sqlQuery.get() );
+
+	query.groupBy("track").orderBy("artist.name,track.creation_time,release.name,track.disc_number,track.track_number");
+
+	BOOST_FOREACH(const std::string& bindArg, sqlQuery.where().getBindArgs()) {
+		std::cout << "Binding value '" << bindArg << "'" << std::endl;
+		query.bind(bindArg);
+	}
+
+	_queryModel.setQuery( query, true );
+
+	updateStats();
+}
+
+void
+TrackWidget::handleTrackSelected(void)
+{
+	Wt::WModelIndexSet indexSet = _tableView->selectedIndexes();
+	if (!indexSet.empty()) {
+		Wt::WModelIndex currentIndex( *indexSet.begin() );
+
+		// Check there are remainin tracks!
+		if (currentIndex.isValid())
+		{
+			ResultType result = _queryModel.resultRow( currentIndex.row());
+
+			// Get the track part
+			Wt::Dbo::ptr<Track> track ( result.get<0>() );
+
+			_trackSelected.emit( track->getPath() );
+		}
+
+	}
+}
+
+void
+TrackWidget::selectNextTrack(void)
+{
+	Wt::WModelIndexSet indexSet = _tableView->selectedIndexes();
+	if (!indexSet.empty()) {
+		Wt::WModelIndex currentIndex( *indexSet.begin() );
+		// Check there are remainin tracks!
+		if (currentIndex.isValid() && _tableView->model()->rowCount() > currentIndex.row() + 1)
+		{
+			_tableView->select( _tableView->model()->index( currentIndex.row() + 1, currentIndex.column()));
+
+			ResultType result = _queryModel.resultRow( currentIndex.row() + 1 );
+
+			// Get the track part
+			Wt::Dbo::ptr<Track> track ( result.get<0>() );
+
+			_trackSelected.emit( track->getPath() );
+		}
+	}
+}
+

ui/audio/TrackWidget.hpp

@@ -0,0 +1,49 @@
+#ifndef TRACK_WIDGET_HPP
+#define TRACK_WIDGET_HPP
+
+#include <Wt/WTableView>
+#include <Wt/Dbo/QueryModel>
+
+#include "database/DatabaseHandler.hpp"
+#include "database/AudioTypes.hpp"
+
+#include "FilterWidget.hpp"
+
+
+class TrackWidget : public FilterWidget
+{
+	public:
+
+		TrackWidget( DatabaseHandler& db, Wt::WContainerWidget* parent = 0);
+
+		// Set constraints created by parent filters
+		void refresh(const Constraint& constraint);
+
+		// Create constraints for child filters (N/A)
+		void getConstraint(Constraint& constraint) {}
+
+		void selectNextTrack(void);	// Emit a trackSelected() if success
+
+		// Signals
+		Wt::Signal< boost::filesystem::path >& trackSelected() { return _trackSelected; }
+
+	private:
+
+		void handleTrackSelected();
+
+		Wt::Signal< boost::filesystem::path > _trackSelected;
+
+		DatabaseHandler&                        _db;
+
+		typedef boost::tuple<Track::pointer, Release::pointer, Artist::pointer>  ResultType;
+		Wt::Dbo::QueryModel< ResultType > _queryModel;
+		Wt::WTableView* _tableView;
+
+		void updateStats(void);
+
+		Wt::WText*	_trackStats;
+
+};
+
+#endif
+