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

939 lines
33 KiB
C++
Raw Blame History

/* 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/MainFrame.hpp"
#include "GUI/Dialogs/Settings.hpp"
#include "Database/Database.hpp"
#include "Utility/ControlIDs.hpp"
#include "Utility/HiveData.hpp"
#include "Utility/Log.hpp"
#include "Utility/Paths.hpp"
#include "Utility/Utils.hpp"
#include "SampleHiveConfig.hpp"
#include <exception>
#include <wx/aboutdlg.h>
#include <wx/artprov.h>
#include <wx/defs.h>
#include <wx/filedlg.h>
#include <wx/fswatcher.h>
#include <wx/gdicmn.h>
#include <wx/menu.h>
#include <wx/msgdlg.h>
#include <wx/stringimpl.h>
cMainFrame::cMainFrame()
: wxFrame(NULL, wxID_ANY, "SampleHive", wxDefaultPosition)
{
// Initialize statusbar with 4 sections
m_pStatusBar = CreateStatusBar(4);
// Set width for each section of the statusbar
int status_width[4] = { 300, -6, -1, -2 };
m_pStatusBar->SetStatusWidths(4, status_width);
m_pHiveBitmap = new wxStaticBitmap(m_pStatusBar, wxID_ANY, wxBitmap(ICON_HIVE_24px));
// Initialize menubar and menus
m_pMenuBar = new wxMenuBar();
m_pFileMenu = new wxMenu();
m_pEditMenu = new wxMenu();
m_pViewMenu = new wxMenu();
m_pHelpMenu = new wxMenu();
// File menu items
m_pAddFile = new wxMenuItem(m_pFileMenu, SampleHive::ID::MN_AddFile, _("Add a file\tCtrl+F"), _("Add a file"));
m_pAddFile->SetBitmap(wxArtProvider::GetBitmap(wxART_NORMAL_FILE));
m_pFileMenu->Append(m_pAddFile);
m_pAddDirectory = new wxMenuItem(m_pFileMenu, SampleHive::ID::MN_AddDirectory, _("Add a directory\tCtrl+D"), _("Add a directory"));
m_pAddDirectory->SetBitmap(wxArtProvider::GetBitmap(wxART_FOLDER));
m_pFileMenu->Append(m_pAddDirectory);
m_pFileMenu->AppendSeparator();
m_pFileMenu->Append(wxID_EXIT, wxEmptyString, _("Exits the application"));
// Edit menu items
m_pEditMenu->Append(wxID_PREFERENCES, _("Preferences\tCtrl+P"), _("Open preferences dialog"));
// View menu items
m_pToggleExtension = new wxMenuItem(m_pViewMenu, SampleHive::ID::MN_ToggleExtension,
_("Toggle Extension\tCtrl+E"), _("Show/Hide Extension"), wxITEM_CHECK);
m_pToggleMenuBar = new wxMenuItem(m_pViewMenu, SampleHive::ID::MN_ToggleMenuBar,
_("Toggle Menu Bar\tCtrl+M"), _("Show/Hide Menu Bar"), wxITEM_CHECK);
m_pToggleStatusBar = new wxMenuItem(m_pViewMenu, SampleHive::ID::MN_ToggleStatusBar,
_("Toggle Status Bar\tCtrl+B"), _("Show/Hide Status Bar"), wxITEM_CHECK);
m_pViewMenu->Append(m_pToggleExtension)->Check(true);
m_pViewMenu->Append(m_pToggleMenuBar)->Check(m_pMenuBar->IsShown());
m_pViewMenu->Append(m_pToggleStatusBar)->Check(m_pStatusBar->IsShown());
// Help menu items
m_pHelpMenu->Append(wxID_REFRESH, _("Reset app data"), _("Clear the application data revert to default configuration"));
m_pHelpMenu->Append(wxID_ABOUT, wxEmptyString, _("Show about the application"));
// Append all menus to menubar
m_pMenuBar->Append(m_pFileMenu, _("&File"));
m_pMenuBar->Append(m_pEditMenu, _("&Edit"));
m_pMenuBar->Append(m_pViewMenu, _("&View"));
m_pMenuBar->Append(m_pHelpMenu, _("&Help"));
// Set the menu bar to use
SetMenuBar(m_pMenuBar);
// Load default yaml config file.
LoadConfigFile();
// Initialize the database
InitDatabase();
// Initializing Sizers
m_pMainSizer = new wxBoxSizer(wxVERTICAL);
m_pTopPanelMainSizer = new wxBoxSizer(wxVERTICAL);
// Creating top splitter window
m_pTopSplitter = new wxSplitterWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxSP_NOBORDER | wxSP_LIVE_UPDATE | wxSP_THIN_SASH);
m_pTopSplitter->SetMinimumPaneSize(200);
m_pTopSplitter->SetSashGravity(0);
// Top half of TopSplitter window
m_pTopPanel = new wxPanel(m_pTopSplitter, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
// Bottom half of the TopSplitter window
m_pBottomSplitter = new wxSplitterWindow(m_pTopSplitter, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxSP_NOBORDER | wxSP_LIVE_UPDATE | wxSP_THIN_SASH);
m_pBottomSplitter->SetMinimumPaneSize(300);
m_pBottomSplitter->SetSashGravity(0);
m_pNotebook = new cNotebook(m_pBottomSplitter);
m_pLibrary = new cLibrary(m_pBottomSplitter);
SampleHive::cHiveData::Get().InitHiveData(*m_pLibrary->GetListCtrlObject(),
*m_pNotebook->GetHivesPanel()->GetHivesObject(),
m_pNotebook->GetHivesPanel()->GetFavoritesHive(),
*m_pNotebook->GetTrashPanel()->GetTrashObject(),
m_pNotebook->GetTrashPanel()->GetTrashRoot());
// Set split direction
m_pTopSplitter->SplitHorizontally(m_pTopPanel, m_pBottomSplitter);
m_pBottomSplitter->SplitVertically(m_pNotebook, m_pLibrary);
// Initializing wxMediaCtrl.
m_pMediaCtrl = new wxMediaCtrl(this, SampleHive::ID::BC_MediaCtrl, wxEmptyString, wxDefaultPosition,
wxDefaultSize, 0, wxEmptyString);
// Intializing wxTimer
m_pTimer = new wxTimer(this);
m_pTransportControls = new cTransportControls(m_pTopPanel, *m_pMediaCtrl);
m_pWaveformViewer = new cWaveformViewer(m_pTopPanel, *m_pMediaCtrl, *m_pDatabase);
// Binding events.
Bind(wxEVT_MENU, &cMainFrame::OnSelectAddFile, this, SampleHive::ID::MN_AddFile);
Bind(wxEVT_MENU, &cMainFrame::OnSelectAddDirectory, this, SampleHive::ID::MN_AddDirectory);
Bind(wxEVT_MENU, &cMainFrame::OnSelectToggleExtension, this, SampleHive::ID::MN_ToggleExtension);
Bind(wxEVT_MENU, &cMainFrame::OnSelectToggleMenuBar, this, SampleHive::ID::MN_ToggleMenuBar);
Bind(wxEVT_MENU, &cMainFrame::OnSelectToggleStatusBar, this, SampleHive::ID::MN_ToggleStatusBar);
Bind(wxEVT_MENU, &cMainFrame::OnSelectExit, this, wxID_EXIT);
Bind(wxEVT_MENU, &cMainFrame::OnSelectPreferences, this, wxID_PREFERENCES);
Bind(wxEVT_MENU, &cMainFrame::OnSelectResetAppData, this, wxID_REFRESH);
Bind(wxEVT_MENU, &cMainFrame::OnSelectAbout, this, wxID_ABOUT);
Bind(wxEVT_SPLITTER_SASH_POS_CHANGING, &cMainFrame::OnTopSplitterSashPosChanged, this, m_pTopSplitter->GetId());
Bind(wxEVT_SPLITTER_SASH_POS_CHANGING, &cMainFrame::OnBottomSplitterSashPosChanged, this, m_pBottomSplitter->GetId());
this->Connect(wxEVT_SIZE, wxSizeEventHandler(cMainFrame::OnResizeFrame), NULL, this);
m_pStatusBar->Connect(wxEVT_SIZE, wxSizeEventHandler(cMainFrame::OnResizeStatusBar), NULL, this);
Bind(wxEVT_MEDIA_FINISHED, &cMainFrame::OnMediaFinished, this, SampleHive::ID::BC_MediaCtrl);
Bind(wxEVT_TIMER, &cMainFrame::UpdateElapsedTime, this);
Bind(SampleHive::SH_EVT_LOOP_POINTS_UPDATED, &cMainFrame::OnRecieveLoopPoints, this);
Bind(SampleHive::SH_EVT_LOOP_POINTS_CLEAR, &cMainFrame::OnRecieveClearLoopPointsStatus, this);
Bind(SampleHive::SH_EVT_STATUSBAR_STATUS_PUSH, &cMainFrame::OnRecievePushStatusBarStatus, this);
Bind(SampleHive::SH_EVT_STATUSBAR_STATUS_POP, &cMainFrame::OnRecievePopStatusBarStatus, this);
Bind(SampleHive::SH_EVT_STATUSBAR_STATUS_SET, &cMainFrame::OnRecieveSetStatusBarStatus, this);
Bind(SampleHive::SH_EVT_INFOBAR_MESSAGE_SHOW, &cMainFrame::OnRecieveInfoBarStatus, this);
Bind(SampleHive::SH_EVT_TIMER_STOP, &cMainFrame::OnRecieveTimerStopStatus, this);
Bind(SampleHive::SH_EVT_UPDATE_WAVEFORM, &cMainFrame::OnRecieveWaveformUpdateStatus, this);
Bind(SampleHive::SH_EVT_CALL_FUNC_PLAY, &cMainFrame::OnRecieveCallFunctionPlay, this);
Bind(SampleHive::SH_EVT_LOOP_AB_BUTTON_VALUE_CHANGE, &cMainFrame::OnRecieveLoopABButtonValueChange, this);
// Adding widgets to their sizers
m_pMainSizer->Add(m_pTopSplitter, 1, wxALL | wxEXPAND, 0);
m_pTopPanelMainSizer->Add(m_pWaveformViewer, 1, wxALL | wxEXPAND, 2);
m_pTopPanelMainSizer->Add(m_pTransportControls, 0, wxALL | wxEXPAND, 2);
// Sizer for the frame
this->SetSizer(m_pMainSizer);
this->Layout();
this->Center(wxBOTH);
// Sizer for TopPanel
m_pTopPanel->SetSizer(m_pTopPanelMainSizer);
m_pTopPanelMainSizer->Fit(m_pTopPanel);
m_pTopPanelMainSizer->SetSizeHints(m_pTopPanel);
m_pTopPanelMainSizer->Layout();
// Restore the data previously added to Library
LoadDatabase();
// Set some properites after the frame has been created
CallAfter(&cMainFrame::SetAfterFrameCreate);
}
void cMainFrame::OnMediaFinished(wxMediaEvent& event)
{
if (m_pTransportControls->CanLoop())
{
if (!m_pMediaCtrl->Play())
{
wxMessageDialog msgDialog(NULL, _("Error! Cannot loop media."), _("Error"), wxOK | wxICON_ERROR);
msgDialog.ShowModal();
}
else
m_pMediaCtrl->Play();
}
else
{
if (m_pTimer->IsRunning())
{
m_pTimer->Stop();
SH_LOG_DEBUG("TIMER STOPPED");
}
m_pTransportControls->SetSamplePositionText("--:--/--:--");
PopStatusText(1);
this->SetStatusText(_("Stopped"), 1);
}
}
void cMainFrame::UpdateElapsedTime(wxTimerEvent& event)
{
SH_LOG_DEBUG("TIMER IS RUNNING..");
wxString duration, position;
wxLongLong llLength, llTell;
llLength = m_pMediaCtrl->Length();
int total_min = static_cast<int>((llLength / 60000).GetValue());
int total_sec = static_cast<int>(((llLength % 60000) / 1000).GetValue());
llTell = m_pMediaCtrl->Tell();
int current_min = static_cast<int>((llTell / 60000).GetValue());
int current_sec = static_cast<int>(((llTell % 60000) / 1000).GetValue());
duration.Printf(wxT("%2i:%02i"), total_min, total_sec);
position.Printf(wxT("%2i:%02i"), current_min, current_sec);
m_pTransportControls->SetSamplePositionText(wxString::Format(wxT("%s/%s"), position.c_str(), duration.c_str()));
this->Refresh();
m_pTransportControls->Refresh();
m_pWaveformViewer->Refresh();
if (m_bLoopPointsSet && m_pTransportControls->IsLoopABOn())
if (static_cast<double>(m_pMediaCtrl->Tell()) >= m_LoopB.ToDouble())
m_pMediaCtrl->Seek(m_LoopA.ToDouble(), wxFromStart);
}
void cMainFrame::LoadDatabase()
{
SampleHive::cSerializer serializer;
try
{
const auto dataset = m_pDatabase->LoadSamplesDatabase(*m_pNotebook->GetHivesPanel()->GetHivesObject(),
m_pNotebook->GetHivesPanel()->GetFavoritesHive(),
*m_pNotebook->GetTrashPanel()->GetTrashObject(),
m_pNotebook->GetTrashPanel()->GetTrashRoot(),
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)
SampleHive::cHiveData::Get().ListCtrlAppendItem(data);
}
m_pDatabase->LoadHivesDatabase(*m_pNotebook->GetHivesPanel()->GetHivesObject());
}
catch (std::exception& e)
{
SH_LOG_ERROR("Error loading data. {}", e.what());
}
}
void cMainFrame::LoadConfigFile()
{
// Check if SampleHive configuration directory exist and create it if not
if (!wxDirExists(APP_CONFIG_DIR))
{
SH_LOG_WARN("Configuration directory not found. Creating directory at {}", APP_CONFIG_DIR);
if (wxFileName::Mkdir(APP_CONFIG_DIR, wxPOSIX_USER_READ | wxPOSIX_USER_WRITE | wxPOSIX_USER_EXECUTE |
wxPOSIX_GROUP_READ | wxPOSIX_GROUP_EXECUTE |
wxPOSIX_OTHERS_READ | wxPOSIX_OTHERS_EXECUTE, wxPATH_MKDIR_FULL))
{
SH_LOG_INFO("Successfully created configuration directory at {}", APP_CONFIG_DIR);
}
else
{
wxMessageBox(wxString::Format(_("Error! Could not create configuration directory %s"), APP_CONFIG_DIR),
_("Error!"), wxOK | wxCENTRE, this);
}
}
else
SH_LOG_INFO("Found {} directory.", APP_CONFIG_DIR);
// Check if SampleHive data directory exist and create it if not
if (!wxDirExists(APP_DATA_DIR))
{
SH_LOG_WARN("Data directory not found. Creating directory at {}", APP_DATA_DIR);
if (wxFileName::Mkdir(APP_DATA_DIR, wxPOSIX_USER_READ | wxPOSIX_USER_WRITE | wxPOSIX_USER_EXECUTE |
wxPOSIX_GROUP_READ | wxPOSIX_GROUP_EXECUTE |
wxPOSIX_OTHERS_READ | wxPOSIX_OTHERS_EXECUTE, wxPATH_MKDIR_FULL))
{
SH_LOG_INFO("Successfully created data directory at {}", APP_DATA_DIR);
}
else
{
wxMessageBox(wxString::Format(_("Error! Could not create data directory %s"), APP_DATA_DIR),
_("Error!"), wxOK | wxCENTRE, this);
}
}
else
SH_LOG_INFO("Found {} directory.", APP_DATA_DIR);
SampleHive::cSerializer serializer;
SH_LOG_INFO("Reading configuration file..");
int height = 600, width = 800;
width = serializer.DeserializeWinSize().first;
height = serializer.DeserializeWinSize().second;
int min_width = 960, min_height = 540;
m_bShowMenuBar = serializer.DeserializeShowMenuAndStatusBar("menubar");
m_bShowStatusBar = serializer.DeserializeShowMenuAndStatusBar("statusbar");
m_pToggleMenuBar->Check(m_bShowMenuBar);
m_pMenuBar->Show(m_bShowMenuBar);
m_pToggleStatusBar->Check(m_bShowStatusBar);
m_pStatusBar->Show(m_bShowStatusBar);
m_pToggleExtension->Check(serializer.DeserializeShowFileExtension());
this->SetFont(serializer.DeserializeFontSettings());
this->SetSize(width, height);
this->SetMinSize(wxSize(min_width, min_height));
this->CenterOnScreen(wxBOTH);
this->SetIcon(wxIcon(ICON_HIVE_256px, wxICON_DEFAULT_TYPE, -1, -1));
this->SetTitle(PROJECT_NAME);
this->SetStatusText(wxString::Format("%s %s", PROJECT_NAME, PROJECT_VERSION), 3);
this->SetStatusText(_("Stopped"), 1);
}
// void cMainFrame::RefreshDatabase()
// {
// m_pLibrary->GetListCtrlObject()->DeleteAllItems();
// if (m_pNotebook->GetHivesPanel()->GetHivesObject()->GetChildCount(wxDataViewItem(wxNullPtr)) <= 1 &&
// m_pNotebook->GetHivesPanel()->GetHivesObject()->GetItemText(wxDataViewItem(wxNullPtr)) ==
// m_pNotebook->GetHivesPanel()->GetHivesObject()->GetItemText(m_pNotebook->GetHivesPanel()->GetFavoritesHive()))
// return;
// else
// m_pNotebook->GetHivesPanel()->GetHivesObject()->DeleteAllItems();
// m_pNotebook->GetTrashPanel()->GetTrashObject()->DeleteAllItems();
// LoadDatabase();
// }
bool cMainFrame::CreateWatcherIfNecessary()
{
if (m_pFsWatcher)
return false;
CreateWatcher();
Bind(wxEVT_FSWATCHER, &cMainFrame::OnFileSystemEvent, this);
return true;
}
void cMainFrame::CreateWatcher()
{
SampleHive::cSerializer serializer;
wxCHECK_RET(!m_pFsWatcher, _("Watcher already initialized"));
m_pFsWatcher = new wxFileSystemWatcher();
m_pFsWatcher->SetOwner(this);
wxString path = serializer.DeserializeAutoImport().second;
if (serializer.DeserializeAutoImport().first)
{
SH_LOG_INFO("Adding watch entry: {}", path);
if (serializer.DeserializeRecursiveImport())
AddWatchEntry(wxFSWPath_Tree, path.ToStdString());
else
AddWatchEntry(wxFSWPath_Dir, path.ToStdString());
}
}
void cMainFrame::AddWatchEntry(wxFSWPathType type, std::string path)
{
SampleHive::cSerializer serializer;
if (path.empty())
{
path = wxDirSelector(_("Choose a directory to watch"), "", wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
if (path.empty())
return;
}
wxCHECK_RET(m_pFsWatcher, _("Watcher not initialized"));
SH_LOG_INFO("Adding {}: '{}'", path, type == wxFSWPath_Dir ? "directory" : "directory tree");
wxFileName filename = wxFileName::DirName(path);
if (!filename.IsOk() || !filename.IsDir() || !filename.IsDirReadable())
{
SH_LOG_ERROR("Error! Something wrong with {} path", filename.GetFullPath());
return;
}
if (!serializer.DeserializeFollowSymLink())
{
filename.DontFollowLink();
}
bool ok = false;
switch (type)
{
case wxFSWPath_Dir:
ok = m_pFsWatcher->Add(filename);
break;
case wxFSWPath_Tree:
ok = m_pFsWatcher->AddTree(filename);
break;
case wxFSWPath_File:
break;
case wxFSWPath_None:
wxFAIL_MSG(_("Error! Unexpected path type."));
}
if (!ok)
{
SH_LOG_ERROR("Error! Cannot add '{}' to watched paths", filename.GetPath());
return;
}
}
void cMainFrame::OnFileSystemEvent(wxFileSystemWatcherEvent& event)
{
wxLogTrace(wxTRACE_FSWATCHER, "*** %s ***", event.ToString());
int type = event.GetChangeType();
wxString path = event.GetPath().GetFullPath();
wxArrayString files;
files.push_back(path);
SH_LOG_DEBUG("{} {}", path, event.ToString());
switch (type)
{
case wxFSW_EVENT_CREATE:
SH_LOG_INFO("NEW FILES DETECTED, ADDING: {}", path);
SampleHive::cUtils::Get().AddSamples(files, this);
break;
case wxFSW_EVENT_ACCESS:
SH_LOG_INFO("ACCESSING DIRECTORY: {}", path);
break;
case wxFSW_EVENT_DELETE:
SH_LOG_INFO("FILES DELETED IN DIRECTORY: {}", path);
break;
case wxFSW_EVENT_MODIFY:
SH_LOG_INFO("DIRECTORY MODIFIED: {}", path);
break;
case wxFSW_EVENT_RENAME:
SH_LOG_INFO("FILES RENAMED IN DIRECTORY: {}", event.GetNewPath().GetFullPath());
break;
case wxFSW_EVENT_WARNING:
SH_LOG_INFO("Filesystem watcher warning: {}", event.GetWarningType());
break;
case wxFSW_EVENT_ERROR:
SH_LOG_INFO("Error! Filesystem watcher: {}", event.GetErrorDescription());
break;
default:
break;
}
}
void cMainFrame::OnSelectAddFile(wxCommandEvent& event)
{
wxFileDialog file_dialog(this, wxFileSelectorPromptStr, USER_HOME_DIR,
wxEmptyString, wxFileSelectorDefaultWildcardStr,
wxFD_DEFAULT_STYLE | wxFD_FILE_MUST_EXIST | wxFD_MULTIPLE | wxFD_PREVIEW,
wxDefaultPosition, wxDefaultSize);
switch (file_dialog.ShowModal())
{
case wxID_OK:
{
wxArrayString paths;
file_dialog.GetPaths(paths);
for (size_t i = 0; i < (size_t)paths.size(); i++)
SampleHive::cUtils::Get().AddSamples(paths, this);
}
break;
default:
break;
}
}
void cMainFrame::OnSelectAddDirectory(wxCommandEvent& event)
{
wxDirDialog dir_dialog(this, wxDirSelectorPromptStr, USER_HOME_DIR,
wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST, wxDefaultPosition, wxDefaultSize);
switch (dir_dialog.ShowModal())
{
case wxID_OK:
{
wxString path = dir_dialog.GetPath();
SampleHive::cUtils::Get().OnAutoImportDir(path, this);
}
break;
default:
break;
}
}
void cMainFrame::OnSelectToggleExtension(wxCommandEvent& event)
{
SampleHive::cSerializer serializer;
if (m_pToggleExtension->IsChecked())
{
serializer.SerializeShowFileExtension(true);
m_pLibrary->GetInfoBarObject()->ShowMessage(_("Extension showing, restart the application to view changes "
"or press CTRL+E to toggle show/hide."), wxICON_INFORMATION);
}
else
{
serializer.SerializeShowFileExtension(false);
m_pLibrary->GetInfoBarObject()->ShowMessage(_("Extension hidden, restart the application to view changes "
"or press CTRL+E to toggle show/hide."), wxICON_INFORMATION);
}
}
void cMainFrame::OnSelectToggleMenuBar(wxCommandEvent& event)
{
SampleHive::cSerializer serializer;
if (m_pToggleMenuBar->IsChecked())
{
m_pMenuBar->Show();
m_pLibrary->GetInfoBarObject()->ShowMessage(_("MenuBar showing, press CTRL+M to toggle show/hide."), wxICON_INFORMATION);
m_bShowMenuBar = true;
serializer.SerializeShowMenuAndStatusBar("menubar", m_bShowMenuBar);
}
else
{
m_pMenuBar->Hide();
m_pLibrary->GetInfoBarObject()->ShowMessage(_("MenuBar hidden, press CTRL+M to toggle show/hide."), wxICON_INFORMATION);
m_bShowMenuBar = false;
serializer.SerializeShowMenuAndStatusBar("menubar", m_bShowMenuBar);
}
}
void cMainFrame::OnSelectToggleStatusBar(wxCommandEvent& event)
{
SampleHive::cSerializer serializer;
if (m_pToggleStatusBar->IsChecked())
{
m_pStatusBar->Show();
m_pLibrary->GetInfoBarObject()->ShowMessage(_("StatusBar showing, press CTRL+B to toggle show/hide."), wxICON_INFORMATION);
m_bShowStatusBar = true;
serializer.SerializeShowMenuAndStatusBar("statusbar", m_bShowStatusBar);
}
else
{
m_pStatusBar->Hide();
m_pLibrary->GetInfoBarObject()->ShowMessage(_("StatusBar hidden, press CTRL+B to toggle show/hide."), wxICON_INFORMATION);
m_bShowStatusBar = false;
serializer.SerializeShowMenuAndStatusBar("statusbar", m_bShowStatusBar);
}
}
void cMainFrame::OnSelectExit(wxCommandEvent& event)
{
Close();
}
void cMainFrame::OnSelectPreferences(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())
{
m_pWaveformViewer->ResetDC();
}
break;
case wxID_CANCEL:
break;
default:
return;
}
}
void cMainFrame::OnSelectResetAppData(wxCommandEvent& event)
{
wxMessageDialog clearDataDialog(this, wxString::Format(_("Warning! This will delete configuration file "
"\"%s\" and database file \"%s\" permanently, "
"are you sure you want to delete these files?"),
CONFIG_FILEPATH, DATABASE_FILEPATH),
_("Clear app data?"), wxYES_NO | wxNO_DEFAULT | wxCENTRE, wxDefaultPosition);
bool remove = false;
switch (clearDataDialog.ShowModal())
{
case wxID_YES:
remove = true;
if (remove)
{
if (!wxFileExists(CONFIG_FILEPATH))
{
SH_LOG_ERROR("Error! File {} doesn't exist.", CONFIG_FILEPATH);
return;
}
bool config_is_deleted = wxRemoveFile(CONFIG_FILEPATH);
if (config_is_deleted)
SH_LOG_INFO("Deleted {}", CONFIG_FILEPATH);
else
SH_LOG_ERROR("Could not delete {}", CONFIG_FILEPATH);
if (!wxFileExists(DATABASE_FILEPATH))
{
SH_LOG_ERROR("Error! File {} doesn't exist.", DATABASE_FILEPATH);
return;
}
bool db_is_deleted = wxRemoveFile(DATABASE_FILEPATH);
if (db_is_deleted)
SH_LOG_INFO("Deleted {}", DATABASE_FILEPATH);
else
SH_LOG_ERROR("Could not delete {}", DATABASE_FILEPATH);
if (config_is_deleted && db_is_deleted)
{
m_pLibrary->GetInfoBarObject()->ShowMessage(_("Successfully cleared app data"), wxICON_INFORMATION);
SH_LOG_INFO("Cleared app data successfully");
}
else
wxMessageBox(_("Error! Could not clear app data"), _("Error!"), wxOK | wxCENTRE | wxICON_ERROR, this);
}
break;
case wxID_NO:
break;
default:
break;
}
}
void cMainFrame::OnSelectAbout(wxCommandEvent& event)
{
wxAboutDialogInfo aboutInfo;
aboutInfo.SetName(PROJECT_NAME);
aboutInfo.SetIcon(wxIcon(ICON_HIVE_64px));
aboutInfo.AddArtist(PROJECT_AUTHOR);
aboutInfo.SetVersion(PROJECT_VERSION, _("Version 0.9.0_alpha.1"));
aboutInfo.SetDescription(_(PROJECT_DESCRIPTION));
aboutInfo.SetCopyright("(C)" PROJECT_COPYRIGHT_YEARS);
aboutInfo.SetWebSite(PROJECT_WEBSITE);
aboutInfo.AddDeveloper(PROJECT_AUTHOR);
aboutInfo.SetLicence(wxString::Format(wxString::FromAscii(
"%s %s\n"
"Copyright (C) %s Apoorv Singh\n"
"\n"
"%s is free software: you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation, either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"%s is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program. If not, see <https://www.gnu.org/licenses/>.\n"
), PROJECT_NAME, PROJECT_VERSION, PROJECT_COPYRIGHT_YEARS, PROJECT_NAME, PROJECT_NAME));
wxAboutBox(aboutInfo);
}
void cMainFrame::OnResizeStatusBar(wxSizeEvent& event)
{
wxRect rect;
m_pStatusBar->GetFieldRect(2, rect);
wxSize bitmap_size = m_pHiveBitmap->GetSize();
m_pHiveBitmap->Move(rect.x + (rect.width - bitmap_size.x),
rect.y + (rect.height - bitmap_size.y));
event.Skip();
}
void cMainFrame::OnResizeFrame(wxSizeEvent& event)
{
SampleHive::cSerializer serializer;
SH_LOG_DEBUG("Frame resized to {}, {}", GetSize().GetWidth(), GetSize().GetHeight());
serializer.SerializeWinSize(GetSize().GetWidth(), GetSize().GetHeight());
event.Skip();
}
void cMainFrame::OnTopSplitterSashPosChanged(wxSplitterEvent& event)
{
SampleHive::cSerializer serializer;
SH_LOG_DEBUG("TopSplitter at {}", m_pTopSplitter->GetSashPosition());
serializer.SerializeSplitterSashPos("top", m_pTopSplitter->GetSashPosition());
}
void cMainFrame::OnBottomSplitterSashPosChanged(wxSplitterEvent& event)
{
SampleHive::cSerializer serializer;
SH_LOG_DEBUG("BottomSplitter at {}", m_pBottomSplitter->GetSashPosition());
serializer.SerializeSplitterSashPos("bottom", m_pBottomSplitter->GetSashPosition());
}
void cMainFrame::SetAfterFrameCreate()
{
SampleHive::cSerializer serializer;
m_pTopSplitter->SetSashPosition(serializer.DeserializeSplitterSashPos("top"));
m_pBottomSplitter->SetSashPosition(serializer.DeserializeSplitterSashPos("bottom"));
}
void cMainFrame::OnRecieveLoopPoints(SampleHive::cLoopPointsEvent& event)
{
std::pair<double, double> loop_points = event.GetLoopPoints();
m_LoopA = wxLongLong(loop_points.first);
m_LoopB = wxLongLong(loop_points.second);
int loopA_min = static_cast<int>((m_LoopA / 60000).GetValue());
int loopA_sec = static_cast<int>(((m_LoopA % 60000) / 1000).GetValue());
int loopB_min = static_cast<int>((m_LoopB / 60000).GetValue());
int loopB_sec = static_cast<int>(((m_LoopB % 60000) / 1000).GetValue());
SH_LOG_INFO(wxString::Format(_("Loop points set: A: %2i:%02i, B: %2i:%02i"), loopA_min, loopA_sec, loopB_min, loopB_sec));
m_pTransportControls->SetLoopABValue(true);
m_bLoopPointsSet = true;
}
void cMainFrame::OnRecievePushStatusBarStatus(SampleHive::cStatusBarStatusEvent& event)
{
std::pair<wxString, int> status = event.GetPushMessageAndSection();
m_pStatusBar->PushStatusText(status.first, status.second);
}
void cMainFrame::OnRecievePopStatusBarStatus(SampleHive::cStatusBarStatusEvent& event)
{
m_pStatusBar->PopStatusText(event.GetPopMessageSection());
}
void cMainFrame::OnRecieveSetStatusBarStatus(SampleHive::cStatusBarStatusEvent& event)
{
std::pair<wxString, int> status = event.GetStatusTextAndSection();
m_pStatusBar->SetStatusText(status.first, status.second);
}
void cMainFrame::OnRecieveInfoBarStatus(SampleHive::cInfoBarMessageEvent& event)
{
std::pair<wxString, int> info = event.GetInfoBarMessage();
m_pLibrary->GetInfoBarObject()->ShowMessage(info.first, info.second);
}
void cMainFrame::OnRecieveTimerStopStatus(SampleHive::cTimerEvent& event)
{
if (m_pTimer->IsRunning())
m_pTimer->Stop();
}
void cMainFrame::OnRecieveCallFunctionPlay(SampleHive::cCallFunctionEvent& event)
{
SampleHive::cSerializer serializer;
wxString selection = event.GetSlection();
bool checkAutoplay = event.GetAutoplayValue();
wxString sample_path = serializer.DeserializeShowFileExtension() ?
m_pDatabase->GetSamplePathByFilename(selection.BeforeLast('.').ToStdString()) :
m_pDatabase->GetSamplePathByFilename(selection.ToStdString());
if (checkAutoplay)
{
if (m_pTransportControls->CanAutoplay())
{
if (m_bLoopPointsSet && m_pTransportControls->IsLoopABOn())
PlaySample(sample_path.ToStdString(), selection.ToStdString(), true, m_LoopA.ToDouble(), wxFromStart);
else
PlaySample(sample_path.ToStdString(), selection.ToStdString());
}
else
m_pMediaCtrl->Stop();
}
else
{
if (m_bLoopPointsSet && m_pTransportControls->IsLoopABOn())
PlaySample(sample_path.ToStdString(), selection.ToStdString(), true, m_LoopA.ToDouble(), wxFromStart);
else
PlaySample(sample_path.ToStdString(), selection.ToStdString());
}
}
void cMainFrame::OnRecieveWaveformUpdateStatus(SampleHive::cWaveformUpdateEvent& event)
{
m_pWaveformViewer->ResetDC();
}
void cMainFrame::OnRecieveClearLoopPointsStatus(SampleHive::cLoopPointsEvent& event)
{
ClearLoopPoints();
}
void cMainFrame::OnRecieveLoopABButtonValueChange(SampleHive::cLoopPointsEvent& event)
{
m_pTransportControls->SetLoopABValue(false);
}
void cMainFrame::ClearLoopPoints()
{
m_LoopA = 0;
m_LoopB = 0;
m_bLoopPointsSet = false;
}
void cMainFrame::PlaySample(const std::string& filepath, const std::string& sample, bool seek, wxFileOffset where, wxSeekMode mode)
{
if (m_pMediaCtrl->Load(filepath))
{
if (seek)
m_pMediaCtrl->Seek(where, mode);
if (!m_pMediaCtrl->Play())
SH_LOG_ERROR("Error! Cannot play sample.");
PushStatusText(wxString::Format(_("Now playing: %s"), sample), 1);
if (!m_pTimer->IsRunning())
{
SH_LOG_INFO("Starting timer..");
m_pTimer->Start(20, wxTIMER_CONTINUOUS);
}
}
else
SH_LOG_ERROR("Error! Cannot load sample.");
}
void cMainFrame::InitDatabase()
{
// Initialize the database
try
{
m_pDatabase = std::make_unique<cDatabase>();
m_pDatabase->CreateTableSamples();
m_pDatabase->CreateTableHives();
}
catch (std::exception& e)
{
SH_LOG_ERROR("Error! Cannot initialize database {}", e.what());
}
}
cMainFrame::~cMainFrame()
{
// Delete wxTimer
delete m_pTimer;
// Delete wxFilesystemWatcher
delete m_pFsWatcher;
}
Reference in New Issue View Git Blame Copy Permalink