Superminaren
/
sample-hive
mirror of https://gitlab.com/samplehive/sample-hive.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More encapsulation, lots of reformatting and cleanup.

This commit is contained in:
apoorv569 2022-01-24 02:39:57 +05:30
parent 9e0be8f55a
commit 010a798fe5
46 changed files with 3488 additions and 5177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
meson.build
View File

@ -163,9 +163,10 @@ src = [
'src/Utility/Sample.cpp', 'src/Utility/Sample.cpp',
'src/Utility/Serialize.cpp', 'src/Utility/Serialize.cpp',
'src/Utility/Tags.cpp', 'src/Utility/Tags.cpp',
'src/Utility/SH_Event.cpp', 'src/Utility/Event.cpp',
'src/Utility/Signal.cpp', 'src/Utility/Signal.cpp',
'src/Utility/Log.cpp', 'src/Utility/Log.cpp',
'src/Utility/Utils.cpp',
] ]

18
src/App.cpp
View File

@ -29,20 +29,20 @@
#include <wx/gdicmn.h> #include <wx/gdicmn.h>
#include <wx/splash.h> #include <wx/splash.h>
wxIMPLEMENT_APP(App); wxIMPLEMENT_APP(cApp);
App::App() cApp::cApp()
{ {
// Initialize the logger // Initialize the logger
SampleHive::Log::InitLogger("SampleHive"); SampleHive::cLog::InitLogger("SampleHive");
} }
App::~App() cApp::~cApp()
{ {
} }
bool App::OnInit() bool cApp::OnInit()
{ {
if (!wxApp::OnInit()) if (!wxApp::OnInit())
return false; return false;
@ -50,7 +50,7 @@ bool App::OnInit()
wxLog::AddTraceMask("EventSource"); wxLog::AddTraceMask("EventSource");
wxLog::AddTraceMask(wxTRACE_FSWATCHER); wxLog::AddTraceMask(wxTRACE_FSWATCHER);
m_Frame = new MainFrame(); m_Frame = new cMainFrame();
wxBitmap bitmap; wxBitmap bitmap;
wxSplashScreen* splash; wxSplashScreen* splash;
@ -69,7 +69,7 @@ bool App::OnInit()
return true; return true;
} }
void App::OnInitCmdLine(wxCmdLineParser& parser) void cApp::OnInitCmdLine(wxCmdLineParser& parser)
{ {
wxApp::OnInitCmdLine(parser); wxApp::OnInitCmdLine(parser);
@ -78,7 +78,7 @@ void App::OnInitCmdLine(wxCmdLineParser& parser)
parser.Parse(true); parser.Parse(true);
} }
bool App::OnCmdLineParsed(wxCmdLineParser& parser) bool cApp::OnCmdLineParsed(wxCmdLineParser& parser)
{ {
if (!wxApp::OnCmdLineParsed(parser)) if (!wxApp::OnCmdLineParsed(parser))
return false; return false;
@ -142,7 +142,7 @@ bool App::OnCmdLineParsed(wxCmdLineParser& parser)
return true; return true;
} }
void App::OnEventLoopEnter(wxEventLoopBase* event) void cApp::OnEventLoopEnter(wxEventLoopBase* event)
{ {
if (m_Frame->CreateWatcherIfNecessary()) if (m_Frame->CreateWatcherIfNecessary())
SH_LOG_INFO("Filesystem watcher created sucessfully"); SH_LOG_INFO("Filesystem watcher created sucessfully");

12
src/App.hpp
View File

@ -25,18 +25,18 @@
#include <wx/app.h> #include <wx/app.h>
#include <wx/cmdline.h> #include <wx/cmdline.h>
class App : public wxApp class cApp : public wxApp
{ {
public: public:
App(); cApp();
~App(); ~cApp();
private:
MainFrame* m_Frame = nullptr;
private: private:
virtual bool OnInit(); virtual bool OnInit();
virtual void OnEventLoopEnter(wxEventLoopBase* event); virtual void OnEventLoopEnter(wxEventLoopBase* event);
virtual void OnInitCmdLine(wxCmdLineParser& parser); virtual void OnInitCmdLine(wxCmdLineParser& parser);
virtual bool OnCmdLineParsed(wxCmdLineParser& parser); virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
private:
cMainFrame* m_Frame = nullptr;
}; };

306
src/Database/Database.cpp
View File

@ -26,6 +26,7 @@
#include <exception> #include <exception>
#include <sstream> #include <sstream>
#include <stdexcept>
#include <wx/dataview.h> #include <wx/dataview.h>
#include <wx/dvrenderers.h> #include <wx/dvrenderers.h>
#include <wx/msgdlg.h> #include <wx/msgdlg.h>
@ -49,8 +50,7 @@ void debug_log_on_error(int rc)
} }
} }
void show_modal_dialog_and_log(const std::string &message, const std::string &title, void show_modal_dialog_and_log(const std::string &message, const std::string &title, const std::string &error_msg)
const std::string &error_msg)
{ {
std::stringstream ss; std::stringstream ss;
ss << message << " : " << error_msg; ss << message << " : " << error_msg;
@ -78,17 +78,17 @@ class Sqlite3Statement
sqlite3_stmt* stmt = nullptr; sqlite3_stmt* stmt = nullptr;
}; };
Database::Database() cDatabase::cDatabase()
{ {
OpenDatabase(); OpenDatabase();
} }
Database::~Database() cDatabase::~cDatabase()
{ {
CloseDatabase(); CloseDatabase();
} }
void Database::CreateTableSamples() void cDatabase::CreateTableSamples()
{ {
/* Create SQL statement */ /* Create SQL statement */
const auto samples = "CREATE TABLE IF NOT EXISTS SAMPLES(" const auto samples = "CREATE TABLE IF NOT EXISTS SAMPLES("
@ -107,7 +107,7 @@ void Database::CreateTableSamples()
try try
{ {
throw_on_sqlite3_error(sqlite3_exec(m_Database, samples, NULL, 0, &m_ErrMsg)); throw_on_sqlite3_error(sqlite3_exec(m_pDatabase, samples, NULL, 0, &m_pErrMsg));
SH_LOG_INFO("SAMPLES table created successfully."); SH_LOG_INFO("SAMPLES table created successfully.");
} }
catch (const std::exception &e) catch (const std::exception &e)
@ -116,14 +116,14 @@ void Database::CreateTableSamples()
} }
} }
void Database::CreateTableHives() void cDatabase::CreateTableHives()
{ {
/* Create SQL statement */ /* Create SQL statement */
const auto hives = "CREATE TABLE IF NOT EXISTS HIVES(HIVE TEXT NOT NULL);"; const auto hives = "CREATE TABLE IF NOT EXISTS HIVES(HIVE TEXT NOT NULL);";
try try
{ {
throw_on_sqlite3_error(sqlite3_exec(m_Database, hives, NULL, 0, &m_ErrMsg)); throw_on_sqlite3_error(sqlite3_exec(m_pDatabase, hives, NULL, 0, &m_pErrMsg));
SH_LOG_INFO("HIVES table created successfully."); SH_LOG_INFO("HIVES table created successfully.");
} }
catch (const std::exception &e) catch (const std::exception &e)
@ -133,7 +133,7 @@ void Database::CreateTableHives()
} }
//Loops through a Sample array and adds them to the database //Loops through a Sample array and adds them to the database
void Database::InsertIntoSamples(const std::vector<Sample> &samples) void cDatabase::InsertIntoSamples(const std::vector<Sample> &samples)
{ {
try try
{ {
@ -142,9 +142,9 @@ void Database::InsertIntoSamples(const std::vector<Sample> &samples)
SAMPLERATE, BITRATE, PATH, TRASHED, HIVE) \ SAMPLERATE, BITRATE, PATH, TRASHED, HIVE) \
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"; VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_exec(m_Database, "BEGIN TRANSACTION", NULL, NULL, &m_ErrMsg)); throw_on_sqlite3_error(sqlite3_exec(m_pDatabase, "BEGIN TRANSACTION", NULL, NULL, &m_pErrMsg));
Sample sample; Sample sample;
@ -167,30 +167,25 @@ void Database::InsertIntoSamples(const std::vector<Sample> &samples)
std::string hive = "Favorites"; std::string hive = "Favorites";
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 1, sample.GetFavorite())); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 1, sample.GetFavorite()));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC)); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 3, file_extension.c_str(), file_extension.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 3, file_extension.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 4, sample_pack.c_str(), sample_pack.size(), SQLITE_STATIC));
file_extension.size(), SQLITE_STATIC)); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 5, type.c_str(), type.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 4, sample_pack.c_str(),
sample_pack.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 5, type.c_str(),
type.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 6, sample.GetChannels())); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 6, sample.GetChannels()));
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 7, sample.GetLength())); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 7, sample.GetLength()));
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 8, sample.GetSampleRate())); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 8, sample.GetSampleRate()));
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 9, sample.GetBitrate())); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 9, sample.GetBitrate()));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 10, path.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 10, path.c_str(), path.size(), SQLITE_STATIC));
path.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 11, sample.GetTrashed())); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 11, sample.GetTrashed()));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 12, hive.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 12, hive.c_str(), hive.size(), SQLITE_STATIC));
hive.size(), SQLITE_STATIC));
sqlite3_step(statement.stmt); sqlite3_step(statement.stmt);
throw_on_sqlite3_error(sqlite3_clear_bindings(statement.stmt)); throw_on_sqlite3_error(sqlite3_clear_bindings(statement.stmt));
throw_on_sqlite3_error(sqlite3_reset(statement.stmt)); throw_on_sqlite3_error(sqlite3_reset(statement.stmt));
} }
throw_on_sqlite3_error(sqlite3_exec(m_Database, "END TRANSACTION", NULL, NULL, &m_ErrMsg)); throw_on_sqlite3_error(sqlite3_exec(m_pDatabase, "END TRANSACTION", NULL, NULL, &m_pErrMsg));
SH_LOG_INFO("Data inserted successfully into SAMPLES."); SH_LOG_INFO("Data inserted successfully into SAMPLES.");
} }
@ -200,46 +195,17 @@ void Database::InsertIntoSamples(const std::vector<Sample> &samples)
} }
} }
void Database::InsertIntoHives(const std::string &hiveName) void cDatabase::InsertIntoHives(const std::string &hiveName)
{ {
try try
{ {
const auto sql = "INSERT INTO HIVES(HIVE) VALUES(?);"; const auto sql = "INSERT INTO HIVES(HIVE) VALUES(?);";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
// rc = sqlite3_exec(m_Database, "BEGIN TRANSACTION", NULL, NULL, &m_ErrMsg); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), hiveName.size(), SQLITE_STATIC));
// Sample sample;
// std::string filename;
// std::string file_extension;
// std::string sample_pack;
// std::string type;
// std::string path;
// for(unsigned int i = 0; i < samples.size(); i++)
// {
// sample = samples[i];
// filename = sample.GetFilename();
// file_extension = sample.GetFileExtension();
// sample_pack = sample.GetSamplePack();
// type = sample.GetType();
// path = sample.GetPath();
// std::string hive = "Favourites";
// rc = sqlite3_bind_int(statement.stmt, 1, sample.GetFavorite());
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(),
hiveName.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_step(statement.stmt)); throw_on_sqlite3_error(sqlite3_step(statement.stmt));
// rc = sqlite3_clear_bindings(statement.stmt);
// rc = sqlite3_reset(statement.stmt);
// }
// rc = sqlite3_exec(m_Database, "END TRANSACTION", NULL, NULL, &m_ErrMsg);
SH_LOG_INFO("Data inserted successfully into HIVES."); SH_LOG_INFO("Data inserted successfully into HIVES.");
} }
@ -249,18 +215,16 @@ void Database::InsertIntoHives(const std::string &hiveName)
} }
} }
void Database::UpdateHive(const std::string &hiveOldName, const std::string &hiveNewName) void cDatabase::UpdateHive(const std::string &hiveOldName, const std::string &hiveNewName)
{ {
try try
{ {
const auto sql = "UPDATE HIVES SET HIVE = ? WHERE HIVE = ?;"; const auto sql = "UPDATE HIVES SET HIVE = ? WHERE HIVE = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveNewName.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveNewName.c_str(), hiveNewName.size(), SQLITE_STATIC));
hiveNewName.size(), SQLITE_STATIC)); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, hiveOldName.c_str(), hiveOldName.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, hiveOldName.c_str(),
hiveOldName.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) != SQLITE_DONE) if (sqlite3_step(statement.stmt) != SQLITE_DONE)
{ {
@ -277,18 +241,16 @@ void Database::UpdateHive(const std::string &hiveOldName, const std::string &hiv
} }
} }
void Database::UpdateHiveName(const std::string &filename, const std::string &hiveName) void cDatabase::UpdateHiveName(const std::string &filename, const std::string &hiveName)
{ {
try try
{ {
const auto sql = "UPDATE SAMPLES SET HIVE = ? WHERE FILENAME = ?;"; const auto sql = "UPDATE SAMPLES SET HIVE = ? WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), hiveName.size(), SQLITE_STATIC));
hiveName.size(), SQLITE_STATIC)); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), filename.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(),
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -303,17 +265,16 @@ void Database::UpdateHiveName(const std::string &filename, const std::string &hi
} }
} }
void Database::UpdateFavoriteColumn(const std::string &filename, int value) void cDatabase::UpdateFavoriteColumn(const std::string &filename, int value)
{ {
try try
{ {
const auto sql = "UPDATE SAMPLES SET FAVORITE = ? WHERE FILENAME = ?;"; const auto sql = "UPDATE SAMPLES SET FAVORITE = ? WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 1, value)); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 1, value));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -328,18 +289,16 @@ void Database::UpdateFavoriteColumn(const std::string &filename, int value)
} }
} }
void Database::UpdateSamplePack(const std::string &filename, const std::string &samplePack) void cDatabase::UpdateSamplePack(const std::string &filename, const std::string &samplePack)
{ {
try try
{ {
const auto sql = "UPDATE SAMPLES SET SAMPLEPACK = ? WHERE FILENAME = ?;"; const auto sql = "UPDATE SAMPLES SET SAMPLEPACK = ? WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, samplePack.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, samplePack.c_str(), samplePack.size(), SQLITE_STATIC));
samplePack.size(), SQLITE_STATIC)); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), filename.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(),
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -354,17 +313,16 @@ void Database::UpdateSamplePack(const std::string &filename, const std::string &
} }
} }
void Database::UpdateSampleType(const std::string &filename, const std::string &type) void cDatabase::UpdateSampleType(const std::string &filename, const std::string &type)
{ {
try try
{ {
const auto sql = "UPDATE SAMPLES SET TYPE = ? WHERE FILENAME = ?;"; const auto sql = "UPDATE SAMPLES SET TYPE = ? WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, type.c_str(), type.size(), SQLITE_STATIC)); throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, type.c_str(), type.size(), SQLITE_STATIC));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -379,7 +337,7 @@ void Database::UpdateSampleType(const std::string &filename, const std::string &
} }
} }
std::string Database::GetSampleType(const std::string &filename) std::string cDatabase::GetSampleType(const std::string &filename)
{ {
std::string type; std::string type;
@ -387,10 +345,9 @@ std::string Database::GetSampleType(const std::string &filename)
{ {
const auto sql = "SELECT TYPE FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT TYPE FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -409,7 +366,7 @@ std::string Database::GetSampleType(const std::string &filename)
return type; return type;
} }
int Database::GetFavoriteColumnValueByFilename(const std::string &filename) int cDatabase::GetFavoriteColumnValueByFilename(const std::string &filename)
{ {
int value = 0; int value = 0;
@ -417,10 +374,9 @@ int Database::GetFavoriteColumnValueByFilename(const std::string &filename)
{ {
const auto sql = "SELECT FAVORITE FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT FAVORITE FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -438,7 +394,7 @@ int Database::GetFavoriteColumnValueByFilename(const std::string &filename)
return value; return value;
} }
std::string Database::GetHiveByFilename(const std::string &filename) std::string cDatabase::GetHiveByFilename(const std::string &filename)
{ {
std::string hive; std::string hive;
@ -446,10 +402,9 @@ std::string Database::GetHiveByFilename(const std::string &filename)
{ {
const auto sql = "SELECT HIVE FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT HIVE FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -467,16 +422,15 @@ std::string Database::GetHiveByFilename(const std::string &filename)
return hive; return hive;
} }
void Database::RemoveSampleFromDatabase(const std::string &filename) void cDatabase::RemoveSampleFromDatabase(const std::string &filename)
{ {
try try
{ {
const auto sql = "DELETE FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "DELETE FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_DONE) if (sqlite3_step(statement.stmt) == SQLITE_DONE)
{ {
@ -491,16 +445,15 @@ void Database::RemoveSampleFromDatabase(const std::string &filename)
} }
} }
void Database::RemoveHiveFromDatabase(const std::string &hiveName) void cDatabase::RemoveHiveFromDatabase(const std::string &hiveName)
{ {
try try
{ {
const auto sql = "DELETE FROM HIVES WHERE HIVE = ?;"; const auto sql = "DELETE FROM HIVES WHERE HIVE = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), hiveName.size(), SQLITE_STATIC));
hiveName.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_DONE) if (sqlite3_step(statement.stmt) == SQLITE_DONE)
{ {
@ -515,7 +468,7 @@ void Database::RemoveHiveFromDatabase(const std::string &hiveName)
} }
} }
std::string Database::GetSamplePathByFilename(const std::string &filename) std::string cDatabase::GetSamplePathByFilename(const std::string &filename)
{ {
std::string path; std::string path;
@ -523,10 +476,9 @@ std::string Database::GetSamplePathByFilename(const std::string &filename)
{ {
const auto sql = "SELECT PATH FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT PATH FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -544,7 +496,7 @@ std::string Database::GetSamplePathByFilename(const std::string &filename)
return path; return path;
} }
std::string Database::GetSampleFileExtension(const std::string &filename) std::string cDatabase::GetSampleFileExtension(const std::string &filename)
{ {
std::string extension; std::string extension;
@ -552,10 +504,9 @@ std::string Database::GetSampleFileExtension(const std::string &filename)
{ {
const auto sql = "SELECT EXTENSION FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT EXTENSION FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -573,7 +524,7 @@ std::string Database::GetSampleFileExtension(const std::string &filename)
return extension; return extension;
} }
wxVector<wxVector<wxVariant>> Database::LoadSamplesDatabase(wxDataViewTreeCtrl &favorite_tree, wxVector<wxVector<wxVariant>> cDatabase::LoadSamplesDatabase(wxDataViewTreeCtrl &favorite_tree,
wxDataViewItem &favorite_item, wxDataViewItem &favorite_item,
wxTreeCtrl &trash_tree, wxTreeItemId &trash_item, wxTreeCtrl &trash_tree, wxTreeItemId &trash_item,
bool show_extension, bool show_extension,
@ -590,7 +541,7 @@ wxVector<wxVector<wxVariant>> Database::LoadSamplesDatabase(wxDataViewTreeCtrl &
{ {
int num_rows = 0; int num_rows = 0;
Sqlite3Statement statement1(m_Database, "SELECT Count(*) FROM SAMPLES;"); Sqlite3Statement statement1(m_pDatabase, "SELECT Count(*) FROM SAMPLES;");
if (SQLITE_ROW == sqlite3_step(statement1.stmt)) if (SQLITE_ROW == sqlite3_step(statement1.stmt))
{ {
@ -601,7 +552,7 @@ wxVector<wxVector<wxVariant>> Database::LoadSamplesDatabase(wxDataViewTreeCtrl &
vecSet.reserve(num_rows); vecSet.reserve(num_rows);
} }
Sqlite3Statement statement(m_Database, "SELECT FAVORITE, FILENAME, EXTENSION, SAMPLEPACK, \ Sqlite3Statement statement(m_pDatabase, "SELECT FAVORITE, FILENAME, EXTENSION, SAMPLEPACK, \
TYPE, CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH, \ TYPE, CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH, \
TRASHED, HIVE FROM SAMPLES;"); TRASHED, HIVE FROM SAMPLES;");
@ -610,23 +561,17 @@ wxVector<wxVector<wxVariant>> Database::LoadSamplesDatabase(wxDataViewTreeCtrl &
while (SQLITE_ROW == sqlite3_step(statement.stmt)) while (SQLITE_ROW == sqlite3_step(statement.stmt))
{ {
int favorite = sqlite3_column_int(statement.stmt, 0); int favorite = sqlite3_column_int(statement.stmt, 0);
wxString filename = std::string(reinterpret_cast<const char *> wxString filename = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 1)));
(sqlite3_column_text(statement.stmt, 1))); wxString file_extension = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 2)));
wxString file_extension = std::string(reinterpret_cast<const char *> wxString sample_pack = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 3)));
(sqlite3_column_text(statement.stmt, 2))); wxString sample_type = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 4)));
wxString sample_pack = std::string(reinterpret_cast<const char *>
(sqlite3_column_text(statement.stmt, 3)));
wxString sample_type = std::string(reinterpret_cast<const char *>
(sqlite3_column_text(statement.stmt, 4)));
int channels = sqlite3_column_int(statement.stmt, 5); int channels = sqlite3_column_int(statement.stmt, 5);
int length = sqlite3_column_int(statement.stmt, 6); int length = sqlite3_column_int(statement.stmt, 6);
int sample_rate = sqlite3_column_int(statement.stmt, 7); int sample_rate = sqlite3_column_int(statement.stmt, 7);
int bitrate = sqlite3_column_int(statement.stmt, 8); int bitrate = sqlite3_column_int(statement.stmt, 8);
wxString path = std::string(reinterpret_cast<const char *> wxString path = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 9)));
(sqlite3_column_text(statement.stmt, 9)));
int trashed = sqlite3_column_int(statement.stmt, 10); int trashed = sqlite3_column_int(statement.stmt, 10);
wxString hive_name = std::string(reinterpret_cast<const char *> wxString hive_name = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 11)));
(sqlite3_column_text(statement.stmt, 11)));
wxLongLong llLength = length; wxLongLong llLength = length;
int total_min = static_cast<int>((llLength / 60000).GetValue()); int total_min = static_cast<int>((llLength / 60000).GetValue());
@ -683,8 +628,7 @@ wxVector<wxVector<wxVariant>> Database::LoadSamplesDatabase(wxDataViewTreeCtrl &
if (found_item.IsOk()) if (found_item.IsOk())
{ {
if (show_extension) if (show_extension)
favorite_tree.AppendItem(found_item, favorite_tree.AppendItem(found_item, wxString::Format("%s.%s", filename, file_extension));
wxString::Format("%s.%s", filename, file_extension));
else else
favorite_tree.AppendItem(found_item, filename); favorite_tree.AppendItem(found_item, filename);
} }
@ -723,9 +667,9 @@ wxVector<wxVector<wxVariant>> Database::LoadSamplesDatabase(wxDataViewTreeCtrl &
return vecSet; return vecSet;
} }
wxVector<wxVector<wxVariant>> wxVector<wxVector<wxVariant>>cDatabase::FilterDatabaseBySampleName(const std::string &sampleName, bool show_extension,
Database::FilterDatabaseBySampleName(const std::string &sampleName, bool show_extension, const std::string &icon_star_filled,
const std::string &icon_star_filled, const std::string &icon_star_empty) const std::string &icon_star_empty)
{ {
wxVector<wxVector<wxVariant>> sampleVec; wxVector<wxVector<wxVariant>> sampleVec;
@ -735,12 +679,11 @@ Database::FilterDatabaseBySampleName(const std::string &sampleName, bool show_ex
try try
{ {
Sqlite3Statement statement(m_Database, "SELECT FAVORITE, FILENAME, SAMPLEPACK, TYPE, \ Sqlite3Statement statement(m_pDatabase, "SELECT FAVORITE, FILENAME, SAMPLEPACK, TYPE, \
CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH \ CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH \
FROM SAMPLES WHERE FILENAME LIKE '%' || ? || '%' ;"); FROM SAMPLES WHERE FILENAME LIKE '%' || ? || '%' ;");
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, sampleName.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, sampleName.c_str(), sampleName.size(), SQLITE_STATIC));
sampleName.size(), SQLITE_STATIC));
int row = 0; int row = 0;
@ -749,18 +692,14 @@ Database::FilterDatabaseBySampleName(const std::string &sampleName, bool show_ex
SH_LOG_INFO("Record found, filtering db by {}", sampleName); SH_LOG_INFO("Record found, filtering db by {}", sampleName);
int favorite = sqlite3_column_int(statement.stmt, 0); int favorite = sqlite3_column_int(statement.stmt, 0);
wxString filename = wxString(std::string(reinterpret_cast<const char *> wxString filename = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 1))));
(sqlite3_column_text(statement.stmt, 1)))); wxString sample_pack = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 2))));
wxString sample_pack = wxString(std::string(reinterpret_cast<const char *> wxString sample_type = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 3)));
(sqlite3_column_text(statement.stmt, 2))));
wxString sample_type = std::string(reinterpret_cast<const char *>
(sqlite3_column_text(statement.stmt, 3)));
int channels = sqlite3_column_int(statement.stmt, 4); int channels = sqlite3_column_int(statement.stmt, 4);
int length = sqlite3_column_int(statement.stmt, 5); int length = sqlite3_column_int(statement.stmt, 5);
int sample_rate = sqlite3_column_int(statement.stmt, 6); int sample_rate = sqlite3_column_int(statement.stmt, 6);
int bitrate = sqlite3_column_int(statement.stmt, 7); int bitrate = sqlite3_column_int(statement.stmt, 7);
wxString path = wxString(std::string(reinterpret_cast<const char *> wxString path = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 8))));
(sqlite3_column_text(statement.stmt, 8))));
wxLongLong llLength = length; wxLongLong llLength = length;
int total_min = static_cast<int>((llLength / 60000).GetValue()); int total_min = static_cast<int>((llLength / 60000).GetValue());
@ -803,9 +742,9 @@ Database::FilterDatabaseBySampleName(const std::string &sampleName, bool show_ex
return sampleVec; return sampleVec;
} }
wxVector<wxVector<wxVariant>> wxVector<wxVector<wxVariant>>cDatabase::FilterDatabaseByHiveName(const std::string &hiveName, bool show_extension,
Database::FilterDatabaseByHiveName(const std::string &hiveName, bool show_extension, const std::string &icon_star_filled,
const std::string &icon_star_filled, const std::string &icon_star_empty) const std::string &icon_star_empty)
{ {
wxVector<wxVector<wxVariant>> sampleVec; wxVector<wxVector<wxVariant>> sampleVec;
@ -815,12 +754,11 @@ Database::FilterDatabaseByHiveName(const std::string &hiveName, bool show_extens
try try
{ {
Sqlite3Statement statement(m_Database, "SELECT FAVORITE, FILENAME, SAMPLEPACK, TYPE, \ Sqlite3Statement statement(m_pDatabase, "SELECT FAVORITE, FILENAME, SAMPLEPACK, TYPE, \
CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH \ CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH \
FROM SAMPLES WHERE HIVE = ? AND FAVORITE = 1;"); FROM SAMPLES WHERE HIVE = ? AND FAVORITE = 1;");
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, hiveName.c_str(), hiveName.size(), SQLITE_STATIC));
hiveName.size(), SQLITE_STATIC));
int row = 0; int row = 0;
@ -829,18 +767,14 @@ Database::FilterDatabaseByHiveName(const std::string &hiveName, bool show_extens
SH_LOG_INFO("Record found, filtering db by {}", hiveName); SH_LOG_INFO("Record found, filtering db by {}", hiveName);
int favorite = sqlite3_column_int(statement.stmt, 0); int favorite = sqlite3_column_int(statement.stmt, 0);
wxString filename = wxString(std::string(reinterpret_cast<const char *> wxString filename = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 1))));
(sqlite3_column_text(statement.stmt, 1)))); wxString sample_pack = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 2))));
wxString sample_pack = wxString(std::string(reinterpret_cast<const char *> wxString sample_type = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 3)));
(sqlite3_column_text(statement.stmt, 2))));
wxString sample_type = std::string(reinterpret_cast<const char *>
(sqlite3_column_text(statement.stmt, 3)));
int channels = sqlite3_column_int(statement.stmt, 4); int channels = sqlite3_column_int(statement.stmt, 4);
int length = sqlite3_column_int(statement.stmt, 5); int length = sqlite3_column_int(statement.stmt, 5);
int sample_rate = sqlite3_column_int(statement.stmt, 6); int sample_rate = sqlite3_column_int(statement.stmt, 6);
int bitrate = sqlite3_column_int(statement.stmt, 7); int bitrate = sqlite3_column_int(statement.stmt, 7);
wxString path = wxString(std::string(reinterpret_cast<const char *> wxString path = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 8))));
(sqlite3_column_text(statement.stmt, 8))));
wxLongLong llLength = length; wxLongLong llLength = length;
int total_min = static_cast<int>((llLength / 60000).GetValue()); int total_min = static_cast<int>((llLength / 60000).GetValue());
@ -879,20 +813,19 @@ Database::FilterDatabaseByHiveName(const std::string &hiveName, bool show_extens
return sampleVec; return sampleVec;
} }
void Database::LoadHivesDatabase(wxDataViewTreeCtrl &treeCtrl) void cDatabase::LoadHivesDatabase(wxDataViewTreeCtrl &treeCtrl)
{ {
try try
{ {
const auto sql = "SELECT HIVE FROM HIVES;"; const auto sql = "SELECT HIVE FROM HIVES;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
while (SQLITE_ROW == sqlite3_step(statement.stmt)) while (SQLITE_ROW == sqlite3_step(statement.stmt))
{ {
SH_LOG_INFO("Loading hives.."); SH_LOG_INFO("Loading hives..");
const auto hive = wxString(std::string(reinterpret_cast<const char *> const auto hive = wxString(std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 0))));
(sqlite3_column_text(statement.stmt, 0))));
treeCtrl.AppendContainer(wxDataViewItem(wxNullPtr), hive); treeCtrl.AppendContainer(wxDataViewItem(wxNullPtr), hive);
} }
@ -904,7 +837,7 @@ void Database::LoadHivesDatabase(wxDataViewTreeCtrl &treeCtrl)
} }
// Compares the input array with the database and removes duplicates. // Compares the input array with the database and removes duplicates.
wxArrayString Database::CheckDuplicates(const wxArrayString &files) wxArrayString cDatabase::CheckDuplicates(const wxArrayString &files)
{ {
wxArrayString sorted_files; wxArrayString sorted_files;
@ -915,7 +848,7 @@ wxArrayString Database::CheckDuplicates(const wxArrayString &files)
{ {
const auto sql = "SELECT * FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT * FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
for (unsigned int i = 0; i < files.size(); i++) for (unsigned int i = 0; i < files.size(); i++)
{ {
@ -940,16 +873,15 @@ wxArrayString Database::CheckDuplicates(const wxArrayString &files)
return sorted_files; return sorted_files;
} }
bool Database::IsTrashed(const std::string &filename) bool cDatabase::IsTrashed(const std::string &filename)
{ {
try try
{ {
const auto sql = "SELECT TRASHED FROM SAMPLES WHERE FILENAME = ?;"; const auto sql = "SELECT TRASHED FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -969,17 +901,16 @@ bool Database::IsTrashed(const std::string &filename)
return false; return false;
} }
void Database::UpdateTrashColumn(const std::string &filename, int value) void cDatabase::UpdateTrashColumn(const std::string &filename, int value)
{ {
try try
{ {
const auto sql = "UPDATE SAMPLES SET TRASHED = ? WHERE FILENAME = ?;"; const auto sql = "UPDATE SAMPLES SET TRASHED = ? WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 1, value)); throw_on_sqlite3_error(sqlite3_bind_int(statement.stmt, 1, value));
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 2, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
if (sqlite3_step(statement.stmt) == SQLITE_ROW) if (sqlite3_step(statement.stmt) == SQLITE_ROW)
{ {
@ -994,10 +925,10 @@ void Database::UpdateTrashColumn(const std::string &filename, int value)
} }
} }
wxVector<wxVector<wxVariant>> wxVector<wxVector<wxVariant>>cDatabase::RestoreFromTrashByFilename(const std::string &filename,
Database::RestoreFromTrashByFilename(const std::string &filename,
wxVector<wxVector<wxVariant>> &vecSet, bool show_extension, wxVector<wxVector<wxVariant>> &vecSet, bool show_extension,
const std::string &icon_star_filled, const std::string &icon_star_empty) const std::string &icon_star_filled,
const std::string &icon_star_empty)
{ {
wxVariant icon_filled, icon_empty; wxVariant icon_filled, icon_empty;
icon_filled = wxVariant(wxBitmap(icon_star_filled)); icon_filled = wxVariant(wxBitmap(icon_star_filled));
@ -1009,31 +940,24 @@ Database::RestoreFromTrashByFilename(const std::string &filename,
TYPE, CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH, \ TYPE, CHANNELS, LENGTH, SAMPLERATE, BITRATE, PATH, \
TRASHED, HIVE FROM SAMPLES WHERE FILENAME = ?;"; TRASHED, HIVE FROM SAMPLES WHERE FILENAME = ?;";
Sqlite3Statement statement(m_Database, sql); Sqlite3Statement statement(m_pDatabase, sql);
throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), throw_on_sqlite3_error(sqlite3_bind_text(statement.stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC));
filename.size(), SQLITE_STATIC));
while (SQLITE_ROW == sqlite3_step(statement.stmt)) while (SQLITE_ROW == sqlite3_step(statement.stmt))
{ {
int favorite = sqlite3_column_int(statement.stmt, 0); int favorite = sqlite3_column_int(statement.stmt, 0);
wxString filename = std::string(reinterpret_cast<const char *> wxString filename = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 1)));
(sqlite3_column_text(statement.stmt, 1))); wxString file_extension = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 2)));
wxString file_extension = std::string(reinterpret_cast<const char *> wxString sample_pack = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 3)));
(sqlite3_column_text(statement.stmt, 2))); wxString sample_type = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 4)));
wxString sample_pack = std::string(reinterpret_cast<const char *>
(sqlite3_column_text(statement.stmt, 3)));
wxString sample_type = std::string(reinterpret_cast<const char *>
(sqlite3_column_text(statement.stmt, 4)));
int channels = sqlite3_column_int(statement.stmt, 5); int channels = sqlite3_column_int(statement.stmt, 5);
int length = sqlite3_column_int(statement.stmt, 6); int length = sqlite3_column_int(statement.stmt, 6);
int sample_rate = sqlite3_column_int(statement.stmt, 7); int sample_rate = sqlite3_column_int(statement.stmt, 7);
int bitrate = sqlite3_column_int(statement.stmt, 8); int bitrate = sqlite3_column_int(statement.stmt, 8);
wxString path = std::string(reinterpret_cast<const char *> wxString path = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 9)));
(sqlite3_column_text(statement.stmt, 9)));
int trashed = sqlite3_column_int(statement.stmt, 10); int trashed = sqlite3_column_int(statement.stmt, 10);
wxString hive_name = std::string(reinterpret_cast<const char *> wxString hive_name = std::string(reinterpret_cast<const char*>(sqlite3_column_text(statement.stmt, 11)));
(sqlite3_column_text(statement.stmt, 11)));
wxLongLong llLength = length; wxLongLong llLength = length;
int total_min = static_cast<int>((llLength / 60000).GetValue()); int total_min = static_cast<int>((llLength / 60000).GetValue());
@ -1073,12 +997,12 @@ Database::RestoreFromTrashByFilename(const std::string &filename,
return vecSet; return vecSet;
} }
void Database::OpenDatabase() void cDatabase::OpenDatabase()
{ {
throw_on_sqlite3_error(sqlite3_open(static_cast<std::string>(DATABASE_FILEPATH).c_str(), &m_Database)); throw_on_sqlite3_error(sqlite3_open(static_cast<std::string>(DATABASE_FILEPATH).c_str(), &m_pDatabase));
} }
void Database::CloseDatabase() void cDatabase::CloseDatabase()
{ {
throw_on_sqlite3_error(sqlite3_close(m_Database)); throw_on_sqlite3_error(sqlite3_close(m_pDatabase));
} }

10
src/Database/Database.hpp
View File

