AxioDL
/
amuse
mirror of https://github.com/AxioDL/amuse.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
amuse/Editor/MainWindow.cpp

1900 lines
71 KiB
C++
Raw Blame History

#include "MainWindow.hpp"
#include <QClipboard>
#include <QFileDialog>
#include <QInputDialog>
#include <QLineEdit>
#include <QMessageBox>
#include <QMouseEvent>
#include <QProgressDialog>
#include <QtSvg/QtSvg>
#include <QUndoStack>
#include "ADSREditor.hpp"
#include "Common.hpp"
#include "CurveEditor.hpp"
#include "KeymapEditor.hpp"
#include "LayersEditor.hpp"
#include "MIDIReader.hpp"
#include "NewSoundMacroDialog.hpp"
#include "SampleEditor.hpp"
#include "SongGroupEditor.hpp"
#include "SoundGroupEditor.hpp"
#include "SoundGroupEditor.hpp"
#include "SoundMacroEditor.hpp"
#include "StudioSetupWidget.hpp"
#include <amuse/BooBackend.hpp>
#include <amuse/ContainerRegistry.hpp>
#include <amuse/Engine.hpp>
#include <boo/audiodev/IAudioVoiceEngine.hpp>
MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent)
, m_navIt(m_navList.begin())
, m_treeDelegate(*this, this)
, m_mainMessenger(this)
, m_openDirectoryDialog(this)
, m_openFileDialog(this)
, m_newFileDialog(this)
, m_undoStack(new QUndoStack(this))
, m_backgroundThread(this) {
m_backgroundThread.start();
m_newFileDialog.setAcceptMode(QFileDialog::AcceptSave);
m_newFileDialog.setFileMode(QFileDialog::AnyFile);
m_newFileDialog.setOption(QFileDialog::ShowDirsOnly, false);
m_openDirectoryDialog.setAcceptMode(QFileDialog::AcceptOpen);
m_openDirectoryDialog.setFileMode(QFileDialog::Directory);
m_openDirectoryDialog.setOption(QFileDialog::ShowDirsOnly, true);
m_openFileDialog.setAcceptMode(QFileDialog::AcceptOpen);
m_openFileDialog.setFileMode(QFileDialog::ExistingFile);
m_openFileDialog.setOption(QFileDialog::ShowDirsOnly, false);
m_ui.setupUi(this);
m_ui.splitter->setCollapsible(1, false);
QPalette palette = m_ui.projectOutlineFilter->palette();
palette.setColor(QPalette::Base, palette.color(QPalette::Window));
m_ui.projectOutlineFilter->setPalette(palette);
m_ui.projectOutline->setItemDelegate(&m_treeDelegate);
connect(m_ui.projectOutline, &QTreeView::activated, this, &MainWindow::outlineItemActivated);
m_goBack = new QAction(m_ui.backButton->icon(), tr("Go Back"), this);
m_goBack->setEnabled(false);
connect(m_goBack, &QAction::triggered, this, &MainWindow::goBack);
m_goBack->setShortcut(QKeySequence::Back);
m_ui.backButton->setDefaultAction(m_goBack);
m_goForward = new QAction(m_ui.forwardButton->icon(), tr("Go Forward"), this);
m_goForward->setEnabled(false);
connect(m_goForward, &QAction::triggered, this, &MainWindow::goForward);
m_goForward->setShortcut(QKeySequence::Forward);
m_ui.forwardButton->setDefaultAction(m_goForward);
connectMessenger(&m_mainMessenger, Qt::DirectConnection);
m_ui.statusbar->connectKillClicked(this, &MainWindow::killSounds);
m_ui.statusbar->connectFXPressed(this, &MainWindow::fxPressed);
m_ui.statusbar->setVolumeValue(70);
m_ui.statusbar->connectVolumeSlider(this, &MainWindow::volumeChanged);
m_ui.statusbar->connectASlider(this, &MainWindow::auxAChanged);
m_ui.statusbar->connectBSlider(this, &MainWindow::auxBChanged);
m_ui.keyboardContents->setStatusFocus(new StatusBarFocus(m_ui.statusbar));
m_ui.velocitySlider->setStatusFocus(new StatusBarFocus(m_ui.statusbar));
m_ui.modulationSlider->setStatusFocus(new StatusBarFocus(m_ui.statusbar));
m_ui.pitchSlider->setStatusFocus(new StatusBarFocus(m_ui.statusbar));
connect(m_ui.keyboardContents, &KeyboardWidget::notePressed, this, &MainWindow::notePressed);
connect(m_ui.keyboardContents, &KeyboardWidget::noteReleased, this, &MainWindow::noteReleased);
connect(m_ui.velocitySlider, qOverload<int>(&VelocitySlider::valueChanged), this, &MainWindow::velocityChanged);
connect(m_ui.modulationSlider, qOverload<int>(&ModulationSlider::valueChanged), this, &MainWindow::modulationChanged);
connect(m_ui.pitchSlider, qOverload<int>(&PitchSlider::valueChanged), this, &MainWindow::pitchChanged);
m_ui.actionNew_Project->setShortcut(QKeySequence::New);
connect(m_ui.actionNew_Project, &QAction::triggered, this, &MainWindow::newAction);
m_ui.actionOpen_Project->setShortcut(QKeySequence::Open);
connect(m_ui.actionOpen_Project, &QAction::triggered, this, &MainWindow::openAction);
m_ui.actionSave_Project->setShortcut(QKeySequence::Save);
connect(m_ui.actionSave_Project, &QAction::triggered, this, &MainWindow::saveAction);
connect(m_ui.actionRevert_Project, &QAction::triggered, this, &MainWindow::revertAction);
connect(m_ui.actionReload_Sample_Data, &QAction::triggered, this, &MainWindow::reloadSampleDataAction);
connect(m_ui.actionImport_Groups, &QAction::triggered, this, &MainWindow::importAction);
connect(m_ui.actionImport_Songs, &QAction::triggered, this, &MainWindow::importSongsAction);
connect(m_ui.actionExport_GameCube_Groups, &QAction::triggered, this, &MainWindow::exportAction);
connect(m_ui.actionImport_C_Headers, &QAction::triggered, this, &MainWindow::importHeadersAction);
connect(m_ui.actionExport_C_Headers, &QAction::triggered, this, &MainWindow::exportHeadersAction);
m_ui.actionQuit->setShortcut(QKeySequence::Quit);
connect(m_ui.actionQuit, &QAction::triggered, this, &MainWindow::close);
for (int i = 0; i < MaxRecentFiles; ++i) {
m_recentFileActs[i] = new QAction(this);
m_recentFileActs[i]->setVisible(false);
m_ui.menuRecent_Projects->addAction(m_recentFileActs[i]);
connect(m_recentFileActs[i], &QAction::triggered, this, &MainWindow::openRecentFileAction);
}
m_ui.menuRecent_Projects->addSeparator();
m_clearRecentFileAct = new QAction(tr("Clear Recent Projects"), this);
connect(m_clearRecentFileAct, &QAction::triggered, this, &MainWindow::clearRecentFilesAction);
m_ui.menuRecent_Projects->addAction(m_clearRecentFileAct);
updateRecentFileActions();
connect(m_undoStack, &QUndoStack::cleanChanged, this, &MainWindow::cleanChanged);
QAction* undoAction = m_undoStack->createUndoAction(this);
undoAction->setShortcut(QKeySequence::Undo);
undoAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-undo")));
m_ui.menuEdit->insertAction(m_ui.actionCut, undoAction);
QAction* redoAction = m_undoStack->createRedoAction(this);
redoAction->setShortcut(QKeySequence::Redo);
redoAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-redo")));
m_ui.menuEdit->insertAction(m_ui.actionCut, redoAction);
m_ui.menuEdit->insertSeparator(m_ui.actionCut);
m_ui.actionCut->setShortcut(QKeySequence::Cut);
m_ui.actionCopy->setShortcut(QKeySequence::Copy);
m_ui.actionPaste->setShortcut(QKeySequence::Paste);
m_ui.actionDelete->setShortcut(QKeySequence::Delete);
onFocusChanged(nullptr, this);
connect(m_ui.actionAbout_Amuse, &QAction::triggered, this, &MainWindow::aboutAmuseAction);
connect(m_ui.actionAbout_Qt, &QAction::triggered, this, &MainWindow::aboutQtAction);
QGridLayout* faceLayout = new QGridLayout;
QSvgWidget* faceSvg = new QSvgWidget(QStringLiteral(":/bg/FaceGrey.svg"));
faceSvg->setGeometry(0, 0, 256, 256);
faceSvg->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
faceLayout->addWidget(faceSvg);
m_faceSvg = new QWidget;
m_faceSvg->setLayout(faceLayout);
m_ui.editorContents->addWidget(m_faceSvg);
m_songGroupEditor = new SongGroupEditor;
m_ui.editorContents->addWidget(m_songGroupEditor);
m_soundGroupEditor = new SoundGroupEditor;
m_ui.editorContents->addWidget(m_soundGroupEditor);
m_soundMacroEditor = new SoundMacroEditor;
m_ui.editorContents->addWidget(m_soundMacroEditor);
m_adsrEditor = new ADSREditor;
m_ui.editorContents->addWidget(m_adsrEditor);
m_curveEditor = new CurveEditor;
m_ui.editorContents->addWidget(m_curveEditor);
m_keymapEditor = new KeymapEditor;
m_ui.editorContents->addWidget(m_keymapEditor);
m_layersEditor = new LayersEditor;
m_ui.editorContents->addWidget(m_layersEditor);
m_sampleEditor = new SampleEditor;
m_ui.editorContents->addWidget(m_sampleEditor);
m_ui.editorContents->setCurrentWidget(m_faceSvg);
m_studioSetup = new StudioSetupWidget(this);
connect(m_studioSetup, &StudioSetupWidget::hidden, this, &MainWindow::studioSetupHidden);
connect(m_studioSetup, &StudioSetupWidget::shown, this, &MainWindow::studioSetupShown);
connect(m_ui.actionNew_Subproject, &QAction::triggered, this, &MainWindow::newSubprojectAction);
connect(m_ui.actionNew_SFX_Group, &QAction::triggered, this, &MainWindow::newSFXGroupAction);
connect(m_ui.actionNew_Song_Group, &QAction::triggered, this, &MainWindow::newSongGroupAction);
connect(m_ui.actionNew_Sound_Macro, &QAction::triggered, this, &MainWindow::newSoundMacroAction);
connect(m_ui.actionNew_ADSR, &QAction::triggered, this, &MainWindow::newADSRAction);
connect(m_ui.actionNew_Curve, &QAction::triggered, this, &MainWindow::newCurveAction);
connect(m_ui.actionNew_Keymap, &QAction::triggered, this, &MainWindow::newKeymapAction);
connect(m_ui.actionNew_Layers, &QAction::triggered, this, &MainWindow::newLayersAction);
connect(m_ui.menuAudio, &QMenu::aboutToShow, this, &MainWindow::aboutToShowAudioIOMenu);
connect(m_ui.menuMIDI, &QMenu::aboutToShow, this, &MainWindow::aboutToShowMIDIIOMenu);
connect(qApp, &QApplication::focusChanged, this, &MainWindow::onFocusChanged);
connect(QGuiApplication::clipboard(), &QClipboard::dataChanged, this, &MainWindow::onClipboardChanged);
m_voxEngine = boo::NewAudioVoiceEngine();
m_voxAllocator = std::make_unique<VoiceAllocator>(*m_voxEngine);
m_engine = std::make_unique<amuse::Engine>(*m_voxAllocator);
m_engine->setVolume(0.7f);
m_studioSetup->loadData(m_engine->getDefaultStudio().get());
m_ctrlVals[7] = 127;
m_ctrlVals[10] = 64;
startTimer(16);
}
MainWindow::~MainWindow() {
m_backgroundThread.quit();
m_backgroundThread.wait();
fmt::print(FMT_STRING("IM DYING\n"));
}
void MainWindow::connectMessenger(UIMessenger* messenger, Qt::ConnectionType type) {
connect(messenger,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&UIMessenger::information),
this,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&MainWindow::msgInformation),
type);
connect(messenger,
qOverload<const QString&, const QString&, const QString&, const QString&, const QString&, int, int>(
&UIMessenger::question),
this,
qOverload<const QString&, const QString&, const QString&, const QString&, const QString&, int, int>(
&MainWindow::msgQuestion),
type);
connect(messenger,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&UIMessenger::question),
this,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&MainWindow::msgQuestion),
type);
connect(messenger,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&UIMessenger::warning),
this,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&MainWindow::msgWarning),
type);
connect(messenger,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&UIMessenger::critical),
this,
qOverload<const QString&, const QString&, QMessageBox::StandardButtons, QMessageBox::StandardButton>(
&MainWindow::msgCritical),
type);
}
void MainWindow::updateWindowTitle() {
if (!m_projectModel) {
setWindowTitle(tr("Amuse[*]"));
return;
}
QDir dir(m_projectModel->path());
if (EditorWidget* w = getEditorWidget()) {
ProjectModel::BasePoolObjectNode* objNode = static_cast<ProjectModel::BasePoolObjectNode*>(w->currentNode());
setWindowTitle(tr("%1/%2/%3[*] - Amuse")
.arg(dir.dirName())
.arg(m_projectModel->getGroupNode(objNode)->text())
.arg(objNode->text()));
return;
}
setWindowTitle(tr("%1[*] - Amuse").arg(dir.dirName()));
}
void MainWindow::updateRecentFileActions() {
const QSettings settings;
const QStringList files = settings.value(QStringLiteral("recentFileList")).toStringList();
const int numRecentFiles = std::min(files.size(), int(MaxRecentFiles));
for (int i = 0; i < numRecentFiles; ++i) {
const QString text = QStringLiteral("&%1 %2").arg(i + 1).arg(QDir(files[i]).dirName());
m_recentFileActs[i]->setText(text);
m_recentFileActs[i]->setData(files[i]);
m_recentFileActs[i]->setToolTip(files[i]);
m_recentFileActs[i]->setVisible(true);
}
for (int j = numRecentFiles; j < MaxRecentFiles; ++j)
m_recentFileActs[j]->setVisible(false);
m_ui.menuRecent_Projects->setEnabled(numRecentFiles > 0);
}
bool MainWindow::setProjectPath(const QString& path) {
QDir dir(path);
if (dir.path().isEmpty() || dir.path() == QStringLiteral(".") || dir.path() == QStringLiteral("..")) {
QString msg = QString(tr("The directory at '%1' must not be empty.")).arg(path);
m_mainMessenger.critical(tr("Directory empty"), msg);
return false;
} else if (!dir.exists()) {
QString msg = QString(tr("The directory at '%1' must exist for the Amuse editor.")).arg(path);
m_mainMessenger.critical(tr("Directory does not exist"), msg);
return false;
}
QString testWritePath = dir.filePath(tr("__amuse_test__"));
QFile testWriteFile(testWritePath);
if (!testWriteFile.open(QFile::ReadWrite)) {
QString msg = QString(tr("The directory at '%1' must be writable for the Amuse editor: %2"))
.arg(path)
.arg(testWriteFile.errorString());
m_mainMessenger.critical(tr("Unable to write to directory"), msg);
return false;
}
testWriteFile.remove();
closeEditor();
if (m_projectModel)
m_projectModel->deleteLater();
m_projectModel = new ProjectModel(path, this);
m_ui.projectOutlineFilter->clear();
connect(m_ui.projectOutlineFilter, &QLineEdit::textChanged, m_projectModel->getOutlineProxy(),
&OutlineFilterProxyModel::setFilterRegExp);
m_ui.projectOutline->setModel(m_projectModel->getOutlineProxy());
connect(m_ui.projectOutline->selectionModel(), &QItemSelectionModel::selectionChanged, this,
&MainWindow::onOutlineSelectionChanged);
m_openDirectoryDialog.setDirectory(path);
m_openFileDialog.setDirectory(path);
m_newFileDialog.setDirectory(path);
m_ui.actionSave_Project->setEnabled(true);
m_ui.actionRevert_Project->setEnabled(true);
m_ui.actionReload_Sample_Data->setEnabled(true);
m_ui.actionImport_Songs->setEnabled(true);
m_ui.actionExport_GameCube_Groups->setEnabled(true);
m_ui.actionImport_C_Headers->setEnabled(true);
m_ui.actionExport_C_Headers->setEnabled(true);
m_ui.actionNew_Subproject->setEnabled(true);
setWindowFilePath(path);
updateWindowTitle();
updateFocus();
m_undoStack->clear();
m_navList.clear();
m_navIt = m_navList.begin();
updateNavigationButtons();
const QString key = QStringLiteral("recentFileList");
QSettings settings;
QStringList files = settings.value(key).toStringList();
files.removeAll(dir.path());
files.prepend(dir.path());
while (files.size() > MaxRecentFiles) {
files.removeLast();
}
settings.setValue(key, files);
settings.sync();
updateRecentFileActions();
return true;
}
void MainWindow::refreshAudioIO() {
QList<QAction*> audioActions = m_ui.menuAudio->actions();
if (audioActions.size() > 2)
for (auto it = audioActions.begin() + 2; it != audioActions.end(); ++it)
m_ui.menuAudio->removeAction(*it);
bool addedDev = false;
if (m_voxEngine) {
std::string curOut = m_voxEngine->getCurrentAudioOutput();
for (const auto& dev : m_voxEngine->enumerateAudioOutputs()) {
QAction* act = m_ui.menuAudio->addAction(QString::fromStdString(dev.second));
act->setCheckable(true);
act->setData(QString::fromStdString(dev.first));
if (curOut == dev.first)
act->setChecked(true);
connect(act, &QAction::triggered, this, &MainWindow::setAudioIO);
addedDev = true;
}
}
if (!addedDev)
m_ui.menuAudio->addAction(tr("No Audio Devices Found"))->setEnabled(false);
}
void MainWindow::refreshMIDIIO() {
QList<QAction*> midiActions = m_ui.menuMIDI->actions();
if (midiActions.size() > 2)
for (auto it = midiActions.begin() + 2; it != midiActions.end(); ++it)
m_ui.menuMIDI->removeAction(*it);
bool addedDev = false;
if (m_voxEngine) {
if (m_voxEngine->supportsVirtualMIDIIn()) {
QAction* act = m_ui.menuMIDI->addAction(tr("Virtual MIDI-In"));
act->setCheckable(true);
act->setData(QStringLiteral("<amuse-virtual-in>"));
act->setChecked(static_cast<MIDIReader*>(m_engine->getMIDIReader())->hasVirtualIn());
connect(act, &QAction::triggered, this, &MainWindow::setMIDIIO);
addedDev = true;
}
for (const auto& dev : m_voxEngine->enumerateMIDIInputs()) {
QAction* act = m_ui.menuMIDI->addAction(QString::fromStdString(dev.second));
act->setCheckable(true);
act->setData(QString::fromStdString(dev.first));
act->setChecked(static_cast<MIDIReader*>(m_engine->getMIDIReader())->hasMIDIIn(dev.first.c_str()));
connect(act, &QAction::triggered, this, &MainWindow::setMIDIIO);
addedDev = true;
}
}
if (!addedDev)
m_ui.menuMIDI->addAction(tr("No MIDI Devices Found"))->setEnabled(false);
}
void MainWindow::timerEvent(QTimerEvent* ev) {
if (m_voxEngine && m_engine) {
m_voxEngine->pumpAndMixVoices();
m_peakVoices = std::max(int(m_engine->getNumTotalActiveVoices()), m_peakVoices);
if (!(m_timerFireCount % 10)) {
/* Rate limit voice counter */
m_ui.statusbar->setVoiceCount(m_peakVoices);
m_peakVoices = 0;
}
if (m_engine->getActiveVoices().empty() && m_uiDisabled) {
m_ui.projectOutline->setEnabled(true);
m_ui.backButton->setEnabled(true);
m_ui.forwardButton->setEnabled(true);
if (EditorWidget* w = getEditorWidget())
w->setEditorEnabled(true);
m_ui.menubar->setEnabled(true);
m_uiDisabled = false;
} else if (!m_engine->getActiveVoices().empty() && !m_uiDisabled) {
m_ui.projectOutline->setEnabled(false);
m_ui.backButton->setEnabled(false);
m_ui.forwardButton->setEnabled(false);
if (EditorWidget* w = getEditorWidget())
w->setEditorEnabled(false);
m_ui.menubar->setEnabled(false);
m_uiDisabled = true;
}
if (SampleEditor* sampleEditor = qobject_cast<SampleEditor*>(m_ui.editorContents->currentWidget())) {
const auto& activeVoxs = m_engine->getActiveVoices();
if (activeVoxs.size() && activeVoxs.back()->state() != amuse::VoiceState::Dead)
sampleEditor->setSamplePos(activeVoxs.back()->getSamplePos());
else
sampleEditor->setSamplePos(-1);
}
QTableView* songTable = m_songGroupEditor->getSetupListView();
for (int i = 0; i < songTable->model()->rowCount(); ++i)
if (MIDIPlayerWidget* player =
qobject_cast<MIDIPlayerWidget*>(songTable->indexWidget(songTable->model()->index(i, 1))))
if (player->sequencer() && player->sequencer()->state() != amuse::SequencerState::Playing)
player->stopped();
QTableView* sfxTable = m_soundGroupEditor->getSFXListView();
for (int i = 0; i < sfxTable->model()->rowCount(); ++i)
if (SFXPlayerWidget* player =
qobject_cast<SFXPlayerWidget*>(sfxTable->indexWidget(sfxTable->model()->index(i, 1))))
if (player->voice() && player->voice()->state() != amuse::VoiceState::Playing)
player->stopped();
++m_timerFireCount;
}
}
void MainWindow::setSustain(bool sustain) {
if (sustain && m_ctrlVals[64] < 0x40) {
m_ui.statusbar->setNormalMessage(tr("SUSTAIN"));
for (auto& v : m_engine->getActiveVoices())
v->setPedal(true);
m_ctrlVals[64] = 127;
} else if (!sustain && m_ctrlVals[64] >= 0x40) {
m_ui.statusbar->setNormalMessage({});
for (auto& v : m_engine->getActiveVoices())
v->setPedal(false);
m_ctrlVals[64] = 0;
}
}
void MainWindow::keyPressEvent(QKeyEvent* ev) {
if (ev->key() == Qt::Key_Shift)
setSustain(true);
else if (ev->key() == Qt::Key_Escape)
killSounds();
}
void MainWindow::keyReleaseEvent(QKeyEvent* ev) {
if (ev->key() == Qt::Key_Shift)
setSustain(false);
}
void MainWindow::startBackgroundTask(int id, const QString& windowTitle, const QString& label,
std::function<void(BackgroundTask&)>&& task) {
assert(m_backgroundTask == nullptr && "existing background process");
setEnabled(false);
m_backgroundTask = new BackgroundTask(id, std::move(task));
m_backgroundTask->moveToThread(&m_backgroundThread);
m_backgroundDialog = new QProgressDialog(this);
m_backgroundDialog->setWindowTitle(windowTitle);
m_backgroundDialog->setLabelText(label);
m_backgroundDialog->setMinimumWidth(300);
m_backgroundDialog->setAutoClose(false);
m_backgroundDialog->setAutoReset(false);
m_backgroundDialog->setMinimumDuration(0);
m_backgroundDialog->setMinimum(0);
m_backgroundDialog->setMaximum(0);
m_backgroundDialog->setValue(0);
connect(m_backgroundTask, &BackgroundTask::setMinimum, m_backgroundDialog, &QProgressDialog::setMinimum,
Qt::QueuedConnection);
connect(m_backgroundTask, &BackgroundTask::setMaximum, m_backgroundDialog, &QProgressDialog::setMaximum,
Qt::QueuedConnection);
connect(m_backgroundTask, &BackgroundTask::setValue, m_backgroundDialog, &QProgressDialog::setValue,
Qt::QueuedConnection);
connect(m_backgroundTask, &BackgroundTask::setLabelText, m_backgroundDialog, &QProgressDialog::setLabelText,
Qt::QueuedConnection);
connect(m_backgroundTask, &BackgroundTask::finished, this, &MainWindow::onBackgroundTaskFinished,
Qt::QueuedConnection);
m_backgroundDialog->open(m_backgroundTask, SLOT(cancel()));
connectMessenger(&m_backgroundTask->uiMessenger(), Qt::BlockingQueuedConnection);
QMetaObject::invokeMethod(m_backgroundTask, "run", Qt::QueuedConnection);
}
bool MainWindow::_setEditor(EditorWidget* editor, bool appendNav) {
m_interactiveSeq.reset();
if (editor != m_ui.editorContents->currentWidget() && m_ui.editorContents->currentWidget() != m_faceSvg)
getEditorWidget()->unloadData();
if (appendNav && m_navIt != m_navList.end()) {
m_navList.erase(std::next(m_navIt, 1), m_navList.end());
}
if (!editor || !editor->valid()) {
m_ui.editorContents->setCurrentWidget(m_faceSvg);
updateWindowTitle();
if (appendNav) {
m_navIt = m_navList.end();
updateNavigationButtons();
}
return false;
}
m_ui.editorContents->setCurrentWidget(editor);
m_ui.editorContents->update();
updateWindowTitle();
ProjectModel::INode* currentNode = editor->currentNode();
if (appendNav) {
if (m_navIt == m_navList.end() || *m_navIt != currentNode)
m_navIt = m_navList.insert(m_navList.end(), currentNode);
updateNavigationButtons();
}
recursiveExpandAndSelectOutline(m_projectModel->index(currentNode));
return true;
}
bool MainWindow::openEditor(ProjectModel::SongGroupNode* node, bool appendNav) {
bool ret = _setEditor(m_songGroupEditor->loadData(node) ? m_songGroupEditor : nullptr, appendNav);
if (ProjectModel::INode* n = getEditorNode()) {
if (n->type() == ProjectModel::INode::Type::SongGroup) {
ProjectModel::SongGroupNode* cn = static_cast<ProjectModel::SongGroupNode*>(n);
ProjectModel::GroupNode* gn = m_projectModel->getGroupNode(n);
m_interactiveSeq = m_engine->seqPlay(gn->getAudioGroup(), cn->m_id, {}, nullptr);
}
}
return ret;
}
bool MainWindow::openEditor(ProjectModel::SoundGroupNode* node, bool appendNav) {
bool ret = _setEditor(m_soundGroupEditor->loadData(node) ? m_soundGroupEditor : nullptr, appendNav);
if (ProjectModel::INode* n = getEditorNode()) {
if (n->type() == ProjectModel::INode::Type::SoundGroup) {
ProjectModel::SoundGroupNode* cn = static_cast<ProjectModel::SoundGroupNode*>(n);
ProjectModel::GroupNode* gn = m_projectModel->getGroupNode(n);
m_interactiveSeq = m_engine->seqPlay(gn->getAudioGroup(), cn->m_id, {}, nullptr);
}
}
return ret;
}
bool MainWindow::openEditor(ProjectModel::SoundMacroNode* node, bool appendNav) {
return _setEditor(m_soundMacroEditor->loadData(node) ? m_soundMacroEditor : nullptr, appendNav);
}
bool MainWindow::openEditor(ProjectModel::ADSRNode* node, bool appendNav) {
return _setEditor(m_adsrEditor->loadData(node) ? m_adsrEditor : nullptr, appendNav);
}
bool MainWindow::openEditor(ProjectModel::CurveNode* node, bool appendNav) {
return _setEditor(m_curveEditor->loadData(node) ? m_curveEditor : nullptr, appendNav);
}
bool MainWindow::openEditor(ProjectModel::KeymapNode* node, bool appendNav) {
return _setEditor(m_keymapEditor->loadData(node) ? m_keymapEditor : nullptr, appendNav);
}
bool MainWindow::openEditor(ProjectModel::LayersNode* node, bool appendNav) {
return _setEditor(m_layersEditor->loadData(node) ? m_layersEditor : nullptr, appendNav);
}
bool MainWindow::openEditor(ProjectModel::SampleNode* node, bool appendNav) {
return _setEditor(m_sampleEditor->loadData(node) ? m_sampleEditor : nullptr, appendNav);
}
bool MainWindow::openEditor(ProjectModel::INode* node, bool appendNav) {
if (m_uiDisabled)
return false;
switch (node->type()) {
case ProjectModel::INode::Type::SongGroup:
return openEditor(static_cast<ProjectModel::SongGroupNode*>(node), appendNav);
case ProjectModel::INode::Type::SoundGroup:
return openEditor(static_cast<ProjectModel::SoundGroupNode*>(node), appendNav);
case ProjectModel::INode::Type::SoundMacro:
return openEditor(static_cast<ProjectModel::SoundMacroNode*>(node), appendNav);
case ProjectModel::INode::Type::ADSR:
return openEditor(static_cast<ProjectModel::ADSRNode*>(node), appendNav);
case ProjectModel::INode::Type::Curve:
return openEditor(static_cast<ProjectModel::CurveNode*>(node), appendNav);
case ProjectModel::INode::Type::Keymap:
return openEditor(static_cast<ProjectModel::KeymapNode*>(node), appendNav);
case ProjectModel::INode::Type::Layer:
return openEditor(static_cast<ProjectModel::LayersNode*>(node), appendNav);
case ProjectModel::INode::Type::Sample:
return openEditor(static_cast<ProjectModel::SampleNode*>(node), appendNav);
default:
return false;
}
}
void MainWindow::closeEditor() { _setEditor(nullptr); }
ProjectModel::INode* MainWindow::getEditorNode() const {
if (EditorWidget* w = getEditorWidget())
return w->currentNode();
return nullptr;
}
EditorWidget* MainWindow::getEditorWidget() const {
if (m_ui.editorContents->currentWidget() != m_faceSvg)
return static_cast<EditorWidget*>(m_ui.editorContents->currentWidget());
return nullptr;
}
amuse::ObjToken<amuse::Voice> MainWindow::startEditorVoice(uint8_t key, uint8_t velocity) {
amuse::ObjToken<amuse::Voice> vox;
if (ProjectModel::INode* node = getEditorNode()) {
amuse::AudioGroupDatabase* group = projectModel()->getGroupNode(node)->getAudioGroup();
if (node->type() == ProjectModel::INode::Type::SoundMacro) {
ProjectModel::SoundMacroNode* cNode = static_cast<ProjectModel::SoundMacroNode*>(node);
vox = m_engine->macroStart(group, cNode->id(), key, velocity, m_ctrlVals[1]);
} else if (node->type() == ProjectModel::INode::Type::Keymap || node->type() == ProjectModel::INode::Type::Layer) {
ProjectModel::BasePoolObjectNode* cNode = static_cast<ProjectModel::BasePoolObjectNode*>(node);
vox = m_engine->pageObjectStart(group, cNode->id(), key, velocity, m_ctrlVals[1]);
} else if (node->type() == ProjectModel::INode::Type::Sample) {
SampleEditor* editor = static_cast<SampleEditor*>(m_ui.editorContents->currentWidget());
vox = m_engine->macroStart(group, editor->soundMacro(), key, velocity, m_ctrlVals[1]);
}
if (vox) {
vox->setPedal(m_ctrlVals[64] >= 0x40);
vox->setPitchWheel(m_pitch);
vox->installCtrlValues(m_ctrlVals);
vox->setReverbVol(m_auxAVol);
vox->setAuxBVol(m_auxBVol);
}
}
return vox;
}
amuse::ObjToken<amuse::Voice> MainWindow::startSFX(amuse::GroupId groupId, amuse::SFXId sfxId) {
if (ProjectModel::INode* node = getEditorNode()) {
amuse::AudioGroupDatabase* group = projectModel()->getGroupNode(node)->getAudioGroup();
auto ret = m_engine->fxStart(group, groupId, sfxId, 1.f, 0.f);
ret->setReverbVol(m_auxAVol);
ret->setAuxBVol(m_auxBVol);
return ret;
}
return {};
}
amuse::ObjToken<amuse::Sequencer> MainWindow::startSong(amuse::GroupId groupId, amuse::SongId songId,
const unsigned char* arrData) {
if (ProjectModel::INode* node = getEditorNode()) {
amuse::AudioGroupDatabase* group = projectModel()->getGroupNode(node)->getAudioGroup();
auto ret = m_engine->seqPlay(group, groupId, songId, arrData);
for (uint8_t i = 0; i < 16; ++i) {
ret->setCtrlValue(i, 0x5b, int8_t(m_auxAVol * 127.f));
ret->setCtrlValue(i, 0x5d, int8_t(m_auxBVol * 127.f));
}
return ret;
}
return {};
}
void MainWindow::pushUndoCommand(EditorUndoCommand* cmd) { m_undoStack->push(cmd); }
void MainWindow::updateFocus() { onFocusChanged(nullptr, focusWidget()); }
void MainWindow::aboutToDeleteNode(ProjectModel::INode* node) {
if (*m_navIt == node && m_navIt != m_navList.end()) {
m_navList.erase(m_navIt, m_navList.end());
m_navIt = m_navList.end();
}
for (auto it = m_navList.begin(); it != m_navList.end();) {
if (*it == node) {
it = m_navList.erase(it);
continue;
}
++it;
}
updateNavigationButtons();
if (getEditorNode() == node)
closeEditor();
}
bool MainWindow::askAboutSave() {
if (!m_projectModel)
return true;
if (!m_undoStack->isClean()) {
QDir dir(m_projectModel->path());
int result =
m_mainMessenger.question(tr("Unsaved Changes"), tr("Save Changes in %1?").arg(dir.dirName()),
QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Save);
if (result == QMessageBox::Save) {
saveAction();
return true;
}
return result == QMessageBox::Discard;
} else {
return true;
}
}
void MainWindow::closeEvent(QCloseEvent* ev) {
if (askAboutSave())
ev->accept();
else
ev->ignore();
}
void MainWindow::showEvent(QShowEvent* ev) { m_studioSetup->updateWindowPosition(); }
void MainWindow::newAction() {
if (!askAboutSave())
return;
m_newFileDialog.setWindowTitle(tr("New Project"));
m_newFileDialog.open(this, SLOT(_newAction(const QString&)));
}
void MainWindow::_newAction(const QString& path) {
m_newFileDialog.close();
if (path.isEmpty())
return;
if (!MkPath(path, m_mainMessenger))
return;
if (!setProjectPath(path))
return;
m_projectModel->clearProjectData();
bool hasGroups = m_projectModel->ensureModelData();
m_ui.actionImport_Groups->setDisabled(hasGroups);
m_ui.actionImport_Songs->setEnabled(hasGroups);
}
bool MainWindow::openProject(const QString& path) {
QDir dir(path);
if (dir.path().isEmpty() || dir.path() == QStringLiteral(".") || dir.path() == QStringLiteral("..")) {
QString msg = QString(tr("The directory at '%1' must not be empty.")).arg(path);
m_mainMessenger.critical(tr("Directory empty"), msg);
return false;
} else if (!dir.exists()) {
QString msg = QString(tr("The directory at '%1' does not exist.")).arg(path);
m_mainMessenger.critical(tr("Bad Directory"), msg);
return false;
}
if (QFileInfo(dir, QStringLiteral("!project.yaml")).exists() && QFileInfo(dir, QStringLiteral("!pool.yaml")).exists())
dir.cdUp();
if (m_projectModel && m_projectModel->path() == dir.path())
return true;
if (!setProjectPath(dir.path()))
return false;
ProjectModel* model = m_projectModel;
startBackgroundTask(TaskOpen, tr("Opening"), tr("Scanning Project"), [dir, model](BackgroundTask& task) {
QStringList childDirs = dir.entryList(QDir::Dirs);
for (const auto& chDir : childDirs) {
if (task.isCanceled())
return;
if (chDir == QStringLiteral("out"))
continue;
QString chPath = dir.filePath(chDir);
if (QFileInfo(chPath, QStringLiteral("!project.yaml")).exists() &&
QFileInfo(chPath, QStringLiteral("!pool.yaml")).exists()) {
task.setLabelText(tr("Opening %1").arg(chDir));
if (!model->openGroupData(chDir, task.uiMessenger()))
return;
}
}
model->openSongsData();
});
return true;
}
void MainWindow::openAction() {
if (!askAboutSave())
return;
m_openDirectoryDialog.setWindowTitle(tr("Open Project"));
m_openDirectoryDialog.open(this, SLOT(_openAction(const QString&)));
}
void MainWindow::_openAction(const QString& path) {
m_openDirectoryDialog.close();
if (path.isEmpty())
return;
openProject(path);
}
void MainWindow::openRecentFileAction() {
if (!askAboutSave()) {
return;
}
if (const QAction* action = qobject_cast<QAction*>(sender())) {
const QString path = action->data().toString();
if (openProject(path)) {
return;
}
const QString key = QStringLiteral("recentFileList");
QSettings settings;
QStringList files = settings.value(key).toStringList();
files.removeAll(path);
settings.setValue(key, files);
settings.sync();
updateRecentFileActions();
}
}
void MainWindow::clearRecentFilesAction() {
QSettings settings;
settings.setValue(QStringLiteral("recentFileList"), QStringList());
settings.sync();
updateRecentFileActions();
}
void MainWindow::saveAction() {
if (m_projectModel) {
m_projectModel->saveToFile(m_mainMessenger);
m_undoStack->setClean();
}
}
void MainWindow::revertAction() {
if (m_projectModel && !m_undoStack->isClean()) {
QDir dir(m_projectModel->path());
int result = m_mainMessenger.question(tr("Unsaved Changes"), tr("Discard Changes in %1?").arg(dir.dirName()),
QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Cancel);
if (result == QMessageBox::Cancel)
return;
}
QString path = m_projectModel->path();
closeEditor();
m_undoStack->clear();
m_navList.clear();
m_navIt = m_navList.begin();
updateNavigationButtons();
delete m_projectModel;
m_projectModel = nullptr;
openProject(path);
}
void MainWindow::reloadSampleDataAction() {
closeEditor();
ProjectModel* model = m_projectModel;
if (!m_projectModel)
return;
QDir dir(m_projectModel->path());
if (!dir.exists())
return;
startBackgroundTask(TaskReloadSamples, tr("Reloading Samples"), tr("Scanning Project"),
[dir, model](BackgroundTask& task) {
QStringList childDirs = dir.entryList(QDir::Dirs);
for (const auto& chDir : childDirs) {
if (task.isCanceled())
return;
if (chDir == QStringLiteral("out"))
continue;
QString chPath = dir.filePath(chDir);
if (QFileInfo(chPath, QStringLiteral("!project.yaml")).exists() &&
QFileInfo(chPath, QStringLiteral("!pool.yaml")).exists()) {
task.setLabelText(tr("Scanning %1").arg(chDir));
if (!model->reloadSampleData(chDir, task.uiMessenger()))
return;
}
}
});
}
void MainWindow::importAction() {
m_openFileDialog.setWindowTitle(tr("Import Project"));
m_openFileDialog.open(this, SLOT(_importAction(const QString&)));
}
void MainWindow::_importAction(const QString& path) {
m_openFileDialog.close();
if (path.isEmpty())
return;
/* Validate input file */
amuse::ContainerRegistry::Type tp = amuse::ContainerRegistry::DetectContainerType(QStringToSysString(path).c_str());
if (tp == amuse::ContainerRegistry::Type::Invalid) {
QString msg = QString(tr("The file at '%1' could not be interpreted as a MusyX container.")).arg(path);
m_mainMessenger.critical(tr("Unsupported MusyX Container"), msg);
return;
}
/* Ask user about sample conversion */
int impMode = m_mainMessenger.question(tr("Sample Import Mode"),
tr("Amuse can import samples as WAV files for ease of editing, "
"import original compressed data for lossless repacking, or both. "
"Exporting the project will prefer whichever version was modified "
"most recently."),
tr("Import Compressed"), tr("Import WAVs"), tr("Import Both"));
switch (impMode) {
case 0:
case 1:
case 2:
break;
default:
return;
}
ProjectModel::ImportMode importMode = ProjectModel::ImportMode(impMode);
/* Special handling for raw groups - gather sibling groups in filesystem */
if (tp == amuse::ContainerRegistry::Type::Raw4) {
int scanMode = m_mainMessenger.question(tr("Raw Import Mode"),
tr("Would you like to scan for all MusyX group files in this directory?"),
QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
if (scanMode == QMessageBox::Yes) {
/* Auto-create project */
if (m_projectModel == nullptr) {
QString newName;
bool ok = true;
while (ok && newName.isEmpty())
newName = QInputDialog::getText(this, tr("Project Name"), tr("What should this project be named?"),
QLineEdit::Normal, QString(), &ok);
if (!ok)
return;
QFileInfo fInfo(path);
QString newPath = QFileInfo(fInfo.dir(), newName).filePath();
if (!MkPath(fInfo.dir(), newName, m_mainMessenger))
return;
if (!setProjectPath(newPath))
return;
}
ProjectModel* model = m_projectModel;
startBackgroundTask(
TaskImport, tr("Importing"), tr("Scanning Project"), [model, path, importMode](BackgroundTask& task) {
const QDir dir = QFileInfo(path).dir();
const QStringList filters{QStringLiteral("*.proj"), QStringLiteral("*.pro")};
const QStringList files = dir.entryList(filters, QDir::Files);
for (const QString& fPath : files) {
auto data = amuse::ContainerRegistry::LoadContainer(QStringToSysString(dir.filePath(fPath)).c_str());
for (auto& p : data) {
task.setLabelText(tr("Importing %1").arg(SysStringToQString(p.first)));
if (task.isCanceled())
return;
if (!model->importGroupData(SysStringToQString(p.first), p.second, importMode, task.uiMessenger()))
return;
}
}
model->openSongsData();
});
return;
} else if (scanMode == QMessageBox::No) {
} else {
return;
}
}
/* Auto-create project */
if (m_projectModel == nullptr) {
QFileInfo fInfo(path);
QString newPath = QFileInfo(fInfo.dir(), fInfo.completeBaseName()).filePath();
if (!MkPath(fInfo.dir(), fInfo.completeBaseName(), m_mainMessenger))
return;
if (!setProjectPath(newPath))
return;
}
ProjectModel* model = m_projectModel;
startBackgroundTask(
TaskImport, tr("Importing"), tr("Scanning Project"), [model, path, importMode](BackgroundTask& task) {
/* Handle single container */
auto data = amuse::ContainerRegistry::LoadContainer(QStringToSysString(path).c_str());
task.setMaximum(int(data.size()));
int curVal = 0;
for (auto& p : data) {
task.setLabelText(tr("Importing %1").arg(SysStringToQString(p.first)));
if (task.isCanceled())
return;
if (!model->importGroupData(SysStringToQString(p.first), p.second, importMode, task.uiMessenger()))
return;
task.setValue(++curVal);
}
model->openSongsData();
});
}
void MainWindow::importSongsAction() {
if (!m_projectModel)
return;
m_openFileDialog.setWindowTitle(tr("Import Songs"));
m_openFileDialog.open(this, SLOT(_importSongsAction(const QString&)));
}
void MainWindow::_importSongsAction(const QString& path) {
m_openFileDialog.close();
if (path.isEmpty())
return;
closeEditor();
m_projectModel->importSongsData(path);
}
void MainWindow::exportAction() {
if (!m_projectModel)
return;
QFileInfo dirInfo(m_projectModel->dir(), QStringLiteral("out"));
if (!MkPath(dirInfo.filePath(), m_mainMessenger))
return;
QDir dir(dirInfo.filePath());
ProjectModel* model = m_projectModel;
startBackgroundTask(BackgroundTaskId::TaskExport, tr("Exporting"), tr("Scanning Project"),
[model, dir](BackgroundTask& task) {
QStringList groupList = model->getGroupList();
task.setMaximum(groupList.size());
int curVal = 0;
for (QString group : groupList) {
task.setLabelText(tr("Exporting %1").arg(group));
if (task.isCanceled())
return;
if (!model->exportGroup(dir.path(), group, task.uiMessenger()))
return;
task.setValue(++curVal);
}
});
}
void MainWindow::importHeadersAction() {
if (!m_projectModel)
return;
int confirm =
m_mainMessenger.warning(tr("Import C Headers"),
tr("<p>Importing names from C headers depends on up-to-date, "
"consistent names relative to the sound group data.</p>"
"<p>Headers are imported on a per-subproject basis from "
"a single directory. Headers must be named with the form "
"<code>&lt;subproject&gt;.h</code>.</p>"
"<p>Group, Song and SFX definitions are matched according to the following forms:"
"<pre>#define GRP&lt;name&gt; &lt;id&gt;\n#define SNG&lt;name&gt; &lt;id&gt;\n"
"#define SFX&lt;name> &lt;id&gt;</pre></p>"
"<p><strong>This operation cannot be undone! It is recommended to "
"make a backup of the project directory before proceeding.</strong></p>"
"<p>Continue?</p>"),
QMessageBox::Yes | QMessageBox::No);
if (confirm == QMessageBox::No)
return;
m_openDirectoryDialog.setWindowTitle(tr("Import C Headers"));
m_openDirectoryDialog.open(this, SLOT(_importHeadersAction(const QString&)));
}
void MainWindow::_importHeadersAction(const QString& path) {
m_openDirectoryDialog.close();
if (path.isEmpty())
return;
closeEditor();
for (QString group : m_projectModel->getGroupList())
m_projectModel->importHeader(path, group, m_mainMessenger);
m_projectModel->updateNodeNames();
/* Samples may have been renamed.. stay consistent! */
saveAction();
}
void MainWindow::exportHeadersAction() {
if (!m_projectModel)
return;
m_openDirectoryDialog.setWindowTitle(tr("Export C Headers"));
m_openDirectoryDialog.open(this, SLOT(_exportHeadersAction(const QString&)));
}
void MainWindow::_exportHeadersAction(const QString& path) {
m_openDirectoryDialog.close();
if (path.isEmpty())
return;
bool yesToAll = false;
for (QString group : m_projectModel->getGroupList())
if (!m_projectModel->exportHeader(path, group, yesToAll, m_mainMessenger))
return;
}
bool TreeDelegate::editorEvent(QEvent* event, QAbstractItemModel* __model, const QStyleOptionViewItem& option,
const QModelIndex& index) {
QSortFilterProxyModel* _model = static_cast<QSortFilterProxyModel*>(__model);
ProjectModel* model = static_cast<ProjectModel*>(_model->sourceModel());
ProjectModel::INode* node = model->node(_model->mapToSource(index));
if (!node || !(node->flags() & Qt::ItemIsEditable))
return false;
AmuseItemEditFlags flags = node->editFlags();
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent* ev = static_cast<QMouseEvent*>(event);
if (ev->button() == Qt::RightButton) {
ContextMenu* menu = new ContextMenu;
if (node->type() == ProjectModel::INode::Type::Group) {
QAction* exportGroupAction = new QAction(tr("Export GameCube Group"), menu);
exportGroupAction->setData(QVariant::fromValue((void*)node));
connect(exportGroupAction, &QAction::triggered, this, &TreeDelegate::doExportGroup);
menu->addAction(exportGroupAction);
menu->addSeparator();
}
QAction* findUsagesAction = new QAction(tr("Find Usages"), menu);
findUsagesAction->setData(QVariant::fromValue((void*)node));
findUsagesAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-find")));
connect(findUsagesAction, &QAction::triggered, this, &TreeDelegate::doFindUsages);
menu->addAction(findUsagesAction);
menu->addSeparator();
QAction* cutAction = new QAction(tr("Cut"), menu);
cutAction->setData(index);
cutAction->setEnabled(flags & AmuseItemCut);
cutAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-cut")));
cutAction->setShortcut(QKeySequence::Cut);
connect(cutAction, &QAction::triggered, this, &TreeDelegate::doCut);
menu->addAction(cutAction);
QAction* copyAction = new QAction(tr("Copy"), menu);
copyAction->setData(index);
copyAction->setEnabled(flags & AmuseItemCopy);
copyAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
copyAction->setShortcut(QKeySequence::Copy);
connect(copyAction, &QAction::triggered, this, &TreeDelegate::doCopy);
menu->addAction(copyAction);
QAction* pasteAction = new QAction(tr("Paste"), menu);
pasteAction->setData(index);
pasteAction->setEnabled(g_MainWindow->m_clipboardAmuseData && flags & AmuseItemPaste);
pasteAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
pasteAction->setShortcut(QKeySequence::Paste);
connect(pasteAction, &QAction::triggered, this, &TreeDelegate::doPaste);
menu->addAction(pasteAction);
QAction* dupeAction = new QAction(tr("Duplicate"), menu);
dupeAction->setData(index);
connect(dupeAction, &QAction::triggered, this, &TreeDelegate::doDuplicate);
menu->addAction(dupeAction);
QAction* deleteAction = new QAction(tr("Delete"), menu);
deleteAction->setData(index);
deleteAction->setEnabled(flags & AmuseItemDelete);
deleteAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
deleteAction->setShortcut(QKeySequence::Delete);
connect(deleteAction, &QAction::triggered, this, &TreeDelegate::doDelete);
menu->addAction(deleteAction);
QAction* renameAction = new QAction(tr("Rename"), menu);
renameAction->setData(index);
renameAction->setShortcut(Qt::Key_F2);
connect(renameAction, &QAction::triggered, this, &TreeDelegate::doRename);
menu->addAction(renameAction);
menu->popup(ev->globalPos());
}
}
return false;
}
void TreeDelegate::doExportGroup() {
if (!m_window.m_projectModel)
return;
QAction* act = qobject_cast<QAction*>(sender());
if (ProjectModel::INode* node = reinterpret_cast<ProjectModel::INode*>(act->data().value<void*>())) {
if (node->type() != ProjectModel::INode::Type::Group)
return;
QString groupName = static_cast<ProjectModel::GroupNode*>(node)->name();
ProjectModel* model = m_window.m_projectModel;
QFileInfo dirInfo(model->dir(), QStringLiteral("out"));
if (!MkPath(dirInfo.filePath(), m_window.m_mainMessenger))
return;
QDir dir(dirInfo.filePath());
m_window.startBackgroundTask(BackgroundTaskId::TaskExport, tr("Exporting"), tr("Exporting %1").arg(groupName),
[model, dir, groupName](BackgroundTask& task) {
model->exportGroup(dir.path(), groupName, task.uiMessenger());
});
}
}
void TreeDelegate::doFindUsages() {
QAction* act = qobject_cast<QAction*>(sender());
if (ProjectModel::INode* node = reinterpret_cast<ProjectModel::INode*>(act->data().value<void*>()))
m_window.findUsages(node);
}
void TreeDelegate::doCut() {
QAction* act = qobject_cast<QAction*>(sender());
if (!m_window.m_projectModel)
return;
m_window.m_projectModel->cut(m_window.m_projectModel->getOutlineProxy()->mapToSource(act->data().toModelIndex()));
}
void TreeDelegate::doCopy() {
QAction* act = qobject_cast<QAction*>(sender());
if (!m_window.m_projectModel)
return;
m_window.m_projectModel->copy(m_window.m_projectModel->getOutlineProxy()->mapToSource(act->data().toModelIndex()));
}
void TreeDelegate::doPaste() {
QAction* act = qobject_cast<QAction*>(sender());
if (!m_window.m_projectModel)
return;
m_window.m_projectModel->paste(m_window.m_projectModel->getOutlineProxy()->mapToSource(act->data().toModelIndex()));
}
void TreeDelegate::doDuplicate() {
QAction* act = qobject_cast<QAction*>(sender());
if (!m_window.m_projectModel)
return;
QModelIndex newIdx = m_window.m_projectModel->duplicate(
m_window.m_projectModel->getOutlineProxy()->mapToSource(act->data().toModelIndex()));
if (newIdx.isValid()) {
newIdx = m_window.m_projectModel->getOutlineProxy()->mapFromSource(newIdx);
m_window.m_ui.projectOutline->edit(newIdx);
}
}
void TreeDelegate::doDelete() {
QAction* act = qobject_cast<QAction*>(sender());
if (!m_window.m_projectModel)
return;
m_window.m_projectModel->del(m_window.m_projectModel->getOutlineProxy()->mapToSource(act->data().toModelIndex()));
}
void TreeDelegate::doRename() {
QAction* act = qobject_cast<QAction*>(sender());
m_window.m_ui.projectOutline->edit(act->data().toModelIndex());
}
QString MainWindow::getGroupName(ProjectModel::GroupNode* group) const {
if (group)
return group->text();
return {};
}
ProjectModel::GroupNode* MainWindow::getSelectedGroupNode() const {
if (!m_projectModel)
return nullptr;
if (!m_ui.projectOutline->currentIndex().isValid())
return nullptr;
return m_projectModel->getGroupNode(
m_projectModel->node(m_projectModel->getOutlineProxy()->mapToSource(m_ui.projectOutline->currentIndex())));
}
QString MainWindow::getSelectedGroupName() const { return getGroupName(getSelectedGroupNode()); }
void MainWindow::_recursiveExpandOutline(const QModelIndex& filterIndex) const {
if (filterIndex.isValid()) {
_recursiveExpandOutline(filterIndex.parent());
m_ui.projectOutline->expand(filterIndex);
}
}
void MainWindow::recursiveExpandAndSelectOutline(const QModelIndex& index) const {
QModelIndex filterIndex = m_projectModel->getOutlineProxy()->mapFromSource(index);
_recursiveExpandOutline(filterIndex);
if (filterIndex.isValid())
m_ui.projectOutline->setCurrentIndex(filterIndex);
}
void MainWindow::newSubprojectAction() {
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(this, tr("New Subproject"), tr("What should this subproject be named?"),
QLineEdit::Normal, QString(), &ok);
}
if (!ok) {
return;
}
m_projectModel->newSubproject(std::move(newName));
}
void MainWindow::newSFXGroupAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(
this, tr("New SFX Group"), tr("What should the new SFX group in %1 be named?").arg(groupName),
QLineEdit::Normal,
QString::fromStdString(amuse::GroupId::CurNameDB->generateDefaultName(amuse::NameDB::Type::Group)), &ok);
}
if (!ok) {
return;
}
ProjectModel::SoundGroupNode* node = m_projectModel->newSoundGroup(group, std::move(newName));
if (node) {
openEditor(node);
}
}
void MainWindow::newSongGroupAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(
this, tr("New Song Group"), tr("What should the new Song group in %1 be named?").arg(groupName),
QLineEdit::Normal,
QString::fromStdString(amuse::GroupId::CurNameDB->generateDefaultName(amuse::NameDB::Type::Group)), &ok);
}
if (!ok) {
return;
}
ProjectModel::SongGroupNode* node = m_projectModel->newSongGroup(group, std::move(newName));
if (node) {
openEditor(node);
}
}
void MainWindow::newSoundMacroAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
const SoundMacroTemplateEntry* templ = nullptr;
int result = QDialog::Accepted;
while (result == QDialog::Accepted && newName.isEmpty()) {
NewSoundMacroDialog dialog(groupName, this);
dialog.setWindowModality(Qt::WindowModal);
result = dialog.exec();
newName = dialog.getName();
templ = dialog.getSelectedTemplate();
}
if (result == QDialog::Rejected) {
return;
}
ProjectModel::SoundMacroNode* node = m_projectModel->newSoundMacro(group, std::move(newName), templ);
if (node) {
openEditor(node);
}
}
void MainWindow::newADSRAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(
this, tr("New ADSR"), tr("What should the new ADSR in %1 be named?").arg(groupName), QLineEdit::Normal,
QString::fromStdString(amuse::TableId::CurNameDB->generateDefaultName(amuse::NameDB::Type::Table)), &ok);
}
if (!ok) {
return;
}
ProjectModel::ADSRNode* node = m_projectModel->newADSR(group, std::move(newName));
if (node) {
openEditor(node);
}
}
void MainWindow::newCurveAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(
this, tr("New Curve"), tr("What should the new Curve in %1 be named?").arg(groupName), QLineEdit::Normal,
QString::fromStdString(amuse::TableId::CurNameDB->generateDefaultName(amuse::NameDB::Type::Table)), &ok);
}
if (!ok) {
return;
}
ProjectModel::CurveNode* node = m_projectModel->newCurve(group, std::move(newName));
if (node) {
openEditor(node);
}
}
void MainWindow::newKeymapAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(
this, tr("New Keymap"), tr("What should the new Keymap in %1 be named?").arg(groupName), QLineEdit::Normal,
QString::fromStdString(amuse::KeymapId::CurNameDB->generateDefaultName(amuse::NameDB::Type::Keymap)), &ok);
}
if (!ok) {
return;
}
ProjectModel::KeymapNode* node = m_projectModel->newKeymap(group, std::move(newName));
if (node) {
openEditor(node);
}
}
void MainWindow::newLayersAction() {
ProjectModel::GroupNode* group = getSelectedGroupNode();
m_projectModel->setIdDatabases(group);
const QString groupName = getGroupName(group);
QString newName;
bool ok = true;
while (ok && newName.isEmpty()) {
newName = QInputDialog::getText(
this, tr("New Layers"), tr("What should the new Layers in %1 be named?").arg(groupName), QLineEdit::Normal,
QString::fromStdString(amuse::LayersId::CurNameDB->generateDefaultName(amuse::NameDB::Type::Layer)), &ok);
}
if (!ok) {
return;
}
ProjectModel::LayersNode* node = m_projectModel->newLayers(group, std::move(newName));
if (node) {
openEditor(node);
}
}
void MainWindow::updateNavigationButtons() {
m_goForward->setDisabled(m_navIt == m_navList.end() || std::next(m_navIt, 1) == m_navList.end());
m_goBack->setDisabled(m_navIt == m_navList.begin());
}
void MainWindow::goForward() {
if (m_navIt == m_navList.end() || std::next(m_navIt, 1) == m_navList.end())
return;
++m_navIt;
openEditor(*m_navIt, false);
updateNavigationButtons();
}
void MainWindow::goBack() {
if (m_navIt == m_navList.begin())
return;
--m_navIt;
openEditor(*m_navIt, false);
updateNavigationButtons();
}
void MainWindow::findUsages(ProjectModel::INode* node) {
m_ui.projectOutlineFilter->setText(QStringLiteral("usages:") + node->name());
}
void MainWindow::aboutToShowAudioIOMenu() { refreshAudioIO(); }
void MainWindow::aboutToShowMIDIIOMenu() { refreshMIDIIO(); }
void MainWindow::setAudioIO() {
QByteArray devName = qobject_cast<QAction*>(sender())->data().toString().toUtf8();
if (m_voxEngine)
m_voxEngine->setCurrentAudioOutput(devName.data());
}
void MainWindow::setMIDIIO(bool checked) {
QAction* action = qobject_cast<QAction*>(sender());
QByteArray devName = action->data().toString().toUtf8();
if (m_voxEngine) {
MIDIReader* mr = static_cast<MIDIReader*>(m_engine->getMIDIReader());
if (devName == "<amuse-virtual-in>") {
mr->setVirtualIn(checked);
action->setChecked(mr->hasVirtualIn());
} else {
if (checked)
mr->addMIDIIn(devName.data());
else
mr->removeMIDIIn(devName.data());
action->setChecked(mr->hasMIDIIn(devName.data()));
}
}
}
void MainWindow::aboutAmuseAction() {
#ifdef Q_OS_MAC
static QPointer<QMessageBox> oldMsgBox;
if (oldMsgBox) {
oldMsgBox->show();
oldMsgBox->raise();
oldMsgBox->activateWindow();
return;
}
#endif
QString translatedTextAboutAmuseCaption;
translatedTextAboutAmuseCaption = QMessageBox::tr("<h3>About Amuse</h3>");
QString translatedTextAboutAmuseText;
translatedTextAboutAmuseText = QMessageBox::tr(
"<p>Amuse is an alternate editor and runtime library for MusyX sound groups.</p>"
"<p>MusyX originally served as a widely-deployed audio system for "
"developing games on the Nintendo 64, GameCube, and GameBoy Advance.</p>"
"<p>Amuse is available under the MIT license.<br>"
"Please see <a href=\"https://gitlab.axiodl.com/AxioDL/amuse/blob/master/LICENSE\">"
"https://gitlab.axiodl.com/AxioDL/amuse/blob/master/LICENSE</a> for futher information.</p>"
"<p>Copyright (C) 2015-2018 Antidote / Jackoalan.</p>"
"<p>MusyX is a trademark of Factor 5, LLC.</p>"
"<p>Nintendo 64, GameCube, and GameBoy Advance are trademarks of Nintendo Co., Ltd.</p>");
QMessageBox* msgBox = new QMessageBox(this);
msgBox->setAttribute(Qt::WA_DeleteOnClose);
msgBox->setWindowTitle(tr("About Amuse"));
msgBox->setText(translatedTextAboutAmuseCaption);
msgBox->setInformativeText(translatedTextAboutAmuseText);
msgBox->setIconPixmap(windowIcon().pixmap(64, 64));
// should perhaps be a style hint
#ifdef Q_OS_MAC
oldMsgBox = msgBox;
#if 0
// ### doesn't work until close button is enabled in title bar
//msgBox->d_func()->autoAddOkButton = false;
#else
// msgBox->d_func()->buttonBox->setCenterButtons(true);
#endif
msgBox->show();
#else
msgBox->exec();
#endif
}
void MainWindow::aboutQtAction() { QMessageBox::aboutQt(this); }
void MainWindow::notePressed(int key) {
if (m_engine) {
if (m_lastSound)
m_lastSound->keyOff();
m_lastSound = startEditorVoice(key, m_velocity);
}
}
void MainWindow::noteReleased() {
if (m_lastSound) {
m_lastSound->keyOff();
m_lastSound.reset();
}
}
void MainWindow::velocityChanged(int vel) { m_velocity = vel; }
void MainWindow::modulationChanged(int mod) {
m_ctrlVals[1] = int8_t(mod);
for (auto& v : m_engine->getActiveVoices())
v->setCtrlValue(1, m_ctrlVals[1]);
}
void MainWindow::pitchChanged(int pitch) {
m_pitch = pitch / 2048.f;
for (auto& v : m_engine->getActiveVoices())
v->setPitchWheel(m_pitch);
}
void MainWindow::killSounds() {
for (auto& v : m_engine->getActiveVoices())
v->kill();
}
void MainWindow::fxPressed() {
if (m_studioSetup->isVisible())
m_studioSetup->hide();
else
m_studioSetup->show();
}
void MainWindow::volumeChanged(int vol) { m_engine->setVolume(vol / 100.f); }
void MainWindow::auxAChanged(int vol) {
m_auxAVol = vol / 100.f;
for (auto& vox : m_engine->getActiveVoices())
vox->setReverbVol(m_auxAVol);
for (auto& seq : m_engine->getActiveSequencers())
for (uint8_t i = 0; i < 16; ++i)
seq->setCtrlValue(i, 0x5b, int8_t(m_auxAVol * 127.f));
}
void MainWindow::auxBChanged(int vol) {
m_auxBVol = vol / 100.f;
for (auto& vox : m_engine->getActiveVoices())
vox->setAuxBVol(m_auxBVol);
for (auto& seq : m_engine->getActiveSequencers())
for (uint8_t i = 0; i < 16; ++i)
seq->setCtrlValue(i, 0x5d, int8_t(m_auxBVol * 127.f));
}
void MainWindow::outlineCutAction() {
if (!m_projectModel)
return;
m_projectModel->cut(m_projectModel->getOutlineProxy()->mapToSource(m_ui.projectOutline->currentIndex()));
}
void MainWindow::outlineCopyAction() {
if (!m_projectModel)
return;
m_projectModel->copy(m_projectModel->getOutlineProxy()->mapToSource(m_ui.projectOutline->currentIndex()));
}
void MainWindow::outlinePasteAction() {
if (!m_projectModel)
return;
m_projectModel->paste(m_projectModel->getOutlineProxy()->mapToSource(m_ui.projectOutline->currentIndex()));
}
void MainWindow::outlineDeleteAction() {
if (!m_projectModel)
return;
m_projectModel->del(m_projectModel->getOutlineProxy()->mapToSource(m_ui.projectOutline->currentIndex()));
}
void MainWindow::onFocusChanged(QWidget* old, QWidget* now) {
disconnect(m_cutConn);
disconnect(m_copyConn);
disconnect(m_pasteConn);
disconnect(m_deleteConn);
disconnect(m_canEditConn);
if (QLineEdit* le = qobject_cast<QLineEdit*>(now)) {
m_cutConn = connect(m_ui.actionCut, &QAction::triggered, le, &QLineEdit::cut);
m_ui.actionCut->setEnabled(le->hasSelectedText());
m_copyConn = connect(m_ui.actionCopy, &QAction::triggered, le, &QLineEdit::copy);
m_ui.actionCopy->setEnabled(le->hasSelectedText());
m_pasteConn = connect(m_ui.actionPaste, &QAction::triggered, le, &QLineEdit::paste);
m_ui.actionPaste->setEnabled(true);
m_deleteConn = connect(m_ui.actionDelete, &QAction::triggered, this, &MainWindow::onTextDelete);
m_ui.actionDelete->setEnabled(true);
m_canEditConn = connect(le, &QLineEdit::selectionChanged, this, &MainWindow::onTextSelect);
return;
}
if (now == m_ui.projectOutline || m_ui.projectOutline->isAncestorOf(now)) {
AmuseItemEditFlags editFlags = outlineEditFlags();
if (!m_clipboardAmuseData)
editFlags = AmuseItemEditFlags(editFlags & ~AmuseItemPaste);
setItemEditFlags(editFlags);
if (m_projectModel) {
m_cutConn = connect(m_ui.actionCut, &QAction::triggered, this, &MainWindow::outlineCutAction);
m_copyConn = connect(m_ui.actionCopy, &QAction::triggered, this, &MainWindow::outlineCopyAction);
m_pasteConn = connect(m_ui.actionPaste, &QAction::triggered, this, &MainWindow::outlinePasteAction);
m_deleteConn = connect(m_ui.actionDelete, &QAction::triggered, this, &MainWindow::outlineDeleteAction);
}
} else if (now == m_ui.editorContents || m_ui.editorContents->isAncestorOf(now)) {
if (EditorWidget* editor = getEditorWidget()) {
setItemEditFlags(editor->itemEditFlags());
m_cutConn = connect(m_ui.actionCut, &QAction::triggered, editor, &EditorWidget::itemCutAction);
m_copyConn = connect(m_ui.actionCopy, &QAction::triggered, editor, &EditorWidget::itemCopyAction);
m_pasteConn = connect(m_ui.actionPaste, &QAction::triggered, editor, &EditorWidget::itemPasteAction);
m_deleteConn = connect(m_ui.actionDelete, &QAction::triggered, editor, &EditorWidget::itemDeleteAction);
} else {
setItemEditFlags(AmuseItemNone);
}
}
}
void MainWindow::onClipboardChanged() {
if (QClipboard* cb = qobject_cast<QClipboard*>(sender())) {
if (const QMimeData* md = cb->mimeData()) {
for (const QString& str : md->formats()) {
if (str.startsWith(QStringLiteral("application/x-amuse-"))) {
m_clipboardAmuseData = true;
updateFocus();
return;
}
}
}
}
m_clipboardAmuseData = false;
updateFocus();
}
void MainWindow::outlineItemActivated(const QModelIndex& index) {
ProjectModel::INode* node = m_projectModel->node(m_projectModel->getOutlineProxy()->mapToSource(index));
if (!node)
return;
openEditor(node);
}
void MainWindow::setItemEditFlags(AmuseItemEditFlags flags) {
m_ui.actionCut->setEnabled(flags & AmuseItemCut);
m_ui.actionCopy->setEnabled(flags & AmuseItemCopy);
m_ui.actionPaste->setEnabled(flags & AmuseItemPaste);
m_ui.actionDelete->setEnabled(flags & AmuseItemDelete);
}
void MainWindow::setItemNewEnabled(bool enabled) {
m_ui.actionNew_SFX_Group->setEnabled(enabled);
m_ui.actionNew_Song_Group->setEnabled(enabled);
m_ui.actionNew_Sound_Macro->setEnabled(enabled);
m_ui.actionNew_ADSR->setEnabled(enabled);
m_ui.actionNew_Curve->setEnabled(enabled);
m_ui.actionNew_Keymap->setEnabled(enabled);
m_ui.actionNew_Layers->setEnabled(enabled);
}
AmuseItemEditFlags MainWindow::outlineEditFlags() {
if (!m_projectModel)
return AmuseItemNone;
QModelIndex curIndex = m_ui.projectOutline->currentIndex();
if (!curIndex.isValid())
return AmuseItemNone;
return m_projectModel->editFlags(m_projectModel->getOutlineProxy()->mapToSource(curIndex));
}
void MainWindow::onOutlineSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
if (!m_projectModel)
return;
setItemNewEnabled(m_ui.projectOutline->currentIndex().isValid());
if (selected.indexes().empty())
setItemEditFlags(AmuseItemNone);
else
setItemEditFlags(
m_projectModel->editFlags(m_projectModel->getOutlineProxy()->mapToSource(selected.indexes().front())));
}
void MainWindow::onTextSelect() {
if (QLineEdit* le = qobject_cast<QLineEdit*>(sender())) {
m_ui.actionCut->setEnabled(le->hasSelectedText());
m_ui.actionCopy->setEnabled(le->hasSelectedText());
}
}
void MainWindow::onTextDelete() {
if (QLineEdit* le = qobject_cast<QLineEdit*>(focusWidget())) {
le->del();
}
}
void MainWindow::cleanChanged(bool clean) { setWindowModified(!clean); }
void MainWindow::studioSetupHidden() { m_ui.statusbar->setFXDown(false); }
void MainWindow::studioSetupShown() { m_ui.statusbar->setFXDown(true); }
void MainWindow::onBackgroundTaskFinished(int id) {
m_backgroundDialog->close();
m_backgroundDialog->reset();
m_backgroundDialog->deleteLater();
m_backgroundDialog = nullptr;
m_backgroundTask->deleteLater();
m_backgroundTask = nullptr;
if (id == TaskExport) {
if (m_mainMessenger.question(tr("Export Complete"), tr("%1?").arg(ShowInGraphicalShellString())) ==
QMessageBox::Yes) {
QFileInfo dirInfo(m_projectModel->dir(), QStringLiteral("out"));
QDir dir(dirInfo.filePath());
QStringList entryList = dir.entryList(QDir::Files);
ShowInGraphicalShell(this, entryList.empty() ? dirInfo.filePath() : QFileInfo(dir, entryList.first()).filePath());
}
} else {
bool hasGroups = m_projectModel->ensureModelData();
m_ui.actionImport_Groups->setDisabled(hasGroups);
m_ui.actionImport_Songs->setEnabled(hasGroups);
}
setEnabled(true);
}
static int ShowOldMessageBox(QWidget* parent, QMessageBox::Icon icon, const QString& title, const QString& text,
const QString& button0Text, const QString& button1Text, const QString& button2Text,
int defaultButtonNumber, int escapeButtonNumber) {
QMessageBox messageBox(icon, title, text, QMessageBox::NoButton, parent);
messageBox.setWindowModality(Qt::WindowModal);
QString myButton0Text = button0Text;
if (myButton0Text.isEmpty())
myButton0Text = QDialogButtonBox::tr("OK");
messageBox.addButton(myButton0Text, QMessageBox::ActionRole);
if (!button1Text.isEmpty())
messageBox.addButton(button1Text, QMessageBox::ActionRole);
if (!button2Text.isEmpty())
messageBox.addButton(button2Text, QMessageBox::ActionRole);
const QList<QAbstractButton*>& buttonList = messageBox.buttons();
messageBox.setDefaultButton(static_cast<QPushButton*>(buttonList.value(defaultButtonNumber)));
messageBox.setEscapeButton(buttonList.value(escapeButtonNumber));
return messageBox.exec();
}
static QMessageBox::StandardButton ShowNewMessageBox(QWidget* parent, QMessageBox::Icon icon, const QString& title,
const QString& text, QMessageBox::StandardButtons buttons,
QMessageBox::StandardButton defaultButton) {
QMessageBox msgBox(icon, title, text, QMessageBox::NoButton, parent);
msgBox.setWindowModality(Qt::WindowModal);
QDialogButtonBox* buttonBox = msgBox.findChild<QDialogButtonBox*>();
Q_ASSERT(buttonBox != 0);
uint mask = QMessageBox::FirstButton;
while (mask <= QMessageBox::LastButton) {
uint sb = buttons & mask;
mask <<= 1;
if (!sb)
continue;
QPushButton* button = msgBox.addButton((QMessageBox::StandardButton)sb);
// Choose the first accept role as the default
if (msgBox.defaultButton())
continue;
if ((defaultButton == QMessageBox::NoButton && buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) ||
(defaultButton != QMessageBox::NoButton && sb == uint(defaultButton)))
msgBox.setDefaultButton(button);
}
if (msgBox.exec() == -1)
return QMessageBox::Cancel;
return msgBox.standardButton(msgBox.clickedButton());
}
QMessageBox::StandardButton MainWindow::msgInformation(const QString& title, const QString& text,
QMessageBox::StandardButtons buttons,
QMessageBox::StandardButton defaultButton) {
return ShowNewMessageBox(this, QMessageBox::Information, title, text, buttons, defaultButton);
}
int MainWindow::msgQuestion(const QString& title, const QString& text, const QString& button0Text,
const QString& button1Text, const QString& button2Text, int defaultButtonNumber,
int escapeButtonNumber) {
return ShowOldMessageBox(this, QMessageBox::Question, title, text, button0Text, button1Text, button2Text,
defaultButtonNumber, escapeButtonNumber);
}
QMessageBox::StandardButton MainWindow::msgQuestion(const QString& title, const QString& text,
QMessageBox::StandardButtons buttons,
QMessageBox::StandardButton defaultButton) {
return ShowNewMessageBox(this, QMessageBox::Question, title, text, buttons, defaultButton);
}
QMessageBox::StandardButton MainWindow::msgWarning(const QString& title, const QString& text,
QMessageBox::StandardButtons buttons,
QMessageBox::StandardButton defaultButton) {
return ShowNewMessageBox(this, QMessageBox::Warning, title, text, buttons, defaultButton);
}
QMessageBox::StandardButton MainWindow::msgCritical(const QString& title, const QString& text,
QMessageBox::StandardButtons buttons,
QMessageBox::StandardButton defaultButton) {
return ShowNewMessageBox(this, QMessageBox::Critical, title, text, buttons, defaultButton);
}
Reference in New Issue View Git Blame Copy Permalink