@ -34,17 +34,17 @@
#include <sqlite3.h> #include <sqlite3.h>
class Database class cDatabase
{ {
public: public:
Database(); cDatabase();
~Database(); ~cDatabase();
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
sqlite3* m_Database; sqlite3* m_pDatabase = nullptr;
int rc; int rc;
char* m_ErrMsg; char* m_pErrMsg = nullptr;
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------

389
src/GUI/Dialogs/Settings.cpp
View File

@ -20,189 +20,187 @@
#include "GUI/Dialogs/Settings.hpp" #include "GUI/Dialogs/Settings.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/Serialize.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Serialize.hpp"
#include <wx/defs.h> #include <wx/defs.h>
#include <wx/gdicmn.h> #include <wx/gdicmn.h>
#include <wx/stringimpl.h> #include <wx/stringimpl.h>
Settings::Settings(wxWindow *window) cSettings::cSettings(wxWindow *window)
: wxDialog(window, wxID_ANY, "Settings", wxDefaultPosition, : wxDialog(window, wxID_ANY, "cSettings", wxDefaultPosition,
wxSize(720, 270), wxDEFAULT_DIALOG_STYLE | wxSTAY_ON_TOP), wxSize(720, 270), wxDEFAULT_DIALOG_STYLE | wxSTAY_ON_TOP),
m_Window(window) m_pWindow(window)
{ {
m_Panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize); m_pPanel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_MainSizer = new wxBoxSizer(wxVERTICAL); m_pMainSizer = new wxBoxSizer(wxVERTICAL);
m_NotebookSizer = new wxBoxSizer(wxVERTICAL); m_pNotebookSizer = new wxBoxSizer(wxVERTICAL);
m_ButtonSizer = new wxBoxSizer(wxHORIZONTAL); m_pButtonSizer = new wxBoxSizer(wxHORIZONTAL);
m_Notebook = new wxNotebook(m_Panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, _T("NOTEBOOK")); m_pNotebook = new wxNotebook(m_pPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, _T("NOTEBOOK"));
m_DisplaySettingPanel = new wxPanel(m_Notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize); m_pDisplaySettingPanel = new wxPanel(m_pNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_DisplayTopSizer = new wxBoxSizer(wxVERTICAL); m_pDisplayTopSizer = new wxBoxSizer(wxVERTICAL);
m_DisplayFontSizer = new wxBoxSizer(wxHORIZONTAL); m_pDisplayFontSizer = new wxBoxSizer(wxHORIZONTAL);
m_WaveformColourSizer = new wxBoxSizer(wxHORIZONTAL); m_pWaveformColourSizer = new wxBoxSizer(wxHORIZONTAL);
Serializer serializer; SampleHive::cSerializer serializer;
wxString fontChoices[] = { "System default" }; wxString fontChoices[] = { "System default" };
m_FontTypeText = new wxStaticText(m_DisplaySettingPanel, wxID_ANY, "Font", m_pFontTypeText = new wxStaticText(m_pDisplaySettingPanel, wxID_ANY, "Font", wxDefaultPosition, wxDefaultSize, 0);
wxDefaultPosition, wxDefaultSize, 0); m_pFontType = new wxChoice(m_pDisplaySettingPanel, SampleHive::ID::SD_FontType,
m_FontType = new wxChoice(m_DisplaySettingPanel, SD_FontType,
wxDefaultPosition, wxDefaultSize, 1, fontChoices, 0); wxDefaultPosition, wxDefaultSize, 1, fontChoices, 0);
m_FontType->SetSelection(0); m_pFontType->SetSelection(0);
m_FontSize = new wxSpinCtrl(m_DisplaySettingPanel, SD_FontSize, "Default", m_pFontSize = new wxSpinCtrl(m_pDisplaySettingPanel, SampleHive::ID::SD_FontSize, "Default", wxDefaultPosition, wxDefaultSize);
wxDefaultPosition, wxDefaultSize); m_pFontSize->SetValue(window->GetFont().GetPointSize());
m_FontSize->SetValue(window->GetFont().GetPointSize()); m_pFontBrowseButton = new wxButton(m_pDisplaySettingPanel, SampleHive::ID::SD_FontBrowseButton, "Select font",
m_FontBrowseButton = new wxButton(m_DisplaySettingPanel, SD_FontBrowseButton, "Select font",
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_WaveformColourLabel = new wxStaticText(m_DisplaySettingPanel, wxID_ANY, "Waveform colour", m_pWaveformColourLabel = new wxStaticText(m_pDisplaySettingPanel, wxID_ANY, "Waveform colour",
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_WaveformColourPickerCtrl = new wxColourPickerCtrl(m_DisplaySettingPanel, SD_WaveformColourPickerCtrl, m_pWaveformColourPickerCtrl = new wxColourPickerCtrl(m_pDisplaySettingPanel, SampleHive::ID::SD_WaveformColourPickerCtrl,
serializer.DeserializeWaveformColour(), serializer.DeserializeWaveformColour(),
wxDefaultPosition, wxDefaultSize, wxDefaultPosition, wxDefaultSize,
wxCLRP_DEFAULT_STYLE); wxCLRP_DEFAULT_STYLE);
m_CollectionSettingPanel = new wxPanel(m_Notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize); m_pCollectionSettingPanel = new wxPanel(m_pNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_CollectionMainSizer = new wxBoxSizer(wxVERTICAL); m_pCollectionMainSizer = new wxBoxSizer(wxVERTICAL);
m_CollectionImportDirSizer = new wxBoxSizer(wxHORIZONTAL); m_pCollectionImportDirSizer = new wxBoxSizer(wxHORIZONTAL);
m_CollectionImportOptionsSizer = new wxBoxSizer(wxHORIZONTAL); m_pCollectionImportOptionsSizer = new wxBoxSizer(wxHORIZONTAL);
m_CollectionShowExtensionSizer = new wxBoxSizer(wxVERTICAL); m_pCollectionShowExtensionSizer = new wxBoxSizer(wxVERTICAL);
wxString defaultDir = wxGetHomeDir(); wxString defaultDir = wxGetHomeDir();
m_AutoImportCheck = new wxCheckBox(m_CollectionSettingPanel, SD_AutoImport, "Auto import", m_pAutoImportCheck = new wxCheckBox(m_pCollectionSettingPanel, SampleHive::ID::SD_AutoImport, "Auto import",
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_ImportDirLocation = new wxTextCtrl(m_CollectionSettingPanel, wxID_ANY, defaultDir, m_pImportDirLocation = new wxTextCtrl(m_pCollectionSettingPanel, wxID_ANY, defaultDir,
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_ImportDirLocation->Disable(); m_pImportDirLocation->Disable();
m_BrowseAutoImportDirButton = new wxButton(m_CollectionSettingPanel, SD_BrowseAutoImportDir, "Browse", m_pBrowseAutoImportDirButton = new wxButton(m_pCollectionSettingPanel, SampleHive::ID::SD_BrowseAutoImportDir, "Browse",
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_BrowseAutoImportDirButton->Disable(); m_pBrowseAutoImportDirButton->Disable();
m_FollowSymLinksCheck = new wxCheckBox(m_CollectionSettingPanel, SD_FollowSymLinks, m_pFollowSymLinksCheck = new wxCheckBox(m_pCollectionSettingPanel, SampleHive::ID::SD_FollowSymLinks,
"Follow symbolic links", wxDefaultPosition, wxDefaultSize, 0); "Follow symbolic links", wxDefaultPosition, wxDefaultSize, 0);
m_FollowSymLinksCheck->SetToolTip("Wheather to follow symbolic links"); m_pFollowSymLinksCheck->SetToolTip("Wheather to follow symbolic links");
m_FollowSymLinksCheck->Disable(); m_pFollowSymLinksCheck->Disable();
m_RecursiveImportCheck = new wxCheckBox(m_CollectionSettingPanel, SD_RecursiveImport, m_pRecursiveImportCheck = new wxCheckBox(m_pCollectionSettingPanel, SampleHive::ID::SD_RecursiveImport,
"Recursive search", wxDefaultPosition, wxDefaultSize, 0); "Recursive search", wxDefaultPosition, wxDefaultSize, 0);
m_RecursiveImportCheck->SetToolTip("Recursively search for samples in the directory"); m_pRecursiveImportCheck->SetToolTip("Recursively search for samples in the directory");
m_RecursiveImportCheck->Disable(); m_pRecursiveImportCheck->Disable();
m_ShowFileExtensionCheck = new wxCheckBox(m_CollectionSettingPanel, SD_ShowFileExtension, m_pShowFileExtensionCheck = new wxCheckBox(m_pCollectionSettingPanel, SampleHive::ID::SD_ShowFileExtension,
"Show file extension", wxDefaultPosition, wxDefaultSize, 0); "Show file extension", wxDefaultPosition, wxDefaultSize, 0);
m_ShowFileExtensionCheck->SetToolTip("Weather to show file extension"); m_pShowFileExtensionCheck->SetToolTip("Weather to show file extension");
m_ConfigurationSettingPanel = new wxPanel(m_Notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize); m_pConfigurationSettingPanel = new wxPanel(m_pNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_GeneralMainSizer = new wxFlexGridSizer(2, 3, 0, 0); m_pGeneralMainSizer = new wxFlexGridSizer(2, 3, 0, 0);
m_GeneralMainSizer->AddGrowableCol(1); m_pGeneralMainSizer->AddGrowableCol(1);
m_GeneralMainSizer->SetFlexibleDirection(wxBOTH); m_pGeneralMainSizer->SetFlexibleDirection(wxBOTH);
m_GeneralMainSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED); m_pGeneralMainSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
m_ConfigLabel = new wxStaticText(m_ConfigurationSettingPanel, wxID_ANY, m_pConfigLabel = new wxStaticText(m_pConfigurationSettingPanel, wxID_ANY,
"Default configuration file location", wxDefaultPosition, wxDefaultSize); "Default configuration file location", wxDefaultPosition, wxDefaultSize);
m_ConfigText = new wxTextCtrl(m_ConfigurationSettingPanel, wxID_ANY, CONFIG_FILEPATH, m_pConfigText = new wxTextCtrl(m_pConfigurationSettingPanel, wxID_ANY, CONFIG_FILEPATH,
wxDefaultPosition, wxDefaultSize); wxDefaultPosition, wxDefaultSize);
m_ConfigBrowse = new wxButton(m_ConfigurationSettingPanel, SD_BrowseConfigDir, "Browse", m_pConfigBrowse = new wxButton(m_pConfigurationSettingPanel, SampleHive::ID::SD_BrowseConfigDir, "Browse",
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_DatabaseLabel = new wxStaticText(m_ConfigurationSettingPanel, wxID_ANY, "Default database location", m_pDatabaseLabel = new wxStaticText(m_pConfigurationSettingPanel, wxID_ANY, "Default database location",
wxDefaultPosition, wxDefaultSize); wxDefaultPosition, wxDefaultSize);
m_DatabaseText = new wxTextCtrl(m_ConfigurationSettingPanel, wxID_ANY, DATABASE_FILEPATH, m_pDatabaseText = new wxTextCtrl(m_pConfigurationSettingPanel, wxID_ANY, DATABASE_FILEPATH,
wxDefaultPosition, wxDefaultSize); wxDefaultPosition, wxDefaultSize);
m_DatabaseBrowse = new wxButton(m_ConfigurationSettingPanel, SD_BrowseDatabaseDir, "Browse", m_pDatabaseBrowse = new wxButton(m_pConfigurationSettingPanel, SampleHive::ID::SD_BrowseDatabaseDir, "Browse",
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_Notebook->AddPage(m_DisplaySettingPanel, "Display"); m_pNotebook->AddPage(m_pDisplaySettingPanel, "Display");
m_Notebook->AddPage(m_CollectionSettingPanel, "Collection"); m_pNotebook->AddPage(m_pCollectionSettingPanel, "Collection");
m_Notebook->AddPage(m_ConfigurationSettingPanel, "General"); m_pNotebook->AddPage(m_pConfigurationSettingPanel, "General");
m_OkButton = new wxButton(m_Panel, wxID_OK, "OK", wxDefaultPosition, wxDefaultSize); m_pOkButton = new wxButton(m_pPanel, wxID_OK, "OK", wxDefaultPosition, wxDefaultSize);
m_CancelButton = new wxButton(m_Panel, wxID_CANCEL, "Cancel", wxDefaultPosition, wxDefaultSize); m_pCancelButton = new wxButton(m_pPanel, wxID_CANCEL, "Cancel", wxDefaultPosition, wxDefaultSize);
LoadDefaultConfig(); LoadDefaultConfig();
// Bind events // Bind events
Bind(wxEVT_CHECKBOX, &Settings::OnCheckAutoImport, this, SD_AutoImport); Bind(wxEVT_CHECKBOX, &cSettings::OnCheckAutoImport, this, SampleHive::ID::SD_AutoImport);
Bind(wxEVT_CHECKBOX, &Settings::OnCheckFollowSymLinks, this, SD_FollowSymLinks); Bind(wxEVT_CHECKBOX, &cSettings::OnCheckFollowSymLinks, this, SampleHive::ID::SD_FollowSymLinks);
Bind(wxEVT_CHECKBOX, &Settings::OnCheckRecursiveImport, this, SD_RecursiveImport); Bind(wxEVT_CHECKBOX, &cSettings::OnCheckRecursiveImport, this, SampleHive::ID::SD_RecursiveImport);
Bind(wxEVT_CHECKBOX, &Settings::OnCheckShowFileExtension, this, SD_ShowFileExtension); Bind(wxEVT_CHECKBOX, &cSettings::OnCheckShowFileExtension, this, SampleHive::ID::SD_ShowFileExtension);
Bind(wxEVT_SPINCTRL, &Settings::OnChangeFontSize, this, SD_FontSize); Bind(wxEVT_SPINCTRL, &cSettings::OnChangeFontSize, this, SampleHive::ID::SD_FontSize);
Bind(wxEVT_BUTTON, &Settings::OnSelectFont, this, SD_FontBrowseButton); Bind(wxEVT_BUTTON, &cSettings::OnSelectFont, this, SampleHive::ID::SD_FontBrowseButton);
Bind(wxEVT_BUTTON, &Settings::OnClickBrowseAutoImportDir, this, SD_BrowseAutoImportDir); Bind(wxEVT_BUTTON, &cSettings::OnClickBrowseAutoImportDir, this, SampleHive::ID::SD_BrowseAutoImportDir);
Bind(wxEVT_BUTTON, &Settings::OnClickConfigBrowse, this, SD_BrowseConfigDir); Bind(wxEVT_BUTTON, &cSettings::OnClickConfigBrowse, this, SampleHive::ID::SD_BrowseConfigDir);
Bind(wxEVT_BUTTON, &Settings::OnClickDatabaseBrowse, this, SD_BrowseDatabaseDir); Bind(wxEVT_BUTTON, &cSettings::OnClickDatabaseBrowse, this, SampleHive::ID::SD_BrowseDatabaseDir);
Bind(wxEVT_COLOURPICKER_CHANGED, &Settings::OnChangeWaveformColour, this, SD_WaveformColourPickerCtrl); Bind(wxEVT_COLOURPICKER_CHANGED, &cSettings::OnChangeWaveformColour, this, SampleHive::ID::SD_WaveformColourPickerCtrl);
// Adding controls to sizers // Adding controls to sizers
m_NotebookSizer->Add(m_Notebook, 1, wxALL | wxEXPAND, 2); m_pNotebookSizer->Add(m_pNotebook, 1, wxALL | wxEXPAND, 2);
m_GeneralMainSizer->Add(m_ConfigLabel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pGeneralMainSizer->Add(m_pConfigLabel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_GeneralMainSizer->Add(m_ConfigText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pGeneralMainSizer->Add(m_pConfigText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_GeneralMainSizer->Add(m_ConfigBrowse, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pGeneralMainSizer->Add(m_pConfigBrowse, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_GeneralMainSizer->Add(m_DatabaseLabel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pGeneralMainSizer->Add(m_pDatabaseLabel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_GeneralMainSizer->Add(m_DatabaseText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pGeneralMainSizer->Add(m_pDatabaseText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_GeneralMainSizer->Add(m_DatabaseBrowse, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pGeneralMainSizer->Add(m_pDatabaseBrowse, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_DisplayFontSizer->Add(m_FontTypeText, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pDisplayFontSizer->Add(m_pFontTypeText, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_DisplayFontSizer->Add(m_FontType, 1, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pDisplayFontSizer->Add(m_pFontType, 1, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_DisplayFontSizer->Add(m_FontSize, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pDisplayFontSizer->Add(m_pFontSize, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_DisplayFontSizer->Add(m_FontBrowseButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pDisplayFontSizer->Add(m_pFontBrowseButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_WaveformColourSizer->Add(m_WaveformColourLabel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pWaveformColourSizer->Add(m_pWaveformColourLabel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_WaveformColourSizer->Add(m_WaveformColourPickerCtrl, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pWaveformColourSizer->Add(m_pWaveformColourPickerCtrl, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_DisplayTopSizer->Add(m_DisplayFontSizer, 0, wxALL | wxEXPAND, 2); m_pDisplayTopSizer->Add(m_pDisplayFontSizer, 0, wxALL | wxEXPAND, 2);
m_DisplayTopSizer->Add(m_WaveformColourSizer, 0, wxALL | wxEXPAND, 2); m_pDisplayTopSizer->Add(m_pWaveformColourSizer, 0, wxALL | wxEXPAND, 2);
m_CollectionImportDirSizer->Add(m_AutoImportCheck, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pCollectionImportDirSizer->Add(m_pAutoImportCheck, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_CollectionImportDirSizer->Add(m_ImportDirLocation, 1, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pCollectionImportDirSizer->Add(m_pImportDirLocation, 1, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_CollectionImportDirSizer->Add(m_BrowseAutoImportDirButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pCollectionImportDirSizer->Add(m_pBrowseAutoImportDirButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_CollectionImportOptionsSizer->Add(m_FollowSymLinksCheck, 0, wxALL, 2); m_pCollectionImportOptionsSizer->Add(m_pFollowSymLinksCheck, 0, wxALL, 2);
m_CollectionImportOptionsSizer->Add(m_RecursiveImportCheck, 0, wxALL, 2); m_pCollectionImportOptionsSizer->Add(m_pRecursiveImportCheck, 0, wxALL, 2);
m_CollectionShowExtensionSizer->Add(m_ShowFileExtensionCheck, 0, wxALL, 2); m_pCollectionShowExtensionSizer->Add(m_pShowFileExtensionCheck, 0, wxALL, 2);
m_CollectionMainSizer->Add(m_CollectionImportDirSizer, 0, wxALL | wxEXPAND, 2); m_pCollectionMainSizer->Add(m_pCollectionImportDirSizer, 0, wxALL | wxEXPAND, 2);
m_CollectionMainSizer->Add(m_CollectionImportOptionsSizer, 0, wxALL | wxEXPAND, 2); m_pCollectionMainSizer->Add(m_pCollectionImportOptionsSizer, 0, wxALL | wxEXPAND, 2);
m_CollectionMainSizer->Add(m_CollectionShowExtensionSizer, 0, wxALL | wxEXPAND, 2); m_pCollectionMainSizer->Add(m_pCollectionShowExtensionSizer, 0, wxALL | wxEXPAND, 2);
m_ButtonSizer->Add(m_OkButton, 0, wxALL | wxALIGN_BOTTOM, 2); m_pButtonSizer->Add(m_pOkButton, 0, wxALL | wxALIGN_BOTTOM, 2);
m_ButtonSizer->Add(m_CancelButton, 0, wxALL | wxALIGN_BOTTOM, 2); m_pButtonSizer->Add(m_pCancelButton, 0, wxALL | wxALIGN_BOTTOM, 2);
m_MainSizer->Add(m_NotebookSizer, 1, wxALL | wxEXPAND, 2); m_pMainSizer->Add(m_pNotebookSizer, 1, wxALL | wxEXPAND, 2);
m_MainSizer->Add(m_ButtonSizer, 0, wxALL | wxALIGN_RIGHT, 2); m_pMainSizer->Add(m_pButtonSizer, 0, wxALL | wxALIGN_RIGHT, 2);
// Top panel layout // Top panel layout
m_Panel->SetSizer(m_MainSizer); m_pPanel->SetSizer(m_pMainSizer);
m_MainSizer->Fit(m_Panel); m_pMainSizer->Fit(m_pPanel);
m_MainSizer->SetSizeHints(m_Panel); m_pMainSizer->SetSizeHints(m_pPanel);
m_MainSizer->Layout(); m_pMainSizer->Layout();
// Display panel layout // Display panel layout
m_DisplaySettingPanel->SetSizer(m_DisplayTopSizer); m_pDisplaySettingPanel->SetSizer(m_pDisplayTopSizer);
m_DisplayTopSizer->Fit(m_DisplaySettingPanel); m_pDisplayTopSizer->Fit(m_pDisplaySettingPanel);
m_DisplayTopSizer->SetSizeHints(m_DisplaySettingPanel); m_pDisplayTopSizer->SetSizeHints(m_pDisplaySettingPanel);
m_DisplayTopSizer->Layout(); m_pDisplayTopSizer->Layout();
// Collection panel layout // Collection panel layout
m_CollectionSettingPanel->SetSizer(m_CollectionMainSizer); m_pCollectionSettingPanel->SetSizer(m_pCollectionMainSizer);
m_CollectionMainSizer->Fit(m_CollectionSettingPanel); m_pCollectionMainSizer->Fit(m_pCollectionSettingPanel);
m_CollectionMainSizer->SetSizeHints(m_CollectionSettingPanel); m_pCollectionMainSizer->SetSizeHints(m_pCollectionSettingPanel);
m_CollectionMainSizer->Layout(); m_pCollectionMainSizer->Layout();
// Configuration panel layout // Configuration panel layout
m_ConfigurationSettingPanel->SetSizer(m_GeneralMainSizer); m_pConfigurationSettingPanel->SetSizer(m_pGeneralMainSizer);
m_GeneralMainSizer->Fit(m_ConfigurationSettingPanel); m_pGeneralMainSizer->Fit(m_pConfigurationSettingPanel);
m_GeneralMainSizer->SetSizeHints(m_ConfigurationSettingPanel); m_pGeneralMainSizer->SetSizeHints(m_pConfigurationSettingPanel);
m_GeneralMainSizer->Layout(); m_pGeneralMainSizer->Layout();
} }
void Settings::OnClickConfigBrowse(wxCommandEvent& event) void cSettings::OnClickConfigBrowse(wxCommandEvent& event)
{ {
wxString initial_dir = wxGetHomeDir(); wxString initial_dir = wxGetHomeDir();
@ -217,7 +215,7 @@ void Settings::OnClickConfigBrowse(wxCommandEvent& event)
case wxID_OK: case wxID_OK:
{ {
wxString path = dir_dialog.GetPath(); wxString path = dir_dialog.GetPath();
m_ConfigText->SetValue(path + "/config.yaml"); m_pConfigText->SetValue(path + "/config.yaml");
break; break;
} }
default: default:
@ -225,7 +223,7 @@ void Settings::OnClickConfigBrowse(wxCommandEvent& event)
} }
} }
void Settings::OnClickDatabaseBrowse(wxCommandEvent& event) void cSettings::OnClickDatabaseBrowse(wxCommandEvent& event)
{ {
wxString initial_dir = wxGetHomeDir(); wxString initial_dir = wxGetHomeDir();
@ -240,7 +238,7 @@ void Settings::OnClickDatabaseBrowse(wxCommandEvent& event)
case wxID_OK: case wxID_OK:
{ {
wxString path = dir_dialog.GetPath(); wxString path = dir_dialog.GetPath();
m_DatabaseText->SetValue(path + "/config.yaml"); m_pDatabaseText->SetValue(path + "/config.yaml");
break; break;
} }
default: default:
@ -248,56 +246,56 @@ void Settings::OnClickDatabaseBrowse(wxCommandEvent& event)
} }
} }
void Settings::OnCheckAutoImport(wxCommandEvent& event) void cSettings::OnCheckAutoImport(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
if (!m_AutoImportCheck->GetValue()) if (!m_pAutoImportCheck->GetValue())
{ {
bAutoImport = false; m_bAutoImport = false;
m_ImportDirLocation->Disable(); m_pImportDirLocation->Disable();
m_BrowseAutoImportDirButton->Disable(); m_pBrowseAutoImportDirButton->Disable();
m_FollowSymLinksCheck->Disable(); m_pFollowSymLinksCheck->Disable();
m_RecursiveImportCheck->Disable(); m_pRecursiveImportCheck->Disable();
serializer.SerializeAutoImport(bAutoImport, m_ImportDirLocation->GetValue().ToStdString()); serializer.SerializeAutoImport(m_bAutoImport, m_pImportDirLocation->GetValue().ToStdString());
} }
else else
{ {
bAutoImport = true; m_bAutoImport = true;
m_ImportDirLocation->Enable(); m_pImportDirLocation->Enable();
m_BrowseAutoImportDirButton->Enable(); m_pBrowseAutoImportDirButton->Enable();
m_FollowSymLinksCheck->Enable(); m_pFollowSymLinksCheck->Enable();
m_RecursiveImportCheck->Enable(); m_pRecursiveImportCheck->Enable();
serializer.SerializeAutoImport(bAutoImport, m_ImportDirLocation->GetValue().ToStdString()); serializer.SerializeAutoImport(m_bAutoImport, m_pImportDirLocation->GetValue().ToStdString());
} }
} }
void Settings::OnCheckFollowSymLinks(wxCommandEvent& event) void cSettings::OnCheckFollowSymLinks(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
serializer.SerializeFollowSymLink(m_FollowSymLinksCheck->GetValue()); serializer.SerializeFollowSymLink(m_pFollowSymLinksCheck->GetValue());
} }
void Settings::OnCheckRecursiveImport(wxCommandEvent& event) void cSettings::OnCheckRecursiveImport(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
serializer.SerializeRecursiveImport(m_RecursiveImportCheck->GetValue()); serializer.SerializeRecursiveImport(m_pRecursiveImportCheck->GetValue());
} }
void Settings::OnCheckShowFileExtension(wxCommandEvent& event) void cSettings::OnCheckShowFileExtension(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
serializer.SerializeShowFileExtension(m_ShowFileExtensionCheck->GetValue()); serializer.SerializeShowFileExtension(m_pShowFileExtensionCheck->GetValue());
} }
void Settings::OnClickBrowseAutoImportDir(wxCommandEvent& event) void cSettings::OnClickBrowseAutoImportDir(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
wxString initial_dir = wxGetHomeDir(); wxString initial_dir = wxGetHomeDir();
@ -312,9 +310,9 @@ void Settings::OnClickBrowseAutoImportDir(wxCommandEvent& event)
case wxID_OK: case wxID_OK:
{ {
wxString path = dir_dialog.GetPath(); wxString path = dir_dialog.GetPath();
m_ImportDirLocation->SetValue(path); m_pImportDirLocation->SetValue(path);
serializer.SerializeAutoImport(bAutoImport, m_ImportDirLocation->GetValue().ToStdString()); serializer.SerializeAutoImport(m_bAutoImport, m_pImportDirLocation->GetValue().ToStdString());
break; break;
} }
default: default:
@ -322,7 +320,7 @@ void Settings::OnClickBrowseAutoImportDir(wxCommandEvent& event)
} }
} }
void Settings::OnSelectFont(wxCommandEvent& event) void cSettings::OnSelectFont(wxCommandEvent& event)
{ {
wxFontDialog font_dialog(this); wxFontDialog font_dialog(this);
@ -333,16 +331,16 @@ void Settings::OnSelectFont(wxCommandEvent& event)
wxFontData fontData = font_dialog.GetFontData(); wxFontData fontData = font_dialog.GetFontData();
m_Font = fontData.GetChosenFont(); m_Font = fontData.GetChosenFont();
if (m_FontType->GetCount() > 1) if (m_pFontType->GetCount() > 1)
{ {
m_FontType->Delete(1); m_pFontType->Delete(1);
m_FontType->AppendString(m_Font.GetFaceName()); m_pFontType->AppendString(m_Font.GetFaceName());
m_FontType->SetSelection(1); m_pFontType->SetSelection(1);
} }
else else
{ {
m_FontType->AppendString(m_Font.GetFaceName()); m_pFontType->AppendString(m_Font.GetFaceName());
m_FontType->SetSelection(1); m_pFontType->SetSelection(1);
} }
SetCustomFont(); SetCustomFont();
@ -354,29 +352,29 @@ void Settings::OnSelectFont(wxCommandEvent& event)
PrintFont(); PrintFont();
} }
void Settings::OnChangeFontSize(wxSpinEvent& event) void cSettings::OnChangeFontSize(wxSpinEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
int font_size = m_FontSize->GetValue(); int font_size = m_pFontSize->GetValue();
if (m_FontType->GetStringSelection() == "System default") if (m_pFontType->GetStringSelection() == "System default")
m_Font = wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT); m_Font = wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT);
m_Font.SetPointSize(font_size); m_Font.SetPointSize(font_size);
serializer.SerializeFontSettings(m_Font); serializer.SerializeFontSettings(m_Font);
m_Window->SetFont(m_Font); m_pWindow->SetFont(m_Font);
this->SetFont(m_Font); this->SetFont(m_Font);
SH_LOG_DEBUG("Font size: {}", font_size); SH_LOG_DEBUG("Font size: {}", font_size);
SH_LOG_DEBUG("Font size: {}", m_Font.GetPointSize()); SH_LOG_DEBUG("Font size: {}", m_Font.GetPointSize());
} }
void Settings::LoadDefaultConfig() void cSettings::LoadDefaultConfig()
{ {
Serializer serializer; SampleHive::cSerializer serializer;
wxFont sys_font = wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT); wxFont sys_font = wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT);
wxString system_font = sys_font.GetFaceName(); wxString system_font = sys_font.GetFaceName();
@ -387,54 +385,54 @@ void Settings::LoadDefaultConfig()
if (system_font != font_face) if (system_font != font_face)
{ {
if (m_FontType->GetCount() > 1) if (m_pFontType->GetCount() > 1)
{ {
m_FontType->Delete(1); m_pFontType->Delete(1);
m_FontType->AppendString(font_face); m_pFontType->AppendString(font_face);
m_FontType->SetSelection(1); m_pFontType->SetSelection(1);
m_Font.SetFaceName(font_face); m_Font.SetFaceName(font_face);
m_Font.SetPointSize(font_size); m_Font.SetPointSize(font_size);
} }
else else
{ {
m_FontType->AppendString(font_face); m_pFontType->AppendString(font_face);
m_FontType->SetSelection(1); m_pFontType->SetSelection(1);
m_Font.SetFaceName(font_face); m_Font.SetFaceName(font_face);
m_Font.SetPointSize(font_size); m_Font.SetPointSize(font_size);
} }
} }
m_FontSize->SetValue(font_size); m_pFontSize->SetValue(font_size);
SetCustomFont(); SetCustomFont();
bAutoImport = serializer.DeserializeAutoImport().first; m_bAutoImport = serializer.DeserializeAutoImport().first;
m_AutoImportCheck->SetValue(bAutoImport); m_pAutoImportCheck->SetValue(m_bAutoImport);
m_ImportDirLocation->SetValue(serializer.DeserializeAutoImport().second); m_pImportDirLocation->SetValue(serializer.DeserializeAutoImport().second);
m_ShowFileExtensionCheck->SetValue(serializer.DeserializeShowFileExtension()); m_pShowFileExtensionCheck->SetValue(serializer.DeserializeShowFileExtension());
m_FollowSymLinksCheck->SetValue(serializer.DeserializeFollowSymLink()); m_pFollowSymLinksCheck->SetValue(serializer.DeserializeFollowSymLink());
m_RecursiveImportCheck->SetValue(serializer.DeserializeRecursiveImport()); m_pRecursiveImportCheck->SetValue(serializer.DeserializeRecursiveImport());
if (bAutoImport) if (m_bAutoImport)
{ {
m_ImportDirLocation->Enable(); m_pImportDirLocation->Enable();
m_BrowseAutoImportDirButton->Enable(); m_pBrowseAutoImportDirButton->Enable();
m_FollowSymLinksCheck->Enable(); m_pFollowSymLinksCheck->Enable();
m_RecursiveImportCheck->Enable(); m_pRecursiveImportCheck->Enable();
} }
} }
void Settings::SetShowExtension(bool value) void cSettings::SetShowExtension(bool value)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
m_ShowFileExtensionCheck->SetValue(value); m_pShowFileExtensionCheck->SetValue(value);
serializer.SerializeShowFileExtension(value); serializer.SerializeShowFileExtension(value);
} }
void Settings::PrintFont() void cSettings::PrintFont()
{ {
SH_LOG_DEBUG("Font face: {}", m_Font.GetFaceName()); SH_LOG_DEBUG("Font face: {}", m_Font.GetFaceName());
SH_LOG_DEBUG("Font size: {}", m_Font.GetPointSize()); SH_LOG_DEBUG("Font size: {}", m_Font.GetPointSize());
@ -443,9 +441,9 @@ void Settings::PrintFont()
SH_LOG_DEBUG("Font weight: {}", m_Font.GetWeightString()); SH_LOG_DEBUG("Font weight: {}", m_Font.GetWeightString());
} }
void Settings::SetCustomFont() void cSettings::SetCustomFont()
{ {
Serializer serializer; SampleHive::cSerializer serializer;
wxFont sys_font = wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT); wxFont sys_font = wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT);
std::string system_font = sys_font.GetFaceName().ToStdString(); std::string system_font = sys_font.GetFaceName().ToStdString();
@ -454,53 +452,56 @@ void Settings::SetCustomFont()
wxString font_face = serializer.DeserializeFontSettings().GetFaceName(); wxString font_face = serializer.DeserializeFontSettings().GetFaceName();
int font_size = serializer.DeserializeFontSettings().GetPointSize(); int font_size = serializer.DeserializeFontSettings().GetPointSize();
if (m_FontType->GetStringSelection() == "System default") if (m_pFontType->GetStringSelection() == "System default")
{ {
m_Window->SetFont(sys_font); m_pWindow->SetFont(sys_font);
this->SetFont(sys_font); this->SetFont(sys_font);
serializer.SerializeFontSettings(sys_font); serializer.SerializeFontSettings(sys_font);
} }
else else
{ {
m_Window->SetFont(m_Font); m_pWindow->SetFont(m_Font);
this->SetFont(m_Font); this->SetFont(m_Font);
serializer.SerializeFontSettings(m_Font); serializer.SerializeFontSettings(m_Font);
} }
} }
wxString Settings::GetImportDirPath() wxString cSettings::GetImportDirPath()
{ {
wxString dir = wxEmptyString; wxString dir = wxEmptyString;
if (m_AutoImportCheck->GetValue()) if (m_pAutoImportCheck->GetValue())
dir = m_ImportDirLocation->GetValue(); dir = m_pImportDirLocation->GetValue();
return dir; return dir;
} }
void Settings::OnChangeWaveformColour(wxColourPickerEvent& event) void cSettings::OnChangeWaveformColour(wxColourPickerEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
wxColour colour = m_WaveformColourPickerCtrl->GetColour(); wxColour colour = m_pWaveformColourPickerCtrl->GetColour();
wxColour wave_colour = serializer.DeserializeWaveformColour(); wxColour wave_colour = serializer.DeserializeWaveformColour();
if (colour != wave_colour) if (colour != wave_colour)
{ {
SH_LOG_INFO("Waveform colour changed."); SH_LOG_INFO("Waveform colour changed.");
bWaveformColourChanged = true; m_bWaveformColourChanged = true;
serializer.SerializeWaveformColour(colour); serializer.SerializeWaveformColour(colour);
} }
else else
{ {
SH_LOG_INFO("Waveform colour not changed."); SH_LOG_INFO("Waveform colour not changed.");
bWaveformColourChanged = false; m_bWaveformColourChanged = false;
serializer.SerializeWaveformColour(colour); serializer.SerializeWaveformColour(colour);
} }
} }
Settings::~Settings(){} cSettings::~cSettings()
{
}

169
src/GUI/Dialogs/Settings.hpp
View File

@ -40,89 +40,11 @@
#include <wx/toplevel.h> #include <wx/toplevel.h>
#include <wx/window.h> #include <wx/window.h>
class Settings : public wxDialog class cSettings : public wxDialog
{ {
public: public:
Settings(wxWindow* window); cSettings(wxWindow* window);
~Settings(); ~cSettings();
private:
// -------------------------------------------------------------------
wxWindow* m_Window;
private:
// -------------------------------------------------------------------
// Top panel for wxDialog
wxPanel* m_Panel;
// -------------------------------------------------------------------
// Notebook page panels
wxPanel* m_DisplaySettingPanel;
wxPanel* m_CollectionSettingPanel;
wxPanel* m_ConfigurationSettingPanel;
// -------------------------------------------------------------------
// Top panel sizers
wxBoxSizer* m_MainSizer;
wxBoxSizer* m_NotebookSizer;
wxBoxSizer* m_ButtonSizer;
// -------------------------------------------------------------------
// Notebook
wxNotebook* m_Notebook;
// -------------------------------------------------------------------
// Display page
wxBoxSizer* m_DisplayTopSizer;
wxBoxSizer* m_DisplayFontSizer;
wxStaticText* m_RowHeightText;
wxStaticText* m_FontTypeText;
wxChoice* m_RowHeight;
wxChoice* m_FontType;
wxButton* m_FontBrowseButton;
wxSpinCtrl* m_FontSize;
wxBoxSizer* m_WaveformColourSizer;
wxStaticText* m_WaveformColourLabel;
wxColourPickerCtrl* m_WaveformColourPickerCtrl;
// -------------------------------------------------------------------
// Collection page
wxBoxSizer* m_CollectionMainSizer;
wxBoxSizer* m_CollectionImportDirSizer;
wxBoxSizer* m_CollectionImportOptionsSizer;
wxBoxSizer* m_CollectionShowExtensionSizer;
wxCheckBox* m_AutoImportCheck;
wxCheckBox* m_FollowSymLinksCheck;
wxCheckBox* m_RecursiveImportCheck;
wxCheckBox* m_ShowFileExtensionCheck;
wxTextCtrl* m_ImportDirLocation;
wxButton* m_BrowseAutoImportDirButton;
// -------------------------------------------------------------------
// General configuration page
wxFlexGridSizer* m_GeneralMainSizer;
wxStaticText* m_ConfigLabel;
wxStaticText* m_DatabaseLabel;
wxTextCtrl* m_ConfigText;
wxTextCtrl* m_DatabaseText;
wxButton* m_ConfigBrowse;
wxButton* m_DatabaseBrowse;
// -------------------------------------------------------------------
// Common buttons for wxDialog
wxButton* m_OkButton;
wxButton* m_CancelButton;
private:
// -------------------------------------------------------------------
wxFont m_Font;
private:
// -------------------------------------------------------------------
bool bAutoImport = false;
// bool bFollowSymLinks = false;
// bool bShowExtension = true;
bool bWaveformColourChanged = false;
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
@ -150,13 +72,88 @@ class Settings : public wxDialog
wxString GetImportDirPath(); wxString GetImportDirPath();
// inline wxFont GetFontType() { return m_Font; }; // inline wxFont GetFontType() { return m_Font; };
inline bool CanAutoImport() { return bAutoImport; }; inline bool CanAutoImport() { return m_bAutoImport; };
// inline bool ShouldFollowSymLinks() { return bFollowSymLinks; }; inline bool IsWaveformColourChanged() { return m_bWaveformColourChanged; }
// inline bool ShouldShowFileExtension() { return bShowExtension; };
inline bool IsWaveformColourChanged() { return bWaveformColourChanged; }
// inline wxColour GetWaveformColour() { return m_WaveformColourPickerCtrl->GetColour(); }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Setters // Setters
void SetShowExtension(bool value); void SetShowExtension(bool value);
private:
// -------------------------------------------------------------------
wxWindow* m_pWindow = nullptr;
private:
// -------------------------------------------------------------------
// Top panel for wxDialog
wxPanel* m_pPanel = nullptr;
// -------------------------------------------------------------------
// Notebook page panels
wxPanel* m_pDisplaySettingPanel = nullptr;
wxPanel* m_pCollectionSettingPanel = nullptr;
wxPanel* m_pConfigurationSettingPanel = nullptr;
// -------------------------------------------------------------------
// Top panel sizers
wxBoxSizer* m_pMainSizer = nullptr;
wxBoxSizer* m_pNotebookSizer = nullptr;
wxBoxSizer* m_pButtonSizer = nullptr;
// -------------------------------------------------------------------
// Notebook
wxNotebook* m_pNotebook = nullptr;
// -------------------------------------------------------------------
// Display page
wxBoxSizer* m_pDisplayTopSizer = nullptr;
wxBoxSizer* m_pDisplayFontSizer = nullptr;
wxStaticText* m_pRowHeightText = nullptr;
wxStaticText* m_pFontTypeText = nullptr;
wxChoice* m_pRowHeight = nullptr;
wxChoice* m_pFontType = nullptr;
wxButton* m_pFontBrowseButton = nullptr;
wxSpinCtrl* m_pFontSize = nullptr;
wxBoxSizer* m_pWaveformColourSizer = nullptr;
wxStaticText* m_pWaveformColourLabel = nullptr;
wxColourPickerCtrl* m_pWaveformColourPickerCtrl = nullptr;
// -------------------------------------------------------------------
// Collection page
wxBoxSizer* m_pCollectionMainSizer = nullptr;
wxBoxSizer* m_pCollectionImportDirSizer = nullptr;
wxBoxSizer* m_pCollectionImportOptionsSizer = nullptr;
wxBoxSizer* m_pCollectionShowExtensionSizer = nullptr;
wxCheckBox* m_pAutoImportCheck = nullptr;
wxCheckBox* m_pFollowSymLinksCheck = nullptr;
wxCheckBox* m_pRecursiveImportCheck = nullptr;
wxCheckBox* m_pShowFileExtensionCheck = nullptr;
wxTextCtrl* m_pImportDirLocation = nullptr;
wxButton* m_pBrowseAutoImportDirButton = nullptr;
// -------------------------------------------------------------------
// General configuration page
wxFlexGridSizer* m_pGeneralMainSizer = nullptr;
wxStaticText* m_pConfigLabel = nullptr;
wxStaticText* m_pDatabaseLabel = nullptr;
wxTextCtrl* m_pConfigText = nullptr;
wxTextCtrl* m_pDatabaseText = nullptr;
wxButton* m_pConfigBrowse = nullptr;
wxButton* m_pDatabaseBrowse = nullptr;
// -------------------------------------------------------------------
// Common buttons for wxDialog
wxButton* m_pOkButton = nullptr;
wxButton* m_pCancelButton = nullptr;
private:
// -------------------------------------------------------------------
wxFont m_Font;
private:
// -------------------------------------------------------------------
bool m_bAutoImport = false;
// bool bFollowSymLinks = false;
// bool bShowExtension = true;
bool m_bWaveformColourChanged = false;
}; };

242
src/GUI/Dialogs/TagEditor.cpp
View File

@ -18,13 +18,13 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
#include "GUI/Dialogs/TagEditor.hpp"
#include "Database/Database.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/SH_Event.hpp"
#include "Utility/Signal.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Database/Database.hpp" #include "Utility/Event.hpp"
#include "GUI/Dialogs/TagEditor.hpp" #include "Utility/Signal.hpp"
#include <wx/defs.h> #include <wx/defs.h>
#include <wx/gdicmn.h> #include <wx/gdicmn.h>
@ -32,179 +32,179 @@
#include <wx/stringimpl.h> #include <wx/stringimpl.h>
#include <wx/textdlg.h> #include <wx/textdlg.h>
TagEditor::TagEditor(wxWindow* window, const std::string& filename) cTagEditor::cTagEditor(wxWindow* window, const std::string& filename)
: wxDialog(window, wxID_ANY, "Edit tags", wxDefaultPosition, : wxDialog(window, wxID_ANY, "Edit tags", wxDefaultPosition,
wxSize(640, 360), wxDEFAULT_DIALOG_STYLE | wxSTAY_ON_TOP), wxSize(640, 360), wxDEFAULT_DIALOG_STYLE | wxSTAY_ON_TOP),
m_Window(window), m_Filename(filename), tags(filename) m_pWindow(window), m_Filename(filename), tags(filename)
{ {
m_Panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize); m_pPanel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_MainSizer = new wxBoxSizer(wxVERTICAL); m_pMainSizer = new wxBoxSizer(wxVERTICAL);
m_ButtonSizer = new wxBoxSizer(wxHORIZONTAL); m_pButtonSizer = new wxBoxSizer(wxHORIZONTAL);
m_EditTagSizer = new wxFlexGridSizer(6, 2, 0, 0); m_pEditTagSizer = new wxFlexGridSizer(6, 2, 0, 0);
m_EditTagSizer->AddGrowableCol(1); m_pEditTagSizer->AddGrowableCol(1);
m_EditTagSizer->SetFlexibleDirection(wxBOTH); m_pEditTagSizer->SetFlexibleDirection(wxBOTH);
m_EditTagSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED); m_pEditTagSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
m_SampleTypeSizer = new wxFlexGridSizer(1, 3, 0, 0); m_pSampleTypeSizer = new wxFlexGridSizer(1, 3, 0, 0);
m_SampleTypeSizer->AddGrowableCol(1); m_pSampleTypeSizer->AddGrowableCol(1);
m_SampleTypeSizer->SetFlexibleDirection(wxBOTH); m_pSampleTypeSizer->SetFlexibleDirection(wxBOTH);
m_SampleTypeSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED); m_pSampleTypeSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
m_StaticEditTagSizer = new wxStaticBoxSizer(wxVERTICAL, m_Panel, "Edit tags"); m_pStaticEditTagSizer = new wxStaticBoxSizer(wxVERTICAL, m_pPanel, "Edit tags");
m_StaticSampleTypeSizer = new wxStaticBoxSizer(wxVERTICAL, m_Panel, "Sample type"); m_pStaticSampleTypeSizer = new wxStaticBoxSizer(wxVERTICAL, m_pPanel, "Sample type");
wxString choices[] = {"Kick", "Snare", "Clap", "HiHat", "Cymbal", "Cowbell", "Ride", "Tom", "Shaker", "Percussion"}; wxString choices[] = {"Kick", "Snare", "Clap", "HiHat", "Cymbal", "Cowbell", "Ride", "Tom", "Shaker", "Percussion"};
m_TitleCheck = new wxCheckBox(m_Panel, ET_TitleCheck, "Title", wxDefaultPosition, wxDefaultSize); m_pTitleCheck = new wxCheckBox(m_pPanel, SampleHive::ID::ET_TitleCheck, "Title", wxDefaultPosition, wxDefaultSize);
m_ArtistCheck = new wxCheckBox(m_Panel, ET_ArtistCheck, "Artist", wxDefaultPosition, wxDefaultSize); m_pArtistCheck = new wxCheckBox(m_pPanel, SampleHive::ID::ET_ArtistCheck, "Artist", wxDefaultPosition, wxDefaultSize);
m_AlbumCheck = new wxCheckBox(m_Panel, ET_AlbumCheck, "Album", wxDefaultPosition, wxDefaultSize); m_pAlbumCheck = new wxCheckBox(m_pPanel, SampleHive::ID::ET_AlbumCheck, "Album", wxDefaultPosition, wxDefaultSize);
m_GenreCheck = new wxCheckBox(m_Panel, ET_GenreCheck, "Genre", wxDefaultPosition, wxDefaultSize); m_pGenreCheck = new wxCheckBox(m_pPanel, SampleHive::ID::ET_GenreCheck, "Genre", wxDefaultPosition, wxDefaultSize);
m_CommentCheck = new wxCheckBox(m_Panel, ET_CommentsCheck, "Comments", wxDefaultPosition, wxDefaultSize); m_pCommentCheck = new wxCheckBox(m_pPanel, SampleHive::ID::ET_CommentsCheck, "Comments", wxDefaultPosition, wxDefaultSize);
m_SampleTypeCheck = new wxCheckBox(m_Panel, ET_TypeCheck, "Type", wxDefaultPosition, wxDefaultSize); m_pSampleTypeCheck = new wxCheckBox(m_pPanel, SampleHive::ID::ET_TypeCheck, "Type", wxDefaultPosition, wxDefaultSize);
m_TitleText = new wxTextCtrl(m_Panel, wxID_ANY, tags.GetAudioInfo().title, wxDefaultPosition, wxDefaultSize); m_pTitleText = new wxTextCtrl(m_pPanel, wxID_ANY, tags.GetAudioInfo().title, wxDefaultPosition, wxDefaultSize);
m_TitleText->Disable(); m_pTitleText->Disable();
m_ArtistText = new wxTextCtrl(m_Panel, wxID_ANY, tags.GetAudioInfo().artist, wxDefaultPosition, wxDefaultSize); m_pArtistText = new wxTextCtrl(m_pPanel, wxID_ANY, tags.GetAudioInfo().artist, wxDefaultPosition, wxDefaultSize);
m_ArtistText->Disable(); m_pArtistText->Disable();
m_AlbumText = new wxTextCtrl(m_Panel, wxID_ANY, tags.GetAudioInfo().album, wxDefaultPosition, wxDefaultSize); m_pAlbumText = new wxTextCtrl(m_pPanel, wxID_ANY, tags.GetAudioInfo().album, wxDefaultPosition, wxDefaultSize);
m_AlbumText->Disable(); m_pAlbumText->Disable();
m_GenreText = new wxTextCtrl(m_Panel, wxID_ANY, tags.GetAudioInfo().genre, wxDefaultPosition, wxDefaultSize); m_pGenreText = new wxTextCtrl(m_pPanel, wxID_ANY, tags.GetAudioInfo().genre, wxDefaultPosition, wxDefaultSize);
m_GenreText->Disable(); m_pGenreText->Disable();
m_CommentText = new wxTextCtrl(m_Panel, wxID_ANY, tags.GetAudioInfo().comment, wxDefaultPosition, wxDefaultSize); m_pCommentText = new wxTextCtrl(m_pPanel, wxID_ANY, tags.GetAudioInfo().comment, wxDefaultPosition, wxDefaultSize);
m_CommentText->Disable(); m_pCommentText->Disable();
m_SampleTypeChoice = new wxChoice(m_Panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, 10, choices, wxCB_SORT); m_pSampleTypeChoice = new wxChoice(m_pPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, 10, choices, wxCB_SORT);
m_SampleTypeChoice->Disable(); m_pSampleTypeChoice->Disable();
m_SampleTypeButton = new wxButton(m_Panel, ET_CustomTag, "Custom", wxDefaultPosition, wxDefaultSize); m_pSampleTypeButton = new wxButton(m_pPanel, SampleHive::ID::ET_CustomTag, "Custom", wxDefaultPosition, wxDefaultSize);
m_SampleTypeButton->Disable(); m_pSampleTypeButton->Disable();
m_OkButton = new wxButton(m_Panel, wxID_OK, "OK", wxDefaultPosition, wxDefaultSize); m_pOkButton = new wxButton(m_pPanel, wxID_OK, "OK", wxDefaultPosition, wxDefaultSize);
m_ApplyButton = new wxButton(m_Panel, wxID_APPLY, "Apply", wxDefaultPosition, wxDefaultSize); m_pApplyButton = new wxButton(m_pPanel, wxID_APPLY, "Apply", wxDefaultPosition, wxDefaultSize);
m_CancelButton = new wxButton(m_Panel, wxID_CANCEL, "Cancel", wxDefaultPosition, wxDefaultSize); m_pCancelButton = new wxButton(m_pPanel, wxID_CANCEL, "Cancel", wxDefaultPosition, wxDefaultSize);
// Binding events // Binding events
Bind(wxEVT_CHECKBOX, &TagEditor::OnCheckTitle, this, ET_TitleCheck); Bind(wxEVT_CHECKBOX, &cTagEditor::OnCheckTitle, this, SampleHive::ID::ET_TitleCheck);
Bind(wxEVT_CHECKBOX, &TagEditor::OnCheckArtist, this, ET_ArtistCheck); Bind(wxEVT_CHECKBOX, &cTagEditor::OnCheckArtist, this, SampleHive::ID::ET_ArtistCheck);
Bind(wxEVT_CHECKBOX, &TagEditor::OnCheckAlbum, this, ET_AlbumCheck); Bind(wxEVT_CHECKBOX, &cTagEditor::OnCheckAlbum, this, SampleHive::ID::ET_AlbumCheck);
Bind(wxEVT_CHECKBOX, &TagEditor::OnCheckGenre, this, ET_GenreCheck); Bind(wxEVT_CHECKBOX, &cTagEditor::OnCheckGenre, this, SampleHive::ID::ET_GenreCheck);
Bind(wxEVT_CHECKBOX, &TagEditor::OnCheckComments, this, ET_CommentsCheck); Bind(wxEVT_CHECKBOX, &cTagEditor::OnCheckComments, this, SampleHive::ID::ET_CommentsCheck);
Bind(wxEVT_CHECKBOX, &TagEditor::OnCheckType, this, ET_TypeCheck); Bind(wxEVT_CHECKBOX, &cTagEditor::OnCheckType, this, SampleHive::ID::ET_TypeCheck);
Bind(wxEVT_BUTTON, &TagEditor::OnClickCustomTagButton, this, ET_CustomTag); Bind(wxEVT_BUTTON, &cTagEditor::OnClickCustomTagButton, this, SampleHive::ID::ET_CustomTag);
Bind(wxEVT_BUTTON, &TagEditor::OnClickApply, this, wxID_APPLY); Bind(wxEVT_BUTTON, &cTagEditor::OnClickApply, this, wxID_APPLY);
m_EditTagSizer->Add(m_TitleCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2); m_pEditTagSizer->Add(m_pTitleCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2);
m_EditTagSizer->Add(m_TitleText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pEditTagSizer->Add(m_pTitleText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_EditTagSizer->Add(m_ArtistCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2); m_pEditTagSizer->Add(m_pArtistCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2);
m_EditTagSizer->Add(m_ArtistText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pEditTagSizer->Add(m_pArtistText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_EditTagSizer->Add(m_AlbumCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2); m_pEditTagSizer->Add(m_pAlbumCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2);
m_EditTagSizer->Add(m_AlbumText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pEditTagSizer->Add(m_pAlbumText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_EditTagSizer->Add(m_GenreCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2); m_pEditTagSizer->Add(m_pGenreCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2);
m_EditTagSizer->Add(m_GenreText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pEditTagSizer->Add(m_pGenreText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_EditTagSizer->Add(m_CommentCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2); m_pEditTagSizer->Add(m_pCommentCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2);
m_EditTagSizer->Add(m_CommentText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pEditTagSizer->Add(m_pCommentText, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_SampleTypeSizer->Add(m_SampleTypeCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2); m_pSampleTypeSizer->Add(m_pSampleTypeCheck, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 2);
m_SampleTypeSizer->Add(m_SampleTypeChoice, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2); m_pSampleTypeSizer->Add(m_pSampleTypeChoice, 1, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 2);
m_SampleTypeSizer->Add(m_SampleTypeButton, 0, wxALL | wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL, 2); m_pSampleTypeSizer->Add(m_pSampleTypeButton, 0, wxALL | wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL, 2);
m_StaticEditTagSizer->Add(m_EditTagSizer, 1, wxALL | wxEXPAND, 2); m_pStaticEditTagSizer->Add(m_pEditTagSizer, 1, wxALL | wxEXPAND, 2);
m_StaticSampleTypeSizer->Add(m_SampleTypeSizer, 1, wxALL | wxEXPAND, 2); m_pStaticSampleTypeSizer->Add(m_pSampleTypeSizer, 1, wxALL | wxEXPAND, 2);
m_ButtonSizer->Add(m_OkButton, 0, wxALL | wxALIGN_BOTTOM, 2); m_pButtonSizer->Add(m_pOkButton, 0, wxALL | wxALIGN_BOTTOM, 2);
m_ButtonSizer->Add(m_ApplyButton, 0, wxALL | wxALIGN_BOTTOM, 2); m_pButtonSizer->Add(m_pApplyButton, 0, wxALL | wxALIGN_BOTTOM, 2);
m_ButtonSizer->Add(m_CancelButton, 0, wxALL | wxALIGN_BOTTOM, 2); m_pButtonSizer->Add(m_pCancelButton, 0, wxALL | wxALIGN_BOTTOM, 2);
m_MainSizer->Add(m_StaticEditTagSizer, 1, wxALL | wxEXPAND, 2); m_pMainSizer->Add(m_pStaticEditTagSizer, 1, wxALL | wxEXPAND, 2);
m_MainSizer->Add(m_StaticSampleTypeSizer, 1, wxALL | wxEXPAND, 2); m_pMainSizer->Add(m_pStaticSampleTypeSizer, 1, wxALL | wxEXPAND, 2);
m_MainSizer->Add(m_ButtonSizer, 0, wxALL | wxALIGN_RIGHT, 2); m_pMainSizer->Add(m_pButtonSizer, 0, wxALL | wxALIGN_RIGHT, 2);
// Top panel layout // Top panel layout
m_Panel->SetSizer(m_MainSizer); m_pPanel->SetSizer(m_pMainSizer);
m_MainSizer->Fit(m_Panel); m_pMainSizer->Fit(m_pPanel);
m_MainSizer->SetSizeHints(m_Panel); m_pMainSizer->SetSizeHints(m_pPanel);
m_MainSizer->Layout(); m_pMainSizer->Layout();
} }
void TagEditor::OnCheckTitle(wxCommandEvent &event) void cTagEditor::OnCheckTitle(wxCommandEvent &event)
{ {
if (m_TitleCheck->GetValue()) if (m_pTitleCheck->GetValue())
{ {
m_TitleText->Enable(); m_pTitleText->Enable();
} }
else else
{ {
m_TitleText->Disable(); m_pTitleText->Disable();
} }
} }
void TagEditor::OnCheckArtist(wxCommandEvent &event) void cTagEditor::OnCheckArtist(wxCommandEvent &event)
{ {
if (m_ArtistCheck->GetValue()) if (m_pArtistCheck->GetValue())
{ {
m_ArtistText->Enable(); m_pArtistText->Enable();
} }
else else
{ {
m_ArtistText->Disable(); m_pArtistText->Disable();
} }
} }
void TagEditor::OnCheckAlbum(wxCommandEvent &event) void cTagEditor::OnCheckAlbum(wxCommandEvent &event)
{ {
if (m_AlbumCheck->GetValue()) if (m_pAlbumCheck->GetValue())
{ {
m_AlbumText->Enable(); m_pAlbumText->Enable();
} }
else else
{ {
m_AlbumText->Disable(); m_pAlbumText->Disable();
} }
} }
void TagEditor::OnCheckGenre(wxCommandEvent &event) void cTagEditor::OnCheckGenre(wxCommandEvent &event)
{ {
if (m_GenreCheck->GetValue()) if (m_pGenreCheck->GetValue())
{ {
m_GenreText->Enable(); m_pGenreText->Enable();
} }
else else
{ {
m_GenreText->Disable(); m_pGenreText->Disable();
} }
} }
void TagEditor::OnCheckComments(wxCommandEvent &event) void cTagEditor::OnCheckComments(wxCommandEvent &event)
{ {
if (m_CommentCheck->GetValue()) if (m_pCommentCheck->GetValue())
{ {
m_CommentText->Enable(); m_pCommentText->Enable();
} }
else else
{ {
m_CommentText->Disable(); m_pCommentText->Disable();
} }
} }
void TagEditor::OnCheckType(wxCommandEvent &event) void cTagEditor::OnCheckType(wxCommandEvent &event)
{ {
if (m_SampleTypeCheck->GetValue()) if (m_pSampleTypeCheck->GetValue())
{ {
m_SampleTypeChoice->Enable(); m_pSampleTypeChoice->Enable();
m_SampleTypeButton->Enable(); m_pSampleTypeButton->Enable();
} }
else else
{ {
m_SampleTypeChoice->Disable(); m_pSampleTypeChoice->Disable();
m_SampleTypeButton->Disable(); m_pSampleTypeButton->Disable();
} }
} }
void TagEditor::OnClickCustomTagButton(wxCommandEvent& event) void cTagEditor::OnClickCustomTagButton(wxCommandEvent& event)
{ {
wxTextEntryDialog* customTag; wxTextEntryDialog* customTag;
customTag = new wxTextEntryDialog(this, "Enter a custom tag", customTag = new wxTextEntryDialog(this, "Enter a custom tag",
@ -216,8 +216,8 @@ void TagEditor::OnClickCustomTagButton(wxCommandEvent& event)
case wxID_OK: case wxID_OK:
{ {
wxString tag = customTag->GetValue(); wxString tag = customTag->GetValue();
m_SampleTypeChoice->AppendString(tag); m_pSampleTypeChoice->AppendString(tag);
m_SampleTypeChoice->SetStringSelection(tag); m_pSampleTypeChoice->SetStringSelection(tag);
break; break;
} }
case wxID_CANCEL: case wxID_CANCEL:
@ -227,16 +227,16 @@ void TagEditor::OnClickCustomTagButton(wxCommandEvent& event)
} }
} }
void TagEditor::OnClickApply(wxCommandEvent& event) void cTagEditor::OnClickApply(wxCommandEvent& event)
{ {
Database db; cDatabase db;
wxString title = m_TitleText->GetValue(); wxString title = m_pTitleText->GetValue();
wxString artist = m_ArtistText->GetValue(); wxString artist = m_pArtistText->GetValue();
wxString album = m_AlbumText->GetValue(); wxString album = m_pAlbumText->GetValue();
wxString genre = m_GenreText->GetValue(); wxString genre = m_pGenreText->GetValue();
wxString comment = m_CommentText->GetValue(); wxString comment = m_pCommentText->GetValue();
wxString type = m_SampleTypeChoice->GetStringSelection(); wxString type = m_pSampleTypeChoice->GetStringSelection();
std::string sampleType = db.GetSampleType(m_Filename); std::string sampleType = db.GetSampleType(m_Filename);
@ -255,7 +255,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
switch (msgDialog->ShowModal()) switch (msgDialog->ShowModal())
{ {
case wxID_YES: case wxID_YES:
if (m_TitleCheck->GetValue() && m_TitleText->GetValue() != tags.GetAudioInfo().title) if (m_pTitleCheck->GetValue() && m_pTitleText->GetValue() != tags.GetAudioInfo().title)
{ {
SH_LOG_INFO("Changing title tag.."); SH_LOG_INFO("Changing title tag..");
tags.SetTitle(title.ToStdString()); tags.SetTitle(title.ToStdString());
@ -263,7 +263,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
info_msg = wxString::Format("Successfully changed title tag to %s", title); info_msg = wxString::Format("Successfully changed title tag to %s", title);
} }
if (m_ArtistCheck->GetValue() && m_ArtistText->GetValue() != tags.GetAudioInfo().artist) if (m_pArtistCheck->GetValue() && m_pArtistText->GetValue() != tags.GetAudioInfo().artist)
{ {
SH_LOG_INFO("Changing artist tag.."); SH_LOG_INFO("Changing artist tag..");
tags.SetArtist(artist.ToStdString()); tags.SetArtist(artist.ToStdString());
@ -275,7 +275,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
info_msg = wxString::Format("Successfully changed artist tag to %s", artist); info_msg = wxString::Format("Successfully changed artist tag to %s", artist);
} }
if (m_AlbumCheck->GetValue() && m_AlbumText->GetValue() != tags.GetAudioInfo().album) if (m_pAlbumCheck->GetValue() && m_pAlbumText->GetValue() != tags.GetAudioInfo().album)
{ {
SH_LOG_INFO("Changing album tag.."); SH_LOG_INFO("Changing album tag..");
tags.SetAlbum(album.ToStdString()); tags.SetAlbum(album.ToStdString());
@ -283,7 +283,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
info_msg = wxString::Format("Successfully changed album tag to %s", album); info_msg = wxString::Format("Successfully changed album tag to %s", album);
} }
if (m_GenreCheck->GetValue() && m_GenreText->GetValue() != tags.GetAudioInfo().genre) if (m_pGenreCheck->GetValue() && m_pGenreText->GetValue() != tags.GetAudioInfo().genre)
{ {
SH_LOG_INFO("Changing genre tag.."); SH_LOG_INFO("Changing genre tag..");
tags.SetGenre(genre.ToStdString()); tags.SetGenre(genre.ToStdString());
@ -291,7 +291,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
info_msg = wxString::Format("Successfully changed genre tag to %s", genre); info_msg = wxString::Format("Successfully changed genre tag to %s", genre);
} }
if (m_CommentCheck->GetValue() && m_CommentText->GetValue() != tags.GetAudioInfo().comment) if (m_pCommentCheck->GetValue() && m_pCommentText->GetValue() != tags.GetAudioInfo().comment)
{ {
SH_LOG_INFO("Changing comment tag.."); SH_LOG_INFO("Changing comment tag..");
tags.SetComment(comment.ToStdString()); tags.SetComment(comment.ToStdString());
@ -299,7 +299,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
info_msg = wxString::Format("Successfully changed comment tag to %s", comment); info_msg = wxString::Format("Successfully changed comment tag to %s", comment);
} }
if (m_SampleTypeCheck->GetValue() && m_SampleTypeChoice->GetStringSelection() != sampleType) if (m_pSampleTypeCheck->GetValue() && m_pSampleTypeChoice->GetStringSelection() != sampleType)
{ {
SH_LOG_INFO("Changing type tag.."); SH_LOG_INFO("Changing type tag..");
db.UpdateSampleType(filename, type.ToStdString()); db.UpdateSampleType(filename, type.ToStdString());
@ -313,10 +313,10 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
info_msg = "Error, cannot change tag!"; info_msg = "Error, cannot change tag!";
} }
SampleHive::Signal::SendInfoBarMessage(info_msg, wxICON_INFORMATION, *this, true); SampleHive::cSignal::SendInfoBarMessage(info_msg, wxICON_INFORMATION, *this, true);
} }
// void TagEditor::SendInfoBarMessage(const wxString& msg, int mode) // void cTagEditor::SendInfoBarMessage(const wxString& msg, int mode)
// { // {
// SH_LOG_INFO("{} called..", __FUNCTION__); // SH_LOG_INFO("{} called..", __FUNCTION__);
@ -328,7 +328,7 @@ void TagEditor::OnClickApply(wxCommandEvent& event)
// GetParent()->GetEventHandler()->ProcessEvent(event); // GetParent()->GetEventHandler()->ProcessEvent(event);
// } // }
TagEditor::~TagEditor() cTagEditor::~cTagEditor()
{ {
} }

99
src/GUI/Dialogs/TagEditor.hpp
View File

@ -36,58 +36,11 @@
#include <wx/toplevel.h> #include <wx/toplevel.h>
#include <wx/window.h> #include <wx/window.h>
class TagEditor : public wxDialog class cTagEditor : public wxDialog
{ {
public: public:
TagEditor(wxWindow* window, const std::string& filename); cTagEditor(wxWindow* window, const std::string& filename);
~TagEditor(); ~cTagEditor();
private:
// -------------------------------------------------------------------
wxWindow* m_Window;
// -------------------------------------------------------------------
const std::string m_Filename;
private:
// -------------------------------------------------------------------
// Top panel for wxDialog
wxPanel* m_Panel;
// -------------------------------------------------------------------
// Top panel sizers
wxBoxSizer* m_MainSizer;
wxFlexGridSizer* m_EditTagSizer;
wxFlexGridSizer* m_SampleTypeSizer;
wxBoxSizer* m_ButtonSizer;
wxStaticBoxSizer* m_StaticEditTagSizer;
wxStaticBoxSizer* m_StaticSampleTypeSizer;
// -------------------------------------------------------------------
// Dialog controls
wxCheckBox* m_TitleCheck;
wxCheckBox* m_ArtistCheck;
wxCheckBox* m_AlbumCheck;
wxCheckBox* m_GenreCheck;
wxCheckBox* m_CommentCheck;
wxCheckBox* m_SampleTypeCheck;
wxTextCtrl* m_TitleText;
wxTextCtrl* m_ArtistText;
wxTextCtrl* m_AlbumText;
wxTextCtrl* m_GenreText;
wxTextCtrl* m_CommentText;
wxChoice* m_SampleTypeChoice;
wxButton* m_SampleTypeButton;
// -------------------------------------------------------------------
// Common buttons for wxDialog
wxButton* m_OkButton;
wxButton* m_ApplyButton;
wxButton* m_CancelButton;
private:
// -------------------------------------------------------------------
Tags tags;
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
@ -105,6 +58,50 @@ class TagEditor : public wxDialog
// ------------------------------------------------------------------- // -------------------------------------------------------------------
void OnClickApply(wxCommandEvent& event); void OnClickApply(wxCommandEvent& event);
private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// void SendInfoBarMessage(const wxString& msg, int mode); wxWindow* m_pWindow = nullptr;
// -------------------------------------------------------------------
const std::string& m_Filename;
private:
// -------------------------------------------------------------------
// Top panel for wxDialog
wxPanel* m_pPanel = nullptr;
// -------------------------------------------------------------------
// Top panel sizers
wxBoxSizer* m_pMainSizer = nullptr;
wxFlexGridSizer* m_pEditTagSizer = nullptr;
wxFlexGridSizer* m_pSampleTypeSizer = nullptr;
wxBoxSizer* m_pButtonSizer = nullptr;
wxStaticBoxSizer* m_pStaticEditTagSizer = nullptr;
wxStaticBoxSizer* m_pStaticSampleTypeSizer = nullptr;
// -------------------------------------------------------------------
// Dialog controls
wxCheckBox* m_pTitleCheck = nullptr;
wxCheckBox* m_pArtistCheck = nullptr;
wxCheckBox* m_pAlbumCheck = nullptr;
wxCheckBox* m_pGenreCheck = nullptr;
wxCheckBox* m_pCommentCheck = nullptr;
wxCheckBox* m_pSampleTypeCheck = nullptr;
wxTextCtrl* m_pTitleText = nullptr;
wxTextCtrl* m_pArtistText = nullptr;
wxTextCtrl* m_pAlbumText = nullptr;
wxTextCtrl* m_pGenreText = nullptr;
wxTextCtrl* m_pCommentText = nullptr;
wxChoice* m_pSampleTypeChoice = nullptr;
wxButton* m_pSampleTypeButton = nullptr;
// -------------------------------------------------------------------
// Common buttons for wxDialog
wxButton* m_pOkButton = nullptr;
wxButton* m_pApplyButton = nullptr;
wxButton* m_pCancelButton = nullptr;
private:
// -------------------------------------------------------------------
SampleHive::cTags tags;
}; };

52
src/GUI/DirectoryBrowser.cpp
View File

@ -1,20 +1,42 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/DirectoryBrowser.hpp" #include "GUI/DirectoryBrowser.hpp"
#include "Utility/Paths.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp"
#include "Utility/Utils.hpp"
#include <wx/dataobj.h> #include <wx/dataobj.h>
#include <wx/dnd.h> #include <wx/dnd.h>
cDirectoryBrowser::cDirectoryBrowser(wxWindow* window) cDirectoryBrowser::cDirectoryBrowser(wxWindow* window)
: wxGenericDirCtrl(window, BC_DirCtrl, wxDirDialogDefaultFolderStr, wxDefaultPosition, : wxGenericDirCtrl(window, SampleHive::ID::BC_DirCtrl, wxDirDialogDefaultFolderStr, wxDefaultPosition,
wxDefaultSize, wxDIRCTRL_SHOW_FILTERS, wxDefaultSize, wxDIRCTRL_SHOW_FILTERS,
_("All files|*|Ogg files (*.ogg)|*.ogg|Wav files (*.wav)|*.wav|" _("All files|*|Ogg files (*.ogg)|*.ogg|Wav files (*.wav)|*.wav|"
"Flac files (*.flac)|*.flac"), 0) "Flac files (*.flac)|*.flac"), 0),
m_pWindow(window)
{ {
SetPath(USER_HOME_DIR); SetPath(USER_HOME_DIR);
Bind(wxEVT_DIRCTRL_FILEACTIVATED, &cDirectoryBrowser::OnClickDirCtrl, this, BC_DirCtrl); Bind(wxEVT_DIRCTRL_FILEACTIVATED, &cDirectoryBrowser::OnClickDirCtrl, this, SampleHive::ID::BC_DirCtrl);
Bind(wxEVT_TREE_BEGIN_DRAG, &cDirectoryBrowser::OnDragFromDirCtrl, this, this->GetTreeCtrl()->GetId()); Bind(wxEVT_TREE_BEGIN_DRAG, &cDirectoryBrowser::OnDragFromDirCtrl, this, this->GetTreeCtrl()->GetId());
} }
@ -23,8 +45,24 @@ void cDirectoryBrowser::OnClickDirCtrl(wxCommandEvent& event)
wxArrayString path; wxArrayString path;
path.push_back(this->GetFilePath()); path.push_back(this->GetFilePath());
// TODO SampleHive::cUtils::Get().AddSamples(path, m_pWindow);
// AddSamples(path); }
// Temporary function to check drag and drop result
void LogDragResult(wxDragResult result)
{
wxString msg;
switch (result)
{
case wxDragError: msg = "Error!"; break;
case wxDragNone: msg = "Nothing"; break;
case wxDragCopy: msg = "Copied"; break;
case wxDragMove: msg = "Moved"; break;
case wxDragCancel: msg = "Cancelled"; break;
default: msg = "Huh?"; break;
}
SH_LOG_DEBUG("Drag result: {}", msg);
} }
void cDirectoryBrowser::OnDragFromDirCtrl(wxTreeEvent& event) void cDirectoryBrowser::OnDragFromDirCtrl(wxTreeEvent& event)
@ -35,7 +73,7 @@ void cDirectoryBrowser::OnDragFromDirCtrl(wxTreeEvent& event)
wxDropSource drop_source(this); wxDropSource drop_source(this);
drop_source.SetData(file_data); drop_source.SetData(file_data);
// LogDragResult(drop_source.DoDragDrop()); LogDragResult(drop_source.DoDragDrop());
} }
cDirectoryBrowser::~cDirectoryBrowser() cDirectoryBrowser::~cDirectoryBrowser()

23
src/GUI/DirectoryBrowser.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/control.h> #include <wx/control.h>
@ -15,4 +35,7 @@ class cDirectoryBrowser : public wxGenericDirCtrl
// DirCtrl event handlers // DirCtrl event handlers
void OnClickDirCtrl(wxCommandEvent& event); void OnClickDirCtrl(wxCommandEvent& event);
void OnDragFromDirCtrl(wxTreeEvent& event); void OnDragFromDirCtrl(wxTreeEvent& event);
private:
wxWindow* m_pWindow = nullptr;
}; };

264
src/GUI/Hives.cpp
View File

@ -1,11 +1,31 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/Hives.hpp" #include "GUI/Hives.hpp"
#include "GUI/ListCtrl.hpp"
#include "Database/Database.hpp" #include "Database/Database.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/HiveData.hpp"
#include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Signal.hpp" #include "Utility/Signal.hpp"
#include "Utility/Serialize.hpp" #include "Utility/Serialize.hpp"
#include "Utility/Log.hpp"
#include <deque> #include <deque>
@ -13,27 +33,26 @@
#include <wx/menu.h> #include <wx/menu.h>
#include <wx/msgdlg.h> #include <wx/msgdlg.h>
cHivesPanel::cHivesPanel(wxWindow* window, wxDataViewListCtrl& listCtrl) cHivesPanel::cHivesPanel(wxWindow* window)
: wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL), : wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL),
m_ListCtrl(listCtrl), m_pWindow(window) m_pWindow(window)
{ {
m_pMainSizer = new wxBoxSizer(wxVERTICAL); m_pMainSizer = new wxBoxSizer(wxVERTICAL);
m_pHivesSizer = new wxBoxSizer(wxVERTICAL); m_pHivesSizer = new wxBoxSizer(wxVERTICAL);
m_pButtonSizer = new wxBoxSizer(wxHORIZONTAL); m_pButtonSizer = new wxBoxSizer(wxHORIZONTAL);
m_pAddHiveButton = new wxButton(this, BC_HiveAdd, "+", wxDefaultPosition, wxDefaultSize, 0); m_pAddHiveButton = new wxButton(this, SampleHive::ID::BC_HiveAdd, "+", wxDefaultPosition, wxDefaultSize, 0);
m_pAddHiveButton->SetToolTip(_("Create new hive")); m_pAddHiveButton->SetToolTip(_("Create new hive"));
m_pButtonSizer->Add(m_pAddHiveButton, wxSizerFlags(1).Expand()); m_pButtonSizer->Add(m_pAddHiveButton, wxSizerFlags(1).Expand());
m_pRemoveHiveButton = new wxButton(this, BC_HiveRemove, "-", wxDefaultPosition, wxDefaultSize, 0); m_pRemoveHiveButton = new wxButton(this, SampleHive::ID::BC_HiveRemove, "-", wxDefaultPosition, wxDefaultSize, 0);
m_pRemoveHiveButton->SetToolTip(_("Delete selected hive")); m_pRemoveHiveButton->SetToolTip(_("Delete selected hive"));
m_pButtonSizer->Add(m_pRemoveHiveButton, wxSizerFlags(1).Expand()); m_pButtonSizer->Add(m_pRemoveHiveButton, wxSizerFlags(1).Expand());
// Initializing wxDataViewTreeCtrl as another page of wxNotebook // Initializing wxDataViewTreeCtrl as another page of wxNotebook
m_pHives = new wxDataViewTreeCtrl(this, BC_Hives, wxDefaultPosition, wxDefaultSize, m_pHives = new wxDataViewTreeCtrl(this, SampleHive::ID::BC_Hives, wxDefaultPosition, wxDefaultSize, wxDV_NO_HEADER | wxDV_SINGLE);
wxDV_NO_HEADER | wxDV_SINGLE);
m_pHivesSizer->Add(m_pHives, wxSizerFlags(1).Expand()); m_pHivesSizer->Add(m_pHives, wxSizerFlags(1).Expand());
@ -44,10 +63,10 @@ cHivesPanel::cHivesPanel(wxWindow* window, wxDataViewListCtrl& listCtrl)
m_pHives->DragAcceptFiles(true); m_pHives->DragAcceptFiles(true);
m_pHives->Connect(wxEVT_DROP_FILES, wxDropFilesEventHandler(cHivesPanel::OnDragAndDropToHives), NULL, this); m_pHives->Connect(wxEVT_DROP_FILES, wxDropFilesEventHandler(cHivesPanel::OnDragAndDropToHives), NULL, this);
Bind(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, &cHivesPanel::OnShowHivesContextMenu, this, BC_Hives); Bind(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, &cHivesPanel::OnShowHivesContextMenu, this, SampleHive::ID::BC_Hives);
Bind(wxEVT_DATAVIEW_ITEM_START_EDITING, &cHivesPanel::OnHiveStartEditing, this, BC_Hives); Bind(wxEVT_DATAVIEW_ITEM_START_EDITING, &cHivesPanel::OnHiveStartEditing, this, SampleHive::ID::BC_Hives);
Bind(wxEVT_BUTTON, &cHivesPanel::OnClickAddHive, this, BC_HiveAdd); Bind(wxEVT_BUTTON, &cHivesPanel::OnClickAddHive, this, SampleHive::ID::BC_HiveAdd);
Bind(wxEVT_BUTTON, &cHivesPanel::OnClickRemoveHive, this, BC_HiveRemove); Bind(wxEVT_BUTTON, &cHivesPanel::OnClickRemoveHive, this, SampleHive::ID::BC_HiveRemove);
m_pMainSizer->Add(m_pHivesSizer, wxSizerFlags(1).Expand()); m_pMainSizer->Add(m_pHivesSizer, wxSizerFlags(1).Expand());
m_pMainSizer->Add(m_pButtonSizer, wxSizerFlags(0).Expand()); m_pMainSizer->Add(m_pButtonSizer, wxSizerFlags(0).Expand());
@ -61,9 +80,8 @@ cHivesPanel::cHivesPanel(wxWindow* window, wxDataViewListCtrl& listCtrl)
void cHivesPanel::OnDragAndDropToHives(wxDropFilesEvent& event) void cHivesPanel::OnDragAndDropToHives(wxDropFilesEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
// cListCtrl m_ListCtrl.m_pWindow);
if (event.GetNumberOfFiles() > 0) if (event.GetNumberOfFiles() > 0)
{ {
@ -71,8 +89,7 @@ void cHivesPanel::OnDragAndDropToHives(wxDropFilesEvent& event)
wxArrayString files; wxArrayString files;
wxDataViewItemArray items; wxDataViewItemArray items;
int rows = m_ListCtrl.GetSelections(items); int rows = SampleHive::cHiveData::Get().GetListCtrlSelections(items);
// int rows = 2;
wxDataViewItem drop_target;; wxDataViewItem drop_target;;
wxDataViewColumn* column; wxDataViewColumn* column;
@ -86,9 +103,9 @@ void cHivesPanel::OnDragAndDropToHives(wxDropFilesEvent& event)
for (int i = 0; i < rows; i++) for (int i = 0; i < rows; i++)
{ {
int row = m_ListCtrl.ItemToRow(items[i]); int row = SampleHive::cHiveData::Get().GetListCtrlRowFromItem(items, i);
wxString name = m_ListCtrl.GetTextValue(row, 1); wxString name = SampleHive::cHiveData::Get().GetListCtrlTextValue(row, 1);
file_data.AddFile(name); file_data.AddFile(name);
@ -104,7 +121,7 @@ void cHivesPanel::OnDragAndDropToHives(wxDropFilesEvent& event)
{ {
m_pHives->AppendItem(drop_target, files[i]); m_pHives->AppendItem(drop_target, files[i]);
m_ListCtrl.SetValue(wxVariant(wxBitmap(ICON_STAR_FILLED_16px)), row, 0); SampleHive::cHiveData::Get().ListCtrlSetVariant(wxVariant(wxBitmap(ICON_STAR_FILLED_16px)), row, 0);
db.UpdateFavoriteColumn(file_name.ToStdString(), 1); db.UpdateFavoriteColumn(file_name.ToStdString(), 1);
db.UpdateHiveName(file_name.ToStdString(), hive_name.ToStdString()); db.UpdateHiveName(file_name.ToStdString(), hive_name.ToStdString());
@ -132,17 +149,15 @@ void cHivesPanel::OnDragAndDropToHives(wxDropFilesEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_ERROR, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_ERROR, *this);
// m_InfoBar->ShowMessage(msg, wxICON_ERROR);
} }
} }
} }
void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event) void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
// cListCtrl m_ListCtrl.m_pWindow);
wxDataViewItem selected_hive = event.GetItem(); wxDataViewItem selected_hive = event.GetItem();
@ -153,27 +168,26 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
if (m_pHives->IsContainer(selected_hive)) if (m_pHives->IsContainer(selected_hive))
{ {
// Container menu items // Container menu items
menu.Append(MN_RenameHive, _("Rename hive"), _("Rename selected hive")); menu.Append(SampleHive::ID::MN_RenameHive, _("Rename hive"), _("Rename selected hive"));
menu.Append(MN_DeleteHive, _("Delete hive"), _("Delete selected hive")); menu.Append(SampleHive::ID::MN_DeleteHive, _("Delete hive"), _("Delete selected hive"));
if (!m_bFiltered) if (!m_bFiltered)
menu.Append(MN_FilterLibrary, _("Filter library"), menu.Append(SampleHive::ID::MN_FilterLibrary, _("Filter library"), _("Show only samples from current hive in library"));
_("Show only samples from current hive in library"));
else else
menu.Append(MN_FilterLibrary, _("Clear filter"), _("Clear the filter")); menu.Append(SampleHive::ID::MN_FilterLibrary, _("Clear filter"), _("Clear the filter"));
} }
else else
{ {
// Child menu items // Child menu items
menu.Append(MN_RemoveSample, _("Remove sample"), _("Remove the selected sample(s)")); menu.Append(SampleHive::ID::MN_RemoveSample, _("Remove sample"), _("Remove the selected sample(s)"));
menu.Append(MN_ShowInLibrary, _("Show sample in library"), _("Show the selected in library")); menu.Append(SampleHive::ID::MN_ShowInLibrary, _("Show sample in library"), _("Show the selected in library"));
} }
if (selected_hive.IsOk() && m_pHives->IsContainer(selected_hive)) if (selected_hive.IsOk() && m_pHives->IsContainer(selected_hive))
{ {
switch (m_pHives->GetPopupMenuSelectionFromUser(menu, event.GetPosition())) switch (m_pHives->GetPopupMenuSelectionFromUser(menu, event.GetPosition()))
{ {
case MN_RenameHive: case SampleHive::ID::MN_RenameHive:
{ {
std::deque<wxDataViewItem> nodes; std::deque<wxDataViewItem> nodes;
nodes.push_back(m_pHives->GetNthChild(wxDataViewItem(wxNullPtr), 0)); nodes.push_back(m_pHives->GetNthChild(wxDataViewItem(wxNullPtr), 0));
@ -224,8 +238,7 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
if (found_item.IsOk()) if (found_item.IsOk())
{ {
wxMessageBox(wxString::Format(_("Another hive by the name %s already exist. " wxMessageBox(wxString::Format(_("Another hive by the name %s already exist. "
"Please try with a different name."), "Please try with a different name."), hive_name),
hive_name),
_("Error!"), wxOK | wxCENTRE, this); _("Error!"), wxOK | wxCENTRE, this);
} }
else else
@ -237,8 +250,7 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
if (sample_count <= 0) if (sample_count <= 0)
{ {
m_pHives->SetItemText(selected_hive, hive_name); m_pHives->SetItemText(selected_hive, hive_name);
db.UpdateHive(selected_hive_name.ToStdString(), db.UpdateHive(selected_hive_name.ToStdString(), hive_name.ToStdString());
hive_name.ToStdString());
} }
else else
{ {
@ -250,10 +262,8 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
m_pHives->GetItemText(sample_item).BeforeLast('.') : m_pHives->GetItemText(sample_item).BeforeLast('.') :
m_pHives->GetItemText(sample_item); m_pHives->GetItemText(sample_item);
db.UpdateHiveName(sample_name.ToStdString(), db.UpdateHiveName(sample_name.ToStdString(), hive_name.ToStdString());
hive_name.ToStdString()); db.UpdateHive(selected_hive_name.ToStdString(), hive_name.ToStdString());
db.UpdateHive(selected_hive_name.ToStdString(),
hive_name.ToStdString());
m_pHives->SetItemText(selected_hive, hive_name); m_pHives->SetItemText(selected_hive, hive_name);
} }
@ -270,28 +280,22 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_InfoBar->ShowMessage(msg, wxICON_INFORMATION);
} }
break; break;
case MN_DeleteHive: case SampleHive::ID::MN_DeleteHive:
{ {
wxString msg; wxString msg;
wxMessageDialog deleteEmptyHiveDialog(this, wxString::Format(_("Are you sure you want to " wxMessageDialog deleteEmptyHiveDialog(this, wxString::Format(_("Are you sure you want to delete %s from hives?"),
"delete %s from chives?"),
hive_name), hive_name),
wxMessageBoxCaptionStr, wxMessageBoxCaptionStr,
wxYES_NO | wxNO_DEFAULT | wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION | wxSTAY_ON_TOP);
wxICON_QUESTION | wxSTAY_ON_TOP);
wxMessageDialog deleteFilledHiveDialog(this, wxString::Format(_("Are you sure you want to " wxMessageDialog deleteFilledHiveDialog(this, wxString::Format(_("Are you sure you want to delete %s and all samples "
"delete %s and all samples " "inside %s from hives?"), hive_name, hive_name),
"inside %s from chives?"),
hive_name, hive_name),
wxMessageBoxCaptionStr, wxMessageBoxCaptionStr,
wxYES_NO | wxNO_DEFAULT | wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION | wxSTAY_ON_TOP);
wxICON_QUESTION | wxSTAY_ON_TOP);
if (hive_name == m_pHives->GetItemText(m_FavoritesHive)) if (hive_name == m_pHives->GetItemText(m_FavoritesHive))
{ {
@ -307,8 +311,7 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
} }
else if (selected_hive.IsOk() && !m_pHives->IsContainer(selected_hive)) else if (selected_hive.IsOk() && !m_pHives->IsContainer(selected_hive))
{ {
wxMessageBox(wxString::Format(_("Error! %s is not a hive, cannot delete from chives."), wxMessageBox(wxString::Format(_("Error! %s is not a hive, cannot delete from hives."), hive_name),
hive_name),
_("Error!"), wxOK | wxCENTRE, this); _("Error!"), wxOK | wxCENTRE, this);
return; return;
} }
@ -325,7 +328,7 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
db.RemoveHiveFromDatabase(hive_name.ToStdString()); db.RemoveHiveFromDatabase(hive_name.ToStdString());
msg = wxString::Format(_("%s deleted from chives successfully."), hive_name); msg = wxString::Format(_("%s deleted from hives successfully."), hive_name);
} }
break; break;
case wxID_NO: case wxID_NO:
@ -344,13 +347,11 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
{ {
wxDataViewItem child_item; wxDataViewItem child_item;
for (int i = 0; i < m_ListCtrl.GetItemCount(); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetListCtrlItemCount(); i++)
// for (int i = 0; i < 1; i++)
{ {
wxString matched_sample = wxString matched_sample = serializer.DeserializeShowFileExtension() ?
serializer.DeserializeShowFileExtension() ? SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1).BeforeLast('.') :
m_ListCtrl.GetTextValue(i, 1).BeforeLast('.') : SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1);
m_ListCtrl.GetTextValue(i, 1);
for (int j = 0; j < m_pHives->GetChildCount(selected_hive); j++) for (int j = 0; j < m_pHives->GetChildCount(selected_hive); j++)
{ {
@ -362,11 +363,11 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
m_pHives->GetItemText(child_item); m_pHives->GetItemText(child_item);
if (child_name == matched_sample) if (child_name == matched_sample)
// if (child_name == "")
{ {
SH_LOG_DEBUG("Found match"); SH_LOG_DEBUG("Found match");
m_ListCtrl.SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), i, 0); SampleHive::cHiveData::Get().ListCtrlSetVariant(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)),
i, 0);
db.UpdateFavoriteColumn(matched_sample.ToStdString(), 0); db.UpdateFavoriteColumn(matched_sample.ToStdString(), 0);
db.UpdateHiveName(matched_sample.ToStdString(), db.UpdateHiveName(matched_sample.ToStdString(),
@ -384,8 +385,7 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
db.RemoveHiveFromDatabase(hive_name.ToStdString()); db.RemoveHiveFromDatabase(hive_name.ToStdString());
msg = wxString::Format(_("%s and all samples inside %s " msg = wxString::Format(_("%s and all samples inside %s have been deleted from hives successfully."),
"have been deleted from chives successfully."),
hive_name, hive_name); hive_name, hive_name);
} }
break; break;
@ -397,11 +397,10 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_InfoBar->ShowMessage(msg, wxICON_INFORMATION);
} }
break; break;
case MN_FilterLibrary: case SampleHive::ID::MN_FilterLibrary:
{ {
if (!m_bFiltered) if (!m_bFiltered)
{ {
@ -420,18 +419,18 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
} }
else else
{ {
m_ListCtrl.DeleteAllItems(); SampleHive::cHiveData::Get().ListCtrlDeleteAllItems();
for (auto data : dataset) for (auto data : dataset)
{ {
m_ListCtrl.AppendItem(data); SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
} }
} }
} }
catch (...) catch (std::exception& e)
{ {
wxMessageBox(_("Error loading data, cannot filter sample view"), _("Error!"), wxMessageBox(wxString::Format(_("Error loading data, cannot filter sample view. Error: %s"), e.what()),
wxOK | wxICON_ERROR | wxCENTRE, this); _("Error!"), wxOK | wxICON_ERROR | wxCENTRE, this);
} }
m_bFiltered = true; m_bFiltered = true;
@ -445,23 +444,22 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
if (dataset.empty()) if (dataset.empty())
{ {
wxMessageBox(_("Error! Database is empty."), _("Error!"), wxMessageBox(_("Error! Database is empty."), _("Error!"), wxOK | wxICON_ERROR | wxCENTRE, this);
wxOK | wxICON_ERROR | wxCENTRE, this);
} }
else else
{ {
m_ListCtrl.DeleteAllItems(); SampleHive::cHiveData::Get().ListCtrlDeleteAllItems();
for (auto data : dataset) for (auto data : dataset)
{ {
m_ListCtrl.AppendItem(data); SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
} }
} }
} }
catch (...) catch (std::exception& e)
{ {
wxMessageBox(_("Error loading data, cannot filter sample view"), _("Error!"), wxMessageBox(wxString::Format(_("Error loading data, cannot filter sample view. Error: %s"), e.what()),
wxOK | wxICON_ERROR | wxCENTRE, this); _("Error!"), wxOK | wxICON_ERROR | wxCENTRE, this);
} }
m_bFiltered = false; m_bFiltered = false;
@ -476,68 +474,57 @@ void cHivesPanel::OnShowHivesContextMenu(wxDataViewEvent& event)
{ {
switch (m_pHives->GetPopupMenuSelectionFromUser(menu, event.GetPosition())) switch (m_pHives->GetPopupMenuSelectionFromUser(menu, event.GetPosition()))
{ {
case MN_RemoveSample: case SampleHive::ID::MN_RemoveSample:
for(int i = 0; i < m_ListCtrl.GetItemCount(); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetListCtrlItemCount(); i++)
// for(int i = 0; i < 1; i++)
{ {
wxString matched_sample = serializer.DeserializeShowFileExtension() ? wxString matched_sample = serializer.DeserializeShowFileExtension() ?
m_ListCtrl.GetTextValue(i, 1).BeforeLast('.') : SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1).BeforeLast('.') :
m_ListCtrl.GetTextValue(i, 1); SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1);
wxString selected_sample_name = serializer.DeserializeShowFileExtension() ? wxString selected_sample_name = serializer.DeserializeShowFileExtension() ?
m_pHives->GetItemText(event.GetItem()).BeforeLast('.') : m_pHives->GetItemText(event.GetItem()).BeforeLast('.') :
m_pHives->GetItemText(event.GetItem()); m_pHives->GetItemText(event.GetItem());
if (selected_sample_name == matched_sample) if (selected_sample_name == matched_sample)
// if(selected_sample_name == "")
{ {
SH_LOG_DEBUG("Found match"); SH_LOG_DEBUG("Found match");
m_ListCtrl.SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), i, 0); SampleHive::cHiveData::Get().ListCtrlSetVariant(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), i, 0);
db.UpdateFavoriteColumn(matched_sample.ToStdString(), 0); db.UpdateFavoriteColumn(matched_sample.ToStdString(), 0);
db.UpdateHiveName(matched_sample.ToStdString(), db.UpdateHiveName(matched_sample.ToStdString(), m_pHives->GetItemText(m_FavoritesHive).ToStdString());
m_pHives->GetItemText(m_FavoritesHive).ToStdString());
m_pHives->DeleteItem(selected_hive); m_pHives->DeleteItem(selected_hive);
break; break;
} }
wxString msg = wxString::Format(_("Removed %s from %s"), wxString msg = wxString::Format(_("Removed %s from %s"), m_pHives->GetItemText(event.GetItem()),
m_pHives->GetItemText(event.GetItem()),
db.GetHiveByFilename(matched_sample.ToStdString())); db.GetHiveByFilename(matched_sample.ToStdString()));
// m_InfoBar->ShowMessage(wxString::Format(_("Removed %s from %s"), SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_Hives->GetItemText(event.GetItem()),
// db.GetHiveByFilename(matched_sample.ToStdString())),
// wxICON_INFORMATION);
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
} }
break; break;
case MN_ShowInLibrary: case SampleHive::ID::MN_ShowInLibrary:
for(int i = 0; i < m_ListCtrl.GetItemCount(); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetListCtrlItemCount(); i++)
// for(int i = 0; i < 1; i++)
{ {
wxString matched_sample = serializer.DeserializeShowFileExtension() ? wxString matched_sample = serializer.DeserializeShowFileExtension() ?
m_ListCtrl.GetTextValue(i, 1).BeforeLast('.') : SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1).BeforeLast('.') :
m_ListCtrl.GetTextValue(i, 1); SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1);
wxString selected_sample_name = serializer.DeserializeShowFileExtension() ? wxString selected_sample_name = serializer.DeserializeShowFileExtension() ?
m_pHives->GetItemText(event.GetItem()).BeforeLast('.') : m_pHives->GetItemText(event.GetItem()).BeforeLast('.') :
m_pHives->GetItemText(event.GetItem()); m_pHives->GetItemText(event.GetItem());
if (selected_sample_name == matched_sample) if (selected_sample_name == matched_sample)
// if(selected_sample_name == "")
{ {
SH_LOG_DEBUG("Found match"); SH_LOG_DEBUG("Found match");
wxDataViewItem matched_item = m_ListCtrl.RowToItem(i); wxDataViewItem matched_item = SampleHive::cHiveData::Get().GetListCtrlItemFromRow(i);
m_ListCtrl.UnselectAll(); SampleHive::cHiveData::Get().ListCtrlUnselectAllItems();
m_ListCtrl.SelectRow(i); SampleHive::cHiveData::Get().ListCtrlSelectRow(i);
m_ListCtrl.EnsureVisible(matched_item); SampleHive::cHiveData::Get().ListCtrlEnsureVisible(matched_item);
break; break;
} }
@ -557,7 +544,7 @@ void cHivesPanel::OnHiveStartEditing(wxDataViewEvent &event)
void cHivesPanel::OnClickAddHive(wxCommandEvent& event) void cHivesPanel::OnClickAddHive(wxCommandEvent& event)
{ {
Database db; cDatabase db;
std::deque<wxDataViewItem> nodes; std::deque<wxDataViewItem> nodes;
nodes.push_back(m_pHives->GetNthChild(wxDataViewItem(wxNullPtr), 0)); nodes.push_back(m_pHives->GetNthChild(wxDataViewItem(wxNullPtr), 0));
@ -607,17 +594,15 @@ void cHivesPanel::OnClickAddHive(wxCommandEvent& event)
if (found_item.IsOk()) if (found_item.IsOk())
{ {
wxMessageBox(wxString::Format(_("Another hive by the name %s already exist. " wxMessageBox(wxString::Format(_("Another hive by the name %s already exist. Please try with a different name."),
"Please try with a different name."), hive_name), _("Error!"), wxOK | wxCENTRE, this);
hive_name),
_("Error!"), wxOK | wxCENTRE, this);
} }
else else
{ {
m_pHives->AppendContainer(wxDataViewItem(wxNullPtr), hive_name); m_pHives->AppendContainer(wxDataViewItem(wxNullPtr), hive_name);
db.InsertIntoHives(hive_name.ToStdString()); db.InsertIntoHives(hive_name.ToStdString());
msg = wxString::Format(_("%s added to cHivesPanel."), hive_name); msg = wxString::Format(_("%s added to Hives."), hive_name);
} }
break; break;
} }
@ -628,39 +613,29 @@ void cHivesPanel::OnClickAddHive(wxCommandEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_InfoBar->ShowMessage(msg, wxICON_INFORMATION);
} }
void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event) void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
// cListCtrl m_ListCtrl.m_pWindow);
wxDataViewItem selected_item = m_pHives->GetSelection(); wxDataViewItem selected_item = m_pHives->GetSelection();
wxString hive_name = m_pHives->GetItemText(selected_item); wxString hive_name = m_pHives->GetItemText(selected_item);
wxString msg; wxString msg;
wxMessageDialog deleteEmptyHiveDialog(this, wxString::Format(_("Are you sure you want to delete " wxMessageDialog deleteEmptyHiveDialog(this, wxString::Format(_("Are you sure you want to delete %s from hives?"), hive_name),
"%s from chives?"), wxMessageBoxCaptionStr, wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION | wxSTAY_ON_TOP);
hive_name),
wxMessageBoxCaptionStr,
wxYES_NO | wxNO_DEFAULT |
wxICON_QUESTION | wxSTAY_ON_TOP);
wxMessageDialog deleteFilledHiveDialog(this, wxString::Format(_("Are you sure you want to delete " wxMessageDialog deleteFilledHiveDialog(this, wxString::Format(_("Are you sure you want to delete "
"%s and all sample inside %s from chives?"), "%s and all sample inside %s from hives?"), hive_name, hive_name),
hive_name, hive_name), wxMessageBoxCaptionStr, wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION | wxSTAY_ON_TOP);
wxMessageBoxCaptionStr,
wxYES_NO | wxNO_DEFAULT |
wxICON_QUESTION | wxSTAY_ON_TOP);
if (hive_name == m_pHives->GetItemText(m_FavoritesHive)) if (hive_name == m_pHives->GetItemText(m_FavoritesHive))
{ {
wxMessageBox(wxString::Format(_("Error! Default hive %s cannot be deleted."), hive_name), wxMessageBox(wxString::Format(_("Error! Default hive %s cannot be deleted."), hive_name), _("Error!"), wxOK | wxCENTRE, this);
_("Error!"), wxOK | wxCENTRE, this);
return; return;
} }
else if (!selected_item.IsOk()) else if (!selected_item.IsOk())
@ -670,7 +645,7 @@ void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
} }
else if (selected_item.IsOk() && !m_pHives->IsContainer(selected_item)) else if (selected_item.IsOk() && !m_pHives->IsContainer(selected_item))
{ {
wxMessageBox(wxString::Format(_("Error! %s is not a hive, cannot delete from chives."), hive_name), wxMessageBox(wxString::Format(_("Error! %s is not a hive, cannot delete from hives."), hive_name),
_("Error!"), wxOK | wxCENTRE, this); _("Error!"), wxOK | wxCENTRE, this);
return; return;
} }
@ -686,7 +661,7 @@ void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
m_pHives->DeleteItem(selected_item); m_pHives->DeleteItem(selected_item);
db.RemoveHiveFromDatabase(hive_name.ToStdString()); db.RemoveHiveFromDatabase(hive_name.ToStdString());
msg = wxString::Format(_("%s deleted from chives successfully."), hive_name); msg = wxString::Format(_("%s deleted from hives successfully."), hive_name);
} }
break; break;
case wxID_NO: case wxID_NO:
@ -705,12 +680,11 @@ void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
{ {
wxDataViewItem child_item; wxDataViewItem child_item;
for (int i = 0; i < m_ListCtrl.GetItemCount(); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetListCtrlItemCount(); i++)
// for (int i = 0; i < 1; i++)
{ {
wxString matched_sample = serializer.DeserializeShowFileExtension() ? wxString matched_sample = serializer.DeserializeShowFileExtension() ?
m_ListCtrl.GetTextValue(i, 1).BeforeLast('.') : SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1).BeforeLast('.') :
m_ListCtrl.GetTextValue(i, 1); SampleHive::cHiveData::Get().GetListCtrlTextValue(i, 1);
for (int j = 0; j < m_pHives->GetChildCount(selected_item); j++) for (int j = 0; j < m_pHives->GetChildCount(selected_item); j++)
{ {
@ -721,15 +695,13 @@ void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
m_pHives->GetItemText(child_item); m_pHives->GetItemText(child_item);
if (child_name == matched_sample) if (child_name == matched_sample)
// if (child_name == "")
{ {
SH_LOG_DEBUG("Found match"); SH_LOG_DEBUG("Found match");
m_ListCtrl.SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), i, 0); SampleHive::cHiveData::Get().ListCtrlSetVariant(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), i, 0);
db.UpdateFavoriteColumn(matched_sample.ToStdString(), 0); db.UpdateFavoriteColumn(matched_sample.ToStdString(), 0);
db.UpdateHiveName(matched_sample.ToStdString(), db.UpdateHiveName(matched_sample.ToStdString(), m_pHives->GetItemText(m_FavoritesHive).ToStdString());
m_pHives->GetItemText(m_FavoritesHive).ToStdString());
break; break;
} }
@ -743,8 +715,7 @@ void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
db.RemoveHiveFromDatabase(hive_name.ToStdString()); db.RemoveHiveFromDatabase(hive_name.ToStdString());
msg = wxString::Format(_("%s and all samples inside %s have been deleted " msg = wxString::Format(_("%s and all samples inside %s have been deleted from hives successfully."),
"from chives successfully."),
hive_name, hive_name); hive_name, hive_name);
} }
break; break;
@ -756,8 +727,7 @@ void cHivesPanel::OnClickRemoveHive(wxCommandEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_InfoBar->ShowMessage(msg, wxICON_INFORMATION);
} }
cHivesPanel::~cHivesPanel() cHivesPanel::~cHivesPanel()

31
src/GUI/Hives.hpp
View File

@ -1,6 +1,24 @@
#pragma once /* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/ListCtrl.hpp" #pragma once
#include <wx/button.h> #include <wx/button.h>
#include <wx/dataview.h> #include <wx/dataview.h>
@ -12,13 +30,13 @@ class cHivesPanel : public wxPanel
{ {
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
cHivesPanel(wxWindow* window, wxDataViewListCtrl& listCtrl); cHivesPanel(wxWindow* window);
~cHivesPanel(); ~cHivesPanel();
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
wxDataViewTreeCtrl* GetHivesObject() { return m_pHives; } wxDataViewTreeCtrl* GetHivesObject() { return m_pHives; }
wxDataViewItem GetFavoritesHive() { return m_FavoritesHive; } wxDataViewItem& GetFavoritesHive() { return m_FavoritesHive; }
bool IsLibraryFiltered() { return m_bFiltered; } bool IsLibraryFiltered() { return m_bFiltered; }
@ -48,9 +66,4 @@ class cHivesPanel : public wxPanel
// ------------------------------------------------------------------- // -------------------------------------------------------------------
wxWindow* m_pWindow = nullptr; wxWindow* m_pWindow = nullptr;
wxDataViewListCtrl& m_ListCtrl;
// -------------------------------------------------------------------
// friend class cListCtrl;
}; };

20
src/GUI/InfoBar.cpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "InfoBar.hpp" #include "InfoBar.hpp"
cInfoBar::cInfoBar(wxWindow* window) cInfoBar::cInfoBar(wxWindow* window)

20
src/GUI/InfoBar.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/infobar.h> #include <wx/infobar.h>

30
src/GUI/Library.cpp
View File

@ -1,16 +1,34 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/Library.hpp" #include "GUI/Library.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
cLibrary::cLibrary(wxWindow* window, wxDataViewItem favHive, wxDataViewTreeCtrl& hives, cLibrary::cLibrary(wxWindow* window)
wxTreeItemId trashRoot, wxTreeCtrl& trash) : wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
: wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL),
m_FavoritesHive(favHive), m_pHives(hives), m_pTrash(trash), m_TrashRoot(trashRoot)
{ {
m_pSizer = new wxBoxSizer(wxVERTICAL); m_pSizer = new wxBoxSizer(wxVERTICAL);
m_pSearchBar = new cSearchBar(this, *m_pListCtrl); m_pSearchBar = new cSearchBar(this);
m_pInfoBar = new cInfoBar(this); m_pInfoBar = new cInfoBar(this);
m_pListCtrl = new cListCtrl(this, m_FavoritesHive, hives, trashRoot, trash); m_pListCtrl = new cListCtrl(this);
m_pSizer->Add(m_pSearchBar, wxSizerFlags(1).Expand()); m_pSizer->Add(m_pSearchBar, wxSizerFlags(1).Expand());
m_pSizer->Add(m_pInfoBar, wxSizerFlags(0).Expand()); m_pSizer->Add(m_pInfoBar, wxSizerFlags(0).Expand());

33
src/GUI/Library.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include "GUI/InfoBar.hpp" #include "GUI/InfoBar.hpp"
@ -13,8 +33,7 @@
class cLibrary : public wxPanel class cLibrary : public wxPanel
{ {
public: public:
cLibrary(wxWindow* window, wxDataViewItem favHive, wxDataViewTreeCtrl& hives, cLibrary(wxWindow* window);
wxTreeItemId trashRoot, wxTreeCtrl& trash);
~cLibrary(); ~cLibrary();
public: public:
@ -22,19 +41,9 @@ class cLibrary : public wxPanel
wxInfoBar* GetInfoBarObject() const { return m_pInfoBar; } wxInfoBar* GetInfoBarObject() const { return m_pInfoBar; }
wxDataViewListCtrl* GetListCtrlObject() const { return m_pListCtrl; } wxDataViewListCtrl* GetListCtrlObject() const { return m_pListCtrl; }
// void SetHivesObject(wxDataViewTreeCtrl& hives) { m_pHives = &hives;}
// void SetFavoritesHive(wxDataViewItem favHive) { m_FavoritesHive = favHive;}
// void SetTrashObject(wxTreeCtrl& trash) { m_pTrash = &trash;}
// void SetTrashRoot(wxTreeItemId trashRoot) { m_TrashRoot = trashRoot;}
private: private:
cSearchBar* m_pSearchBar = nullptr; cSearchBar* m_pSearchBar = nullptr;
cInfoBar* m_pInfoBar = nullptr; cInfoBar* m_pInfoBar = nullptr;
cListCtrl* m_pListCtrl = nullptr; cListCtrl* m_pListCtrl = nullptr;
wxBoxSizer* m_pSizer = nullptr; wxBoxSizer* m_pSizer = nullptr;
wxDataViewItem m_FavoritesHive;
wxDataViewTreeCtrl& m_pHives;
wxTreeCtrl& m_pTrash;
wxTreeItemId m_TrashRoot;
}; };

499
src/GUI/ListCtrl.cpp
View File

@ -1,29 +1,44 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/ListCtrl.hpp" #include "GUI/ListCtrl.hpp"
// #include "GUI/Hives.hpp"
// #include "GUI/Trash.hpp"
#include "GUI/Dialogs/TagEditor.hpp" #include "GUI/Dialogs/TagEditor.hpp"
#include "Database/Database.hpp" #include "Database/Database.hpp"
#include "GUI/Hives.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/SH_Event.hpp" #include "Utility/HiveData.hpp"
#include "Utility/Signal.hpp"
#include "Utility/Serialize.hpp" #include "Utility/Serialize.hpp"
#include "Utility/Event.hpp"
#include "Utility/Signal.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Utils.hpp"
#include <wx/dir.h> #include <wx/dir.h>
#include <wx/menu.h> #include <wx/menu.h>
#include "wx/log.h"
#include <wx/progdlg.h> #include <wx/progdlg.h>
#include <wx/msgdlg.h> #include <wx/msgdlg.h>
// cListCtrl::cListCtrl(wxWindow* window) cListCtrl::cListCtrl(wxWindow* window)
cListCtrl::cListCtrl(wxWindow* window, wxDataViewItem favHive, wxDataViewTreeCtrl& hives, : wxDataViewListCtrl(window, SampleHive::ID::BC_Library, wxDefaultPosition, wxDefaultSize,
wxTreeItemId trashRoot, wxTreeCtrl& trash)
: wxDataViewListCtrl(window, BC_Library, wxDefaultPosition, wxDefaultSize,
wxDV_MULTIPLE | wxDV_HORIZ_RULES | wxDV_VERT_RULES | wxDV_ROW_LINES), wxDV_MULTIPLE | wxDV_HORIZ_RULES | wxDV_VERT_RULES | wxDV_ROW_LINES),
// m_pWindow(window) m_pWindow(window)
m_pWindow(window), m_Hives(hives), m_FavoritesHive(favHive), m_TrashRoot(trashRoot), m_Trash(trash)
{ {
// Adding columns to wxDataViewListCtrl. // Adding columns to wxDataViewListCtrl.
AppendBitmapColumn(wxBitmap(ICON_STAR_FILLED_16px), AppendBitmapColumn(wxBitmap(ICON_STAR_FILLED_16px),
@ -95,20 +110,16 @@ cListCtrl::cListCtrl(wxWindow* window, wxDataViewItem favHive, wxDataViewTreeCtr
// Enable dragging a file from cListCtrl // Enable dragging a file from cListCtrl
this->EnableDragSource(wxDF_FILENAME); this->EnableDragSource(wxDF_FILENAME);
Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, &cListCtrl::OnClickLibrary, this, BC_Library); Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, &cListCtrl::OnClickLibrary, this, SampleHive::ID::BC_Library);
Bind(wxEVT_DATAVIEW_ITEM_BEGIN_DRAG, &cListCtrl::OnDragFromLibrary, this); Bind(wxEVT_DATAVIEW_ITEM_BEGIN_DRAG, &cListCtrl::OnDragFromLibrary, this);
this->Connect(wxEVT_DROP_FILES, wxDropFilesEventHandler(cListCtrl::OnDragAndDropToLibrary), NULL, this); this->Connect(wxEVT_DROP_FILES, wxDropFilesEventHandler(cListCtrl::OnDragAndDropToLibrary), NULL, this);
Bind(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, &cListCtrl::OnShowLibraryContextMenu, this, BC_Library); Bind(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, &cListCtrl::OnShowLibraryContextMenu, this, SampleHive::ID::BC_Library);
Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, &cListCtrl::OnShowLibraryColumnHeaderContextMenu, this, SampleHive::ID::BC_Library);
&cListCtrl::OnShowLibraryColumnHeaderContextMenu, this, BC_Library);
LoadDatabase();
} }
void cListCtrl::OnClickLibrary(wxDataViewEvent& event) void cListCtrl::OnClickLibrary(wxDataViewEvent& event)
{ {
// cHivesPanel hives(m_pWindow); cDatabase db;
Database db;
int selected_row = this->ItemToRow(event.GetItem()); int selected_row = this->ItemToRow(event.GetItem());
int current_row = this->ItemToRow(this->GetCurrentItem()); int current_row = this->ItemToRow(this->GetCurrentItem());
@ -123,19 +134,13 @@ void cListCtrl::OnClickLibrary(wxDataViewEvent& event)
} }
// Update the waveform bitmap // Update the waveform bitmap
SampleHive::Signal::SendWaveformUpdateStatus(*this); SampleHive::cSignal::SendWaveformUpdateStatus(*this);
// m_TopWaveformPanel->ResetDC();
// TODO // Update LoopAB button value
// SampleHive::Signal::SendSetLoopABButton(*this); SampleHive::cSignal::SendLoopABButtonValueChange(*this);
// m_LoopABButton->SetValue(false);
SampleHive::Signal::SendTimerStopStatus(*this); // Stop the timer
// if (m_Timer->IsRunning()) SampleHive::cSignal::SendTimerStopStatus(*this);
// {
// m_Timer->Stop();
// SH_LOG_DEBUG("TIMER STOPPED");
// }
wxString selection = this->GetTextValue(selected_row, 1); wxString selection = this->GetTextValue(selected_row, 1);
@ -148,40 +153,30 @@ void cListCtrl::OnClickLibrary(wxDataViewEvent& event)
if (!CurrentColumn) if (!CurrentColumn)
return; return;
wxString sample_path = GetFilenamePathAndExtension(selection).Path; wxString sample_path = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Path;
std::string filename = GetFilenamePathAndExtension(selection).Filename; std::string filename = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Filename;
std::string extension = GetFilenamePathAndExtension(selection).Extension; std::string extension = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Extension;
if (CurrentColumn != FavoriteColumn) if (CurrentColumn != FavoriteColumn)
{ {
SampleHive::Signal::SendCallFunctionPlay(selection, *this);
// TODO
// ClearLoopPoints(); // ClearLoopPoints();
SampleHive::cSignal::SendClearLoopPointsStatus(*this);
// if (bAutoplay) // Play the sample
// { SampleHive::cSignal::SendCallFunctionPlay(selection, true, *this);
// if (bLoopPointsSet && m_LoopABButton->GetValue())
// PlaySample(sample_path.ToStdString(), selection.ToStdString(),
// true, m_LoopA.ToDouble(), wxFromStart);
// else
// PlaySample(sample_path.ToStdString(), selection.ToStdString());
// }
// else
// m_MediaCtrl->Stop();
} }
else else
{ {
wxString msg; wxString msg;
// Get hive name and location // Get hive name and location
std::string hive_name = m_Hives.GetItemText(m_FavoritesHive).ToStdString(); std::string hive_name = SampleHive::cHiveData::Get().GetHiveItemText(true).ToStdString();
wxDataViewItem hive_selection = m_Hives.GetSelection(); wxDataViewItem hive_selection = SampleHive::cHiveData::Get().GetHiveItemSelection();
SH_LOG_DEBUG("HIVE NAME: {}", hive_name); SH_LOG_DEBUG("HIVE NAME: {}", hive_name);
if (hive_selection.IsOk() && m_Hives.IsContainer(hive_selection)) if (hive_selection.IsOk() && SampleHive::cHiveData::Get().IsHiveItemContainer(hive_selection))
hive_name = m_Hives.GetItemText(hive_selection).ToStdString(); hive_name = SampleHive::cHiveData::Get().GetHiveItemText(false, hive_selection);
wxString name = this->GetTextValue(selected_row, 1); wxString name = this->GetTextValue(selected_row, 1);
@ -192,20 +187,18 @@ void cListCtrl::OnClickLibrary(wxDataViewEvent& event)
if (db.GetFavoriteColumnValueByFilename(filename) == 0) if (db.GetFavoriteColumnValueByFilename(filename) == 0)
{ {
SH_LOG_DEBUG("TRUE COND....");
this->SetValue(wxVariant(wxBitmap(ICON_STAR_FILLED_16px)), selected_row, 0); this->SetValue(wxVariant(wxBitmap(ICON_STAR_FILLED_16px)), selected_row, 0);
db.UpdateFavoriteColumn(filename, 1); db.UpdateFavoriteColumn(filename, 1);
db.UpdateHiveName(filename, hive_name); db.UpdateHiveName(filename, hive_name);
for (int i = 0; i < m_Hives.GetChildCount(root); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetHiveChildCount(root); i++)
{ {
container = m_Hives.GetNthChild(root, i); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, i);
if (m_Hives.GetItemText(container).ToStdString() == hive_name) if (SampleHive::cHiveData::Get().GetHiveItemText(false, container) == hive_name)
{ {
m_Hives.AppendItem(container, name); SampleHive::cHiveData::Get().HiveAppendItem(container, name);
break; break;
} }
} }
@ -217,19 +210,19 @@ void cListCtrl::OnClickLibrary(wxDataViewEvent& event)
this->SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), selected_row, 0); this->SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), selected_row, 0);
db.UpdateFavoriteColumn(filename, 0); db.UpdateFavoriteColumn(filename, 0);
db.UpdateHiveName(filename, m_Hives.GetItemText(m_FavoritesHive).ToStdString()); db.UpdateHiveName(filename, SampleHive::cHiveData::Get().GetHiveItemText(true).ToStdString());
for (int i = 0; i < m_Hives.GetChildCount(root); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetHiveChildCount(root); i++)
{ {
container = m_Hives.GetNthChild(root, i); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, i);
for (int j = 0; j < m_Hives.GetChildCount(container); j++) for (int j = 0; j < SampleHive::cHiveData::Get().GetHiveChildCount(container); j++)
{ {
child = m_Hives.GetNthChild(container, j); child = SampleHive::cHiveData::Get().GetHiveNthChild(container, j);
if (m_Hives.GetItemText(child) == name) if (SampleHive::cHiveData::Get().GetHiveItemText(false, child) == name)
{ {
m_Hives.DeleteItem(child); SampleHive::cHiveData::Get().HiveDeleteItem(child);
break; break;
} }
} }
@ -239,8 +232,7 @@ void cListCtrl::OnClickLibrary(wxDataViewEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_InfoBar->ShowMessage(msg, wxICON_INFORMATION);
} }
} }
@ -288,7 +280,7 @@ void cListCtrl::OnDragAndDropToLibrary(wxDropFilesEvent& event)
progressDialog->Destroy(); progressDialog->Destroy();
AddSamples(filepath_array); SampleHive::cUtils::Get().AddSamples(filepath_array, m_pWindow);
SH_LOG_DEBUG("Done Inserting Samples"); SH_LOG_DEBUG("Done Inserting Samples");
} }
@ -303,7 +295,7 @@ void cListCtrl::OnDragFromLibrary(wxDataViewEvent& event)
wxString selection = this->GetTextValue(selected_row, 1); wxString selection = this->GetTextValue(selected_row, 1);
wxString sample_path = GetFilenamePathAndExtension(selection).Path; wxString sample_path = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Path;
wxFileDataObject* fileData = new wxFileDataObject(); wxFileDataObject* fileData = new wxFileDataObject();
@ -315,10 +307,9 @@ void cListCtrl::OnDragFromLibrary(wxDataViewEvent& event)
void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event) void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
{ {
TagEditor* tagEditor; cTagEditor* tagEditor;
Serializer serializer; cDatabase db;
Database db; SampleHive::cSerializer serializer;
// cHivesPanel hives(m_pWindow);
wxString msg; wxString msg;
@ -332,9 +323,9 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
wxString selection = this->GetTextValue(selected_row, 1); wxString selection = this->GetTextValue(selected_row, 1);
wxString sample_path = GetFilenamePathAndExtension(selection).Path; wxString sample_path = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Path;
std::string filename = GetFilenamePathAndExtension(selection).Filename; std::string filename = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Filename;
std::string extension = GetFilenamePathAndExtension(selection).Extension; std::string extension = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selection).Extension;
wxMenu menu; wxMenu menu;
@ -342,41 +333,41 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
bool favorite_add = false; bool favorite_add = false;
if (db.GetFavoriteColumnValueByFilename(filename) == 1) if (db.GetFavoriteColumnValueByFilename(filename) == 1)
menu.Append(MN_FavoriteSample, _("Remove from hive"), _("Remove the selected sample(s) from hive")); menu.Append(SampleHive::ID::MN_FavoriteSample, _("Remove from hive"), _("Remove the selected sample(s) from hive"));
else else
{ {
menu.Append(MN_FavoriteSample, _("Add to hive"), _("Add selected sample(s) to hive")); menu.Append(SampleHive::ID::MN_FavoriteSample, _("Add to hive"), _("Add selected sample(s) to hive"));
favorite_add = true; favorite_add = true;
} }
menu.Append(MN_DeleteSample, _("Delete"), _("Delete the selected sample(s) from database")); menu.Append(SampleHive::ID::MN_DeleteSample, _("Delete"), _("Delete the selected sample(s) from database"));
menu.Append(MN_TrashSample, _("Trash"), _("Send the selected sample(s) to trash")); menu.Append(SampleHive::ID::MN_TrashSample, _("Trash"), _("Send the selected sample(s) to trash"));
if (this->GetSelectedItemsCount() <= 1) if (this->GetSelectedItemsCount() <= 1)
{ {
menu.Append(MN_EditTagSample, _("Edit tags"), menu.Append(SampleHive::ID::MN_EditTagSample, _("Edit tags"),
_("Edit the tags for the selected sample"))->Enable(true); _("Edit the tags for the selected sample"))->Enable(true);
menu.Append(MN_OpenFile, _("Open in file manager"), menu.Append(SampleHive::ID::MN_OpenFile, _("Open in file manager"),
_("Open the selected sample in system's file manager"))->Enable(true); _("Open the selected sample in system's file manager"))->Enable(true);
} }
else else
{ {
menu.Append(MN_EditTagSample, _("Edit tags"), menu.Append(SampleHive::ID::MN_EditTagSample, _("Edit tags"),
_("Edit the tags for the selected sample"))->Enable(false); _("Edit the tags for the selected sample"))->Enable(false);
menu.Append(MN_OpenFile, _("Open in file manager"), menu.Append(SampleHive::ID::MN_OpenFile, _("Open in file manager"),
_("Open the selected sample in system's file manager"))->Enable(false); _("Open the selected sample in system's file manager"))->Enable(false);
} }
switch (this->GetPopupMenuSelectionFromUser(menu, event.GetPosition())) switch (this->GetPopupMenuSelectionFromUser(menu, event.GetPosition()))
{ {
case MN_FavoriteSample: case SampleHive::ID::MN_FavoriteSample:
{ {
std::string hive_name = m_Hives.GetItemText(m_FavoritesHive).ToStdString(); std::string hive_name = SampleHive::cHiveData::Get().GetHiveItemText(true).ToStdString();
wxDataViewItem hive_selection = m_Hives.GetSelection(); wxDataViewItem hive_selection = SampleHive::cHiveData::Get().GetHiveItemSelection();
if (hive_selection.IsOk() && m_Hives.IsContainer(hive_selection)) if (hive_selection.IsOk() && SampleHive::cHiveData::Get().IsHiveItemContainer(hive_selection))
hive_name = m_Hives.GetItemText(hive_selection).ToStdString(); hive_name = SampleHive::cHiveData::Get().GetHiveItemText(false, hive_selection);
wxDataViewItem root = wxDataViewItem(wxNullPtr); wxDataViewItem root = wxDataViewItem(wxNullPtr);
wxDataViewItem container; wxDataViewItem container;
@ -417,13 +408,13 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
db.UpdateFavoriteColumn(filename, 1); db.UpdateFavoriteColumn(filename, 1);
db.UpdateHiveName(filename, hive_name); db.UpdateHiveName(filename, hive_name);
for (int i = 0; i < m_Hives.GetChildCount(root); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetHiveChildCount(root); i++)
{ {
container = m_Hives.GetNthChild(root, i); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, i);
if (m_Hives.GetItemText(container).ToStdString() == hive_name) if (SampleHive::cHiveData::Get().GetHiveItemText(false, container) == hive_name)
{ {
m_Hives.AppendItem(container, name); SampleHive::cHiveData::Get().HiveAppendItem(container, name);
msg = wxString::Format(_("Added %s to %s"), name, hive_name); msg = wxString::Format(_("Added %s to %s"), name, hive_name);
break; break;
@ -436,20 +427,19 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
this->SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), selected_row, 0); this->SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), selected_row, 0);
db.UpdateFavoriteColumn(filename, 0); db.UpdateFavoriteColumn(filename, 0);
db.UpdateHiveName(filename, db.UpdateHiveName(filename, SampleHive::cHiveData::Get().GetHiveItemText(true).ToStdString());
m_Hives.GetItemText(m_FavoritesHive).ToStdString());
for (int i = 0; i < m_Hives.GetChildCount(root); i++) for (int i = 0; i < SampleHive::cHiveData::Get().GetHiveChildCount(root); i++)
{ {
container = m_Hives.GetNthChild(root, i); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, i);
for (int j = 0; j < m_Hives.GetChildCount(container); j++) for (int j = 0; j < SampleHive::cHiveData::Get().GetHiveChildCount(container); j++)
{ {
child = m_Hives.GetNthChild(container, j); child = SampleHive::cHiveData::Get().GetHiveNthChild(container, j);
if (m_Hives.GetItemText(child) == name) if (SampleHive::cHiveData::Get().GetHiveItemText(false, child) == name)
{ {
m_Hives.DeleteItem(child); SampleHive::cHiveData::Get().HiveDeleteItem(child);
msg = wxString::Format(_("Removed %s from %s"), name, hive_name); msg = wxString::Format(_("Removed %s from %s"), name, hive_name);
break; break;
@ -458,32 +448,25 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
} }
} }
} }
break; break;
} }
case MN_DeleteSample: case SampleHive::ID::MN_DeleteSample:
{ {
wxDataViewItemArray items; wxDataViewItemArray items;
int rows = this->GetSelections(items); int rows = this->GetSelections(items);
wxMessageDialog singleMsgDialog(this, wxString::Format(_("Are you sure you want to delete " wxMessageDialog singleMsgDialog(this, wxString::Format(_("Are you sure you want to delete %s from database? "
"%s from database? " "Warning this change is permanent, and cannot be undone."),
"Warning this change is "
"permanent, and cannot be undone."),
sample_path.AfterLast('/')), sample_path.AfterLast('/')),
wxMessageBoxCaptionStr, wxMessageBoxCaptionStr,
wxYES_NO | wxNO_DEFAULT | wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION | wxSTAY_ON_TOP | wxCENTER);
wxICON_QUESTION | wxSTAY_ON_TOP |
wxCENTER);
wxMessageDialog multipleMsgDialog(this, wxString::Format(_("Are you sure you want to delete " wxMessageDialog multipleMsgDialog(this, wxString::Format(_("Are you sure you want to delete "
"%d selected samples from database? " "%d selected samples from database? Warning this change is "
"Warning this change is " "permanent, and cannot be undone."), rows),
"permanent, and cannot be "
"undone."), rows),
wxMessageBoxCaptionStr, wxMessageBoxCaptionStr,
wxYES_NO | wxNO_DEFAULT | wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION | wxSTAY_ON_TOP | wxCENTER);
wxICON_QUESTION | wxSTAY_ON_TOP |
wxCENTER);
wxDataViewItem root = wxDataViewItem(wxNullPtr); wxDataViewItem root = wxDataViewItem(wxNullPtr);
wxDataViewItem container; wxDataViewItem container;
@ -498,21 +481,21 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
db.RemoveSampleFromDatabase(filename); db.RemoveSampleFromDatabase(filename);
this->DeleteItem(selected_row); this->DeleteItem(selected_row);
for (int j = 0; j < m_Hives.GetChildCount(root); j++) for (int j = 0; j < SampleHive::cHiveData::Get().GetHiveChildCount(root); j++)
{ {
container = m_Hives.GetNthChild(root, j); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, j);
for (int k = 0; k < m_Hives.GetChildCount(container); k++) for (int k = 0; k < SampleHive::cHiveData::Get().GetHiveChildCount(container); k++)
{ {
child = m_Hives.GetNthChild(container, k); child = SampleHive::cHiveData::Get().GetHiveNthChild(container, k);
wxString child_text = serializer.DeserializeShowFileExtension() ? wxString child_text = serializer.DeserializeShowFileExtension() ?
m_Hives.GetItemText(child).BeforeLast('.') : SampleHive::cHiveData::Get().GetHiveItemText(false, child).BeforeLast('.') :
m_Hives.GetItemText(child); SampleHive::cHiveData::Get().GetHiveItemText(false, child);
if (child_text == filename) if (child_text == filename)
{ {
m_Hives.DeleteItem(child); SampleHive::cHiveData::Get().HiveDeleteItem(child);
break; break;
} }
@ -548,21 +531,21 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
db.RemoveSampleFromDatabase(multi_selection); db.RemoveSampleFromDatabase(multi_selection);
this->DeleteItem(row); this->DeleteItem(row);
for (int j = 0; j < m_Hives.GetChildCount(root); j++) for (int j = 0; j < SampleHive::cHiveData::Get().GetHiveChildCount(root); j++)
{ {
container = m_Hives.GetNthChild(root, j); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, j);
for (int k = 0; k < m_Hives.GetChildCount(container); k++) for (int k = 0; k < SampleHive::cHiveData::Get().GetHiveChildCount(container); k++)
{ {
child = m_Hives.GetNthChild(container, k); child = SampleHive::cHiveData::Get().GetHiveNthChild(container, k);
wxString child_text = serializer.DeserializeShowFileExtension() ? wxString child_text = serializer.DeserializeShowFileExtension() ?
m_Hives.GetItemText(child).BeforeLast('.') : SampleHive::cHiveData::Get().GetHiveItemText(false, child).BeforeLast('.') :
m_Hives.GetItemText(child); SampleHive::cHiveData::Get().GetHiveItemText(false, child);
if (child_text == multi_selection) if (child_text == multi_selection)
{ {
m_Hives.DeleteItem(child); SampleHive::cHiveData::Get().HiveDeleteItem(child);
break; break;
} }
} }
@ -582,7 +565,7 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
} }
} }
break; break;
case MN_TrashSample: case SampleHive::ID::MN_TrashSample:
{ {
wxDataViewItem root = wxDataViewItem(wxNullPtr); wxDataViewItem root = wxDataViewItem(wxNullPtr);
wxDataViewItem container, child; wxDataViewItem container, child;
@ -618,43 +601,42 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
db.UpdateFavoriteColumn(files[i].ToStdString(), 0); db.UpdateFavoriteColumn(files[i].ToStdString(), 0);
for (int j = 0; j < m_Hives.GetChildCount(root); j++) for (int j = 0; j < SampleHive::cHiveData::Get().GetHiveChildCount(root); j++)
{ {
container = m_Hives.GetNthChild(root, j); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, j);
for (int k = 0; k < m_Hives.GetChildCount(container); k++) for (int k = 0; k < SampleHive::cHiveData::Get().GetHiveChildCount(container); k++)
{ {
child = m_Hives.GetNthChild(container, k); child = SampleHive::cHiveData::Get().GetHiveNthChild(container, k);
wxString child_text = serializer.DeserializeShowFileExtension() ? wxString child_text = serializer.DeserializeShowFileExtension() ?
m_Hives.GetItemText(child).BeforeLast('.') : SampleHive::cHiveData::Get().GetHiveItemText(false, child).BeforeLast('.') :
m_Hives.GetItemText(child); SampleHive::cHiveData::Get().GetHiveItemText(false, child);
if (child_text == files[i]) if (child_text == files[i])
{ {
m_Hives.DeleteItem(child); SampleHive::cHiveData::Get().HiveDeleteItem(child);
break; break;
} }
} }
} }
} }
m_Trash.AppendItem(m_TrashRoot, text_value); SampleHive::cHiveData::Get().TrashAppendItem(SampleHive::cHiveData::Get().GetTrashRoot(), text_value);
this->DeleteItem(item_row); this->DeleteItem(item_row);
db.UpdateTrashColumn(files[i].ToStdString(), 1); db.UpdateTrashColumn(files[i].ToStdString(), 1);
db.UpdateHiveName(files[i].ToStdString(), db.UpdateHiveName(files[i].ToStdString(), SampleHive::cHiveData::Get().GetHiveItemText(true).ToStdString());
m_Hives.GetItemText(m_FavoritesHive).ToStdString());
msg = wxString::Format(_("%s sent to trash"), text_value); msg = wxString::Format(_("%s sent to trash"), text_value);
} }
} }
} }
break; break;
case MN_EditTagSample: case SampleHive::ID::MN_EditTagSample:
{ {
tagEditor = new TagEditor(this, static_cast<std::string>(sample_path)); tagEditor = new cTagEditor(this, static_cast<std::string>(sample_path));
switch (tagEditor->ShowModal()) switch (tagEditor->ShowModal())
{ {
@ -672,7 +654,7 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
} }
} }
break; break;
case MN_OpenFile: case SampleHive::ID::MN_OpenFile:
wxExecute(wxString::Format("xdg-open '%s'", sample_path.BeforeLast('/'))); wxExecute(wxString::Format("xdg-open '%s'", sample_path.BeforeLast('/')));
break; break;
case wxID_NONE: case wxID_NONE:
@ -684,8 +666,7 @@ void cListCtrl::OnShowLibraryContextMenu(wxDataViewEvent& event)
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_INFORMATION, *this);
// m_InfoBar->ShowMessage(msg);
} }
void cListCtrl::OnShowLibraryColumnHeaderContextMenu(wxDataViewEvent& event) void cListCtrl::OnShowLibraryColumnHeaderContextMenu(wxDataViewEvent& event)
@ -702,233 +683,59 @@ void cListCtrl::OnShowLibraryColumnHeaderContextMenu(wxDataViewEvent& event)
wxDataViewColumn* BitrateColumn = this->GetColumn(7); wxDataViewColumn* BitrateColumn = this->GetColumn(7);
wxDataViewColumn* PathColumn = this->GetColumn(8); wxDataViewColumn* PathColumn = this->GetColumn(8);
menu.AppendCheckItem(MN_ColumnFavorite, _("Favorites"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnFavorite, _("Favorites"),
_("Toggle favorites column"))->Check(FavoriteColumn->IsShown()); _("Toggle favorites column"))->Check(FavoriteColumn->IsShown());
menu.AppendCheckItem(MN_ColumnFilename, _("Filename"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnFilename, _("Filename"),
_("Toggle filename column"))->Check(FilenameColumn->IsShown()); _("Toggle filename column"))->Check(FilenameColumn->IsShown());
menu.AppendCheckItem(MN_ColumnSamplePack, _("Sample Pack"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnSamplePack, _("Sample Pack"),
_("Toggle sample pack column"))->Check(SamplePackColumn->IsShown()); _("Toggle sample pack column"))->Check(SamplePackColumn->IsShown());
menu.AppendCheckItem(MN_ColumnType, _("Type"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnType, _("Type"),
_("Toggle type column"))->Check(TypeColumn->IsShown()); _("Toggle type column"))->Check(TypeColumn->IsShown());
menu.AppendCheckItem(MN_ColumnChannels, _("Channels"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnChannels, _("Channels"),
_("Toggle channels column"))->Check(ChannelsColumn->IsShown()); _("Toggle channels column"))->Check(ChannelsColumn->IsShown());
menu.AppendCheckItem(MN_ColumnLength, _("Length"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnLength, _("Length"),
_("Toggle length column"))->Check(LengthColumn->IsShown()); _("Toggle length column"))->Check(LengthColumn->IsShown());
menu.AppendCheckItem(MN_ColumnSampleRate, _("Sample Rate"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnSampleRate, _("Sample Rate"),
_("Toggle sample rate column"))->Check(SampleRateColumn->IsShown()); _("Toggle sample rate column"))->Check(SampleRateColumn->IsShown());
menu.AppendCheckItem(MN_ColumnBitrate, _("Bitrate"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnBitrate, _("Bitrate"),
_("Toggle bitrate column"))->Check(BitrateColumn->IsShown()); _("Toggle bitrate column"))->Check(BitrateColumn->IsShown());
menu.AppendCheckItem(MN_ColumnPath, _("Path"), menu.AppendCheckItem(SampleHive::ID::MN_ColumnPath, _("Path"),
_("Toggle path column"))->Check(PathColumn->IsShown()); _("Toggle path column"))->Check(PathColumn->IsShown());
switch (this->GetPopupMenuSelectionFromUser(menu, event.GetPosition())) switch (this->GetPopupMenuSelectionFromUser(menu, event.GetPosition()))
{ {
case MN_ColumnFavorite: case SampleHive::ID::MN_ColumnFavorite:
FavoriteColumn->SetHidden(!menu.IsChecked(MN_ColumnFavorite)); FavoriteColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnFavorite));
break; break;
case MN_ColumnFilename: case SampleHive::ID::MN_ColumnFilename:
FilenameColumn->SetHidden(!menu.IsChecked(MN_ColumnFilename)); FilenameColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnFilename));
break; break;
case MN_ColumnSamplePack: case SampleHive::ID::MN_ColumnSamplePack:
SamplePackColumn->SetHidden(!menu.IsChecked(MN_ColumnSamplePack)); SamplePackColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnSamplePack));
break; break;
case MN_ColumnType: case SampleHive::ID::MN_ColumnType:
TypeColumn->SetHidden(!menu.IsChecked(MN_ColumnType)); TypeColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnType));
break; break;
case MN_ColumnChannels: case SampleHive::ID::MN_ColumnChannels:
ChannelsColumn->SetHidden(!menu.IsChecked(MN_ColumnChannels)); ChannelsColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnChannels));
break; break;
case MN_ColumnLength: case SampleHive::ID::MN_ColumnLength:
LengthColumn->SetHidden(!menu.IsChecked(MN_ColumnLength)); LengthColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnLength));
break; break;
case MN_ColumnSampleRate: case SampleHive::ID::MN_ColumnSampleRate:
SampleRateColumn->SetHidden(!menu.IsChecked(MN_ColumnSampleRate)); SampleRateColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnSampleRate));
break; break;
case MN_ColumnBitrate: case SampleHive::ID::MN_ColumnBitrate:
BitrateColumn->SetHidden(!menu.IsChecked(MN_ColumnBitrate)); BitrateColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnBitrate));
break; break;
case MN_ColumnPath: case SampleHive::ID::MN_ColumnPath:
PathColumn->SetHidden(!menu.IsChecked(MN_ColumnPath)); PathColumn->SetHidden(!menu.IsChecked(SampleHive::ID::MN_ColumnPath));
break; break;
default: default:
break; break;
} }
} }
void cListCtrl::AddSamples(wxArrayString& files)
{
Serializer serializer;
Database db;
wxBusyCursor busy_cursor;
wxWindowDisabler window_disabler;
wxProgressDialog* progressDialog = new wxProgressDialog(_("Adding files.."),
_("Adding files, please wait..."),
static_cast<int>(files.size()), this,
wxPD_APP_MODAL | wxPD_SMOOTH | wxPD_CAN_ABORT |
wxPD_AUTO_HIDE);
progressDialog->CenterOnParent(wxBOTH);
std::vector<Sample> sample_array;
std::string path;
std::string artist;
std::string filename_with_extension;
std::string filename_without_extension;
std::string extension;
std::string filename;
//Check All Files At Once
wxArrayString sorted_files;
sorted_files = db.CheckDuplicates(files);
files = sorted_files;
if(files.size() < 1)
{
progressDialog->Destroy();
return;
}
progressDialog->SetRange(files.size());
for(unsigned int i = 0; i < files.size(); i++)
{
progressDialog->Update(i, wxString::Format(_("Getting Data For %s"), files[i].AfterLast('/')));
if(progressDialog->WasCancelled())
{
progressDialog->Destroy();
return;
}
path = files[i].ToStdString();
filename_with_extension = files[i].AfterLast('/').ToStdString();
filename_without_extension = files[i].AfterLast('/').BeforeLast('.').ToStdString();
extension = files[i].AfterLast('.').ToStdString();
filename = serializer.DeserializeShowFileExtension() ?
filename_with_extension : filename_without_extension;
Sample sample;
sample.SetPath(path);
sample.SetFilename(filename_without_extension);
sample.SetFileExtension(extension);
Tags tags(path);
artist = tags.GetAudioInfo().artist.ToStdString();
sample.SetSamplePack(artist);
sample.SetChannels(tags.GetAudioInfo().channels);
sample.SetLength(tags.GetAudioInfo().length);
sample.SetSampleRate(tags.GetAudioInfo().sample_rate);
sample.SetBitrate(tags.GetAudioInfo().bitrate);
wxLongLong llLength = sample.GetLength();
int total_min = static_cast<int>((llLength / 60000).GetValue());
int total_sec = static_cast<int>(((llLength % 60000) / 1000).GetValue());
wxVector<wxVariant> data;
wxVariant icon = wxVariant(wxBitmap(ICON_STAR_EMPTY_16px));
if (tags.IsFileValid())
{
data.clear();
data.push_back(icon);
data.push_back(filename);
data.push_back(sample.GetSamplePack());
data.push_back("");
data.push_back(wxString::Format("%d", sample.GetChannels()));
data.push_back(wxString::Format("%2i:%02i", total_min, total_sec));
data.push_back(wxString::Format("%d", sample.GetSampleRate()));
data.push_back(wxString::Format("%d", sample.GetBitrate()));
data.push_back(path);
SH_LOG_INFO("Adding file: {}, Extension: {}", sample.GetFilename(), sample.GetFileExtension());
this->AppendItem(data);
sample_array.push_back(sample);
}
else
{
wxString msg = wxString::Format(_("Error! Cannot open %s, Invalid file type."),
filename_with_extension);
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_ERROR, *this);
// m_InfoBar->ShowMessage(msg, wxICON_ERROR);
}
}
progressDialog->Pulse(_("Updating Database.."), NULL);
db.InsertIntoSamples(sample_array);
progressDialog->Destroy();
}
cListCtrl::FileInfo cListCtrl::GetFilenamePathAndExtension(const wxString& selected,
bool checkExtension, bool doGetFilename) const
{
Serializer serializer;
Database db;
wxString path;
std::string extension, filename;
wxString filename_with_extension = db.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
wxString filename_without_extension = db.GetSamplePathByFilename(selected.ToStdString());
if (checkExtension)
{
extension = serializer.DeserializeShowFileExtension() ?
db.GetSampleFileExtension(selected.ToStdString()) :
db.GetSampleFileExtension(selected.BeforeLast('.').ToStdString());
}
path = selected.Contains(wxString::Format(".%s", extension)) ?
filename_with_extension : filename_without_extension;
if (doGetFilename)
filename = path.AfterLast('/').BeforeLast('.').ToStdString();
return { path, extension, filename };
}
void cListCtrl::LoadDatabase()
{
Serializer serializer;
Database db;
// cHivesPanel hives(m_pWindow);
// cTrashPanel trash(m_pWindow);
try
{
const auto dataset = db.LoadSamplesDatabase(m_Hives, m_FavoritesHive,
m_Trash, m_TrashRoot,
serializer.DeserializeShowFileExtension(),
ICON_STAR_FILLED_16px, ICON_STAR_EMPTY_16px);
if (dataset.empty())
SH_LOG_INFO("Error! Database is empty.");
else
{
for (auto data : dataset)
this->AppendItem(data);
}
db.LoadHivesDatabase(m_Hives);
}
catch(...)
{
std::cerr << "Error loading data." << std::endl;
}
}
cListCtrl::~cListCtrl() cListCtrl::~cListCtrl()
{ {

52
src/GUI/ListCtrl.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/dataview.h> #include <wx/dataview.h>
@ -6,19 +26,9 @@
class cListCtrl : public wxDataViewListCtrl class cListCtrl : public wxDataViewListCtrl
{ {
struct FileInfo
{
wxString Path;
std::string Extension;
std::string Filename;
};
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// cListCtrl(wxWindow* window); cListCtrl(wxWindow* window);
cListCtrl(wxWindow* window, wxDataViewItem favHive, wxDataViewTreeCtrl& hives,
wxTreeItemId trashRoot, wxTreeCtrl& trash);
~cListCtrl(); ~cListCtrl();
public: public:
@ -34,27 +44,7 @@ class cListCtrl : public wxDataViewListCtrl
void OnShowLibraryContextMenu(wxDataViewEvent& event); void OnShowLibraryContextMenu(wxDataViewEvent& event);
void OnShowLibraryColumnHeaderContextMenu(wxDataViewEvent& event); void OnShowLibraryColumnHeaderContextMenu(wxDataViewEvent& event);
// -------------------------------------------------------------------
void AddSamples(wxArrayString& files);
// -------------------------------------------------------------------
cListCtrl::FileInfo GetFilenamePathAndExtension(const wxString& selected,
bool checkExtension = true,
bool doGetFilename = true) const;
// -------------------------------------------------------------------
void LoadDatabase();
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
wxWindow* m_pWindow = nullptr; wxWindow* m_pWindow = nullptr;
wxDataViewTreeCtrl& m_Hives;
wxDataViewItem m_FavoritesHive;
wxTreeItemId m_TrashRoot;
wxTreeCtrl& m_Trash;
// -------------------------------------------------------------------
// friend class cHives;
// friend class cTrash;
}; };

2694
src/GUI/MainFrame.cpp
View File

File diff suppressed because it is too large Load Diff

293
src/GUI/MainFrame.hpp
View File

@ -20,211 +20,40 @@
#pragma once #pragma once
#include "Database/Database.hpp"
#include "GUI/Library.hpp" #include "GUI/Library.hpp"
#include "GUI/Notebook.hpp"
#include "GUI/TransportControls.hpp" #include "GUI/TransportControls.hpp"
#include "GUI/WaveformViewer.hpp" #include "GUI/WaveformViewer.hpp"
#include "GUI/Notebook.hpp" #include "Database/Database.hpp"
#include "Utility/Serialize.hpp" #include "Utility/Serialize.hpp"
#include "Utility/SH_Event.hpp" #include "Utility/Event.hpp"
#include "SampleHiveConfig.hpp" #include "SampleHiveConfig.hpp"
#include <memory> #include <memory>
#include <string> #include <string>
#include <wx/button.h>
#include <wx/bmpbuttn.h>
#include <wx/checkbox.h>
#include <wx/collpane.h>
#include <wx/dataview.h>
#include <wx/dirctrl.h>
#include <wx/event.h> #include <wx/event.h>
#include <wx/frame.h> #include <wx/frame.h>
#include <wx/fswatcher.h> #include <wx/fswatcher.h>
#include <wx/infobar.h>
#include <wx/listctrl.h>
#include <wx/mediactrl.h> #include <wx/mediactrl.h>
#include <wx/notebook.h>
#include <wx/panel.h> #include <wx/panel.h>
#include <wx/setup.h>
#include <wx/srchctrl.h>
#include <wx/sizer.h> #include <wx/sizer.h>
#include <wx/slider.h>
#include <wx/splitter.h> #include <wx/splitter.h>
#include <wx/settings.h>
#include <wx/statbmp.h> #include <wx/statbmp.h>
#include <wx/statusbr.h> #include <wx/statusbr.h>
#include <wx/string.h> #include <wx/string.h>
#include <wx/tglbtn.h>
#include <wx/timer.h> #include <wx/timer.h>
#include <wx/toplevel.h>
#include <wx/treebase.h>
#include <wx/treectrl.h>
#include <wx/window.h>
#include <taglib/tag.h> class cMainFrame : public wxFrame
#include <taglib/fileref.h>
#ifndef USE_SYSTEM_INCLUDE_PATH
#include <taglib/toolkit/tstring.h>
#else
#include <taglib/tstring.h>
#endif
struct FileInfo
{
wxString Path;
std::string Extension;
std::string Filename;
};
class MainFrame : public wxFrame
{ {
public: public:
MainFrame(); cMainFrame();
~MainFrame(); ~cMainFrame();
private:
// -------------------------------------------------------------------
// Main Panel
// wxPanel* m_MainPanel;
wxBoxSizer* m_MainSizer;
// -------------------------------------------------------------------
// Hive bitmap icon for the statusbar
wxStaticBitmap* m_HiveBitmap;
// -------------------------------------------------------------------
// App statusbar
wxStatusBar* m_StatusBar;
// -------------------------------------------------------------------
// App menubar
wxMenuBar* m_MenuBar;
// -------------------------------------------------------------------
// Menu and menu items for the menubar
wxMenu* m_FileMenu;
wxMenu* m_EditMenu;
wxMenu* m_ViewMenu;
wxMenu* m_HelpMenu;
wxMenuItem* m_AddFile;
wxMenuItem* m_AddDirectory;
wxMenuItem* m_ToggleExtension;
wxMenuItem* m_ToggleMenuBar;
wxMenuItem* m_ToggleStatusBar;
// -------------------------------------------------------------------
// Splitter windows
wxSplitterWindow* m_TopSplitter;
wxSplitterWindow* m_BottomSplitter;
// -------------------------------------------------------------------
// Top panel controls
wxPanel* m_TopPanel;
cTransportControls* m_TransportControls;
cWaveformViewer* m_WaveformViewer;
// wxBoxSizer* m_TopSizer;
wxBoxSizer* m_TopPanelMainSizer;
// wxBoxSizer* m_WaveformDisplaySizer;
// -------------------------------------------------------------------
// Left panel controls
// wxPanel* m_BottomLeftPanel;
cNotebook* m_Notebook;
// wxPanel* m_HivesPanel;
// wxPanel* m_TrashPanel;
// wxNotebook* m_Notebook;
// wxBoxSizer* m_BottomLeftPanelMainSizer;
// wxBoxSizer* m_HivesMainSizer;
// wxBoxSizer* m_HivesFavoritesSizer;
// wxBoxSizer* m_HivesButtonSizer;
// wxBoxSizer* m_TrashMainSizer;
// wxBoxSizer* m_TrashItemSizer;
// wxBoxSizer* m_TrashButtonSizer;
// wxGenericDirCtrl* m_DirCtrl;
// wxDataViewTreeCtrl* m_Hives;
// wxDataViewItem favorites_hive;
// wxTreeItemId trash_root;
// wxTreeCtrl* m_Trash;
// wxButton* m_AddHiveButton;
// wxButton* m_RemoveHiveButton;
// wxButton* m_RestoreTrashedItemButton;
// -------------------------------------------------------------------
// Right panel controls
cLibrary* m_Library;
// wxPanel* m_BottomRightPanel;
// wxBoxSizer* m_BottomRightPanelMainSizer;
// wxSearchCtrl* m_SearchBox;
// wxInfoBar* m_InfoBar;
// wxDataViewListCtrl* m_Library;
// -------------------------------------------------------------------
// MediaCtrl
wxMediaCtrl* m_MediaCtrl;
// -------------------------------------------------------------------
// Timer
wxTimer* m_Timer;
// -------------------------------------------------------------------
std::unique_ptr<Database> m_Database;
// -------------------------------------------------------------------
// FileSystemWatcher
wxFileSystemWatcher* m_FsWatcher = nullptr;
// -------------------------------------------------------------------
wxLongLong m_LoopA, m_LoopB;
// -------------------------------------------------------------------
// wxSystemAppearance m_Theme = wxSystemSettings::GetAppearance();
private:
// -------------------------------------------------------------------
bool bFiltered = false;
bool bShowMenuBar = false;
bool bShowStatusBar = false;
bool bLoopPointsSet = false;
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Top panel control handlers // Top panel control handlers
void OnMediaFinished(wxMediaEvent& event); void OnMediaFinished(wxMediaEvent& event);
// void OnClickSettings(wxCommandEvent& event);
// -------------------------------------------------------------------
// DirCtrl event handlers
// void OnClickDirCtrl(wxCommandEvent& event);
// void OnDragFromDirCtrl(wxTreeEvent& event);
// -------------------------------------------------------------------
// TrashPane event handlers
// void OnShowTrashContextMenu(wxTreeEvent& event);
// void OnClickRestoreTrashItem(wxCommandEvent& event);
// void OnDragAndDropToTrash(wxDropFilesEvent& event);
// -------------------------------------------------------------------
// Hives panel button event handlers
// void OnDragAndDropToHives(wxDropFilesEvent& event);
// void OnClickAddHive(wxCommandEvent& event);
// void OnClickRemoveHive(wxCommandEvent& event);
// void OnShowHivesContextMenu(wxDataViewEvent& event);
// void OnHiveStartEditing(wxDataViewEvent& event);
// -------------------------------------------------------------------
// SearchCtrl event handlers
// void OnDoSearch(wxCommandEvent& event);
// void OnCancelSearch(wxCommandEvent& event);
// -------------------------------------------------------------------
// Library event handlers
// void OnClickLibrary(wxDataViewEvent& event);
// void OnDragAndDropToLibrary(wxDropFilesEvent& event);
// void OnDragFromLibrary(wxDataViewEvent& event);
// void OnShowLibraryContextMenu(wxDataViewEvent& event);
// void OnShowLibraryColumnHeaderContextMenu(wxDataViewEvent& event);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// App menu items event handlers // App menu items event handlers
@ -254,34 +83,27 @@ class MainFrame : public wxFrame
// Timer update event handler // Timer update event handler
void UpdateElapsedTime(wxTimerEvent& event); void UpdateElapsedTime(wxTimerEvent& event);
// -------------------------------------------------------------------
// void AddSamples(wxArrayString& files);
// void OnAutoImportDir(const wxString& pathToDirectory);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
void PlaySample(const std::string& filepath, const std::string& sample, bool seek = false, void PlaySample(const std::string& filepath, const std::string& sample, bool seek = false,
wxFileOffset where = NULL, wxSeekMode mode = wxFromStart); wxFileOffset where = NULL, wxSeekMode mode = wxFromStart);
// Recieve custom events // Recieve custom events
// ------------------------------------------------------------------- // -------------------------------------------------------------------
void OnRecieveLoopPoints(SampleHive::LoopPointsEvent& event); void OnRecieveLoopPoints(SampleHive::cLoopPointsEvent& event);
void OnRecievePushStatusBarStatus(SampleHive::StatusBarStatusEvent& event); void OnRecieveClearLoopPointsStatus(SampleHive::cLoopPointsEvent& event);
void OnRecievePopStatusBarStatus(SampleHive::StatusBarStatusEvent& event); void OnRecieveLoopABButtonValueChange(SampleHive::cLoopPointsEvent& event);
void OnRecieveSetStatusBarStatus(SampleHive::StatusBarStatusEvent& event); void OnRecievePushStatusBarStatus(SampleHive::cStatusBarStatusEvent& event);
void OnRecieveInfoBarStatus(SampleHive::InfoBarMessageEvent& event); void OnRecievePopStatusBarStatus(SampleHive::cStatusBarStatusEvent& event);
void OnRecieveTimerStopStatus(SampleHive::TimerEvent& event); void OnRecieveSetStatusBarStatus(SampleHive::cStatusBarStatusEvent& event);
void OnRecieveCallFunctionPlay(SampleHive::CallFunctionEvent& event); void OnRecieveInfoBarStatus(SampleHive::cInfoBarMessageEvent& event);
void OnRecieveWaveformUpdateStatus(SampleHive::WaveformUpdateEvent& event); void OnRecieveTimerStopStatus(SampleHive::cTimerEvent& event);
void OnRecieveCallFunctionPlay(SampleHive::cCallFunctionEvent& event);
void OnRecieveWaveformUpdateStatus(SampleHive::cWaveformUpdateEvent& event);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// void LoadDatabase(); void LoadDatabase();
// void RefreshDatabase();
void LoadConfigFile(); void LoadConfigFile();
// void RefreshDatabase();
// -------------------------------------------------------------------
// Getters
// FileInfo GetFilenamePathAndExtension(const wxString& selected,
// bool checkExtension = true, bool doGetFilename = true) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Directory watchers // Directory watchers
@ -290,8 +112,6 @@ class MainFrame : public wxFrame
void AddWatchEntry(wxFSWPathType type, std::string path); void AddWatchEntry(wxFSWPathType type, std::string path);
void OnFileSystemEvent(wxFileSystemWatcherEvent& event); void OnFileSystemEvent(wxFileSystemWatcherEvent& event);
// wxString TagLibTowx(const TagLib::String& in);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Call after frame creation // Call after frame creation
void SetAfterFrameCreate(); void SetAfterFrameCreate();
@ -299,8 +119,83 @@ class MainFrame : public wxFrame
// ------------------------------------------------------------------- // -------------------------------------------------------------------
void ClearLoopPoints(); void ClearLoopPoints();
// -------------------------------------------------------------------
void InitDatabase(); void InitDatabase();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
friend class App; friend class cApp;
private:
// -------------------------------------------------------------------
// Main Panel
wxBoxSizer* m_pMainSizer = nullptr;
// -------------------------------------------------------------------
// Hive bitmap icon for the statusbar
wxStaticBitmap* m_pHiveBitmap = nullptr;
// -------------------------------------------------------------------
// App statusbar
wxStatusBar* m_pStatusBar = nullptr;
// -------------------------------------------------------------------
// App menubar
wxMenuBar* m_pMenuBar = nullptr;
// -------------------------------------------------------------------
// Menu and menu items for the menubar
wxMenu* m_pFileMenu = nullptr;
wxMenu* m_pEditMenu = nullptr;
wxMenu* m_pViewMenu = nullptr;
wxMenu* m_pHelpMenu = nullptr;
wxMenuItem* m_pAddFile = nullptr;
wxMenuItem* m_pAddDirectory = nullptr;
wxMenuItem* m_pToggleExtension = nullptr;
wxMenuItem* m_pToggleMenuBar = nullptr;
wxMenuItem* m_pToggleStatusBar = nullptr;
// -------------------------------------------------------------------
// Splitter windows
wxSplitterWindow* m_pTopSplitter = nullptr;
wxSplitterWindow* m_pBottomSplitter = nullptr;
// -------------------------------------------------------------------
// Top panel controls
wxPanel* m_pTopPanel = nullptr;
cWaveformViewer* m_pWaveformViewer = nullptr;
cTransportControls* m_pTransportControls = nullptr;
wxBoxSizer* m_pTopPanelMainSizer = nullptr;
// -------------------------------------------------------------------
// Left panel controls
cNotebook* m_pNotebook = nullptr;
// -------------------------------------------------------------------
// Right panel controls
cLibrary* m_pLibrary = nullptr;
// -------------------------------------------------------------------
// MediaCtrl
wxMediaCtrl* m_pMediaCtrl = nullptr;
// -------------------------------------------------------------------
// Timer
wxTimer* m_pTimer = nullptr;
// -------------------------------------------------------------------
std::unique_ptr<cDatabase> m_pDatabase = nullptr;
// -------------------------------------------------------------------
// FileSystemWatcher
wxFileSystemWatcher* m_pFsWatcher = nullptr;
// -------------------------------------------------------------------
wxLongLong m_LoopA, m_LoopB;
private:
// -------------------------------------------------------------------
bool m_bFiltered = false;
bool m_bShowMenuBar = false;
bool m_bShowStatusBar = false;
bool m_bLoopPointsSet = false;
}; };

24
src/GUI/Notebook.cpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/Notebook.hpp" #include "GUI/Notebook.hpp"
#include "GUI/DirectoryBrowser.hpp" #include "GUI/DirectoryBrowser.hpp"
#include "GUI/Hives.hpp" #include "GUI/Hives.hpp"
@ -9,8 +29,8 @@ cNotebook::cNotebook(wxWindow* window)
m_pNotebook = new wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_TOP); m_pNotebook = new wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_TOP);
m_DirectoryBrowser = new cDirectoryBrowser(m_pNotebook); m_DirectoryBrowser = new cDirectoryBrowser(m_pNotebook);
m_HivesPanel = new cHivesPanel(m_pNotebook, *m_pListCtrl); m_HivesPanel = new cHivesPanel(m_pNotebook);
m_TrashPanel = new cTrashPanel(m_pNotebook, *m_pListCtrl); m_TrashPanel = new cTrashPanel(m_pNotebook);
// Adding the pages to wxNotebook // Adding the pages to wxNotebook
m_pNotebook->AddPage(m_DirectoryBrowser, _("Browse"), false); m_pNotebook->AddPage(m_DirectoryBrowser, _("Browse"), false);

24
src/GUI/Notebook.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include "GUI/DirectoryBrowser.hpp" #include "GUI/DirectoryBrowser.hpp"
@ -21,8 +41,6 @@ class cNotebook : public wxPanel
cHivesPanel* GetHivesPanel() const { return m_HivesPanel; } cHivesPanel* GetHivesPanel() const { return m_HivesPanel; }
cTrashPanel* GetTrashPanel() const { return m_TrashPanel; } cTrashPanel* GetTrashPanel() const { return m_TrashPanel; }
void SetListCtrlObject(wxDataViewListCtrl& listCtrl) { m_pListCtrl = &listCtrl; }
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
wxNotebook* m_pNotebook = nullptr; wxNotebook* m_pNotebook = nullptr;
@ -32,6 +50,4 @@ class cNotebook : public wxPanel
cDirectoryBrowser* m_DirectoryBrowser = nullptr; cDirectoryBrowser* m_DirectoryBrowser = nullptr;
cHivesPanel* m_HivesPanel = nullptr; cHivesPanel* m_HivesPanel = nullptr;
cTrashPanel* m_TrashPanel = nullptr; cTrashPanel* m_TrashPanel = nullptr;
wxDataViewListCtrl* m_pListCtrl;
}; };

48
src/GUI/SearchBar.cpp
View File

@ -1,15 +1,38 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/SearchBar.hpp" #include "GUI/SearchBar.hpp"
#include "GUI/ListCtrl.hpp" #include "GUI/ListCtrl.hpp"
#include "Database/Database.hpp" #include "Database/Database.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/HiveData.hpp"
#include "Utility/Serialize.hpp" #include "Utility/Serialize.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
cSearchBar::cSearchBar(wxWindow* window, wxDataViewListCtrl& listCtrl) #include <exception>
: wxSearchCtrl(window, BC_Search, _("Search for samples.."),
cSearchBar::cSearchBar(wxWindow* window)
: wxSearchCtrl(window, SampleHive::ID::BC_Search, _("Search for samples.."),
wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER),
m_pWindow(window), m_ListCtrl(listCtrl) m_pWindow(window)
{ {
// Set minimum and maximum size of m_SearchBox // Set minimum and maximum size of m_SearchBox
// so it doesn't expand too wide when resizing the main frame. // so it doesn't expand too wide when resizing the main frame.
@ -19,16 +42,15 @@ cSearchBar::cSearchBar(wxWindow* window, wxDataViewListCtrl& listCtrl)
ShowSearchButton(true); ShowSearchButton(true);
ShowCancelButton(true); ShowCancelButton(true);
Bind(wxEVT_TEXT, &cSearchBar::OnDoSearch, this, BC_Search); Bind(wxEVT_TEXT, &cSearchBar::OnDoSearch, this, SampleHive::ID::BC_Search);
Bind(wxEVT_SEARCHCTRL_SEARCH_BTN, &cSearchBar::OnDoSearch, this, BC_Search); Bind(wxEVT_SEARCHCTRL_SEARCH_BTN, &cSearchBar::OnDoSearch, this, SampleHive::ID::BC_Search);
Bind(wxEVT_SEARCHCTRL_CANCEL_BTN, &cSearchBar::OnCancelSearch, this, BC_Search); Bind(wxEVT_SEARCHCTRL_CANCEL_BTN, &cSearchBar::OnCancelSearch, this, SampleHive::ID::BC_Search);
} }
void cSearchBar::OnDoSearch(wxCommandEvent& event) void cSearchBar::OnDoSearch(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
// cListCtrl m_ListCtrl(m_pWindow);
const auto search = this->GetValue().ToStdString(); const auto search = this->GetValue().ToStdString();
@ -43,19 +65,19 @@ void cSearchBar::OnDoSearch(wxCommandEvent& event)
} }
else else
{ {
m_ListCtrl.DeleteAllItems(); SampleHive::cHiveData::Get().ListCtrlDeleteAllItems();
std::cout << search << std::endl; std::cout << search << std::endl;
for (const auto& data : dataset) for (const auto& data : dataset)
{ {
m_ListCtrl.AppendItem(data); SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
} }
} }
} }
catch (...) catch (std::exception& e)
{ {
std::cerr << "Error loading data." << std::endl; SH_LOG_ERROR("Error loading data. {}", e.what());
} }
} }

24
src/GUI/SearchBar.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/dataview.h> #include <wx/dataview.h>
@ -6,7 +26,7 @@
class cSearchBar : public wxSearchCtrl class cSearchBar : public wxSearchCtrl
{ {
public: public:
cSearchBar(wxWindow* window, wxDataViewListCtrl& listCtrl); cSearchBar(wxWindow* window);
~cSearchBar(); ~cSearchBar();
public: public:
@ -21,6 +41,4 @@ class cSearchBar : public wxSearchCtrl
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
wxWindow* m_pWindow = nullptr; wxWindow* m_pWindow = nullptr;
wxDataViewListCtrl& m_ListCtrl;
}; };

157
src/GUI/TransportControls.cpp
View File

@ -1,79 +1,91 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/TransportControls.hpp" #include "GUI/TransportControls.hpp"
#include "GUI/Dialogs/Settings.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/SH_Event.hpp" #include "Utility/Event.hpp"
#include "Utility/HiveData.hpp"
#include "Utility/Sample.hpp"
#include "Utility/Signal.hpp" #include "Utility/Signal.hpp"
#include "Utility/Serialize.hpp" #include "Utility/Serialize.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Utils.hpp"
cTransportControls::cTransportControls(wxWindow* window, wxDataViewListCtrl& library, cTransportControls::cTransportControls(wxWindow* window, wxMediaCtrl& mediaCtrl)
wxMediaCtrl& mediaCtrl, wxTimer& timer)
: wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxNO_BORDER), : wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxNO_BORDER),
m_Library(library), m_MediaCtrl(mediaCtrl), m_Timer(timer) m_MediaCtrl(mediaCtrl)
{ {
m_pMainSizer = new wxBoxSizer(wxHORIZONTAL); m_pMainSizer = new wxBoxSizer(wxHORIZONTAL);
// Looping region controls // Looping region controls
if (m_Theme.IsDark()) if (m_Theme.IsDark())
m_pLoopABButton = new wxBitmapToggleButton(this, BC_LoopABButton, m_pLoopABButton = new wxBitmapToggleButton(this, SampleHive::ID::BC_LoopABButton, static_cast<wxString>(ICON_AB_LIGHT_16px),
static_cast<wxString>(ICON_AB_LIGHT_16px),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
else else
m_pLoopABButton = new wxBitmapToggleButton(this, BC_LoopABButton, m_pLoopABButton = new wxBitmapToggleButton(this, SampleHive::ID::BC_LoopABButton, static_cast<wxString>(ICON_AB_DARK_16px),
static_cast<wxString>(ICON_AB_DARK_16px),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pLoopABButton->SetToolTip(_("Loop selected region")); m_pLoopABButton->SetToolTip(_("Loop selected region"));
// Autoplay checkbox // Autoplay checkbox
m_pAutoPlayCheck = new wxCheckBox(this, BC_Autoplay, _("Autoplay"), m_pAutoPlayCheck = new wxCheckBox(this, SampleHive::ID::BC_Autoplay, _("Autoplay"),
wxDefaultPosition, wxDefaultSize, wxCHK_2STATE); wxDefaultPosition, wxDefaultSize, wxCHK_2STATE);
m_pAutoPlayCheck->SetToolTip(_("Autoplay")); m_pAutoPlayCheck->SetToolTip(_("Autoplay"));
// Volume slider // Volume slider
m_pVolumeSlider = new wxSlider(this, BC_Volume, 100, 0, 100, m_pVolumeSlider = new wxSlider(this, SampleHive::ID::BC_Volume, 100, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL);
wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL);
m_pVolumeSlider->SetToolTip(_("Volume")); m_pVolumeSlider->SetToolTip(_("Volume"));
m_pVolumeSlider->SetMinSize(wxSize(120, -1)); m_pVolumeSlider->SetMinSize(wxSize(120, -1));
m_pVolumeSlider->SetMaxSize(wxSize(120, -1)); m_pVolumeSlider->SetMaxSize(wxSize(120, -1));
// Sample position static text // Sample position static text
m_pSamplePosition = new wxStaticText(this, BC_SamplePosition, "--:--/--:--", m_pSamplePosition = new wxStaticText(this, SampleHive::ID::BC_SamplePosition, "--:--/--:--",
wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE_HORIZONTAL); wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE_HORIZONTAL);
// Transport control buttons // Transport control buttons
if (m_Theme.IsDark()) if (m_Theme.IsDark())
{ {
m_pPlayButton = new wxBitmapButton(this, BC_Play, m_pPlayButton = new wxBitmapButton(this, SampleHive::ID::BC_Play,
wxBitmapBundle::FromBitmap(static_cast<wxString> wxBitmapBundle::FromBitmap(static_cast<wxString>(ICON_PLAY_LIGHT_16px)),
(ICON_PLAY_LIGHT_16px)),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pLoopButton = new wxBitmapToggleButton(this, BC_Loop, m_pLoopButton = new wxBitmapToggleButton(this, SampleHive::ID::BC_Loop, static_cast<wxString>(ICON_LOOP_LIGHT_16px),
static_cast<wxString>(ICON_LOOP_LIGHT_16px),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pStopButton = new wxBitmapButton(this, BC_Stop, m_pStopButton = new wxBitmapButton(this, SampleHive::ID::BC_Stop,
wxBitmapBundle::FromBitmap(static_cast<wxString> wxBitmapBundle::FromBitmap(static_cast<wxString>(ICON_STOP_LIGHT_16px)),
(ICON_STOP_LIGHT_16px)),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pMuteButton = new wxBitmapToggleButton(this, BC_Mute, m_pMuteButton = new wxBitmapToggleButton(this, SampleHive::ID::BC_Mute, static_cast<wxString>(ICON_MUTE_LIGHT_16px),
static_cast<wxString>(ICON_MUTE_LIGHT_16px),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
} }
else else
{ {
m_pPlayButton = new wxBitmapButton(this, BC_Play, m_pPlayButton = new wxBitmapButton(this, SampleHive::ID::BC_Play,
wxBitmapBundle::FromBitmap(static_cast<wxString> wxBitmapBundle::FromBitmap(static_cast<wxString>(ICON_PLAY_DARK_16px)),
(ICON_PLAY_DARK_16px)),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pLoopButton = new wxBitmapToggleButton(this, BC_Loop, m_pLoopButton = new wxBitmapToggleButton(this, SampleHive::ID::BC_Loop, static_cast<wxString>(ICON_LOOP_DARK_16px),
static_cast<wxString>(ICON_LOOP_DARK_16px),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pStopButton = new wxBitmapButton(this, BC_Stop, m_pStopButton = new wxBitmapButton(this, SampleHive::ID::BC_Stop,
wxBitmapBundle::FromBitmap(static_cast<wxString> wxBitmapBundle::FromBitmap(static_cast<wxString>(ICON_STOP_DARK_16px)),
(ICON_STOP_DARK_16px)),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pMuteButton = new wxBitmapToggleButton(this, BC_Mute, m_pMuteButton = new wxBitmapToggleButton(this, SampleHive::ID::BC_Mute, static_cast<wxString>(ICON_MUTE_DARK_16px),
static_cast<wxString>(ICON_MUTE_DARK_16px),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
} }
@ -82,15 +94,14 @@ cTransportControls::cTransportControls(wxWindow* window, wxDataViewListCtrl& lib
m_pStopButton->SetToolTip(_("Stop")); m_pStopButton->SetToolTip(_("Stop"));
m_pMuteButton->SetToolTip(_("Mute")); m_pMuteButton->SetToolTip(_("Mute"));
// m_pSettingsButton = new wxButton(this, BC_Settings, _("Settings"), m_pSettingsButton = new wxButton(this, SampleHive::ID::BC_Settings, _("Settings"), wxDefaultPosition, wxDefaultSize, 0);
// wxDefaultPosition, wxDefaultSize, 0); m_pSettingsButton->SetToolTip(_("Settings"));
// m_pSettingsButton->SetToolTip(_("Settings"));
m_pMainSizer->Add(m_pPlayButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pMainSizer->Add(m_pPlayButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_pMainSizer->Add(m_pStopButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pMainSizer->Add(m_pStopButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_pMainSizer->Add(m_pLoopButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pMainSizer->Add(m_pLoopButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_pMainSizer->Add(m_pLoopABButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pMainSizer->Add(m_pLoopABButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
// m_pMainSizer->Add(m_pSettingsButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pMainSizer->Add(m_pSettingsButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_pMainSizer->Add(0,0,1, wxALL | wxEXPAND, 0); m_pMainSizer->Add(0,0,1, wxALL | wxEXPAND, 0);
m_pMainSizer->Add(m_pSamplePosition, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2); m_pMainSizer->Add(m_pSamplePosition, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
m_pMainSizer->Add(30,0,0, wxALL | wxEXPAND, 0); m_pMainSizer->Add(30,0,0, wxALL | wxEXPAND, 0);
@ -103,37 +114,61 @@ cTransportControls::cTransportControls(wxWindow* window, wxDataViewListCtrl& lib
m_pMainSizer->SetSizeHints(this); m_pMainSizer->SetSizeHints(this);
m_pMainSizer->Layout(); m_pMainSizer->Layout();
Bind(wxEVT_BUTTON, &cTransportControls::OnClickPlay, this, BC_Play); Bind(wxEVT_BUTTON, &cTransportControls::OnClickPlay, this, SampleHive::ID::BC_Play);
Bind(wxEVT_TOGGLEBUTTON, &cTransportControls::OnClickLoop, this, BC_Loop); Bind(wxEVT_TOGGLEBUTTON, &cTransportControls::OnClickLoop, this, SampleHive::ID::BC_Loop);
Bind(wxEVT_BUTTON, &cTransportControls::OnClickStop, this, BC_Stop); Bind(wxEVT_BUTTON, &cTransportControls::OnClickStop, this, SampleHive::ID::BC_Stop);
Bind(wxEVT_TOGGLEBUTTON, &cTransportControls::OnClickMute, this, BC_Mute); Bind(wxEVT_TOGGLEBUTTON, &cTransportControls::OnClickMute, this, SampleHive::ID::BC_Mute);
// Bind(wxEVT_BUTTON, &Controls::OnClickSettings, this, BC_Settings); Bind(wxEVT_BUTTON, &cTransportControls::OnClickSettings, this, SampleHive::ID::BC_Settings);
Bind(wxEVT_CHECKBOX, &cTransportControls::OnCheckAutoplay, this, BC_Autoplay); Bind(wxEVT_CHECKBOX, &cTransportControls::OnCheckAutoplay, this, SampleHive::ID::BC_Autoplay);
Bind(wxEVT_SCROLL_THUMBTRACK, &cTransportControls::OnSlideVolume, this, BC_Volume); Bind(wxEVT_SCROLL_THUMBTRACK, &cTransportControls::OnSlideVolume, this, SampleHive::ID::BC_Volume);
Bind(wxEVT_SCROLL_THUMBRELEASE, &cTransportControls::OnReleaseVolumeSlider, this, BC_Volume); Bind(wxEVT_SCROLL_THUMBRELEASE, &cTransportControls::OnReleaseVolumeSlider, this, SampleHive::ID::BC_Volume);
// Load control values from config file // Load control values from config file
LoadConfigFile(); LoadConfigFile();
} }
void cTransportControls::OnClickSettings(wxCommandEvent& event)
{
cSettings* settings = new cSettings(this);
switch (settings->ShowModal())
{
case wxID_OK:
if (settings->CanAutoImport())
{
SampleHive::cUtils::Get().OnAutoImportDir(settings->GetImportDirPath(), this);
// RefreshDatabase();
}
if (settings->IsWaveformColourChanged())
{
SampleHive::cSignal::SendWaveformUpdateStatus(*this);
}
break;
case wxID_CANCEL:
break;
default:
return;
}
}
void cTransportControls::OnClickPlay(wxCommandEvent& event) void cTransportControls::OnClickPlay(wxCommandEvent& event)
{ {
m_bStopped = false; m_bStopped = false;
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selection = m_Library.GetTextValue(selected_row, 1); wxString selection = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
// Send custom event to MainFrame to play the sample // Send custom event to MainFrame to play the sample
SampleHive::Signal::SendCallFunctionPlay(selection, *this); SampleHive::cSignal::SendCallFunctionPlay(selection, false, *this);
} }
void cTransportControls::OnClickLoop(wxCommandEvent& event) void cTransportControls::OnClickLoop(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
m_bLoop = m_pLoopButton->GetValue(); m_bLoop = m_pLoopButton->GetValue();
@ -148,17 +183,17 @@ void cTransportControls::OnClickStop(wxCommandEvent& event)
m_bStopped = true; m_bStopped = true;
// Send custom event to MainFrame to stop the timer // Send custom event to MainFrame to stop the timer
SampleHive::Signal::SendTimerStopStatus(*this); SampleHive::cSignal::SendTimerStopStatus(*this);
m_pSamplePosition->SetLabel("--:--/--:--"); m_pSamplePosition->SetLabel("--:--/--:--");
// Send custom event to MainFrame to set the statusbar status // Send custom event to MainFrame to set the statusbar status
SampleHive::Signal::SendSetStatusBarStatus(_("Stopped"), 1, *this); SampleHive::cSignal::SendSetStatusBarStatus(_("Stopped"), 1, *this);
} }
void cTransportControls::OnClickMute(wxCommandEvent& event) void cTransportControls::OnClickMute(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
if (m_pMuteButton->GetValue()) if (m_pMuteButton->GetValue())
{ {
@ -178,7 +213,7 @@ void cTransportControls::OnClickMute(wxCommandEvent& event)
void cTransportControls::OnCheckAutoplay(wxCommandEvent& event) void cTransportControls::OnCheckAutoplay(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
if (m_pAutoPlayCheck->GetValue()) if (m_pAutoPlayCheck->GetValue())
{ {
@ -199,39 +234,37 @@ void cTransportControls::OnSlideVolume(wxScrollEvent& event)
m_MediaCtrl.SetVolume(double(m_pVolumeSlider->GetValue()) / 100); m_MediaCtrl.SetVolume(double(m_pVolumeSlider->GetValue()) / 100);
// Send custom event to MainFrame to push status to statusbar // Send custom event to MainFrame to push status to statusbar
SampleHive::Signal::SendPushStatusBarStatus(wxString::Format(_("Volume: %d"), SampleHive::cSignal::SendPushStatusBarStatus(wxString::Format(_("Volume: %d"), m_pVolumeSlider->GetValue()), 1, *this);
m_pVolumeSlider->GetValue()), 1, *this);
} }
void cTransportControls::OnReleaseVolumeSlider(wxScrollEvent& event) void cTransportControls::OnReleaseVolumeSlider(wxScrollEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
serializer.SerializeMediaVolume(m_pVolumeSlider->GetValue()); serializer.SerializeMediaVolume(m_pVolumeSlider->GetValue());
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selection = m_Library.GetTextValue(selected_row, 1); wxString selection = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
// Wait a second then remove the status from statusbar // Wait a second then remove the status from statusbar
wxSleep(1); wxSleep(1);
// Send custom event to MainFrame to pop status from statusbar // Send custom event to MainFrame to pop status from statusbar
SampleHive::Signal::SendPopStatusBarStatus(1, *this); SampleHive::cSignal::SendPopStatusBarStatus(1, *this);
if (m_MediaCtrl.GetState() == wxMEDIASTATE_STOPPED) if (m_MediaCtrl.GetState() == wxMEDIASTATE_STOPPED)
SampleHive::Signal::SendSetStatusBarStatus(_("Stopped"), 1, *this); SampleHive::cSignal::SendSetStatusBarStatus(_("Stopped"), 1, *this);
else else
SampleHive::Signal::SendPushStatusBarStatus(wxString::Format(_("Now playing: %s"), selection), SampleHive::cSignal::SendPushStatusBarStatus(wxString::Format(_("Now playing: %s"), selection), 1, *this);
1, *this);
} }
void cTransportControls::LoadConfigFile() void cTransportControls::LoadConfigFile()
{ {
Serializer serializer; SampleHive::cSerializer serializer;
SH_LOG_INFO("Reading transport control values.."); SH_LOG_INFO("Reading transport control values..");

28
src/GUI/TransportControls.hpp
View File

@ -1,9 +1,28 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/bmpbuttn.h> #include <wx/bmpbuttn.h>
#include <wx/button.h> #include <wx/button.h>
#include <wx/checkbox.h> #include <wx/checkbox.h>
#include <wx/dataview.h>
#include <wx/event.h> #include <wx/event.h>
#include <wx/mediactrl.h> #include <wx/mediactrl.h>
#include <wx/settings.h> #include <wx/settings.h>
@ -12,7 +31,6 @@
#include <wx/stattext.h> #include <wx/stattext.h>
#include <wx/tglbtn.h> #include <wx/tglbtn.h>
#include <wx/panel.h> #include <wx/panel.h>
#include <wx/timer.h>
#include <wx/version.h> #include <wx/version.h>
#include <wx/window.h> #include <wx/window.h>
@ -20,7 +38,7 @@ class cTransportControls : public wxPanel
{ {
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
cTransportControls(wxWindow* window, wxDataViewListCtrl& library, wxMediaCtrl& mediaCtrl, wxTimer& timer); cTransportControls(wxWindow* window, wxMediaCtrl& mediaCtrl);
~cTransportControls(); ~cTransportControls();
public: public:
@ -65,11 +83,11 @@ class cTransportControls : public wxPanel
// Load control values from config file // Load control values from config file
void LoadConfigFile(); void LoadConfigFile();
void OnAutoImportDir(const wxString& pathToDirectory);
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
wxDataViewListCtrl& m_Library;
wxMediaCtrl& m_MediaCtrl; wxMediaCtrl& m_MediaCtrl;
wxTimer& m_Timer;
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------

115
src/GUI/Trash.cpp
View File

@ -1,25 +1,47 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "GUI/Trash.hpp" #include "GUI/Trash.hpp"
#include "GUI/Hives.hpp"
#include "GUI/ListCtrl.hpp"
#include "Database/Database.hpp" #include "Database/Database.hpp"
#include "Utility/ControlIDs.hpp" #include "Utility/ControlIDs.hpp"
#include "Utility/HiveData.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Signal.hpp" #include "Utility/Signal.hpp"
#include "Utility/Serialize.hpp" #include "Utility/Serialize.hpp"
#include "Utility/Utils.hpp"
#include <exception>
#include <wx/menu.h> #include <wx/menu.h>
#include <wx/msgdlg.h> #include <wx/msgdlg.h>
cTrashPanel::cTrashPanel(wxWindow* window, wxDataViewListCtrl& listCtrl) cTrashPanel::cTrashPanel(wxWindow* window)
: wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL), : wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL),
m_pWindow(window), m_ListCtrl(listCtrl) m_pWindow(window)
{ {
m_pMainSizer = new wxBoxSizer(wxVERTICAL); m_pMainSizer = new wxBoxSizer(wxVERTICAL);
m_pTrashSizer = new wxBoxSizer(wxVERTICAL); m_pTrashSizer = new wxBoxSizer(wxVERTICAL);
m_pButtonSizer = new wxBoxSizer(wxHORIZONTAL); m_pButtonSizer = new wxBoxSizer(wxHORIZONTAL);
m_pTrash = new wxTreeCtrl(this, BC_Trash, wxDefaultPosition, wxDefaultSize, m_pTrash = new wxTreeCtrl(this, SampleHive::ID::BC_Trash, wxDefaultPosition, wxDefaultSize,
wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_MULTIPLE); wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_MULTIPLE);
// Setting m_Trash to accept files to be dragged and dropped on it // Setting m_Trash to accept files to be dragged and dropped on it
@ -27,7 +49,7 @@ cTrashPanel::cTrashPanel(wxWindow* window, wxDataViewListCtrl& listCtrl)
m_pTrashSizer->Add(m_pTrash, wxSizerFlags(1).Expand()); m_pTrashSizer->Add(m_pTrash, wxSizerFlags(1).Expand());
m_pRestoreTrashedItemButton = new wxButton(this, BC_RestoreTrashedItem, _("Restore sample"), m_pRestoreTrashedItemButton = new wxButton(this, SampleHive::ID::BC_RestoreTrashedItem, _("Restore sample"),
wxDefaultPosition, wxDefaultSize, 0); wxDefaultPosition, wxDefaultSize, 0);
m_pRestoreTrashedItemButton->SetToolTip(_("Restore selected sample")); m_pRestoreTrashedItemButton->SetToolTip(_("Restore selected sample"));
@ -37,8 +59,8 @@ cTrashPanel::cTrashPanel(wxWindow* window, wxDataViewListCtrl& listCtrl)
m_TrashRoot = m_pTrash->AddRoot("Trash"); m_TrashRoot = m_pTrash->AddRoot("Trash");
m_pTrash->Connect(wxEVT_DROP_FILES, wxDropFilesEventHandler(cTrashPanel::OnDragAndDropToTrash), NULL, this); m_pTrash->Connect(wxEVT_DROP_FILES, wxDropFilesEventHandler(cTrashPanel::OnDragAndDropToTrash), NULL, this);
Bind(wxEVT_TREE_ITEM_RIGHT_CLICK, &cTrashPanel::OnShowTrashContextMenu, this, BC_Trash); Bind(wxEVT_TREE_ITEM_RIGHT_CLICK, &cTrashPanel::OnShowTrashContextMenu, this, SampleHive::ID::BC_Trash);
Bind(wxEVT_BUTTON, &cTrashPanel::OnClickRestoreTrashItem, this, BC_RestoreTrashedItem); Bind(wxEVT_BUTTON, &cTrashPanel::OnClickRestoreTrashItem, this, SampleHive::ID::BC_RestoreTrashedItem);
m_pMainSizer->Add(m_pTrashSizer, wxSizerFlags(1).Expand()); m_pMainSizer->Add(m_pTrashSizer, wxSizerFlags(1).Expand());
m_pMainSizer->Add(m_pButtonSizer, wxSizerFlags(0).Expand()); m_pMainSizer->Add(m_pButtonSizer, wxSizerFlags(0).Expand());
@ -52,10 +74,8 @@ cTrashPanel::cTrashPanel(wxWindow* window, wxDataViewListCtrl& listCtrl)
void cTrashPanel::OnDragAndDropToTrash(wxDropFilesEvent& event) void cTrashPanel::OnDragAndDropToTrash(wxDropFilesEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
cHivesPanel hives(m_pWindow, m_ListCtrl);
// cListCtrl m_ListCtrl.m_pWindow);
if (event.GetNumberOfFiles() > 0) if (event.GetNumberOfFiles() > 0)
{ {
@ -63,8 +83,7 @@ void cTrashPanel::OnDragAndDropToTrash(wxDropFilesEvent& event)
wxArrayString files; wxArrayString files;
wxDataViewItemArray items; wxDataViewItemArray items;
int rows = m_ListCtrl.GetSelections(items); int rows = SampleHive::cHiveData::Get().GetListCtrlSelections(items);
// int rows = 2;
wxString msg; wxString msg;
@ -73,13 +92,13 @@ void cTrashPanel::OnDragAndDropToTrash(wxDropFilesEvent& event)
for (int i = 0; i < rows; i++) for (int i = 0; i < rows; i++)
{ {
int item_row = m_ListCtrl.ItemToRow(items[i]); int item_row = SampleHive::cHiveData::Get().GetListCtrlRowFromItem(items, i);
wxString text_value = m_ListCtrl.GetTextValue(item_row, 1); wxString text_value = SampleHive::cHiveData::Get().GetListCtrlTextValue(item_row, 1);
std::string multi_selection = serializer.DeserializeShowFileExtension() ? std::string multi_selection = serializer.DeserializeShowFileExtension() ?
m_ListCtrl.GetTextValue(item_row, 1).BeforeLast('.').ToStdString() : SampleHive::cHiveData::Get().GetListCtrlTextValue(item_row, 1).BeforeLast('.').ToStdString() :
m_ListCtrl.GetTextValue(item_row, 1).ToStdString() ; SampleHive::cHiveData::Get().GetListCtrlTextValue(item_row, 1).ToStdString() ;
file_data.AddFile(multi_selection); file_data.AddFile(multi_selection);
@ -87,25 +106,25 @@ void cTrashPanel::OnDragAndDropToTrash(wxDropFilesEvent& event)
if (db.GetFavoriteColumnValueByFilename(files[i].ToStdString())) if (db.GetFavoriteColumnValueByFilename(files[i].ToStdString()))
{ {
m_ListCtrl.SetValue(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), item_row, 0); SampleHive::cHiveData::Get().ListCtrlSetVariant(wxVariant(wxBitmap(ICON_STAR_EMPTY_16px)), item_row, 0);
db.UpdateFavoriteColumn(files[i].ToStdString(), 0); db.UpdateFavoriteColumn(files[i].ToStdString(), 0);
for (int j = 0; j < hives.GetHivesObject()->GetChildCount(root); j++) for (int j = 0; j < SampleHive::cHiveData::Get().GetHiveChildCount(root); j++)
{ {
container = hives.GetHivesObject()->GetNthChild(root, j); container = SampleHive::cHiveData::Get().GetHiveNthChild(root, j);
for (int k = 0; k < hives.GetHivesObject()->GetChildCount(container); k++) for (int k = 0; k < SampleHive::cHiveData::Get().GetHiveChildCount(container); k++)
{ {
child = hives.GetHivesObject()->GetNthChild(container, k); child = SampleHive::cHiveData::Get().GetHiveNthChild(container, k);
wxString child_text = serializer.DeserializeShowFileExtension() ? wxString child_text = serializer.DeserializeShowFileExtension() ?
hives.GetHivesObject()->GetItemText(child).BeforeLast('.') : SampleHive::cHiveData::Get().GetHiveItemText(child).BeforeLast('.') :
hives.GetHivesObject()->GetItemText(child); SampleHive::cHiveData::Get().GetHiveItemText(child);
if (child_text == files[i]) if (child_text == files[i])
{ {
hives.GetHivesObject()->DeleteItem(child); SampleHive::cHiveData::Get().HiveDeleteItem(child);
break; break;
} }
} }
@ -114,39 +133,37 @@ void cTrashPanel::OnDragAndDropToTrash(wxDropFilesEvent& event)
db.UpdateTrashColumn(files[i].ToStdString(), 1); db.UpdateTrashColumn(files[i].ToStdString(), 1);
db.UpdateHiveName(files[i].ToStdString(), db.UpdateHiveName(files[i].ToStdString(),
hives.GetHivesObject()->GetItemText(hives.GetFavoritesHive()).ToStdString()); SampleHive::cHiveData::Get().GetHiveItemText(SampleHive::cHiveData::Get().GetFavoritesHive()).ToStdString());
m_pTrash->AppendItem(m_TrashRoot, text_value); m_pTrash->AppendItem(m_TrashRoot, text_value);
m_ListCtrl.DeleteItem(item_row); SampleHive::cHiveData::Get().ListCtrlDeleteItem(item_row);
msg = wxString::Format(_("%s sent to trash"), text_value); msg = wxString::Format(_("%s sent to trash"), text_value);
} }
if (!msg.IsEmpty()) if (!msg.IsEmpty())
SampleHive::Signal::SendInfoBarMessage(msg, wxICON_ERROR, *this); SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_ERROR, *this);
// m_InfoBar->ShowMessage(msg, wxICON_ERROR);
} }
} }
void cTrashPanel::OnShowTrashContextMenu(wxTreeEvent& event) void cTrashPanel::OnShowTrashContextMenu(wxTreeEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
// cListCtrl m_ListCtrl.m_pWindow);
wxTreeItemId selected_trashed_item = event.GetItem(); wxTreeItemId selected_trashed_item = event.GetItem();
wxMenu menu; wxMenu menu;
menu.Append(MN_DeleteTrash, _("Delete from database"), _("Delete the selected sample(s) from database")); menu.Append(SampleHive::ID::MN_DeleteTrash, _("Delete from database"), _("Delete the selected sample(s) from database"));
menu.Append(MN_RestoreTrashedItem, _("Restore sample"), _("Restore the selected sample(s) back to library")); menu.Append(SampleHive::ID::MN_RestoreTrashedItem, _("Restore sample"), _("Restore the selected sample(s) back to library"));
if (selected_trashed_item.IsOk()) if (selected_trashed_item.IsOk())
{ {
switch (m_pTrash->GetPopupMenuSelectionFromUser(menu, event.GetPoint())) switch (m_pTrash->GetPopupMenuSelectionFromUser(menu, event.GetPoint()))
{ {
case MN_DeleteTrash: case SampleHive::ID::MN_DeleteTrash:
{ {
wxString trashed_item_name = serializer.DeserializeShowFileExtension() ? wxString trashed_item_name = serializer.DeserializeShowFileExtension() ?
m_pTrash->GetItemText(selected_trashed_item).BeforeLast('.') : m_pTrash->GetItemText(selected_trashed_item).BeforeLast('.') :
@ -159,7 +176,7 @@ void cTrashPanel::OnShowTrashContextMenu(wxTreeEvent& event)
SH_LOG_INFO("{} deleted from trash and databse", trashed_item_name); SH_LOG_INFO("{} deleted from trash and databse", trashed_item_name);
} }
break; break;
case MN_RestoreTrashedItem: case SampleHive::ID::MN_RestoreTrashedItem:
{ {
wxArrayTreeItemIds selected_item_ids; wxArrayTreeItemIds selected_item_ids;
m_pTrash->GetSelections(selected_item_ids); m_pTrash->GetSelections(selected_item_ids);
@ -174,7 +191,7 @@ void cTrashPanel::OnShowTrashContextMenu(wxTreeEvent& event)
{ {
selected_item_text = m_pTrash->GetItemText(selected_item_ids[i]); selected_item_text = m_pTrash->GetItemText(selected_item_ids[i]);
// filename = GetFilenamePathAndExtension(selected_item_text).Filename; filename = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selected_item_text).Filename;
file_data.AddFile(filename); file_data.AddFile(filename);
@ -198,13 +215,13 @@ void cTrashPanel::OnShowTrashContextMenu(wxTreeEvent& event)
{ {
for (auto data : dataset) for (auto data : dataset)
{ {
m_ListCtrl.AppendItem(data); SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
} }
} }
} }
catch (...) catch (std::exception& e)
{ {
std::cerr << "Error loading data." << std::endl; SH_LOG_ERROR("Error loading data. {}", e.what());
} }
m_pTrash->Delete(selected_item_ids[i]); m_pTrash->Delete(selected_item_ids[i]);
@ -221,9 +238,8 @@ void cTrashPanel::OnShowTrashContextMenu(wxTreeEvent& event)
void cTrashPanel::OnClickRestoreTrashItem(wxCommandEvent& event) void cTrashPanel::OnClickRestoreTrashItem(wxCommandEvent& event)
{ {
Serializer serializer; SampleHive::cSerializer serializer;
Database db; cDatabase db;
// cListCtrl m_ListCtrl.m_pWindow);
wxArrayTreeItemIds selected_item_ids; wxArrayTreeItemIds selected_item_ids;
m_pTrash->GetSelections(selected_item_ids); m_pTrash->GetSelections(selected_item_ids);
@ -242,8 +258,7 @@ void cTrashPanel::OnClickRestoreTrashItem(wxCommandEvent& event)
if (selected_item_ids.IsEmpty()) if (selected_item_ids.IsEmpty())
{ {
wxMessageBox(_("No item selected, try selected a item first."), wxMessageBoxCaptionStr, wxMessageBox(_("No item selected, try selected a item first."), wxMessageBoxCaptionStr, wxOK | wxCENTRE, this);
wxOK | wxCENTRE, this);
return; return;
} }
@ -251,7 +266,7 @@ void cTrashPanel::OnClickRestoreTrashItem(wxCommandEvent& event)
{ {
selected_item_text = m_pTrash->GetItemText(selected_item_ids[i]); selected_item_text = m_pTrash->GetItemText(selected_item_ids[i]);
// filename = GetFilenamePathAndExtension(selected_item_text).Filename; filename = SampleHive::cUtils::Get().GetFilenamePathAndExtension(selected_item_text).Filename;
file_data.AddFile(filename); file_data.AddFile(filename);
@ -273,13 +288,13 @@ void cTrashPanel::OnClickRestoreTrashItem(wxCommandEvent& event)
{ {
for (auto data : dataset) for (auto data : dataset)
{ {
m_ListCtrl.AppendItem(data); SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
} }
} }
} }
catch (...) catch (std::exception& e)
{ {
std::cerr << "Error loading data." << std::endl; SH_LOG_ERROR("Error loading data. {}", e.what());
} }
m_pTrash->Delete(selected_item_ids[i]); m_pTrash->Delete(selected_item_ids[i]);

26
src/GUI/Trash.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/button.h> #include <wx/button.h>
@ -11,12 +31,12 @@
class cTrashPanel : public wxPanel class cTrashPanel : public wxPanel
{ {
public: public:
cTrashPanel(wxWindow* window, wxDataViewListCtrl& listCtrl); cTrashPanel(wxWindow* window);
~cTrashPanel(); ~cTrashPanel();
public: public:
wxTreeCtrl* GetTrashObject() { return m_pTrash; } wxTreeCtrl* GetTrashObject() { return m_pTrash; }
wxTreeItemId GetTrashRoot() { return m_TrashRoot; } wxTreeItemId& GetTrashRoot() { return m_TrashRoot; }
private: private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
@ -35,6 +55,4 @@ class cTrashPanel : public wxPanel
private: private:
wxWindow* m_pWindow = nullptr; wxWindow* m_pWindow = nullptr;
wxDataViewListCtrl& m_ListCtrl;
// friend class cListCtrl;
}; };

79
src/GUI/WaveformViewer.cpp
View File

@ -19,12 +19,13 @@
*/ */
#include "GUI/WaveformViewer.hpp" #include "GUI/WaveformViewer.hpp"
#include "Utility/Serialize.hpp" #include "Utility/HiveData.hpp"
#include "Utility/Signal.hpp"
#include "Utility/Tags.hpp"
#include "Utility/SH_Event.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/Paths.hpp" #include "Utility/Paths.hpp"
#include "Utility/Serialize.hpp"
#include "Utility/Event.hpp"
#include "Utility/Signal.hpp"
#include "Utility/Tags.hpp"
#include <vector> #include <vector>
@ -38,11 +39,9 @@
#include <sndfile.hh> #include <sndfile.hh>
cWaveformViewer::cWaveformViewer(wxWindow* window, wxDataViewListCtrl& library, cWaveformViewer::cWaveformViewer(wxWindow* window, wxMediaCtrl& mediaCtrl, cDatabase& database)
wxMediaCtrl& mediaCtrl, Database& database) : wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxNO_BORDER | wxFULL_REPAINT_ON_RESIZE),
: wxPanel(window, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_Window(window), m_Database(database), m_MediaCtrl(mediaCtrl)
wxTAB_TRAVERSAL | wxNO_BORDER | wxFULL_REPAINT_ON_RESIZE),
m_Window(window), m_Database(database), m_Library(library), m_MediaCtrl(mediaCtrl)
{ {
this->SetDoubleBuffered(true); this->SetDoubleBuffered(true);
@ -110,7 +109,7 @@ void cWaveformViewer::OnPaint(wxPaintEvent& event)
bAreaSelected = true; bAreaSelected = true;
// SendLoopPoints(); // SendLoopPoints();
SampleHive::Signal::SendLoopPoints(CalculateLoopPoints(), *this); SampleHive::cSignal::SendLoopPoints(CalculateLoopPoints(), *this);
} }
else else
bAreaSelected = false; bAreaSelected = false;
@ -118,15 +117,15 @@ void cWaveformViewer::OnPaint(wxPaintEvent& event)
void cWaveformViewer::RenderPlayhead(wxDC& dc) void cWaveformViewer::RenderPlayhead(wxDC& dc)
{ {
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selected = m_Library.GetTextValue(selected_row, 1); wxString selected = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString()); std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
Tags tags(path); SampleHive::cTags tags(path);
int length = tags.GetAudioInfo().length; int length = tags.GetAudioInfo().length;
SH_LOG_DEBUG("Sample length: {}", length); SH_LOG_DEBUG("Sample length: {}", length);
@ -150,23 +149,21 @@ void cWaveformViewer::RenderPlayhead(wxDC& dc)
// Draw the line // Draw the line
dc.SetPen(wxPen(m_PlayheadColour, 2, wxPENSTYLE_SOLID)); dc.SetPen(wxPen(m_PlayheadColour, 2, wxPENSTYLE_SOLID));
dc.DrawLine(line_pos, this->GetSize().GetHeight() - (this->GetSize().GetHeight() - 1), dc.DrawLine(line_pos, this->GetSize().GetHeight() - (this->GetSize().GetHeight() - 1), line_pos, this->GetSize().GetHeight() - 1);
line_pos, this->GetSize().GetHeight() - 1);
} }
void cWaveformViewer::UpdateWaveformBitmap() void cWaveformViewer::UpdateWaveformBitmap()
{ {
Serializer serializer; SampleHive::cSerializer serializer;
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selection = m_Library.GetTextValue(selected_row, 1); wxString selection = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
wxString filepath_with_extension = wxString filepath_with_extension = m_Database.GetSamplePathByFilename(selection.BeforeLast('.').ToStdString());
m_Database.GetSamplePathByFilename(selection.BeforeLast('.').ToStdString());
wxString filepath_without_extension = m_Database.GetSamplePathByFilename(selection.ToStdString()); wxString filepath_without_extension = m_Database.GetSamplePathByFilename(selection.ToStdString());
std::string extension = serializer.DeserializeShowFileExtension() ? std::string extension = serializer.DeserializeShowFileExtension() ?
@ -283,9 +280,12 @@ void cWaveformViewer::OnControlKeyUp(wxKeyEvent &event)
if (bSelectRange) if (bSelectRange)
{ {
SetCursor(wxCURSOR_ARROW); SetCursor(wxCURSOR_ARROW);
bSelectRange = false; bSelectRange = false;
bDrawSelectedArea = false; bDrawSelectedArea = false;
ReleaseMouse(); ReleaseMouse();
return; return;
} }
break; break;
@ -298,15 +298,15 @@ void cWaveformViewer::OnControlKeyUp(wxKeyEvent &event)
void cWaveformViewer::OnMouseMotion(wxMouseEvent& event) void cWaveformViewer::OnMouseMotion(wxMouseEvent& event)
{ {
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selected = m_Library.GetTextValue(selected_row, 1); wxString selected = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString()); std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
Tags tags(path); SampleHive::cTags tags(path);
int length = tags.GetAudioInfo().length; int length = tags.GetAudioInfo().length;
@ -338,15 +338,15 @@ void cWaveformViewer::OnMouseMotion(wxMouseEvent& event)
void cWaveformViewer::OnMouseLeftButtonDown(wxMouseEvent& event) void cWaveformViewer::OnMouseLeftButtonDown(wxMouseEvent& event)
{ {
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selected = m_Library.GetTextValue(selected_row, 1); wxString selected = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString()); std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
Tags tags(path); SampleHive::cTags tags(path);
int length = tags.GetAudioInfo().length; int length = tags.GetAudioInfo().length;
@ -387,15 +387,15 @@ void cWaveformViewer::OnMouseLeftButtonDown(wxMouseEvent& event)
void cWaveformViewer::OnMouseLeftButtonUp(wxMouseEvent& event) void cWaveformViewer::OnMouseLeftButtonUp(wxMouseEvent& event)
{ {
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return; return;
wxString selected = m_Library.GetTextValue(selected_row, 1); wxString selected = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString()); std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
Tags tags(path); SampleHive::cTags tags(path);
int length = tags.GetAudioInfo().length; int length = tags.GetAudioInfo().length;
@ -436,9 +436,8 @@ void cWaveformViewer::OnMouseLeftButtonUp(wxMouseEvent& event)
SetCursor(wxCURSOR_ARROW); SetCursor(wxCURSOR_ARROW);
m_MediaCtrl.Seek(seek_to, wxFromStart); m_MediaCtrl.Seek(seek_to, wxFromStart);
// SendPushStatusBarStatus(wxString::Format(_("Now playing: %s"), selected), 1); SampleHive::cSignal::SendPushStatusBarStatus(wxString::Format(_("Now playing: %s"), selected), 1, *this);
SampleHive::Signal::SendInfoBarMessage(wxString::Format(_("Now playing: %s"), selected), 1, *this); SampleHive::cSignal::SendCallFunctionPlay(selected, false, *this);
m_MediaCtrl.Play();
} }
} }
@ -453,15 +452,15 @@ void cWaveformViewer::ResetDC()
std::pair<double, double> cWaveformViewer::CalculateLoopPoints() std::pair<double, double> cWaveformViewer::CalculateLoopPoints()
{ {
int selected_row = m_Library.GetSelectedRow(); int selected_row = SampleHive::cHiveData::Get().GetListCtrlSelectedRow();
if (selected_row < 0) if (selected_row < 0)
return { 0.0, 0.0 }; return { 0.0, 0.0 };
wxString selected = m_Library.GetTextValue(selected_row, 1); wxString selected = SampleHive::cHiveData::Get().GetListCtrlTextValue(selected_row, 1);
std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString()); std::string path = m_Database.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
Tags tags(path); SampleHive::cTags tags(path);
int length = tags.GetAudioInfo().length; int length = tags.GetAudioInfo().length;
@ -474,13 +473,3 @@ std::pair<double, double> cWaveformViewer::CalculateLoopPoints()
return { loopA, loopB }; return { loopA, loopB };
} }
// void cWaveformViewer::SendPushStatusBarStatus(const wxString& msg, int section)
// {
// SampleHive::SH_StatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_PUSH, this->GetId());
// event.SetEventObject(this);
// event.SetPushMessageAndSection({ msg, section });
// HandleWindowEvent(event);
// }

14
src/GUI/WaveformViewer.hpp
View File

@ -22,24 +22,20 @@
#include "Database/Database.hpp" #include "Database/Database.hpp"
#include <wx/dataview.h>
#include <wx/bitmap.h> #include <wx/bitmap.h>
#include <wx/colour.h> #include <wx/colour.h>
#include <wx/dc.h> #include <wx/dc.h>
#include <wx/event.h> #include <wx/event.h>
#include <wx/infobar.h>
#include <wx/mediactrl.h> #include <wx/mediactrl.h>
#include <wx/panel.h> #include <wx/panel.h>
#include <wx/sizer.h> #include <wx/sizer.h>
#include <wx/statusbr.h> #include <wx/statusbr.h>
#include <wx/timer.h>
#include <wx/window.h> #include <wx/window.h>
class cWaveformViewer : public wxPanel class cWaveformViewer : public wxPanel
{ {
public: public:
cWaveformViewer(wxWindow* window, wxDataViewListCtrl& library, cWaveformViewer(wxWindow* window, wxMediaCtrl& mediaCtrl, cDatabase& database);
wxMediaCtrl& mediaCtrl, Database& database);
~cWaveformViewer(); ~cWaveformViewer();
private: private:
@ -49,8 +45,7 @@ class cWaveformViewer : public wxPanel
wxBoxSizer* m_Sizer; wxBoxSizer* m_Sizer;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
Database& m_Database; cDatabase& m_Database;
wxDataViewListCtrl& m_Library;
wxMediaCtrl& m_MediaCtrl; wxMediaCtrl& m_MediaCtrl;
private: private:
@ -89,11 +84,6 @@ class cWaveformViewer : public wxPanel
// ------------------------------------------------------------------- // -------------------------------------------------------------------
std::pair<double, double> CalculateLoopPoints(); std::pair<double, double> CalculateLoopPoints();
// -------------------------------------------------------------------
// Send custom events
// void SendLoopPoints();
// void SendPushStatusBarStatus(const wxString& msg, int section);
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
void ResetDC(); void ResetDC();

4
src/Utility/ControlIDs.hpp
View File

@ -20,6 +20,8 @@
#include <wx/defs.h> #include <wx/defs.h>
namespace SampleHive { namespace ID {
enum ControlIDs enum ControlIDs
{ {
/* /*
@ -115,3 +117,5 @@ enum ControlIDs
ET_TypeCheck, ET_TypeCheck,
ET_CustomTag, ET_CustomTag,
}; };
}}

57
src/Utility/SH_Event.cpp → src/Utility/Event.cpp
View File

@ -18,35 +18,24 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
#include "Utility/SH_Event.hpp" #include "Utility/Event.hpp"
namespace SampleHive namespace SampleHive
{ {
LoopPointsEvent::LoopPointsEvent(wxEventType eventType, int winId) cLoopPointsEvent::cLoopPointsEvent(wxEventType eventType, int winId)
: wxCommandEvent(eventType, winId) : wxCommandEvent(eventType, winId)
{ {
} }
LoopPointsEvent::~LoopPointsEvent() cLoopPointsEvent::~cLoopPointsEvent()
{ {
} }
wxDEFINE_EVENT(SH_EVT_LOOP_POINTS_UPDATED, LoopPointsEvent); wxDEFINE_EVENT(SH_EVT_LOOP_POINTS_UPDATED, cLoopPointsEvent);
wxDEFINE_EVENT(SH_EVT_LOOP_POINTS_CLEAR, cLoopPointsEvent);
// AddSampleEvent::AddSampleEvent(wxEventType eventType, int winId) wxDEFINE_EVENT(SH_EVT_LOOP_AB_BUTTON_VALUE_CHANGE, cLoopPointsEvent);
// : wxCommandEvent(eventType, winId)
// {
// }
// AddSampleEvent::~AddSampleEvent()
// {
// }
// wxDEFINE_EVENT(SH_EVT_STATUS_ADD_SAMPLE, AddSampleEvent);
// MediaEvent::MediaEvent(wxEventType eventType, int winId) // MediaEvent::MediaEvent(wxEventType eventType, int winId)
// : wxCommandEvent(eventType, winId) // : wxCommandEvent(eventType, winId)
@ -61,70 +50,70 @@ namespace SampleHive
// wxDEFINE_EVENT(SH_EVT_MEDIA_STATUS_UPDATED, MediaEvent); // wxDEFINE_EVENT(SH_EVT_MEDIA_STATUS_UPDATED, MediaEvent);
StatusBarStatusEvent::StatusBarStatusEvent(wxEventType eventType, int winId) cStatusBarStatusEvent::cStatusBarStatusEvent(wxEventType eventType, int winId)
: wxCommandEvent(eventType, winId) : wxCommandEvent(eventType, winId)
{ {
} }
StatusBarStatusEvent::~StatusBarStatusEvent() cStatusBarStatusEvent::~cStatusBarStatusEvent()
{ {
} }
wxDEFINE_EVENT(SH_EVT_STATUSBAR_STATUS_PUSH, StatusBarStatusEvent); wxDEFINE_EVENT(SH_EVT_STATUSBAR_STATUS_PUSH, cStatusBarStatusEvent);
wxDEFINE_EVENT(SH_EVT_STATUSBAR_STATUS_POP, StatusBarStatusEvent); wxDEFINE_EVENT(SH_EVT_STATUSBAR_STATUS_POP, cStatusBarStatusEvent);
wxDEFINE_EVENT(SH_EVT_STATUSBAR_STATUS_SET, StatusBarStatusEvent); wxDEFINE_EVENT(SH_EVT_STATUSBAR_STATUS_SET, cStatusBarStatusEvent);
InfoBarMessageEvent::InfoBarMessageEvent(wxEventType eventType, int winId) cInfoBarMessageEvent::cInfoBarMessageEvent(wxEventType eventType, int winId)
: wxCommandEvent(eventType, winId) : wxCommandEvent(eventType, winId)
{ {
} }
InfoBarMessageEvent::~InfoBarMessageEvent() cInfoBarMessageEvent::~cInfoBarMessageEvent()
{ {
} }
wxDEFINE_EVENT(SH_EVT_INFOBAR_MESSAGE_SHOW, InfoBarMessageEvent); wxDEFINE_EVENT(SH_EVT_INFOBAR_MESSAGE_SHOW, cInfoBarMessageEvent);
TimerEvent::TimerEvent(wxEventType eventType, int winId) cTimerEvent::cTimerEvent(wxEventType eventType, int winId)
: wxCommandEvent(eventType, winId) : wxCommandEvent(eventType, winId)
{ {
} }
TimerEvent::~TimerEvent() cTimerEvent::~cTimerEvent()
{ {
} }
wxDEFINE_EVENT(SH_EVT_TIMER_STOP, TimerEvent); wxDEFINE_EVENT(SH_EVT_TIMER_STOP, cTimerEvent);
CallFunctionEvent::CallFunctionEvent(wxEventType eventType, int winId) cCallFunctionEvent::cCallFunctionEvent(wxEventType eventType, int winId)
: wxCommandEvent(eventType, winId) : wxCommandEvent(eventType, winId)
{ {
} }
CallFunctionEvent::~CallFunctionEvent() cCallFunctionEvent::~cCallFunctionEvent()
{ {
} }
wxDEFINE_EVENT(SH_EVT_CALL_FUNC_PLAY, CallFunctionEvent); wxDEFINE_EVENT(SH_EVT_CALL_FUNC_PLAY, cCallFunctionEvent);
WaveformUpdateEvent::WaveformUpdateEvent(wxEventType eventType, int winId) cWaveformUpdateEvent::cWaveformUpdateEvent(wxEventType eventType, int winId)
: wxCommandEvent(eventType, winId) : wxCommandEvent(eventType, winId)
{ {
} }
WaveformUpdateEvent::~WaveformUpdateEvent() cWaveformUpdateEvent::~cWaveformUpdateEvent()
{ {
} }
wxDEFINE_EVENT(SH_EVT_UPDATE_WAVEFORM, WaveformUpdateEvent); wxDEFINE_EVENT(SH_EVT_UPDATE_WAVEFORM, cWaveformUpdateEvent);
} }

100
src/Utility/SH_Event.hpp → src/Utility/Event.hpp
View File

@ -26,14 +26,14 @@
namespace SampleHive namespace SampleHive
{ {
class LoopPointsEvent : public wxCommandEvent class cLoopPointsEvent : public wxCommandEvent
{ {
public: public:
LoopPointsEvent(wxEventType eventType, int winId); cLoopPointsEvent(wxEventType eventType, int winId);
~LoopPointsEvent(); ~cLoopPointsEvent();
public: public:
virtual wxEvent* Clone() const { return new LoopPointsEvent(*this); } virtual wxEvent* Clone() const { return new cLoopPointsEvent(*this); }
public: public:
std::pair<double, double> GetLoopPoints() const { return { m_LoopA, m_LoopB }; }; std::pair<double, double> GetLoopPoints() const { return { m_LoopA, m_LoopB }; };
@ -44,35 +44,18 @@ namespace SampleHive
double m_LoopA, m_LoopB; double m_LoopA, m_LoopB;
}; };
wxDECLARE_EVENT(SH_EVT_LOOP_POINTS_UPDATED, LoopPointsEvent); wxDECLARE_EVENT(SH_EVT_LOOP_POINTS_UPDATED, cLoopPointsEvent);
wxDECLARE_EVENT(SH_EVT_LOOP_POINTS_CLEAR, cLoopPointsEvent);
wxDECLARE_EVENT(SH_EVT_LOOP_AB_BUTTON_VALUE_CHANGE, cLoopPointsEvent);
// class AddSampleEvent : public wxCommandEvent // class cMediaEvent : public wxCommandEvent
// { // {
// public: // public:
// AddSampleEvent(wxEventType eventType, int winId); // cMediaEvent(wxEventType eventType, int winId);
// ~AddSampleEvent(); // ~cMediaEvent();
// public: // public:
// virtual wxEvent* Clone() const { return new AddSampleEvent(*this); } // virtual wxEvent* Clone() const { return new cMediaEvent(*this); }
// public:
// wxArrayString GetArrayString() const { return m_Files; };
// void SetArrayString(const wxArrayString& files) { m_Files = files; };
// private:
// wxArrayString m_Files;
// };
// wxDECLARE_EVENT(SH_EVT_STATUS_ADD_SAMPLE, AddSampleEvent);
// class MediaEvent : public wxCommandEvent
// {
// public:
// MediaEvent(wxEventType eventType, int winId);
// ~MediaEvent();
// public:
// virtual wxEvent* Clone() const { return new MediaEvent(*this); }
// public: // public:
// void SetPath(const wxString& path) { m_Path = path; } // void SetPath(const wxString& path) { m_Path = path; }
@ -82,16 +65,16 @@ namespace SampleHive
// wxString m_Path; // wxString m_Path;
// }; // };
// wxDECLARE_EVENT(SH_EVT_MEDIA_STATUS_UPDATED, MediaEvent); // wxDECLARE_EVENT(SH_EVT_MEDIA_STATUS_UPDATED, cMediaEvent);
class StatusBarStatusEvent : public wxCommandEvent class cStatusBarStatusEvent : public wxCommandEvent
{ {
public: public:
StatusBarStatusEvent(wxEventType eventType, int winId); cStatusBarStatusEvent(wxEventType eventType, int winId);
~StatusBarStatusEvent(); ~cStatusBarStatusEvent();
public: public:
virtual wxEvent* Clone() const { return new StatusBarStatusEvent(*this); } virtual wxEvent* Clone() const { return new cStatusBarStatusEvent(*this); }
public: public:
std::pair<wxString, int> GetPushMessageAndSection() const { return { m_Msg, m_PushSection }; } std::pair<wxString, int> GetPushMessageAndSection() const { return { m_Msg, m_PushSection }; }
@ -110,18 +93,18 @@ namespace SampleHive
int m_PushSection, m_PopSection, m_SetSection; int m_PushSection, m_PopSection, m_SetSection;
}; };
wxDECLARE_EVENT(SH_EVT_STATUSBAR_STATUS_PUSH, StatusBarStatusEvent); wxDECLARE_EVENT(SH_EVT_STATUSBAR_STATUS_PUSH, cStatusBarStatusEvent);
wxDECLARE_EVENT(SH_EVT_STATUSBAR_STATUS_POP, StatusBarStatusEvent); wxDECLARE_EVENT(SH_EVT_STATUSBAR_STATUS_POP, cStatusBarStatusEvent);
wxDECLARE_EVENT(SH_EVT_STATUSBAR_STATUS_SET, StatusBarStatusEvent); wxDECLARE_EVENT(SH_EVT_STATUSBAR_STATUS_SET, cStatusBarStatusEvent);
class InfoBarMessageEvent : public wxCommandEvent class cInfoBarMessageEvent : public wxCommandEvent
{ {
public: public:
InfoBarMessageEvent(wxEventType eventType, int winId); cInfoBarMessageEvent(wxEventType eventType, int winId);
~InfoBarMessageEvent(); ~cInfoBarMessageEvent();
public: public:
virtual wxEvent* Clone() const { return new InfoBarMessageEvent(*this); } virtual wxEvent* Clone() const { return new cInfoBarMessageEvent(*this); }
public: public:
std::pair<wxString, int> GetInfoBarMessage() const { return { m_Msg, m_Mode }; } std::pair<wxString, int> GetInfoBarMessage() const { return { m_Msg, m_Mode }; }
@ -133,49 +116,52 @@ namespace SampleHive
int m_Mode; int m_Mode;
}; };
wxDECLARE_EVENT(SH_EVT_INFOBAR_MESSAGE_SHOW, InfoBarMessageEvent); wxDECLARE_EVENT(SH_EVT_INFOBAR_MESSAGE_SHOW, cInfoBarMessageEvent);
class TimerEvent : public wxCommandEvent class cTimerEvent : public wxCommandEvent
{ {
public: public:
TimerEvent(wxEventType eventType, int winId); cTimerEvent(wxEventType eventType, int winId);
~TimerEvent(); ~cTimerEvent();
public: public:
virtual wxEvent* Clone() const { return new TimerEvent(*this); } virtual wxEvent* Clone() const { return new cTimerEvent(*this); }
}; };
wxDECLARE_EVENT(SH_EVT_TIMER_STOP, TimerEvent); wxDECLARE_EVENT(SH_EVT_TIMER_STOP, cTimerEvent);
class CallFunctionEvent : public wxCommandEvent class cCallFunctionEvent : public wxCommandEvent
{ {
public: public:
CallFunctionEvent(wxEventType eventType, int winId); cCallFunctionEvent(wxEventType eventType, int winId);
~CallFunctionEvent(); ~cCallFunctionEvent();
public: public:
virtual wxEvent* Clone() const { return new CallFunctionEvent(*this); } virtual wxEvent* Clone() const { return new cCallFunctionEvent(*this); }
public: public:
wxString GetSlection() { return m_Selection; } wxString GetSlection() const { return m_Selection; }
bool GetAutoplayValue() const { return m_bCheckAutoplay; }
void SetSelection(const wxString& selection) { m_Selection = selection; } void SetSelection(const wxString& selection) { m_Selection = selection; }
void SetAutoplayValue(bool autoplay) { m_bCheckAutoplay = autoplay; }
private: private:
wxString m_Selection; wxString m_Selection;
bool m_bCheckAutoplay;
}; };
wxDECLARE_EVENT(SH_EVT_CALL_FUNC_PLAY, CallFunctionEvent); wxDECLARE_EVENT(SH_EVT_CALL_FUNC_PLAY, cCallFunctionEvent);
class WaveformUpdateEvent : public wxCommandEvent class cWaveformUpdateEvent : public wxCommandEvent
{ {
public: public:
WaveformUpdateEvent(wxEventType eventType, int winId); cWaveformUpdateEvent(wxEventType eventType, int winId);
~WaveformUpdateEvent(); ~cWaveformUpdateEvent();
public: public:
virtual wxEvent* Clone() const { return new WaveformUpdateEvent(*this); } virtual wxEvent* Clone() const { return new cWaveformUpdateEvent(*this); }
}; };
wxDECLARE_EVENT(SH_EVT_UPDATE_WAVEFORM, WaveformUpdateEvent); wxDECLARE_EVENT(SH_EVT_UPDATE_WAVEFORM, cWaveformUpdateEvent);
} }

115
src/Utility/HiveData.hpp Normal file
View File

@ -0,0 +1,115 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "wx/dataview.h"
#include "wx/string.h"
#include "wx/treectrl.h"
#include "wx/treebase.h"
#include "wx/variant.h"
#include "wx/vector.h"
#include <string>
namespace SampleHive {
class cHiveData
{
private:
cHiveData() = default;
public:
cHiveData(const cHiveData&) = delete;
cHiveData& operator=(const cHiveData) = delete;
public:
static cHiveData& Get()
{
static cHiveData s_HiveData;
return s_HiveData;
}
public:
// ===============================================================
// HivesPanel functions
void InitHiveData(wxDataViewListCtrl& listCtrl, wxDataViewTreeCtrl& hives, wxDataViewItem favoriteHive,
wxTreeCtrl& trash, wxTreeItemId trashRoot)
{
m_pListCtrl = &listCtrl;
m_FavoriteHive = favoriteHive;
m_pHives = &hives;
m_TrashRoot = trashRoot;
m_pTrash = &trash;
}
inline wxDataViewTreeCtrl& GetHivesObj() { return *m_pHives; }
inline wxDataViewItem& GetFavoritesHive() { return m_FavoriteHive; }
wxString GetHiveItemText(bool ofFavHive = false, wxDataViewItem hive = wxDataViewItem(0))
{
wxString item_text;
if (ofFavHive)
item_text = m_pHives->GetItemText(m_FavoriteHive);
else
item_text = m_pHives->GetItemText(hive);
return item_text;
}
inline wxDataViewItem GetHiveItemSelection() { return m_pHives->GetSelection(); }
inline bool IsHiveItemContainer(wxDataViewItem& hiveItem) { return m_pHives->IsContainer(hiveItem); }
inline int GetHiveChildCount(wxDataViewItem& root) { return m_pHives->GetChildCount(root); }
inline wxDataViewItem GetHiveNthChild(wxDataViewItem& root, int pos) { return m_pHives->GetNthChild(root, pos); }
inline void HiveAppendItem(wxDataViewItem& hiveItem, wxString name) { m_pHives->AppendItem(hiveItem, name); }
inline void HiveDeleteItem(wxDataViewItem& hiveItem) { m_pHives->DeleteItem(hiveItem); }
// ===============================================================
// TrashPanel functions
inline wxTreeCtrl& GetTrashObj() { return *m_pTrash; }
inline wxTreeItemId& GetTrashRoot() { return m_TrashRoot; }
inline void TrashAppendItem(const wxTreeItemId& parent, const wxString& text) { m_pTrash->AppendItem(parent, text); }
// ===============================================================
// ListCtrl functions
inline wxDataViewListCtrl& GetListCtrlObj() { return *m_pListCtrl; }
inline int GetListCtrlSelections(wxDataViewItemArray& items) { return m_pListCtrl->GetSelections(items); }
inline int GetListCtrlRowFromItem(wxDataViewItemArray& items, int index) { return m_pListCtrl->ItemToRow(items[index]); }
inline int GetListCtrlSelectedRow() { return m_pListCtrl->GetSelectedRow(); }
inline wxDataViewItem GetListCtrlItemFromRow(int row) { return m_pListCtrl->RowToItem(row); }
inline wxString GetListCtrlTextValue(unsigned int row, unsigned int col) { return m_pListCtrl->GetTextValue(row, col); }
inline int GetListCtrlItemCount() { return m_pListCtrl->GetItemCount(); }
inline void ListCtrlAppendItem(const wxVector<wxVariant>& values) { m_pListCtrl->AppendItem(values); }
inline void ListCtrlSetVariant(const wxVariant& variant, unsigned int row, unsigned int col)
{ m_pListCtrl->SetValue(variant, row, col); }
inline void ListCtrlUnselectAllItems() { m_pListCtrl->UnselectAll(); }
inline void ListCtrlSelectRow(int row) { m_pListCtrl->SelectRow(row); }
inline void ListCtrlEnsureVisible(const wxDataViewItem& item) { m_pListCtrl->EnsureVisible(item); }
inline void ListCtrlDeleteItem(unsigned int row) { m_pListCtrl->DeleteItem(row); }
inline void ListCtrlDeleteAllItems() { m_pListCtrl->DeleteAllItems(); }
private:
wxDataViewListCtrl* m_pListCtrl = nullptr;
wxDataViewItem m_FavoriteHive;
wxDataViewTreeCtrl* m_pHives = nullptr;
wxTreeCtrl* m_pTrash = nullptr;
wxTreeItemId m_TrashRoot;
};
}

28
src/Utility/Log.cpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "Log.hpp" #include "Log.hpp"
#include <iostream> #include <iostream>
@ -6,16 +26,16 @@
namespace SampleHive { namespace SampleHive {
std::shared_ptr<spdlog::logger> Log::s_Logger; std::shared_ptr<spdlog::logger> cLog::s_pLogger;
void Log::InitLogger(const std::string& logger) void cLog::InitLogger(const std::string& logger)
{ {
spdlog::set_pattern("%^[%-T] [%-n] [%l]: %v %@%$"); spdlog::set_pattern("%^[%-T] [%-n] [%l]: %v %@%$");
try try
{ {
s_Logger = spdlog::stdout_color_mt(logger); s_pLogger = spdlog::stdout_color_mt(logger);
s_Logger->set_level(spdlog::level::trace); s_pLogger->set_level(spdlog::level::trace);
} }
catch (const spdlog::spdlog_ex& ex) catch (const spdlog::spdlog_ex& ex)
{ {

42
src/Utility/Log.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <memory> #include <memory>
@ -8,24 +28,24 @@
namespace SampleHive { namespace SampleHive {
class Log class cLog
{ {
public: public:
static void InitLogger(const std::string& logger); static void InitLogger(const std::string& logger);
public: public:
inline static std::shared_ptr<spdlog::logger>& GetLogger() { return s_Logger; } inline static std::shared_ptr<spdlog::logger>& GetLogger() { return s_pLogger; }
private: private:
static std::shared_ptr<spdlog::logger> s_Logger; static std::shared_ptr<spdlog::logger> s_pLogger;
}; };
}
// Log macros // Log macros
#define SH_LOG_TRACE(...) SPDLOG_LOGGER_TRACE(::SampleHive::Log::GetLogger(), __VA_ARGS__) #define SH_LOG_TRACE(...) SPDLOG_LOGGER_TRACE(::SampleHive::cLog::GetLogger(), __VA_ARGS__)
#define SH_LOG_INFO(...) SPDLOG_LOGGER_INFO(::SampleHive::Log::GetLogger(), __VA_ARGS__) #define SH_LOG_INFO(...) SPDLOG_LOGGER_INFO(::SampleHive::cLog::GetLogger(), __VA_ARGS__)
#define SH_LOG_WARN(...) SPDLOG_LOGGER_WARN(::SampleHive::Log::GetLogger(), __VA_ARGS__) #define SH_LOG_WARN(...) SPDLOG_LOGGER_WARN(::SampleHive::cLog::GetLogger(), __VA_ARGS__)
#define SH_LOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(::SampleHive::Log::GetLogger(), __VA_ARGS__) #define SH_LOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(::SampleHive::cLog::GetLogger(), __VA_ARGS__)
#define SH_LOG_ERROR(...) SPDLOG_LOGGER_ERROR(::SampleHive::Log::GetLogger(), __VA_ARGS__) #define SH_LOG_ERROR(...) SPDLOG_LOGGER_ERROR(::SampleHive::cLog::GetLogger(), __VA_ARGS__)
#define SH_LOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(::SampleHive::Log::GetLogger(), __VA_ARGS__) #define SH_LOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(::SampleHive::cLog::GetLogger(), __VA_ARGS__)
}

24
src/Utility/Paths.hpp
View File

@ -1,7 +1,29 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include "SampleHiveConfig.hpp" #include "SampleHiveConfig.hpp"
namespace SampleHive {
// Path to all the assets // Path to all the assets
#define ICON_HIVE_16px SAMPLEHIVE_DATADIR "/icons/icon-hive_16x16.png" #define ICON_HIVE_16px SAMPLEHIVE_DATADIR "/icons/icon-hive_16x16.png"
#define ICON_HIVE_24px SAMPLEHIVE_DATADIR "/icons/icon-hive_24x24.png" #define ICON_HIVE_24px SAMPLEHIVE_DATADIR "/icons/icon-hive_24x24.png"
@ -29,3 +51,5 @@
#define APP_DATA_DIR USER_HOME_DIR + "/.local/share/SampleHive" #define APP_DATA_DIR USER_HOME_DIR + "/.local/share/SampleHive"
#define CONFIG_FILEPATH APP_CONFIG_DIR + "/config.yaml" #define CONFIG_FILEPATH APP_CONFIG_DIR + "/config.yaml"
#define DATABASE_FILEPATH APP_DATA_DIR "/sample.hive" #define DATABASE_FILEPATH APP_DATA_DIR "/sample.hive"
}

52
src/Utility/Serialize.cpp
View File

@ -31,7 +31,9 @@
#include <yaml-cpp/emittermanip.h> #include <yaml-cpp/emittermanip.h>
#include <yaml-cpp/node/parse.h> #include <yaml-cpp/node/parse.h>
Serializer::Serializer() namespace SampleHive {
cSerializer::cSerializer()
{ {
std::ifstream ifstrm(static_cast<std::string>(CONFIG_FILEPATH)); std::ifstream ifstrm(static_cast<std::string>(CONFIG_FILEPATH));
@ -105,12 +107,12 @@ Serializer::Serializer()
} }
} }
Serializer::~Serializer() cSerializer::~cSerializer()
{ {
} }
void Serializer::SerializeWinSize(int w, int h) void cSerializer::SerializeWinSize(int w, int h)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -139,7 +141,7 @@ void Serializer::SerializeWinSize(int w, int h)
} }
} }
WindowSize Serializer::DeserializeWinSize() const WindowSize cSerializer::DeserializeWinSize() const
{ {
int width = 800, height = 600; int width = 800, height = 600;
@ -168,7 +170,7 @@ WindowSize Serializer::DeserializeWinSize() const
return { width, height }; return { width, height };
} }
void Serializer::SerializeShowMenuAndStatusBar(std::string key, bool value) void cSerializer::SerializeShowMenuAndStatusBar(std::string key, bool value)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -198,7 +200,7 @@ void Serializer::SerializeShowMenuAndStatusBar(std::string key, bool value)
} }
} }
bool Serializer::DeserializeShowMenuAndStatusBar(std::string key) const bool cSerializer::DeserializeShowMenuAndStatusBar(std::string key) const
{ {
bool show = false; bool show = false;
@ -227,7 +229,7 @@ bool Serializer::DeserializeShowMenuAndStatusBar(std::string key) const
return show; return show;
} }
void Serializer::SerializeSplitterSashPos(std::string key, int pos) void cSerializer::SerializeSplitterSashPos(std::string key, int pos)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -257,7 +259,7 @@ void Serializer::SerializeSplitterSashPos(std::string key, int pos)
} }
} }
int Serializer::DeserializeSplitterSashPos(std::string key) const int cSerializer::DeserializeSplitterSashPos(std::string key) const
{ {
int pos = 0; int pos = 0;
@ -286,7 +288,7 @@ int Serializer::DeserializeSplitterSashPos(std::string key) const
return pos; return pos;
} }
void Serializer::SerializeMediaOptions(std::string key, bool value) void cSerializer::SerializeMediaOptions(std::string key, bool value)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -319,7 +321,7 @@ void Serializer::SerializeMediaOptions(std::string key, bool value)
} }
} }
bool Serializer::DeserializeMediaOptions(std::string key) const bool cSerializer::DeserializeMediaOptions(std::string key) const
{ {
bool control = false; bool control = false;
@ -351,7 +353,7 @@ bool Serializer::DeserializeMediaOptions(std::string key) const
return control; return control;
} }
void Serializer::SerializeMediaVolume(int volume) void cSerializer::SerializeMediaVolume(int volume)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -377,7 +379,7 @@ void Serializer::SerializeMediaVolume(int volume)
} }
} }
int Serializer::DeserializeMediaVolume() const int cSerializer::DeserializeMediaVolume() const
{ {
int volume = 0; int volume = 0;
@ -400,7 +402,7 @@ int Serializer::DeserializeMediaVolume() const
return volume; return volume;
} }
void Serializer::SerializeFontSettings(wxFont& font) void cSerializer::SerializeFontSettings(wxFont& font)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -434,7 +436,7 @@ void Serializer::SerializeFontSettings(wxFont& font)
} }
} }
wxFont Serializer::DeserializeFontSettings() const wxFont cSerializer::DeserializeFontSettings() const
{ {
wxFont font; wxFont font;
@ -468,7 +470,7 @@ wxFont Serializer::DeserializeFontSettings() const
return font; return font;
} }
void Serializer::SerializeWaveformColour(wxColour& colour) void cSerializer::SerializeWaveformColour(wxColour& colour)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -500,7 +502,7 @@ void Serializer::SerializeWaveformColour(wxColour& colour)
} }
} }
wxColour Serializer::DeserializeWaveformColour() const wxColour cSerializer::DeserializeWaveformColour() const
{ {
std::string colour; std::string colour;
@ -527,7 +529,7 @@ wxColour Serializer::DeserializeWaveformColour() const
return static_cast<wxString>(colour); return static_cast<wxString>(colour);
} }
void Serializer::SerializeAutoImport(bool autoImport, const std::string& importDir) void cSerializer::SerializeAutoImport(bool autoImport, const std::string& importDir)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -556,7 +558,7 @@ void Serializer::SerializeAutoImport(bool autoImport, const std::string& importD
} }
} }
ImportDirInfo Serializer::DeserializeAutoImport() const ImportDirInfo cSerializer::DeserializeAutoImport() const
{ {
wxString dir; wxString dir;
bool auto_import = false; bool auto_import = false;
@ -583,7 +585,7 @@ ImportDirInfo Serializer::DeserializeAutoImport() const
return { auto_import, dir }; return { auto_import, dir };
} }
void Serializer::SerializeFollowSymLink(bool followSymLinks) void cSerializer::SerializeFollowSymLink(bool followSymLinks)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -611,7 +613,7 @@ void Serializer::SerializeFollowSymLink(bool followSymLinks)
} }
} }
bool Serializer::DeserializeFollowSymLink() const bool cSerializer::DeserializeFollowSymLink() const
{ {
bool follow_sym_links = false; bool follow_sym_links = false;
@ -636,7 +638,7 @@ bool Serializer::DeserializeFollowSymLink() const
return follow_sym_links; return follow_sym_links;
} }
void Serializer::SerializeRecursiveImport(bool recursiveImport) void cSerializer::SerializeRecursiveImport(bool recursiveImport)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -664,7 +666,7 @@ void Serializer::SerializeRecursiveImport(bool recursiveImport)
} }
} }
bool Serializer::DeserializeRecursiveImport() const bool cSerializer::DeserializeRecursiveImport() const
{ {
bool recursive_import = false; bool recursive_import = false;
@ -689,7 +691,7 @@ bool Serializer::DeserializeRecursiveImport() const
return recursive_import; return recursive_import;
} }
void Serializer::SerializeShowFileExtension(bool showExtension) void cSerializer::SerializeShowFileExtension(bool showExtension)
{ {
YAML::Emitter out; YAML::Emitter out;
@ -717,7 +719,7 @@ void Serializer::SerializeShowFileExtension(bool showExtension)
} }
} }
bool Serializer::DeserializeShowFileExtension() const bool cSerializer::DeserializeShowFileExtension() const
{ {
bool show_extension = false; bool show_extension = false;
@ -741,3 +743,5 @@ bool Serializer::DeserializeShowFileExtension() const
return show_extension; return show_extension;
} }
}

18
src/Utility/Serialize.hpp
View File

@ -42,15 +42,13 @@ typedef std::pair<int, int> WindowSize;
// typedef std::pair<wxString, int> FontType; // typedef std::pair<wxString, int> FontType;
typedef std::pair<bool, wxString> ImportDirInfo; typedef std::pair<bool, wxString> ImportDirInfo;
class Serializer namespace SampleHive {
class cSerializer
{ {
public: public:
Serializer(); cSerializer();
~Serializer(); ~cSerializer();
private:
// -------------------------------------------------------------------
YAML::Emitter m_Emitter;
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
@ -105,4 +103,10 @@ class Serializer
// Show file extension // Show file extension
void SerializeShowFileExtension(bool showExtension); void SerializeShowFileExtension(bool showExtension);
bool DeserializeShowFileExtension() const; bool DeserializeShowFileExtension() const;
private:
// -------------------------------------------------------------------
YAML::Emitter m_Emitter;
}; };
}

80
src/Utility/Signal.cpp
View File

@ -1,12 +1,32 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "Utility/Signal.hpp" #include "Utility/Signal.hpp"
#include "Utility/Log.hpp" #include "Utility/Log.hpp"
#include "Utility/SH_Event.hpp" #include "Utility/Event.hpp"
namespace SampleHive { namespace SampleHive {
void Signal::SendInfoBarMessage(const wxString& msg, int mode, wxWindow& window, bool isDialog) void cSignal::SendInfoBarMessage(const wxString& msg, int mode, wxWindow& window, bool isDialog)
{ {
SampleHive::InfoBarMessageEvent event(SampleHive::SH_EVT_INFOBAR_MESSAGE_SHOW, window.GetId()); SampleHive::cInfoBarMessageEvent event(SampleHive::SH_EVT_INFOBAR_MESSAGE_SHOW, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
event.SetInfoBarMessage({ msg, mode }); event.SetInfoBarMessage({ msg, mode });
@ -17,9 +37,9 @@ namespace SampleHive {
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendPushStatusBarStatus(const wxString& msg, int section, wxWindow& window, bool isDialog) void cSignal::SendPushStatusBarStatus(const wxString& msg, int section, wxWindow& window, bool isDialog)
{ {
SampleHive::StatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_PUSH, window.GetId()); SampleHive::cStatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_PUSH, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
event.SetPushMessageAndSection({ msg, section }); event.SetPushMessageAndSection({ msg, section });
@ -30,9 +50,9 @@ namespace SampleHive {
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendPopStatusBarStatus(int section, wxWindow& window, bool isDialog) void cSignal::SendPopStatusBarStatus(int section, wxWindow& window, bool isDialog)
{ {
SampleHive::StatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_POP, window.GetId()); SampleHive::cStatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_POP, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
event.SetPopMessageSection(section); event.SetPopMessageSection(section);
@ -43,9 +63,9 @@ namespace SampleHive {
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendSetStatusBarStatus(const wxString& text, int section, wxWindow& window, bool isDialog) void cSignal::SendSetStatusBarStatus(const wxString& text, int section, wxWindow& window, bool isDialog)
{ {
SampleHive::StatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_SET, window.GetId()); SampleHive::cStatusBarStatusEvent event(SampleHive::SH_EVT_STATUSBAR_STATUS_SET, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
event.SetStatusTextAndSection({ text, section }); event.SetStatusTextAndSection({ text, section });
@ -56,12 +76,13 @@ namespace SampleHive {
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendCallFunctionPlay(const wxString& selection, wxWindow& window, bool isDialog) void cSignal::SendCallFunctionPlay(const wxString& selection, bool checkAutoplay, wxWindow& window, bool isDialog)
{ {
SampleHive::CallFunctionEvent event(SampleHive::SH_EVT_CALL_FUNC_PLAY, window.GetId()); SampleHive::cCallFunctionEvent event(SampleHive::SH_EVT_CALL_FUNC_PLAY, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
event.SetSelection(selection); event.SetSelection(selection);
event.SetAutoplayValue(checkAutoplay);
if (isDialog) if (isDialog)
window.GetParent()->GetEventHandler()->ProcessEvent(event); window.GetParent()->GetEventHandler()->ProcessEvent(event);
@ -69,9 +90,9 @@ namespace SampleHive {
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendTimerStopStatus(wxWindow& window, bool isDialog) void cSignal::SendTimerStopStatus(wxWindow& window, bool isDialog)
{ {
SampleHive::TimerEvent event(SampleHive::SH_EVT_TIMER_STOP, window.GetId()); SampleHive::cTimerEvent event(SampleHive::SH_EVT_TIMER_STOP, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
if (isDialog) if (isDialog)
@ -80,19 +101,44 @@ namespace SampleHive {
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendLoopPoints(std::pair<double, double> loopPoint, wxWindow& window, bool isDialog) void cSignal::SendLoopPoints(std::pair<double, double> loopPoint, wxWindow& window, bool isDialog)
{ {
SampleHive::LoopPointsEvent event(SampleHive::SH_EVT_LOOP_POINTS_UPDATED, window.GetId()); SampleHive::cLoopPointsEvent event(SampleHive::SH_EVT_LOOP_POINTS_UPDATED, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
event.SetLoopPoints({loopPoint.first, loopPoint.second}); event.SetLoopPoints({loopPoint.first, loopPoint.second});
if (isDialog)
window.GetParent()->GetEventHandler()->ProcessEvent(event);
else
window.HandleWindowEvent(event); window.HandleWindowEvent(event);
} }
void Signal::SendWaveformUpdateStatus(wxWindow& window, bool isDialog) void cSignal::SendClearLoopPointsStatus(wxWindow& window, bool isDialog)
{ {
SampleHive::WaveformUpdateEvent event(SampleHive::SH_EVT_UPDATE_WAVEFORM, window.GetId()); SampleHive::cLoopPointsEvent event(SampleHive::SH_EVT_LOOP_POINTS_CLEAR, window.GetId());
event.SetEventObject(&window);
if (isDialog)
window.GetParent()->GetEventHandler()->ProcessEvent(event);
else
window.HandleWindowEvent(event);
}
void cSignal::SendLoopABButtonValueChange(wxWindow& window, bool isDialog)
{
SampleHive::cLoopPointsEvent event(SampleHive::SH_EVT_LOOP_AB_BUTTON_VALUE_CHANGE, window.GetId());
event.SetEventObject(&window);
if (isDialog)
window.GetParent()->GetEventHandler()->ProcessEvent(event);
else
window.HandleWindowEvent(event);
}
void cSignal::SendWaveformUpdateStatus(wxWindow& window, bool isDialog)
{
SampleHive::cWaveformUpdateEvent event(SampleHive::SH_EVT_UPDATE_WAVEFORM, window.GetId());
event.SetEventObject(&window); event.SetEventObject(&window);
if (isDialog) if (isDialog)

31
src/Utility/Signal.hpp
View File

@ -1,3 +1,23 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <wx/string.h> #include <wx/string.h>
@ -5,22 +25,23 @@
namespace SampleHive { namespace SampleHive {
class Signal class cSignal
{ {
public: public:
Signal(); cSignal();
~Signal(); ~cSignal();
public: public:
static void SendInfoBarMessage(const wxString& msg, int mode, wxWindow& window, bool isDialog = false); static void SendInfoBarMessage(const wxString& msg, int mode, wxWindow& window, bool isDialog = false);
static void SendPushStatusBarStatus(const wxString& msg, int section, wxWindow& window, bool isDialog = false); static void SendPushStatusBarStatus(const wxString& msg, int section, wxWindow& window, bool isDialog = false);
static void SendSetStatusBarStatus(const wxString& msg, int section, wxWindow& window, bool isDialog = false); static void SendSetStatusBarStatus(const wxString& msg, int section, wxWindow& window, bool isDialog = false);
static void SendPopStatusBarStatus(int section, wxWindow& window, bool isDialog = false); static void SendPopStatusBarStatus(int section, wxWindow& window, bool isDialog = false);
static void SendCallFunctionPlay(const wxString& selection, wxWindow& window, bool isDialog = false); static void SendCallFunctionPlay(const wxString& selection, bool checkAutoplay, wxWindow& window, bool isDialog = false);
static void SendTimerStopStatus(wxWindow& window, bool isDialog = false); static void SendTimerStopStatus(wxWindow& window, bool isDialog = false);
static void SendLoopPoints(std::pair<double, double> loopPoint, wxWindow& window, bool isDialog = false); static void SendLoopPoints(std::pair<double, double> loopPoint, wxWindow& window, bool isDialog = false);
static void SendClearLoopPointsStatus(wxWindow& window, bool isDialog = false);
static void SendLoopABButtonValueChange(wxWindow& window, bool isDialog = false);
static void SendWaveformUpdateStatus(wxWindow& window, bool isDialog = false); static void SendWaveformUpdateStatus(wxWindow& window, bool isDialog = false);
}; };
} }

24
src/Utility/Tags.cpp
View File

@ -30,18 +30,20 @@
#include <taglib/tstring.h> #include <taglib/tstring.h>
#endif #endif
Tags::Tags(const std::string& filename) namespace SampleHive {
cTags::cTags(const std::string& filename)
: m_Filepath(filename) : m_Filepath(filename)
{ {
} }
Tags::~Tags() cTags::~cTags()
{ {
} }
AudioInfo Tags::GetAudioInfo() cTags::AudioInfo cTags::GetAudioInfo()
{ {
wxString artist, album, genre, title, comment; wxString artist, album, genre, title, comment;
int channels = 0, length = 0, sample_rate = 0, bitrate = 0; int channels = 0, length = 0, sample_rate = 0, bitrate = 0;
@ -74,17 +76,17 @@ AudioInfo Tags::GetAudioInfo()
genre = wxString::FromUTF8(Genre.toCString(true)); genre = wxString::FromUTF8(Genre.toCString(true));
comment = wxString::FromUTF8(Comment.toCString(true)); comment = wxString::FromUTF8(Comment.toCString(true));
bValid = true; m_bValid = true;
} }
else else
{ {
bValid = false; m_bValid = false;
} }
return { title, artist, album, genre, comment, channels, length, sample_rate, bitrate }; return { title, artist, album, genre, comment, channels, length, sample_rate, bitrate };
} }
void Tags::SetTitle(std::string title) void cTags::SetTitle(std::string title)
{ {
TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average); TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average);
@ -97,7 +99,7 @@ void Tags::SetTitle(std::string title)
} }
} }
void Tags::SetArtist(std::string artist) void cTags::SetArtist(std::string artist)
{ {
TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average); TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average);
@ -110,7 +112,7 @@ void Tags::SetArtist(std::string artist)
} }
} }
void Tags::SetAlbum(std::string album) void cTags::SetAlbum(std::string album)
{ {
TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average); TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average);
@ -123,7 +125,7 @@ void Tags::SetAlbum(std::string album)
} }
} }
void Tags::SetGenre(std::string genre) void cTags::SetGenre(std::string genre)
{ {
TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average); TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average);
@ -136,7 +138,7 @@ void Tags::SetGenre(std::string genre)
} }
} }
void Tags::SetComment(std::string comment) void cTags::SetComment(std::string comment)
{ {
TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average); TagLib::FileRef f (static_cast<const char*>(m_Filepath.c_str()), true, TagLib::AudioProperties::ReadStyle::Average);
@ -148,3 +150,5 @@ void Tags::SetComment(std::string comment)
f.save(); f.save();
} }
} }
}

28
src/Utility/Tags.hpp
View File

@ -24,6 +24,10 @@
#include <wx/string.h> #include <wx/string.h>
namespace SampleHive {
class cTags
{
struct AudioInfo struct AudioInfo
{ {
wxString title; wxString title;
@ -38,21 +42,13 @@ struct AudioInfo
int bitrate; int bitrate;
}; };
class Tags
{
public: public:
Tags(const std::string& filepath); cTags(const std::string& filepath);
~Tags(); ~cTags();
private:
// -------------------------------------------------------------------
const std::string& m_Filepath;
bool bValid = false;
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
AudioInfo GetAudioInfo(); cTags::AudioInfo GetAudioInfo();
void SetTitle(std::string artist); void SetTitle(std::string artist);
void SetArtist(std::string artist); void SetArtist(std::string artist);
void SetAlbum(std::string album); void SetAlbum(std::string album);
@ -61,5 +57,13 @@ class Tags
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
inline bool IsFileValid() { return bValid; } inline bool IsFileValid() { return m_bValid; }
private:
// -------------------------------------------------------------------
const std::string& m_Filepath;
bool m_bValid = false;
}; };
}

221
src/Utility/Utils.cpp Normal file
View File

@ -0,0 +1,221 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "Database/Database.hpp"
#include "Utility/HiveData.hpp"
#include "Utility/Log.hpp"
#include "Utility/Paths.hpp"
#include "Utility/Serialize.hpp"
#include "Utility/Signal.hpp"
#include "Utility/Tags.hpp"
#include "Utility/Utils.hpp"
#include <wx/dir.h>
#include <wx/progdlg.h>
namespace SampleHive {
SampleHive::cUtils::FileInfo SampleHive::cUtils::GetFilenamePathAndExtension(const wxString& selected,
bool checkExtension, bool doGetFilename) const
{
SampleHive::cSerializer serializer;
cDatabase db;
wxString path;
std::string extension, filename;
wxString filename_with_extension = db.GetSamplePathByFilename(selected.BeforeLast('.').ToStdString());
wxString filename_without_extension = db.GetSamplePathByFilename(selected.ToStdString());
if (checkExtension)
{
extension = serializer.DeserializeShowFileExtension() ?
db.GetSampleFileExtension(selected.ToStdString()) :
db.GetSampleFileExtension(selected.BeforeLast('.').ToStdString());
}
path = selected.Contains(wxString::Format(".%s", extension)) ?
filename_with_extension : filename_without_extension;
if (doGetFilename)
filename = path.AfterLast('/').BeforeLast('.').ToStdString();
return { path, extension, filename };
}
void SampleHive::cUtils::AddSamples(wxArrayString& files, wxWindow* parent)
{
SampleHive::cSerializer serializer;
cDatabase db;
wxBusyCursor busy_cursor;
wxWindowDisabler window_disabler;
wxProgressDialog* progressDialog = new wxProgressDialog(_("Adding files.."),
_("Adding files, please wait..."),
static_cast<int>(files.size()), parent,
wxPD_APP_MODAL | wxPD_SMOOTH | wxPD_CAN_ABORT |
wxPD_AUTO_HIDE);
progressDialog->CenterOnParent(wxBOTH);
std::vector<Sample> sample_array;
std::string path;
std::string artist;
std::string filename_with_extension;
std::string filename_without_extension;
std::string extension;
std::string filename;
//Check All Files At Once
wxArrayString sorted_files;
sorted_files = db.CheckDuplicates(files);
files = sorted_files;
if (files.size() < 1)
{
progressDialog->Destroy();
return;
}
progressDialog->SetRange(files.size());
for (unsigned int i = 0; i < files.size(); i++)
{
progressDialog->Update(i, wxString::Format(_("Getting Data For %s"), files[i].AfterLast('/')));
if (progressDialog->WasCancelled())
{
progressDialog->Destroy();
return;
}
path = files[i].ToStdString();
filename_with_extension = files[i].AfterLast('/').ToStdString();
filename_without_extension = files[i].AfterLast('/').BeforeLast('.').ToStdString();
extension = files[i].AfterLast('.').ToStdString();
filename = serializer.DeserializeShowFileExtension() ?
filename_with_extension : filename_without_extension;
Sample sample;
sample.SetPath(path);
sample.SetFilename(filename_without_extension);
sample.SetFileExtension(extension);
cTags tags(path);
artist = tags.GetAudioInfo().artist.ToStdString();
sample.SetSamplePack(artist);
sample.SetChannels(tags.GetAudioInfo().channels);
sample.SetLength(tags.GetAudioInfo().length);
sample.SetSampleRate(tags.GetAudioInfo().sample_rate);
sample.SetBitrate(tags.GetAudioInfo().bitrate);
wxLongLong llLength = sample.GetLength();
int total_min = static_cast<int>((llLength / 60000).GetValue());
int total_sec = static_cast<int>(((llLength % 60000) / 1000).GetValue());
wxVector<wxVariant> data;
wxVariant icon = wxVariant(wxBitmap(ICON_STAR_EMPTY_16px));
if (tags.IsFileValid())
{
data.clear();
data.push_back(icon);
data.push_back(filename);
data.push_back(sample.GetSamplePack());
data.push_back("");
data.push_back(wxString::Format("%d", sample.GetChannels()));
data.push_back(wxString::Format("%2i:%02i", total_min, total_sec));
data.push_back(wxString::Format("%d", sample.GetSampleRate()));
data.push_back(wxString::Format("%d", sample.GetBitrate()));
data.push_back(path);
SH_LOG_INFO("Adding file: {}, Extension: {}", sample.GetFilename(), sample.GetFileExtension());
SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
sample_array.push_back(sample);
}
else
{
wxString msg = wxString::Format(_("Error! Cannot open %s, Invalid file type."),
filename_with_extension);
SampleHive::cSignal::SendInfoBarMessage(msg, wxICON_ERROR, *parent);
}
}
progressDialog->Pulse(_("Updating Database.."), NULL);
db.InsertIntoSamples(sample_array);
progressDialog->Destroy();
}
void cUtils::OnAutoImportDir(const wxString& pathToDirectory, wxWindow* parent)
{
SH_LOG_DEBUG("Start Importing Samples");
wxBusyCursor busy_cursor;
wxWindowDisabler window_disabler;
wxString filepath;
wxArrayString filepath_array;
size_t number_of_files = wxDir::GetAllFiles(pathToDirectory, &filepath_array, wxEmptyString, wxDIR_DEFAULT);
wxProgressDialog* progressDialog = new wxProgressDialog(_("Adding files.."),
_("Adding files, please wait..."),
static_cast<int>(number_of_files), parent,
wxPD_APP_MODAL | wxPD_SMOOTH |
wxPD_CAN_ABORT | wxPD_AUTO_HIDE);
progressDialog->CenterOnParent(wxBOTH);
for (size_t i = 0; i < number_of_files; i++)
{
filepath = filepath_array[i];
if (wxFileExists(filepath))
{
filepath_array.push_back(filepath);
}
else if (wxDirExists(filepath))
{
wxDir::GetAllFiles(filepath, &filepath_array);
}
progressDialog->Pulse(_("Reading Samples"), NULL);
}
progressDialog->Destroy();
AddSamples(filepath_array, parent);
SH_LOG_DEBUG("Done Importing Samples");
}
}

59
src/Utility/Utils.hpp Normal file
View File

@ -0,0 +1,59 @@
/* SampleHive
* Copyright (C) 2021 Apoorv Singh
* A simple, modern audio sample browser/manager for GNU/Linux.
*
* This file is a part of SampleHive
*
* SampleHive 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 3 of the License, or
* (at your option) any later version.
*
* SampleHive 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, see <https://www.gnu.org/licenses/>.
*/
#include "wx/arrstr.h"
#include "wx/string.h"
#include "wx/window.h"
namespace SampleHive {
class cUtils
{
private:
cUtils() = default;
public:
cUtils(const cUtils&) = delete;
cUtils& operator=(const cUtils) = delete;
public:
static cUtils& Get()
{
static cUtils s_cUtils;
return s_cUtils;
}
public:
struct FileInfo
{
wxString Path;
std::string Extension;
std::string Filename;
};
// -------------------------------------------------------------------
cUtils::FileInfo GetFilenamePathAndExtension(const wxString& selected,
bool checkExtension = true,
bool doGetFilename = true) const;
void AddSamples(wxArrayString& files, wxWindow* parent);
void OnAutoImportDir(const wxString& pathToDirectory, wxWindow* parent);
};
}