/* * SPDX-FileCopyrightText: 2018 Rerrah * SPDX-License-Identifier: MIT */ #include "mainwindow.hpp" #include "ui_mainwindow.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "jamming.hpp" #include "song.hpp" #include "track.hpp" #include "instrument.hpp" #include "bank.hpp" #include "io/io_file_type.hpp" #include "io/module_io.hpp" #include "io/instrument_io.hpp" #include "io/bank_io.hpp" #include "io/binary_container.hpp" #include "io/wav_container.hpp" #include "version.hpp" #include "gui/command/instrument/instrument_commands_qt.hpp" #include "gui/instrument_editor/fm_instrument_editor.hpp" #include "gui/instrument_editor/ssg_instrument_editor.hpp" #include "gui/instrument_editor/adpcm_instrument_editor.hpp" #include "gui/instrument_editor/adpcm_drumkit_editor.hpp" #include "gui/module_properties_dialog.hpp" #include "gui/groove_settings_dialog.hpp" #include "gui/configuration_dialog.hpp" #include "gui/wave_export_settings_dialog.hpp" #include "gui/vgm_export_settings_dialog.hpp" #include "gui/instrument_selection_dialog.hpp" #include "gui/s98_export_settings_dialog.hpp" #include "gui/configuration_handler.hpp" #include "gui/jam_layout.hpp" #include "gui/wheel_spin_box.hpp" #include "chip/scci/scci_wrapper.hpp" #include "chip/c86ctl/c86ctl_wrapper.hpp" #include "midi/midi.hpp" #include "audio/audio_stream_rtaudio.hpp" #include "enum_hash.hpp" #include "gui/go_to_dialog.hpp" #include "gui/transpose_song_dialog.hpp" #include "gui/swap_tracks_dialog.hpp" #include "gui/hide_tracks_dialog.hpp" #include "gui/file_io_error_message_box.hpp" #include "gui/note_name_manager.hpp" #include "gui/gui_utils.hpp" #include "gui/command_result_message_box.hpp" #include "utils.hpp" namespace { const std::unordered_map TB_POS_ = { { Configuration::ToolbarPosition::TopPosition, Qt::TopToolBarArea }, { Configuration::ToolbarPosition::BottomPosition, Qt::BottomToolBarArea }, { Configuration::ToolbarPosition::LeftPosition, Qt::LeftToolBarArea }, { Configuration::ToolbarPosition::RightPosition, Qt::RightToolBarArea } }; constexpr int STATUS_DISPLAY_TIMEOUT = 0; } ModuleSaveCheckDialog::ModuleSaveCheckDialog(const std::string& name, QWidget* parent) : QMessageBox(QMessageBox::Warning, "BambooTracker", "", QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, parent) { setText(tr("Save changes to %1?").arg(name.empty() ? tr("Untitled") : gui_utils::utf8ToQString(name))); } MainWindow::MainWindow(std::weak_ptr config, QString filePath, bool isFirstLaunch, QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow), config_(config), palette_(std::make_shared()), bt_(std::make_shared(config)), comStack_(std::make_shared(this)), fileHistory_(std::make_shared()), scciDll_(std::make_shared("scci")), c86ctlDll_(std::make_shared("c86ctl")), instDialogMan_(std::make_shared()), renamingInstItem_(nullptr), renamingInstEdit_(nullptr), isModifiedForNotCommand_(false), hasLockedWigets_(false), isEditedPattern_(true), isEditedOrder_(false), isEditedInstList_(false), isSelectedPattern_(false), isSelectedOrder_(false), hasShownOnce_(false), firstViewUpdateRequest_(false), octUpSc_(nullptr), octDownSc_(nullptr), focusPtnSc_(this), focusOdrSc_(this), focusInstSc_(this), playAndStopSc_(nullptr), playStepSc_(nullptr), goPrevOdrSc_(nullptr), goNextOdrSc_(nullptr), prevInstSc_(nullptr), nextInstSc_(nullptr), incPtnSizeSc_(nullptr), decPtnSizeSc_(nullptr), incEditStepSc_(nullptr), decEditStepSc_(nullptr), prevSongSc_(nullptr), nextSongSc_(nullptr), jamVolUpSc_(nullptr), jamVolDownSc_(nullptr), bankJamMidiCtrl_(false) { ui->setupUi(this); if (config.lock()->getMainWindowX() == -1) { // When unset QRect rec = geometry(); rec.moveCenter(QGuiApplication::screens().at(0)->geometry().center()); setGeometry(rec); config.lock()->setMainWindowX(x()); config.lock()->setMainWindowY(y()); } else { move(config.lock()->getMainWindowX(), config.lock()->getMainWindowY()); } if (isFirstLaunch) { const QHash defNoteSysMap = { { "English", NoteNotationSystem::ENGLISH }, { "German", NoteNotationSystem::GERMAN } }; //: Set the name of suitable notation system (English or German) config.lock()->setNotationSystem(defNoteSysMap[tr("English", "Default notation system")]); } resize(config.lock()->getMainWindowWidth(), config.lock()->getMainWindowHeight()); if (config.lock()->getMainWindowMaximized()) showMaximized(); ui->action_Status_Bar->setChecked(config.lock()->getVisibleStatusBar()); ui->statusBar->setVisible(config.lock()->getVisibleStatusBar()); ui->actionFollow_Mode->setChecked(config.lock()->getFollowMode()); ui->action_Instrument_Mask->setChecked(config.lock()->getInstrumentMask()); ui->action_Volume_Mask->setChecked(config.lock()->getVolumeMask()); ui->action_Wave_View->setChecked(config.lock()->getVisibleWaveView()); ui->waveVisual->setVisible(config.lock()->getVisibleWaveView()); bt_->setFollowPlay(config.lock()->getFollowMode()); NoteNameManager::getManager().setNotationSystem(config.lock()->getNotationSystem()); ui->patternEditor->setConfiguration(config_.lock()); ui->orderList->setConfiguration(config_.lock()); updateFonts(); ui->orderList->setHorizontalScrollMode(config.lock()->getMoveCursorByHorizontalScroll(), false); ui->patternEditor->setHorizontalScrollMode(config.lock()->getMoveCursorByHorizontalScroll(), false); ui->patternEditor->setCore(bt_); ui->orderList->setCore(bt_); io::loadPalette(palette_.get()); ui->patternEditor->setColorPallete(palette_); ui->orderList->setColorPallete(palette_); updateInstrumentListColors(); ui->waveVisual->setColorPalette(palette_); /* Command stack */ QObject::connect(comStack_.get(), &QUndoStack::indexChanged, this, [&](int idx) { setWindowModified(idx || isModifiedForNotCommand_); ui->actionUndo->setEnabled(comStack_->canUndo()); ui->actionRedo->setEnabled(comStack_->canRedo()); }); /* File history */ io::loadFileHistory(fileHistory_); for (size_t i = 0; i < fileHistory_->size(); ++i) { // Leave Before Qt5.7.0 style due to windows xp QAction* action = ui->menu_Recent_Files->addAction(QString("&%1 %2").arg(i + 1).arg(fileHistory_->at(i))); action->setData(fileHistory_->at(i)); } QObject::connect(ui->menu_Recent_Files, &QMenu::triggered, this, [&](QAction* action) { if (action != ui->actionClear) { if (isWindowModified()) { switch (ModuleSaveCheckDialog(bt_->getModuleTitle(), this).exec()) { case QMessageBox::Yes: if (!on_actionSave_triggered()) return; break; case QMessageBox::No: break; case QMessageBox::Cancel: return; default: break; } } openModule(action->data().toString()); } }); /* Menus */ pasteModeGroup_ = std::make_unique(this); pasteModeGroup_->addAction(ui->action_Cursor); QObject::connect(ui->action_Cursor, &QAction::triggered, this, [&](bool checked) { if (checked) config_.lock()->setPasteMode(Configuration::PasteMode::Cursor); }); pasteModeGroup_->addAction(ui->action_Selection); QObject::connect(ui->action_Selection, &QAction::triggered, this, [&](bool checked) { if (checked) config_.lock()->setPasteMode(Configuration::PasteMode::Selection); }); pasteModeGroup_->addAction(ui->action_Fill); QObject::connect(ui->action_Fill, &QAction::triggered, this, [&](bool checked) { if (checked) config_.lock()->setPasteMode(Configuration::PasteMode::Fill); }); switch (config.lock()->getPasteMode()) { case Configuration::PasteMode::Cursor: ui->action_Cursor->setChecked(true); break; case Configuration::PasteMode::Selection: ui->action_Selection->setChecked(true); break; case Configuration::PasteMode::Fill: ui->action_Fill->setChecked(true); break; } /* Tool bars */ { auto genSB = [](int value, int min, int max, int minW) { auto sb = new WheelSpinBox(); sb->setMinimum(min); sb->setMaximum(max); sb->setValue(value); sb->setMinimumWidth(minW); sb->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); return sb; }; /* Octave */ auto octLab = new QLabel(tr("Octave")); octLab->setMargin(6); ui->subToolBar->addWidget(octLab); octave_ = genSB(bt_->getCurrentOctave(), 0, 7, 40); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(octave_, static_cast(&QSpinBox::valueChanged), this, [&](int octave) { bt_->setCurrentOctave(octave); statusOctave_->setText(tr("Octave: %1").arg(octave)); }); ui->subToolBar->addWidget(octave_); /* Volume */ auto volLab = new QLabel(tr("Volume")); volLab->setMargin(6); ui->subToolBar->addWidget(volLab); volume_ = [value = bt_->getCurrentVolume(), genSB] { auto sb = genSB(value, 0, 255, 40); sb->setDisplayIntegerBase(16); QFont font = sb->font(); font.setCapitalization(QFont::AllUppercase); sb->setFont(font); return sb; }(); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(volume_, static_cast(&QSpinBox::valueChanged), this, [&](int volume) { bt_->setCurrentVolume(volume); }); ui->subToolBar->addWidget(volume_); ui->subToolBar->addSeparator(); /* Follow mode */ ui->subToolBar->addAction(ui->actionFollow_Mode); ui->subToolBar->addSeparator(); /* Step highlight 1st */ auto hlLab1 = new QLabel(tr("Step highlight 1st")); hlLab1->setMargin(6); ui->subToolBar->addWidget(hlLab1); highlight1_ = genSB(8, 1, 256, 50); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(highlight1_, static_cast(&QSpinBox::valueChanged), this, [&](int count) { bt_->setModuleStepHighlight1Distance(static_cast(count)); ui->patternEditor->setPatternHighlight1Count(count); }); ui->subToolBar->addWidget(highlight1_); /* Step highlight 2nd */ auto hlLab2 = new QLabel(tr("2nd")); hlLab2->setMargin(6); ui->subToolBar->addWidget(hlLab2); highlight2_ = genSB(8, 1, 256, 50); highlight2_->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(highlight2_, static_cast(&QSpinBox::valueChanged), this, [&](int count) { bt_->setModuleStepHighlight2Distance(static_cast(count)); ui->patternEditor->setPatternHighlight2Count(count); }); ui->subToolBar->addWidget(highlight2_); ui->subToolBar->addSeparator(); auto& mainTbConfig = config.lock()->getMainToolbarConfiguration(); if (mainTbConfig.getPosition() == Configuration::ToolbarPosition::FloatPorition) { ui->mainToolBar->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint); ui->mainToolBar->move(mainTbConfig.getX(), mainTbConfig.getY()); } else { addToolBar(TB_POS_.at(mainTbConfig.getPosition()), ui->mainToolBar); } auto& subTbConfig = config.lock()->getSubToolbarConfiguration(); if (subTbConfig.getPosition() == Configuration::ToolbarPosition::FloatPorition) { ui->subToolBar->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint); ui->subToolBar->move(subTbConfig.getX(), subTbConfig.getY()); } else { auto pos = TB_POS_.at(subTbConfig.getPosition()); if (subTbConfig.getNumber()) { if (subTbConfig.hasBreakBefore()) addToolBarBreak(pos); addToolBar(pos, ui->subToolBar); } else { if (mainTbConfig.getPosition() == subTbConfig.getPosition()) { insertToolBar(ui->mainToolBar, ui->subToolBar); if (mainTbConfig.hasBreakBefore()) insertToolBarBreak(ui->mainToolBar); } else { addToolBar(pos, ui->subToolBar); } } } ui->action_Toolbar->setChecked(config.lock()->getVisibleToolbar()); ui->mainToolBar->setVisible(config.lock()->getVisibleToolbar()); ui->subToolBar->setVisible(config.lock()->getVisibleToolbar()); } /* Splitter */ ui->splitter->setStretchFactor(0, 0); ui->splitter->setStretchFactor(1, 1); /* Module settings */ QObject::connect(ui->modTitleLineEdit, &QLineEdit::textEdited, this, [&](const QString& str) { bt_->setModuleTitle(str.toUtf8().toStdString()); setModifiedTrue(); setWindowTitle(); }); QObject::connect(ui->authorLineEdit, &QLineEdit::textEdited, this, [&](const QString& str) { bt_->setModuleAuthor(str.toUtf8().toStdString()); setModifiedTrue(); }); QObject::connect(ui->copyrightLineEdit, &QLineEdit::textEdited, this, [&](const QString& str) { bt_->setModuleCopyright(str.toUtf8().toStdString()); setModifiedTrue(); }); /* Edit settings */ // Leave Before Qt5.7.0 style due to windows xp QObject::connect(ui->editableStepSpinBox, static_cast(&QSpinBox::valueChanged), this, [&](int n) { ui->patternEditor->setEditableStep(n); config_.lock()->setEditableStep(static_cast(n)); }); ui->editableStepSpinBox->setValue(static_cast(config.lock()->getEditableStep())); ui->patternEditor->setEditableStep(static_cast(config.lock()->getEditableStep())); ui->keyRepeatCheckBox->setCheckState(config.lock()->getKeyRepetition() ? Qt::Checked : Qt::Unchecked); /* Song */ // Leave Before Qt5.7.0 style due to windows xp QObject::connect(ui->songComboBox, static_cast(&QComboBox::currentIndexChanged), this, [&](int num) { if (num == -1) return; freezeViews(); if (!tickTimerForRealChip_) { try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } bt_->setCurrentSongNumber(num); loadSong(); if (!tickTimerForRealChip_) { try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } }); /* Song settings */ // Leave Before Qt5.7.0 style due to windows xp QObject::connect(ui->tempoSpinBox, static_cast(&QSpinBox::valueChanged), this, [&](int tempo) { int curSong = bt_->getCurrentSongNumber(); if (tempo != bt_->getSongTempo(curSong)) { bt_->setSongTempo(curSong, tempo); setModifiedTrue(); } }); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(ui->speedSpinBox, static_cast(&QSpinBox::valueChanged), this, [&](int speed) { int curSong = bt_->getCurrentSongNumber(); if (speed != bt_->getSongSpeed(curSong)) { bt_->setSongSpeed(curSong, speed); setModifiedTrue(); } }); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(ui->patternSizeSpinBox, static_cast(&QSpinBox::valueChanged), this, [&](int size) { bt_->setDefaultPatternSize(bt_->getCurrentSongNumber(), static_cast(size)); ui->patternEditor->onDefaultPatternSizeChanged(); setModifiedTrue(); }); // Leave Before Qt5.7.0 style due to windows xp QObject::connect(ui->grooveSpinBox, static_cast(&QSpinBox::valueChanged), this, [&](int n) { bt_->setSongGroove(bt_->getCurrentSongNumber(), n); setModifiedTrue(); }); /* Instrument list */ auto instToolBar = [&] { auto subMenu = [](const QList& actions) { auto menu = new QMenu(); menu->addActions(actions); auto btn = new QToolButton(); btn->setPopupMode(QToolButton::MenuButtonPopup); btn->setMenu(menu); btn->setDefaultAction(actions.front()); return btn; }; auto tb = new QToolBar(); tb->setIconSize(QSize(16, 16)); tb->addWidget(subMenu({ ui->actionNew_Instrument, ui->actionNew_Drumki_t })); tb->addActions({ ui->actionRemove_Instrument, ui->actionClone_Instrument }); tb->addSeparator(); tb->addWidget(subMenu({ ui->actionLoad_From_File, ui->actionImport_From_Bank_File })); tb->addWidget(subMenu({ ui->actionSave_To_File, ui->actionExport_To_Bank_File })); tb->addSeparator(); tb->addAction(ui->actionEdit); tb->addSeparator(); tb->addAction(ui->actionRename_Instrument); return tb; }(); ui->instrumentListGroupBox->layout()->addWidget(instToolBar); ui->instrumentList->installEventFilter(this); QObject::connect(ui->instrumentList, &DropDetectListWidget::itemDroppedAtItemIndex, this, &MainWindow::swapInstruments); /* Pattern editor */ ui->patternEditor->setCommandStack(comStack_); ui->patternEditor->installEventFilter(this); QObject::connect(ui->patternEditor, &PatternEditor::currentTrackChanged, ui->orderList, &OrderListEditor::onPatternEditorCurrentTrackChanged); QObject::connect(ui->patternEditor, &PatternEditor::currentOrderChanged, ui->orderList, &OrderListEditor::onPatternEditorCurrentOrderChanged); QObject::connect(ui->patternEditor, &PatternEditor::focusIn, this, &MainWindow::updateMenuByPattern); QObject::connect(ui->patternEditor, &PatternEditor::selected, this, &MainWindow::updateMenuByPatternSelection); QObject::connect(ui->patternEditor, &PatternEditor::instrumentEntered, this, [&](int num) { auto list = ui->instrumentList; if (num != -1) { for (int i = 0; i < list->count(); ++i) { if (list->item(i)->data(Qt::UserRole).toInt() == num) { list->setCurrentRow(i); return ; } } } }); QObject::connect(ui->patternEditor, &PatternEditor::volumeEntered, this, [&](int volume) { volume_->setValue(volume); }); QObject::connect(ui->patternEditor, &PatternEditor::effectEntered, this, [&](QString text) { ui->statusBar->showMessage(text, STATUS_DISPLAY_TIMEOUT); }); QObject::connect(ui->patternEditor, &PatternEditor::currentTrackChanged, this, &MainWindow::onCurrentTrackChanged); /* Order List */ ui->orderList->setCommandStack(comStack_); ui->orderList->installEventFilter(this); QObject::connect(ui->orderList, &OrderListEditor::currentTrackChanged, ui->patternEditor, &PatternEditor::onOrderListCurrentTrackChanged); QObject::connect(ui->orderList, &OrderListEditor::currentOrderChanged, ui->patternEditor, &PatternEditor::onOrderListCrrentOrderChanged); QObject::connect(ui->orderList, &OrderListEditor::orderEdited, ui->patternEditor, &PatternEditor::onOrderListEdited); QObject::connect(ui->orderList, &OrderListEditor::focusIn, this, &MainWindow::updateMenuByOrder); QObject::connect(ui->orderList, &OrderListEditor::selected, this, &MainWindow::updateMenuByOrderSelection); QObject::connect(ui->orderList, &OrderListEditor::currentTrackChanged, this, &MainWindow::onCurrentTrackChanged); /* Wave view */ visualTimer_.reset(new QTimer); QObject::connect(visualTimer_.get(), &QTimer::timeout, this, &MainWindow::updateVisuals); if (config.lock()->getVisibleWaveView()) visualTimer_->start(static_cast(std::round(1000. / config.lock()->getWaveViewFrameRate()))); /* Status bar */ statusStyle_ = new QLabel(ui->statusBar); statusStyle_->setAlignment(Qt::AlignTrailing | Qt::AlignVCenter); statusInst_ = new QLabel(ui->statusBar); statusInst_->setFixedWidth(110); statusInst_->setAlignment(Qt::AlignLeading | Qt::AlignVCenter); statusOctave_ = new QLabel(ui->statusBar); statusOctave_->setFixedWidth(90); statusOctave_->setAlignment(Qt::AlignLeading | Qt::AlignVCenter); statusIntr_ = new QLabel(ui->statusBar); statusIntr_->setFixedWidth(50); statusIntr_->setAlignment(Qt::AlignLeading | Qt::AlignVCenter); statusMixer_ = new QLabel(ui->statusBar); statusMixer_->setFixedWidth(200); statusMixer_->setAlignment(Qt::AlignLeading | Qt::AlignVCenter); statusBpm_ = new QLabel(ui->statusBar); statusBpm_->setFixedWidth(90); statusBpm_->setAlignment(Qt::AlignLeading | Qt::AlignVCenter); statusPlayPos_ = new QLabel(ui->statusBar); statusPlayPos_->setFixedWidth(40); statusPlayPos_->setAlignment(Qt::AlignLeading | Qt::AlignVCenter); ui->statusBar->addPermanentWidget(statusStyle_); ui->statusBar->addPermanentWidget(statusInst_); ui->statusBar->addPermanentWidget(statusOctave_); ui->statusBar->addPermanentWidget(statusIntr_); ui->statusBar->addPermanentWidget(statusMixer_); ui->statusBar->addPermanentWidget(statusBpm_); ui->statusBar->addPermanentWidget(statusPlayPos_); statusOctave_->setText(tr("Octave: %1").arg(bt_->getCurrentOctave())); statusIntr_->setText(QString::number(bt_->getModuleTickFrequency()) + QString("Hz")); ui->statusBar->showMessage(tr("Welcome to BambooTracker v%1!").arg(QString::fromStdString(Version::ofApplicationInString())), STATUS_DISPLAY_TIMEOUT); /* Bookmark */ bmManForm_ = std::make_unique(bt_, config_.lock()->getShowRowNumberInHex()); auto posJumpFunc = [&](int order, int step) { if (bt_->isPlaySong()) return; int song = bt_->getCurrentSongNumber(); if (static_cast(bt_->getOrderSize(song)) <= order) return; if (static_cast(bt_->getPatternSizeFromOrderNumber(song, order)) <= step) return; bt_->setCurrentOrderNumber(order); bt_->setCurrentStepNumber(step); ui->orderList->updatePositionByPositionJump(); ui->patternEditor->updatepositionByPositionJump(); activateWindow(); }; QObject::connect(bmManForm_.get(), &BookmarkManagerForm::positionJumpRequested, this, posJumpFunc); QObject::connect(bmManForm_.get(), &BookmarkManagerForm::modified, this, &MainWindow::setModifiedTrue); /* Key signature */ ksManForm_ = std::make_unique(bt_, config_.lock()->getShowRowNumberInHex()); QObject::connect(ksManForm_.get(), &KeySignatureManagerForm::positionJumpRequested, this, posJumpFunc); QObject::connect(ksManForm_.get(), &KeySignatureManagerForm::modified, this, [&] { ui->patternEditor->onPatternDataGlobalChanged(); setModifiedTrue(); }); /* Shortcuts */ { auto linkShortcut = [&](QAction* ptr) { ptr->setShortcutContext(Qt::WidgetWithChildrenShortcut); ui->orderList->addAction(ptr); ui->patternEditor->addAction(ptr); }; linkShortcut(&octUpSc_); QObject::connect(&octUpSc_, &QAction::triggered, this, [&] { changeOctave(true); }); linkShortcut(&octDownSc_); QObject::connect(&octDownSc_, &QAction::triggered, this, [&] { changeOctave(false); }); QObject::connect(&focusPtnSc_, &QShortcut::activated, this, [&] { ui->patternEditor->setFocus(); }); QObject::connect(&focusOdrSc_, &QShortcut::activated, this, [&] { ui->orderList->setFocus(); }); QObject::connect(&focusInstSc_, &QShortcut::activated, this, [&] { ui->instrumentList->setFocus(); updateMenuByInstrumentList(); }); auto playLinkShortcut = [&](QAction* ptr) { ptr->setShortcutContext(Qt::WidgetShortcut); ui->instrumentList->addAction(ptr); ui->orderList->addActionToPanel(ptr); ui->patternEditor->addActionToPanel(ptr); }; playLinkShortcut(ui->actionPlay); playLinkShortcut(&playAndStopSc_); QObject::connect(&playAndStopSc_, &QAction::triggered, this, [&] { if (bt_->isPlaySong()) stopPlaySong(); else startPlaySong(); }); playLinkShortcut(&playStepSc_); QObject::connect(&playStepSc_, &QAction::triggered, this, &MainWindow::playStep); playLinkShortcut(ui->actionPlay_From_Start); playLinkShortcut(ui->actionPlay_Pattern); playLinkShortcut(ui->actionPlay_From_Cursor); playLinkShortcut(ui->actionPlay_From_Marker); playLinkShortcut(ui->actionStop); instAddSc_ = std::make_unique(Qt::Key_Insert, ui->instrumentList, nullptr, nullptr, Qt::WidgetShortcut); QObject::connect(instAddSc_.get(), &QShortcut::activated, this, &MainWindow::addInstrument); linkShortcut(&goPrevOdrSc_); QObject::connect(&goPrevOdrSc_, &QAction::triggered, this, [&] { ui->orderList->onGoOrderRequested(false); }); linkShortcut(&goNextOdrSc_); QObject::connect(&goNextOdrSc_, &QAction::triggered, this, [&] { ui->orderList->onGoOrderRequested(true); }); linkShortcut(&prevInstSc_); QObject::connect(&prevInstSc_, &QAction::triggered, this, [&] { if (ui->instrumentList->count()) { int row = ui->instrumentList->currentRow(); if (row == -1) ui->instrumentList->setCurrentRow(0); else if (row > 0) ui->instrumentList->setCurrentRow(row - 1); } }); linkShortcut(&nextInstSc_); QObject::connect(&nextInstSc_, &QAction::triggered, this, [&] { int cnt = ui->instrumentList->count(); if (cnt) { int row = ui->instrumentList->currentRow(); if (row == -1) ui->instrumentList->setCurrentRow(cnt - 1); else if (row < cnt - 1) ui->instrumentList->setCurrentRow(row + 1); } }); linkShortcut(&incPtnSizeSc_); QObject::connect(&incPtnSizeSc_, &QAction::triggered, this, [&] { ui->patternSizeSpinBox->setValue(ui->patternSizeSpinBox->value() + 1); }); linkShortcut(&decPtnSizeSc_); QObject::connect(&decPtnSizeSc_, &QAction::triggered, this, [&] { ui->patternSizeSpinBox->setValue(ui->patternSizeSpinBox->value() - 1); }); linkShortcut(&incEditStepSc_); QObject::connect(&incEditStepSc_, &QAction::triggered, this, [&] { ui->editableStepSpinBox->setValue(ui->editableStepSpinBox->value() + 1); }); linkShortcut(&decEditStepSc_); QObject::connect(&decEditStepSc_, &QAction::triggered, this, [&] { ui->editableStepSpinBox->setValue(ui->editableStepSpinBox->value() - 1); }); linkShortcut(&prevSongSc_); QObject::connect(&prevSongSc_, &QAction::triggered, this, [&] { if (ui->songComboBox->isEnabled()) { ui->songComboBox->setCurrentIndex(std::max(ui->songComboBox->currentIndex() - 1, 0)); } }); linkShortcut(&nextSongSc_); QObject::connect(&nextSongSc_, &QAction::triggered, this, [&] { if (ui->songComboBox->isEnabled()) { ui->songComboBox->setCurrentIndex(std::min(ui->songComboBox->currentIndex() + 1, ui->songComboBox->count() - 1)); } }); linkShortcut(&jamVolUpSc_); QObject::connect(&jamVolUpSc_, &QAction::triggered, this, [&] { volume_->setValue(volume_->value() + 1); }); linkShortcut(&jamVolDownSc_); QObject::connect(&jamVolDownSc_, &QAction::triggered, this, [&] { volume_->setValue(volume_->value() - 1); }); setShortcuts(); } /* Clipboard */ QObject::connect(QApplication::clipboard(), &QClipboard::dataChanged, this, [&]() { if (isEditedOrder_) updateMenuByOrder(); else if (isEditedPattern_) updateMenuByPattern(); }); /* Welcome dialog */ { const QString text = "

" + tr("Welcome to BambooTracker!") + "

" + "
" "" "
" "

" + tr("Don't know where to start?") + "

" + "

" + tr("Check the demo modules and instruments included " "with your download of BambooTracker.") + "

" + "

" + tr("Need a list of effects and shortcuts?") + "

" + "

" + tr("Check the Help menu at the top of the window.") + "

" + "

" + tr("Still lost?") + "

" + "

" + tr("The README.md has a link to our Discord server.") + "

" + "

" + tr("Think you've found a bug? Missing a feature?") + "

" + "

" + tr("BambooTracker is still in development, bugs and missing " "features are to be expected. So we need your help!") + "

    " + //: %1 is the link to the issue submission page in GitHub. "
  • " + tr("Please report any bugs you find and requests and features " "you'd like to see on our Discord server or our bug tracker (%1).") .arg("" "https://github.com/BambooTracker/BambooTracker/issues/new/choose") + "
  • " + "
  • " + tr("If you're a developer yourself or would like to start being one, " "consider contributing to the project yourself. " "Any help would be appreciated!") + "
  • " + "

"; welcomeDialog_ = std::make_unique(QMessageBox::NoIcon, tr("Welcome"), text, QMessageBox::Ok, this); welcomeDialog_->setWindowModality(Qt::ApplicationModal); welcomeDialog_->setWindowFlags(welcomeDialog_->windowFlags() & ~Qt::WindowContextHelpButtonHint); welcomeDialog_->setTextFormat(Qt::RichText); if (isFirstLaunch) on_action_Welcome_triggered(); } /* MIDI */ setMidiConfiguration(); midiKeyEventMethod_ = metaObject()->indexOfSlot("midiKeyEvent(uchar,uchar,uchar)"); Q_ASSERT(midiKeyEventMethod_ != -1); midiProgramEventMethod_ = metaObject()->indexOfSlot("midiProgramEvent(uchar,uchar)"); Q_ASSERT(midiProgramEventMethod_ != -1); MidiInterface::getInstance().installInputHandler(&midiThreadReceivedEvent, this); /* Audio stream */ stream_ = std::make_shared(); stream_->setTickUpdateCallback(+[](void* cbPtr) -> int { auto bt = reinterpret_cast(cbPtr); return bt->streamCountUp(); }, bt_.get()); stream_->setGenerateCallback(+[](int16_t* container, size_t nSamples, void* cbPtr) { auto bt = reinterpret_cast(cbPtr); return bt->getStreamSamples(container, nSamples); }, bt_.get()); QObject::connect(stream_.get(), &AudioStream::streamInterrupted, this, &MainWindow::onNewTickSignaled); QObject::connect(stream_.get(), &AudioStream::streamErrorInCallback, this, [&](const QVariant&) { QMessageBox::critical(this, tr("Error"), tr("An error occurred in the audio playback.\n" "Please change the settings in the configuration.")); }); QString audioApi = gui_utils::utf8ToQString(config.lock()->getSoundAPI()); if (isFirstLaunch) { try { bool streamState = false; QString streamErr; for (const QString& audioApi : stream_->getAvailableBackends()) { config.lock()->setSoundAPI(audioApi.toUtf8().toStdString()); QString audioDevice = stream_->getDefaultOutputDevice(audioApi); config.lock()->setSoundDevice(audioDevice.toUtf8().toStdString()); streamState = stream_->initialize( static_cast(bt_->getStreamRate()), static_cast(bt_->getStreamDuration()), bt_->getModuleTickFrequency(), audioApi, audioDevice, &streamErr); if (streamState) break; } if (streamState) { uint32_t sr = stream_->getStreamRate(); if (config.lock()->getSampleRate() != sr) { showStreamRateWarningDialog(sr); bt_->setStreamRate(sr); } } else { showStreamFailedDialog(streamErr); } } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } else { // Ordinary launch bool savedApiExists = false; const std::vector audioApis = stream_->getAvailableBackends(); for (const QString& api : audioApis) { if (api.toUtf8().toStdString() == config.lock()->getSoundAPI()) { savedApiExists = true; break; } } if (!savedApiExists) { audioApi = audioApis.front(); config.lock()->setSoundAPI(audioApi.toUtf8().toStdString()); } QString audioDevice = gui_utils::utf8ToQString(config.lock()->getSoundDevice()); bool savedDeviceExists = false; for (const QString& device : stream_->getAvailableDevices(audioApi)) { if (device.toUtf8().toStdString() == config.lock()->getSoundDevice()) { savedDeviceExists = true; break; } } if (!savedDeviceExists) { audioDevice = stream_->getDefaultOutputDevice(audioApi); config.lock()->setSoundDevice(audioDevice.toUtf8().toStdString()); } try { QString streamErr; bool streamState = stream_->initialize( static_cast(bt_->getStreamRate()), static_cast(bt_->getStreamDuration()), bt_->getModuleTickFrequency(), audioApi, audioDevice, &streamErr); if (streamState) { uint32_t sr = stream_->getStreamRate(); if (config.lock()->getSampleRate() != sr) { showStreamRateWarningDialog(sr); bt_->setStreamRate(sr); } } else { showStreamFailedDialog(streamErr); } } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } RealChipInterfaceType intf = config.lock()->getRealChipInterface(); if (intf != RealChipInterfaceType::NONE) { tickTimerForRealChip_ = std::make_unique(); tickTimerForRealChip_->setInterval(1000000 / bt_->getModuleTickFrequency()); tickEventMethod_ = metaObject()->indexOfSlot("onNewTickSignaledRealChip()"); Q_ASSERT(tickEventMethod_ != -1); tickTimerForRealChip_->setFunction([&]{ QMetaMethod method = this->metaObject()->method(this->tickEventMethod_); method.invoke(this, Qt::QueuedConnection); }); setRealChipInterface(intf); tickTimerForRealChip_->start(); } /* Load module */ if (filePath.isEmpty()) { loadModule(); setInitialSelectedInstrument(); assignADPCMSamples(); if (!tickTimerForRealChip_) { try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } } else { openModule(QFileInfo(filePath).absoluteFilePath()); // If use emulation, stream starts } } MainWindow::~MainWindow() { MidiInterface::getInstance().uninstallInputHandler(&midiThreadReceivedEvent, this); stream_->shutdown(); } void MainWindow::onApplicationStateChanged(Qt::ApplicationState state) { switch (state) { case Qt::ApplicationHidden: case Qt::ApplicationInactive: if (bt_) bt_->jamkeyOffAll(); break; default: break; } } bool MainWindow::eventFilter(QObject* watched, QEvent* event) { if (auto fmForm = qobject_cast(watched)) { // Change current instrument by activating FM editor if (event->type() == QEvent::WindowActivate) { int row = findRowFromInstrumentList(fmForm->getInstrumentNumber()); ui->instrumentList->setCurrentRow(row); } else if (event->type() == QEvent::Resize) { config_.lock()->setInstrumentFMWindowWidth(fmForm->width()); config_.lock()->setInstrumentFMWindowHeight(fmForm->height()); } return false; } if (auto ssgForm = qobject_cast(watched)) { // Change current instrument by activating SSG editor if (event->type() == QEvent::WindowActivate) { int row = findRowFromInstrumentList(ssgForm->getInstrumentNumber()); ui->instrumentList->setCurrentRow(row); } else if (event->type() == QEvent::Resize) { config_.lock()->setInstrumentSSGWindowWidth(ssgForm->width()); config_.lock()->setInstrumentSSGWindowHeight(ssgForm->height()); } return false; } if (auto adpcmForm = qobject_cast(watched)) { // Change current instrument by activating ADPCM editor if (event->type() == QEvent::WindowActivate) { int row = findRowFromInstrumentList(adpcmForm->getInstrumentNumber()); ui->instrumentList->setCurrentRow(row); } else if (event->type() == QEvent::Resize) { config_.lock()->setInstrumentADPCMWindowWidth(adpcmForm->width()); config_.lock()->setInstrumentADPCMWindowHeight(adpcmForm->height()); } return false; } if (auto kitForm = qobject_cast(watched)) { // Change current instrument by activating drumkit editor if (event->type() == QEvent::WindowActivate) { int row = findRowFromInstrumentList(kitForm->getInstrumentNumber()); ui->instrumentList->setCurrentRow(row); } else if (event->type() == QEvent::Resize) { config_.lock()->setInstrumentDrumkitWindowWidth(kitForm->width()); config_.lock()->setInstrumentDrumkitWindowHeight(kitForm->height()); } return false; } if (watched == ui->instrumentList) { if (event->type() == QEvent::FocusIn) updateMenuByInstrumentList(); return false; } if (watched == renamingInstEdit_) { if (event->type() == QEvent::FocusOut) finishRenamingInstrument(); return false; } return false; } void MainWindow::showEvent(QShowEvent*) { if (!hasShownOnce_) { int y = config_.lock()->getMainWindowVerticalSplit(); if (y == -1) { config_.lock()->setMainWindowVerticalSplit(ui->splitter->sizes().at(0)); } else { ui->splitter->setSizes({ y, ui->splitter->height() - ui->splitter->handleWidth() - y }); } hasShownOnce_ = true; } } void MainWindow::keyPressEvent(QKeyEvent *event) { if (!event->isAutoRepeat()) { // Musical keyboard Qt::Key qtKey = static_cast(event->key()); try { bt_->jamKeyOn(getJamKeyFromLayoutMapping(qtKey, config_), !config_.lock()->getFixJammingVolume()); } catch (std::invalid_argument&) {} } } void MainWindow::keyReleaseEvent(QKeyEvent *event) { int key = event->key(); if (!event->isAutoRepeat()) { // Musical keyboard Qt::Key qtKey = static_cast(key); try { bt_->jamKeyOff(getJamKeyFromLayoutMapping(qtKey, config_)); } catch (std::invalid_argument&) {} } } void MainWindow::dragEnterEvent(QDragEnterEvent* event) { auto mime = event->mimeData(); if (mime->hasUrls()) { const auto urls = mime->urls(); for (auto& url : urls) { const std::string ext = QFileInfo(url.toLocalFile()).suffix().toLower().toStdString(); if (io::ModuleIO::getInstance().testLoadableFormat(ext) || io::BankIO::getInstance().testLoadableFormat(ext)) { if (urls.size() == 1) event->acceptProposedAction(); } if (io::InstrumentIO::getInstance().testLoadableFormat(ext)) { continue; } return; } if (!urls.empty()) event->acceptProposedAction(); // For instruments } } void MainWindow::dropEvent(QDropEvent* event) { const auto urls = event->mimeData()->urls(); for (const auto& url : urls) { const QString file = url.toLocalFile(); const std::string ext = QFileInfo(file).suffix().toLower().toStdString(); if (io::ModuleIO::getInstance().testLoadableFormat(ext)) { if (isWindowModified()) { switch (ModuleSaveCheckDialog(bt_->getModuleTitle(), this).exec()) { case QMessageBox::Yes: if (!on_actionSave_triggered()) return; break; case QMessageBox::No: break; case QMessageBox::Cancel: return; default: break; } } bt_->stopPlaySong(); lockWidgets(false); openModule(file); return; } else if (io::InstrumentIO::getInstance().testLoadableFormat(ext)) { funcLoadInstrument(file); } if (io::BankIO::getInstance().testLoadableFormat(ext)) { funcImportInstrumentsFromBank(file); return; } } } void MainWindow::resizeEvent(QResizeEvent* event) { QWidget::resizeEvent(event); if (!isMaximized()) { // Check previous size config_.lock()->setMainWindowWidth(event->oldSize().width()); config_.lock()->setMainWindowHeight(event->oldSize().height()); } } void MainWindow::moveEvent(QMoveEvent* event) { QWidget::moveEvent(event); if (!isMaximized()) { // Check previous position config_.lock()->setMainWindowX(event->oldPos().x()); config_.lock()->setMainWindowY(event->oldPos().y()); } } void MainWindow::closeEvent(QCloseEvent *event) { if (isWindowModified()) { switch (ModuleSaveCheckDialog(bt_->getModuleTitle(), this).exec()) { case QMessageBox::Yes: if (!on_actionSave_triggered()) { event->ignore(); return; } break; case QMessageBox::No: break; case QMessageBox::Cancel: event->ignore(); return; default: break; } } if (isMaximized()) { config_.lock()->setMainWindowMaximized(true); } else { config_.lock()->setMainWindowMaximized(false); config_.lock()->setMainWindowWidth(width()); config_.lock()->setMainWindowHeight(height()); config_.lock()->setMainWindowX(x()); config_.lock()->setMainWindowY(y()); } config_.lock()->setMainWindowVerticalSplit(ui->splitter->sizes().at(0)); auto& mainTbConfig = config_.lock()->getMainToolbarConfiguration(); auto& subTbConfig = config_.lock()->getSubToolbarConfiguration(); auto mainTbArea = toolBarArea(ui->mainToolBar); auto subTbArea = toolBarArea(ui->subToolBar); if (ui->mainToolBar->isFloating()) { mainTbConfig.setPosition(Configuration::ToolbarPosition::FloatPorition); mainTbConfig.setX(ui->mainToolBar->x()); mainTbConfig.setY(ui->mainToolBar->y()); } else { mainTbConfig.setPosition(utils::findMapValue(TB_POS_, mainTbArea)->first); mainTbConfig.setNumber(0); mainTbConfig.setBreakBefore(false); } if (ui->subToolBar->isFloating()) { subTbConfig.setPosition(Configuration::ToolbarPosition::FloatPorition); subTbConfig.setX(ui->subToolBar->x()); subTbConfig.setY(ui->subToolBar->y()); } else { subTbConfig.setPosition(utils::findMapValue(TB_POS_, mainTbArea)->first); subTbConfig.setNumber(0); subTbConfig.setBreakBefore(false); } if (mainTbArea == subTbArea) { auto mainPos = ui->mainToolBar->pos(); auto subPos = ui->subToolBar->pos(); switch (mainTbArea) { case Qt::TopToolBarArea: { if (mainPos.x() == subPos.x()) { bool cond = (mainPos.y() < subPos.y()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(!cond); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(cond); } else { bool cond = (mainPos.x() < subPos.x()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(false); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(false); } break; } case Qt::BottomToolBarArea: { if (mainPos.x() == subPos.x()) { bool cond = (subPos.y() < mainPos.y()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(!cond); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(cond); } else { bool cond = (mainPos.x() < subPos.x()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(false); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(false); } break; } case Qt::LeftToolBarArea: { if (mainPos.x() == subPos.x()) { bool cond = (mainPos.y() < subPos.y()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(false); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(false); } else { bool cond = (mainPos.x() < subPos.x()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(!cond); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(cond); } break; } case Qt::RightToolBarArea: { if (mainPos.x() == subPos.x()) { bool cond = (mainPos.y() < subPos.y()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(false); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(false); } else { bool cond = (subPos.x() < mainPos.x()); mainTbConfig.setNumber(cond ? 0 : 1); mainTbConfig.setBreakBefore(!cond); subTbConfig.setNumber(cond ? 1 : 0); subTbConfig.setBreakBefore(cond); } break; } default: break; } } config_.lock()->setVisibleToolbar(ui->mainToolBar->isVisible()); config_.lock()->setVisibleStatusBar(ui->statusBar->isVisible()); config_.lock()->setFollowMode(bt_->isFollowPlay()); instDialogMan_->removeAll(); io::saveFileHistory(fileHistory_); bmManForm_->close(); ksManForm_->close(); event->accept(); } void MainWindow::freezeViews() { ui->orderList->freeze(); ui->patternEditor->freeze(); } void MainWindow::unfreezeViews() { ui->orderList->unfreeze(); ui->patternEditor->unfreeze(); } void MainWindow::setShortcuts() { auto shortcuts = config_.lock()->getShortcuts(); octUpSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::OctaveUp))); octDownSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::OctaveDown))); focusPtnSc_.setKey(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::FocusOnPattern))); focusOdrSc_.setKey(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::FocusOnOrder))); focusInstSc_.setKey(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::FocusOnInstrument))); playAndStopSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PlayAndStop))); ui->actionPlay->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::Play))); ui->actionPlay_From_Start->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PlayFromStart))); ui->actionPlay_Pattern->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PlayPattern))); ui->actionPlay_From_Cursor->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PlayFromCursor))); ui->actionPlay_From_Marker->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PlayFromMarker))); playStepSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PlayStep))); ui->actionStop->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::Stop))); ui->actionEdit_Mode->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ToggleEditJam))); ui->actionSet_Ro_w_Marker->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SetMarker))); ui->actionMix->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PasteMix))); ui->actionOverwrite->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PasteOverwrite))); ui->action_Insert->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PasteInsert))); ui->actionAll->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SelectAll))); ui->actionNone->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::Deselect))); ui->actionRow->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SelectRow))); ui->actionColumn->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SelectColumn))); ui->actionPattern->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SelectColumn))); ui->actionOrder->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SelectOrder))); ui->action_Go_To->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::GoToStep))); ui->actionToggle_Track->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ToggleTrack))); ui->actionSolo_Track->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::SoloTrack))); ui->actionInterpolate->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::Interpolate))); goPrevOdrSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::GoToPrevOrder))); goNextOdrSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::GoToNextOrder))); ui->action_Toggle_Bookmark->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ToggleBookmark))); ui->action_Previous_Bookmark->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PrevBookmark))); ui->action_Next_Bookmark->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::NextBookmark))); ui->actionDecrease_Note->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::DecreaseNote))); ui->actionIncrease_Note->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::IncreaseNote))); ui->actionDecrease_Octave->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::DecreaseOctave))); ui->actionIncrease_Octave->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::IncreaseOctave))); prevInstSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PrevInstrument))); nextInstSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::NextInstrument))); ui->action_Instrument_Mask->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::MaskInstrument))); ui->action_Volume_Mask->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::MaskVolume))); ui->actionEdit->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::EditInstrument))); ui->actionFollow_Mode->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::FollowMode))); ui->actionDuplicate_Order->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::DuplicateOrder))); ui->actionClone_Patterns->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ClonePatterns))); ui->actionClone_Order->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::CloneOrder))); ui->actionReplace_Instrument->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ReplaceInstrument))); ui->actionExpand->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ExpandPattern))); ui->actionShrink->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::ShrinkPattern))); ui->actionFine_Decrease_Values->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::FineDecreaseValues))); ui->actionFine_Increase_Values->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::FineIncreaseValues))); ui->actionCoarse_D_ecrease_Values->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::CoarseDecreaseValues))); ui->actionCoarse_I_ncrease_Values->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::CoarseIncreaseValuse))); incPtnSizeSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::IncreasePatternSize))); decPtnSizeSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::DecreasePatternSize))); incEditStepSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::IncreaseEditStep))); decEditStepSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::DecreaseEditStep))); ui->action_Effect_List->setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::DisplayEffectList))); prevSongSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::PreviousSong))); nextSongSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::NextSong))); jamVolUpSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::JamVolumeUp))); jamVolDownSc_.setShortcut(gui_utils::strToKeySeq(shortcuts.at(Configuration::ShortcutAction::JamVolumeDown))); ui->orderList->onShortcutUpdated(); ui->patternEditor->onShortcutUpdated(); } void MainWindow::updateInstrumentListColors() { ui->instrumentList->setStyleSheet( QString("QListWidget { color: %1; background: %2; }") .arg(palette_->ilistTextColor.name(QColor::HexArgb), palette_->ilistBackColor.name(QColor::HexArgb)) + QString("QListWidget::item:hover { color: %1; background: %2; }") .arg(palette_->ilistTextColor.name(QColor::HexArgb), palette_->ilistHovBackColor.name(QColor::HexArgb)) + QString("QListWidget::item:selected { color: %1; background: %2; }") .arg(palette_->ilistTextColor.name(QColor::HexArgb), palette_->ilistSelBackColor.name(QColor::HexArgb)) + QString("QListWidget::item:selected:hover { color: %1; background: %2; }") .arg(palette_->ilistTextColor.name(QColor::HexArgb), palette_->ilistHovSelBackColor.name(QColor::HexArgb))); } void MainWindow::setOrderListGroupMaximumWidth() { ui->orderListGroupBox->setMaximumWidth( ui->orderListGroupBox->contentsMargins().left() + ui->orderListGroupBox->layout()->contentsMargins().left() + ui->orderList->maximumWidth() + ui->orderListGroupBox->layout()->contentsMargins().right() + ui->orderListGroupBox->contentsMargins().right()); } /********** MIDI **********/ void MainWindow::midiThreadReceivedEvent(double delay, const uint8_t *msg, size_t len, void *userData) { MainWindow *self = reinterpret_cast(userData); Q_UNUSED(delay) // Note-On/Note-Off if (len == 3 && (msg[0] & 0xe0) == 0x80) { uint8_t status = msg[0]; uint8_t key = msg[1]; uint8_t velocity = msg[2]; QMetaMethod method = self->metaObject()->method(self->midiKeyEventMethod_); method.invoke(self, Qt::QueuedConnection, Q_ARG(uchar, status), Q_ARG(uchar, key), Q_ARG(uchar, velocity)); } // Program change else if (len == 2 && (msg[0] & 0xf0) == 0xc0) { uint8_t status = msg[0]; uint8_t program = msg[1]; QMetaMethod method = self->metaObject()->method(self->midiProgramEventMethod_); method.invoke(self, Qt::QueuedConnection, Q_ARG(uchar, status), Q_ARG(uchar, program)); } } void MainWindow::midiKeyEvent(uchar status, uchar key, uchar velocity) { bool release = ((status & 0xf0) == 0x80) || velocity == 0; int k = static_cast(key) - 12; octave_->setValue(k / 12); if (importBankDialog_) { if (bankJamMidiCtrl_.load()) return; importBankDialog_->onJamKeyOffByMidi(k); if (!release) importBankDialog_->onJamKeyOnByMidi(k); return; } int n = instDialogMan_->getActivatedEditorIndex(); if (n == -1) { bt_->jamKeyOff(k); // possibility to recover on stuck note if (!release) bt_->jamKeyOn(k, !config_.lock()->getFixJammingVolume()); } else { SoundSource src = bt_->getInstrument(n)->getSoundSource(); bt_->jamKeyOffForced(k, src); // possibility to recover on stuck note if (!release) bt_->jamKeyOnForced(k, src, !config_.lock()->getFixJammingVolume()); } } void MainWindow::midiProgramEvent(uchar status, uchar program) { Q_UNUSED(status) int row = findRowFromInstrumentList(program); ui->instrumentList->setCurrentRow(row); } /********** Instrument list **********/ void MainWindow::addInstrument() { SoundSource src = bt_->getCurrentTrackAttribute().source; switch (src) { case SoundSource::FM: case SoundSource::SSG: case SoundSource::ADPCM: { std::unordered_map map = { { SoundSource::FM, InstrumentType::FM }, { SoundSource::SSG, InstrumentType::SSG }, { SoundSource::ADPCM, InstrumentType::ADPCM }, }; auto& list = ui->instrumentList; int num = bt_->findFirstFreeInstrumentNumber(); if (num == -1) return; // Maximum count check QString name = tr("Instrument %1").arg(num); bt_->addInstrument(num, map.at(src), name.toUtf8().toStdString()); comStack_->push(new AddInstrumentQtCommand( list, num, name, map.at(src), instDialogMan_, this, config_.lock()->getWriteOnlyUsedSamples())); ui->instrumentList->setCurrentRow(num); break; } case SoundSource::RHYTHM: break; } } void MainWindow::addDrumkit() { auto& list = ui->instrumentList; int num = bt_->findFirstFreeInstrumentNumber(); if (num == -1) return; // Maximum count check QString name = tr("Instrument %1").arg(num); bt_->addInstrument(num, InstrumentType::Drumkit, name.toUtf8().toStdString()); comStack_->push(new AddInstrumentQtCommand( list, num, name, InstrumentType::Drumkit, instDialogMan_, this, config_.lock()->getWriteOnlyUsedSamples())); ui->instrumentList->setCurrentRow(num); } void MainWindow::removeInstrument(int row) { if (row < 0) return; auto& list = ui->instrumentList; int num = list->item(row)->data(Qt::UserRole).toInt(); auto inst = bt_->getInstrument(num); bool updateRequest = false; if (config_.lock()->getWriteOnlyUsedSamples()){ if (inst->getSoundSource() == SoundSource::ADPCM) { size_t size = bt_->getSampleADPCMUsers(dynamic_cast( inst.get())->getSampleNumber()).size(); if (size == 1) updateRequest = true; } } bt_->removeInstrument(num); // Cancel renaming instrument if (list->item(row) == renamingInstItem_) { list->removeItemWidget(renamingInstItem_); renamingInstItem_ = nullptr; renamingInstEdit_ = nullptr; } comStack_->push(new RemoveInstrumentQtCommand(list, num, row, gui_utils::utf8ToQString(inst->getName()), inst->getType(), instDialogMan_, this, updateRequest)); } void MainWindow::openInstrumentEditor() { auto item = ui->instrumentList->currentItem(); int num = item->data(Qt::UserRole).toInt(); if (!instDialogMan_->hasShownEditor(num)) { // Create editor InstrumentEditor* editor; auto inst = bt_->getInstrument(num); switch (inst->getType()) { case InstrumentType::FM: { auto fmEditor = new FmInstrumentEditor(num, this); editor = fmEditor; fmEditor->setCore(bt_); fmEditor->setConfiguration(config_.lock()); fmEditor->setColorPalette(palette_); fmEditor->resize(config_.lock()->getInstrumentFMWindowWidth(), config_.lock()->getInstrumentFMWindowHeight()); QObject::connect(fmEditor, &FmInstrumentEditor::envelopeNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMEnvelopeNumberChanged); QObject::connect(fmEditor, &FmInstrumentEditor::envelopeParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMEnvelopeParameterChanged); QObject::connect(fmEditor, &FmInstrumentEditor::lfoNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMLFONumberChanged); QObject::connect(fmEditor, &FmInstrumentEditor::lfoParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMLFOParameterChanged); QObject::connect(fmEditor, &FmInstrumentEditor::operatorSequenceNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMOperatorSequenceNumberChanged); QObject::connect(fmEditor, &FmInstrumentEditor::operatorSequenceParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMOperatorSequenceParameterChanged); QObject::connect(fmEditor, &FmInstrumentEditor::arpeggioNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMArpeggioNumberChanged); QObject::connect(fmEditor, &FmInstrumentEditor::arpeggioParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMArpeggioParameterChanged); QObject::connect(fmEditor, &FmInstrumentEditor::pitchNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMPitchNumberChanged); QObject::connect(fmEditor, &FmInstrumentEditor::pitchParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentFMPitchParameterChanged); QObject::connect(fmEditor, &FmInstrumentEditor::jamKeyOnEvent, this, [&](JamKey key) { bt_->jamKeyOnForced(key, SoundSource::FM, !config_.lock()->getFixJammingVolume()); }, Qt::DirectConnection); QObject::connect(fmEditor, &FmInstrumentEditor::jamKeyOffEvent, this, [&](JamKey key) { bt_->jamKeyOffForced(key, SoundSource::FM); }, Qt::DirectConnection); QObject::connect(fmEditor, &FmInstrumentEditor::modified, this, &MainWindow::setModifiedTrue); fmEditor->installEventFilter(this); instDialogMan_->onInstrumentFMEnvelopeNumberChanged(); instDialogMan_->onInstrumentFMLFONumberChanged(); instDialogMan_->onInstrumentFMOperatorSequenceNumberChanged(); instDialogMan_->onInstrumentFMArpeggioNumberChanged(); instDialogMan_->onInstrumentFMPitchNumberChanged(); break; } case InstrumentType::SSG: { auto ssgEditor = new SsgInstrumentEditor(num, this); editor = ssgEditor; ssgEditor->setCore(bt_); ssgEditor->setConfiguration(config_.lock()); ssgEditor->setColorPalette(palette_); ssgEditor->resize(config_.lock()->getInstrumentSSGWindowWidth(), config_.lock()->getInstrumentSSGWindowHeight()); QObject::connect(ssgEditor, &SsgInstrumentEditor::waveformNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGWaveformNumberChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::waveformParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGWaveformParameterChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::toneNoiseNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGToneNoiseNumberChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::toneNoiseParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGToneNoiseParameterChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::envelopeNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGEnvelopeNumberChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::envelopeParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGEnvelopeParameterChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::arpeggioNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGArpeggioNumberChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::arpeggioParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGArpeggioParameterChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::pitchNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGPitchNumberChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::pitchParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentSSGPitchParameterChanged); QObject::connect(ssgEditor, &SsgInstrumentEditor::jamKeyOnEvent, this, [&](JamKey key) { bt_->jamKeyOnForced(key, SoundSource::SSG, !config_.lock()->getFixJammingVolume()); }, Qt::DirectConnection); QObject::connect(ssgEditor, &SsgInstrumentEditor::jamKeyOffEvent, this, [&](JamKey key) { bt_->jamKeyOffForced(key, SoundSource::SSG); } , Qt::DirectConnection); QObject::connect(ssgEditor, &SsgInstrumentEditor::modified, this, &MainWindow::setModifiedTrue); ssgEditor->installEventFilter(this); instDialogMan_->onInstrumentSSGWaveformNumberChanged(); instDialogMan_->onInstrumentSSGToneNoiseNumberChanged(); instDialogMan_->onInstrumentSSGEnvelopeNumberChanged(); instDialogMan_->onInstrumentSSGArpeggioNumberChanged(); instDialogMan_->onInstrumentSSGPitchNumberChanged(); break; } case InstrumentType::ADPCM: { auto adpcmEditor = new AdpcmInstrumentEditor(num, this); editor = adpcmEditor; adpcmEditor->setCore(bt_); adpcmEditor->setConfiguration(config_.lock()); adpcmEditor->setColorPalette(palette_); adpcmEditor->resize(config_.lock()->getInstrumentADPCMWindowWidth(), config_.lock()->getInstrumentADPCMWindowHeight()); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::sampleNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMSampleNumberChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::sampleParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMSampleParameterChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::sampleAssignRequested, this, &MainWindow::assignADPCMSamples); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::sampleMemoryChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMSampleMemoryUpdated); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::envelopeNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMEnvelopeNumberChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::envelopeParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMEnvelopeParameterChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::arpeggioNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMArpeggioNumberChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::arpeggioParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMArpeggioParameterChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::pitchNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMPitchNumberChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::pitchParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMPitchParameterChanged); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::jamKeyOnEvent, this, [&](JamKey key) { bt_->jamKeyOnForced(key, SoundSource::ADPCM, !config_.lock()->getFixJammingVolume()); }, Qt::DirectConnection); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::jamKeyOffEvent, this, [&](JamKey key) { bt_->jamKeyOffForced(key, SoundSource::ADPCM); }, Qt::DirectConnection); QObject::connect(adpcmEditor, &AdpcmInstrumentEditor::modified, this, &MainWindow::setModifiedTrue); adpcmEditor->installEventFilter(this); instDialogMan_->onInstrumentADPCMSampleNumberChanged(); instDialogMan_->onInstrumentADPCMEnvelopeNumberChanged(); instDialogMan_->onInstrumentADPCMArpeggioNumberChanged(); instDialogMan_->onInstrumentADPCMPitchNumberChanged(); break; } case InstrumentType::Drumkit: { auto kitEditor = new AdpcmDrumkitEditor(num, this); editor = kitEditor; kitEditor->setCore(bt_); kitEditor->setConfiguration(config_.lock()); kitEditor->setColorPalette(palette_); kitEditor->resize(config_.lock()->getInstrumentDrumkitWindowWidth(), config_.lock()->getInstrumentDrumkitWindowHeight()); QObject::connect(kitEditor, &AdpcmDrumkitEditor::sampleNumberChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMSampleNumberChanged); QObject::connect(kitEditor, &AdpcmDrumkitEditor::sampleParameterChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMSampleParameterChanged); QObject::connect(kitEditor, &AdpcmDrumkitEditor::sampleAssignRequested, this, &MainWindow::assignADPCMSamples); QObject::connect(kitEditor, &AdpcmDrumkitEditor::sampleMemoryChanged, instDialogMan_.get(), &InstrumentEditorManager::onInstrumentADPCMSampleMemoryUpdated); QObject::connect(kitEditor, &AdpcmDrumkitEditor::jamKeyOnEvent, this, [&](JamKey key) { bt_->jamKeyOnForced(key, SoundSource::ADPCM, !config_.lock()->getFixJammingVolume()); }, Qt::DirectConnection); QObject::connect(kitEditor, &AdpcmDrumkitEditor::jamKeyOffEvent, this, [&](JamKey key) { bt_->jamKeyOffForced(key, SoundSource::ADPCM); }, Qt::DirectConnection); QObject::connect(kitEditor, &AdpcmDrumkitEditor::modified, this, &MainWindow::setModifiedTrue); kitEditor->installEventFilter(this); instDialogMan_->onInstrumentADPCMSampleNumberChanged(); break; } default: throw std::invalid_argument("Invalid instrument type"); } editor->addActions({ &octUpSc_, &octDownSc_, &jamVolUpSc_, &jamVolDownSc_ }); instDialogMan_->add(num, editor); } instDialogMan_->showEditor(num); } int MainWindow::findRowFromInstrumentList(int instNum) { auto& list = ui->instrumentList; int row = 0; for (; row < list->count(); ++row) { auto item = list->item(row); if (item->data(Qt::UserRole).toInt() == instNum) break; } return row; } void MainWindow::renameInstrument() { auto list = ui->instrumentList; auto item = list->currentItem(); // Finish current edit if (item == renamingInstItem_) { finishRenamingInstrument(); return; } else if (renamingInstItem_) { finishRenamingInstrument(); } renamingInstItem_ = item; int num = item->data(Qt::UserRole).toInt(); renamingInstEdit_ = new QLineEdit(gui_utils::utf8ToQString(bt_->getInstrument(num)->getName())); QObject::connect(renamingInstEdit_, &QLineEdit::editingFinished, this, &MainWindow::finishRenamingInstrument); renamingInstEdit_->installEventFilter(this); ui->instrumentList->setItemWidget(item, renamingInstEdit_); renamingInstEdit_->selectAll(); renamingInstEdit_->setFocus(); } void MainWindow::finishRenamingInstrument() { if (!renamingInstItem_ || !renamingInstEdit_) return; bool hasFocus = renamingInstEdit_->hasFocus(); auto list = ui->instrumentList; int num = renamingInstItem_->data(Qt::UserRole).toInt(); int row = findRowFromInstrumentList(num); auto oldName = gui_utils::utf8ToQString(bt_->getInstrument(num)->getName()); QString newName = renamingInstEdit_->text(); list->removeItemWidget(renamingInstItem_); if (newName != oldName) { bt_->setInstrumentName(num, newName.toUtf8().toStdString()); comStack_->push(new ChangeInstrumentNameQtCommand(list, num, row, instDialogMan_, oldName, newName)); } renamingInstItem_ = nullptr; renamingInstEdit_ = nullptr; if (hasFocus) ui->instrumentList->setFocus(); } void MainWindow::cloneInstrument() { int num = bt_->findFirstFreeInstrumentNumber(); if (num == -1) return; int refNum = ui->instrumentList->currentItem()->data(Qt::UserRole).toInt(); // KEEP CODE ORDER // bt_->cloneInstrument(num, refNum); auto inst = bt_->getInstrument(num); comStack_->push(new CloneInstrumentQtCommand(ui->instrumentList, num, inst->getType(), gui_utils::utf8ToQString(inst->getName()), instDialogMan_)); //----------// } void MainWindow::deepCloneInstrument() { int num = bt_->findFirstFreeInstrumentNumber(); if (num == -1) return; int refNum = ui->instrumentList->currentItem()->data(Qt::UserRole).toInt(); // KEEP CODE ORDER // bt_->deepCloneInstrument(num, refNum); auto inst = bt_->getInstrument(num); comStack_->push(new DeepCloneInstrumentQtCommand( ui->instrumentList, num, inst->getType(), gui_utils::utf8ToQString(inst->getName()), instDialogMan_, this, config_.lock()->getWriteOnlyUsedSamples())); //----------// } void MainWindow::loadInstrument() { QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); std::vector orgFilters = io::InstrumentIO::getInstance().getLoadFilter(); QStringList filters; std::transform(orgFilters.begin(), orgFilters.end(), std::back_inserter(filters), [](const std::string& f) { return QString::fromStdString(f); }); QString selectedFilter = filters.at(config_.lock()->getInstrumentOpenFormat()); const QStringList files = QFileDialog::getOpenFileNames(this, tr("Open instrument"), (dir.isEmpty() ? "./" : dir), filters.join(";;"), &selectedFilter #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (files.empty()) return; int index = std::distance(filters.begin(), utils::find(filters, selectedFilter)); config_.lock()->setInstrumentOpenFormat(index); for (const QString& file : files) funcLoadInstrument(file); } void MainWindow::funcLoadInstrument(QString file) { int n = bt_->findFirstFreeInstrumentNumber(); if (n == -1) { FileIOErrorMessageBox(file, true, io::FileType::Inst, tr("The number of instruments has reached the upper limit."), this).exec(); return; } try { io::BinaryContainer container; { QFile fp(file); if (!fp.open(QIODevice::ReadOnly)) { FileIOErrorMessageBox::openError(file, true, io::FileType::Inst, this); return; } QByteArray&& array = fp.readAll(); fp.close(); std::move(array.begin(), array.end(), std::back_inserter(container)); } bt_->loadInstrument(container, file.toStdString(), n); auto inst = bt_->getInstrument(n); comStack_->push(new AddInstrumentQtCommand( ui->instrumentList, n, gui_utils::utf8ToQString(inst->getName()), inst->getType(), instDialogMan_, this, config_.lock()->getWriteOnlyUsedSamples())); ui->instrumentList->setCurrentRow(n); config_.lock()->setWorkingDirectory(QFileInfo(file).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(file, true, e, this).exec(); } catch (std::exception& e) { FileIOErrorMessageBox(file, true, io::FileType::Inst, QString(e.what()), this).exec(); } } void MainWindow::saveInstrument() { int n = ui->instrumentList->currentItem()->data(Qt::UserRole).toInt(); QString name = gui_utils::utf8ToQString(bt_->getInstrument(n)->getName()); QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); std::vector orgFilters = io::InstrumentIO::getInstance().getSaveFilter(); QStringList filters; std::transform(orgFilters.begin(), orgFilters.end(), std::back_inserter(filters), [](const std::string& f) { return QString::fromStdString(f); }); QString defaultFilter = filters.front(); // bti QString file = QFileDialog::getSaveFileName( this, tr("Save instrument"), QString("%1/%2.bti").arg(dir.isEmpty() ? "." : dir, name), filters.join(";;"), &defaultFilter #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (file.isNull()) return; if (!file.endsWith(".bti")) file += ".bti"; // For linux try { QByteArray bytes; { io::BinaryContainer container; bt_->saveInstrument(container, n); bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } QFile fp(file); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(file, false, io::FileType::Inst, this); return; } fp.write(bytes); fp.close(); config_.lock()->setWorkingDirectory(QFileInfo(file).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(file, false, e, this).exec(); } catch (std::exception& e) { FileIOErrorMessageBox(file, false, io::FileType::Inst, QString(e.what()), this).exec(); } } void MainWindow::importInstrumentsFromBank() { stopPlaySong(); QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); std::vector orgFilters = io::BankIO::getInstance().getLoadFilter(); QStringList filters; std::transform(orgFilters.begin(), orgFilters.end(), std::back_inserter(filters), [](const std::string& f) { return QString::fromStdString(f); }); QString selectedFilter = filters.at(config_.lock()->getBankOpenFormat()); QString file = QFileDialog::getOpenFileName(this, tr("Open bank"), (dir.isEmpty() ? "./" : dir), filters.join(";;"), &selectedFilter #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (file.isNull()) return; int index = std::distance(filters.begin(), utils::find(filters, selectedFilter)); config_.lock()->setBankOpenFormat(index); funcImportInstrumentsFromBank(file); } void MainWindow::funcImportInstrumentsFromBank(QString file) { stopPlaySong(); std::unique_ptr bank; try { io::BinaryContainer container; { QFile fp(file); if (!fp.open(QIODevice::ReadOnly)) { FileIOErrorMessageBox::openError(file, true, io::FileType::Bank, this); return; } QByteArray&& array = fp.readAll(); fp.close(); std::move(array.begin(), array.end(), std::back_inserter(container)); } bank.reset(io::BankIO::getInstance().loadBank(container, file.toStdString())); config_.lock()->setWorkingDirectory(QFileInfo(file).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(file, true, e, this).exec(); return; } catch (std::exception& e) { FileIOErrorMessageBox(file, true, io::FileType::Bank, QString(e.what()), this).exec(); return; } // Change text codec if (auto ff = dynamic_cast(bank.get())) { QTextCodec* codec = QTextCodec::codecForName("Shift-JIS"); for (size_t i = 0; i < ff->getNumInstruments(); ++i) { std::string sjis = ff->getInstrumentName(i); std::string utf8 = codec->toUnicode(sjis.c_str(), sjis.length()).toStdString(); ff->setInstrumentName(i, utf8); } } else if (auto mu88 = dynamic_cast(bank.get())) { QTextCodec* codec = QTextCodec::codecForName("Shift-JIS"); for (size_t i = 0; i < mu88->getNumInstruments(); ++i) { std::string sjis = mu88->getInstrumentName(i); std::string utf8 = codec->toUnicode(sjis.c_str(), sjis.length()).toStdString(); mu88->setInstrumentName(i, utf8); } } size_t jamId = 128; // Dummy std::shared_ptr jamInst; importBankDialog_ = std::make_unique(*bank, tr("Select instruments to load:"), config_, this); auto bankMan = std::make_shared(true); auto updateInst = [&] (size_t id) { if (id != jamId) { bankJamMidiCtrl_.store(true); jamId = id; bankMan->clearAll(); jamInst.reset(bank->loadInstrument(id, bankMan, 0)); jamInst->setNumber(128); // Special number std::unordered_map> sampNums; bt_->assignADPCMBeforeForcedJamKeyOn(jamInst, sampNums); for (const auto& pairs : sampNums) { bankMan->setSampleADPCMStartAddress(pairs.first, pairs.second[0]); bankMan->setSampleADPCMStopAddress(pairs.first, pairs.second[1]); } bankJamMidiCtrl_.store(false); } }; QObject::connect(importBankDialog_.get(), &InstrumentSelectionDialog::jamKeyOnEvent, this, [&](size_t id, JamKey key) { updateInst(id); bt_->jamKeyOnForced(key, jamInst->getSoundSource(), !config_.lock()->getFixJammingVolume(), jamInst); }, Qt::DirectConnection); QObject::connect(importBankDialog_.get(), &InstrumentSelectionDialog::jamKeyOnMidiEvent, this, [&](size_t id, int key) { updateInst(id); bt_->jamKeyOnForced(key, jamInst->getSoundSource(), !config_.lock()->getFixJammingVolume(), jamInst); }, Qt::DirectConnection); QObject::connect(importBankDialog_.get(), &InstrumentSelectionDialog::jamKeyOffEvent, this, [&](JamKey key) { bt_->jamKeyOffForced(key, jamInst->getSoundSource()); }, Qt::DirectConnection); QObject::connect(importBankDialog_.get(), &InstrumentSelectionDialog::jamKeyOffMidiEvent, this, [&](int key) { if (jamInst) bt_->jamKeyOffForced(key, jamInst->getSoundSource()); }, Qt::DirectConnection); importBankDialog_->addActions({ &octUpSc_, &octDownSc_ }); if (importBankDialog_->exec() != QDialog::Accepted) { assignADPCMSamples(); // Restore importBankDialog_.reset(); return; } const QVector selection = importBankDialog_->currentInstrumentSelection(); importBankDialog_.reset(); if (selection.empty()) return; try { bool sampleRestoreRequested = false; int lastNum = ui->instrumentList->currentRow(); for (const size_t& index : selection) { int n = bt_->findFirstFreeInstrumentNumber(); if (n == -1){ FileIOErrorMessageBox(file, true, io::FileType::Inst, tr("The number of instruments has reached the upper limit."), this).exec(); ui->instrumentList->setCurrentRow(lastNum); return; } bt_->importInstrument(*bank, index, n); auto inst = bt_->getInstrument(n); comStack_->push(new AddInstrumentQtCommand( ui->instrumentList, n, gui_utils::utf8ToQString(inst->getName()), inst->getType(), instDialogMan_, this, config_.lock()->getWriteOnlyUsedSamples(), true)); lastNum = n; sampleRestoreRequested |= (inst->getSoundSource() == SoundSource::ADPCM); } ui->instrumentList->setCurrentRow(lastNum); if (sampleRestoreRequested) assignADPCMSamples(); // Store only once } catch (io::FileIOError& e) { FileIOErrorMessageBox(file, true, e, this).exec(); } catch (std::exception& e) { FileIOErrorMessageBox(file, true, io::FileType::Bank, QString(e.what()), this).exec(); } } void MainWindow::exportInstrumentsToBank() { std::vector ids = bt_->getInstrumentIndices(); std::shared_ptr bank(std::make_shared(ids, bt_->getInstrumentNames())); InstrumentSelectionDialog dlg(*bank, tr("Select instruments to save:"), config_, this); if (dlg.exec() != QDialog::Accepted) return; QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); std::vector orgFilters = io::BankIO::getInstance().getSaveFilter(); QStringList filters; std::transform(orgFilters.begin(), orgFilters.end(), std::back_inserter(filters), [](const std::string& f) { return QString::fromStdString(f); }); QString defaultFilter = filters.front(); // btb QString file = QFileDialog::getSaveFileName(this, tr("Save bank"), (dir.isEmpty() ? "./" : dir), filters.join(";;"), &defaultFilter #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (file.isNull()) return; QVector selection = dlg.currentInstrumentSelection(); if (selection.empty()) return; std::vector sel; std::transform(selection.begin(), selection.end(), std::back_inserter(sel), [&ids](size_t i) { return ids.at(i); }); std::sort(sel.begin(), sel.end()); try { QByteArray bytes; { io::BinaryContainer container; bt_->exportInstruments(container, sel); bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } QFile fp(file); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(file, false, io::FileType::Bank, this); return; }fp.write(bytes); fp.close(); config_.lock()->setWorkingDirectory(QFileInfo(file).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(file, false, e, this).exec(); } catch (std::exception& e) { FileIOErrorMessageBox(file, false, io::FileType::Bank, QString(e.what()), this).exec(); } } void MainWindow::swapInstruments(int row1, int row2) { if (row1 == row2) return; // KEEP CODE ORDER // int num1 = ui->instrumentList->item(row1)->data(Qt::UserRole).toInt(); int num2 = ui->instrumentList->item(row2)->data(Qt::UserRole).toInt(); QString name1 = gui_utils::utf8ToQString(bt_->getInstrument(num1)->getName()); QString name2 = gui_utils::utf8ToQString(bt_->getInstrument(num2)->getName()); bt_->swapInstruments(num1, num2, config_.lock()->getReflectInstrumentNumberChange()); comStack_->push(new SwapInstrumentsQtCommand( ui->instrumentList, row1, row2, name1, name2, instDialogMan_, ui->patternEditor)); //----------// } /********** Undo-Redo **********/ void MainWindow::undo() { if (!bt_->undo()) { command_result_message_box::showCommandUndoingErrorMessageBox(this); return; } comStack_->undo(); } void MainWindow::redo() { if (!bt_->redo()) { command_result_message_box::showCommandRedoingErrorMessageBox(this); return; } comStack_->redo(); } /********** Load data **********/ void MainWindow::loadModule() { instDialogMan_->removeAll(); ui->instrumentList->clear(); on_instrumentList_itemSelectionChanged(); ui->modTitleLineEdit->setText(gui_utils::utf8ToQString(bt_->getModuleTitle())); ui->modTitleLineEdit->setCursorPosition(0); ui->authorLineEdit->setText(gui_utils::utf8ToQString(bt_->getModuleAuthor())); ui->authorLineEdit->setCursorPosition(0); ui->copyrightLineEdit->setText(gui_utils::utf8ToQString(bt_->getModuleCopyright())); ui->copyrightLineEdit->setCursorPosition(0); { QSignalBlocker blocker(ui->songComboBox); // Prevent duplicated call "loadSong" ui->songComboBox->clear(); for (size_t i = 0; i < bt_->getSongCount(); ++i) { QString title = gui_utils::utf8ToQString(bt_->getSongTitle(static_cast(i))); if (title.isEmpty()) title = tr("Untitled"); ui->songComboBox->addItem(QString("#%1 %2").arg(i).arg(title)); } } highlight1_->setValue(static_cast(bt_->getModuleStepHighlight1Distance())); highlight2_->setValue(static_cast(bt_->getModuleStepHighlight2Distance())); for (auto& idx : bt_->getInstrumentIndices()) { auto inst = bt_->getInstrument(idx); comStack_->push(new AddInstrumentQtCommand( ui->instrumentList, idx, gui_utils::utf8ToQString(inst->getName()), inst->getType(), instDialogMan_, this, config_.lock()->getWriteOnlyUsedSamples(), true)); } isSavedModBefore_ = false; loadSong(); // Set tick frequency stream_->setInterruption(bt_->getModuleTickFrequency()); if (tickTimerForRealChip_) tickTimerForRealChip_->setInterval(1000000 / bt_->getModuleTickFrequency()); statusIntr_->setText(QString::number(bt_->getModuleTickFrequency()) + QString("Hz")); // Set mixer QString text; switch (bt_->getModuleMixerType()) { case MixerType::UNSPECIFIED: bt_->setMasterVolumeFM(config_.lock()->getMixerVolumeFM()); bt_->setMasterVolumeSSG(config_.lock()->getMixerVolumeSSG()); text = tr("-"); break; case MixerType::CUSTOM: bt_->setMasterVolumeFM(bt_->getModuleCustomMixerFMLevel()); bt_->setMasterVolumeSSG(bt_->getModuleCustomMixerSSGLevel()); text = tr("Custom"); break; case MixerType::PC_9821_PC_9801_86: bt_->setMasterVolumeFM(0); bt_->setMasterVolumeSSG(-5.5); text = tr("PC-9821 with PC-9801-86"); break; case MixerType::PC_9821_SPEAK_BOARD: bt_->setMasterVolumeFM(0); bt_->setMasterVolumeSSG(-3.0); text = tr("PC-9821 with Speak Board"); break; case MixerType::PC_8801_VA2: bt_->setMasterVolumeFM(0); bt_->setMasterVolumeSSG(1.5); text = tr("PC-88VA2"); break; case MixerType::PC_8801_MKII_SR: bt_->setMasterVolumeFM(0); bt_->setMasterVolumeSSG(2.5); text = tr("NEC PC-8801mkIISR"); break; } statusMixer_->setText(text); // Set comment if (commentDialog_) commentDialog_->setComment(gui_utils::utf8ToQString(bt_->getModuleComment())); // Clear records QApplication::clipboard()->clear(); comStack_->clear(); bt_->clearCommandHistory(); } void MainWindow::openModule(const QString& file) { try { freezeViews(); if (tickTimerForRealChip_) tickTimerForRealChip_->stop(); else { try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } QFile fp(file); if (fp.open(QIODevice::ReadOnly)) { io::BinaryContainer container; { QByteArray&& array = fp.readAll(); fp.close(); std::move(array.begin(), array.end(), std::back_inserter(container)); } bt_->loadModule(container); bt_->setModulePath(file.toStdString()); loadModule(); config_.lock()->setWorkingDirectory(QFileInfo(file).dir().path().toStdString()); changeFileHistory(file); goto AFTER_MOD_LOADING; // Skip error handling section } else { FileIOErrorMessageBox::openError(file, true, io::FileType::Mod, this); } } catch (std::exception& e) { if (auto ef = dynamic_cast(&e)) { FileIOErrorMessageBox(file, true, *ef, this).exec(); } else { FileIOErrorMessageBox(file, true, io::FileType::Mod, QString(e.what()), this).exec(); } } // Init module as a plain when something is wrong freezeViews(); bt_->makeNewModule(); loadModule(); AFTER_MOD_LOADING: // Post process of module loading isModifiedForNotCommand_ = false; setWindowModified(false); if (tickTimerForRealChip_) tickTimerForRealChip_->start(); else { try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } setInitialSelectedInstrument(); assignADPCMSamples(); } void MainWindow::loadSong() { // Init position int songCnt = static_cast(bt_->getSongCount()); if (ui->songComboBox->currentIndex() >= songCnt) bt_->setCurrentSongNumber(songCnt - 1); else bt_->setCurrentSongNumber(bt_->getCurrentSongNumber()); bt_->setCurrentOrderNumber(0); bt_->setCurrentTrack(0); bt_->setCurrentStepNumber(0); // Init ui ui->orderList->onSongLoaded(); setOrderListGroupMaximumWidth(); ui->patternEditor->onSongLoaded(); unfreezeViews(); int curSong = bt_->getCurrentSongNumber(); ui->songComboBox->setCurrentIndex(curSong); ui->tempoSpinBox->setValue(bt_->getSongTempo(curSong)); ui->speedSpinBox->setValue(bt_->getSongSpeed(curSong)); ui->patternSizeSpinBox->setValue(static_cast(bt_->getDefaultPatternSize(curSong))); ui->grooveSpinBox->setValue(bt_->getSongGroove(curSong)); ui->grooveSpinBox->setMaximum(static_cast(bt_->getGrooveCount()) - 1); if (bt_->isUsedTempoInSong(curSong)) { ui->tempoSpinBox->setEnabled(true); ui->speedSpinBox->setEnabled(true); ui->grooveCheckBox->setChecked(false); ui->grooveSpinBox->setEnabled(false); } else { ui->tempoSpinBox->setEnabled(false); ui->speedSpinBox->setEnabled(false); ui->grooveCheckBox->setChecked(true); ui->grooveSpinBox->setEnabled(true); } onCurrentTrackChanged(); setWindowTitle(); switch (bt_->getSongStyle(bt_->getCurrentSongNumber()).type) { case SongType::Standard: statusStyle_->setText(tr("Standard")); break; case SongType::FM3chExpanded: statusStyle_->setText(tr("FM3ch expanded")); break; } statusPlayPos_->setText(config_.lock()->getShowRowNumberInHex() ? "00/00" : "000/000"); bmManForm_->onCurrentSongNumberChanged(); ksManForm_->onCurrentSongNumberChanged(); // Update track visibility std::vector visTracks; int all = static_cast(bt_->getSongStyle(curSong).trackAttribs.size()); for (int i = 0; i < all; ++i) { if (bt_->isVisibleTrack(curSong, i)) visTracks.push_back(i); } ui->orderList->setVisibleTracks(visTracks); setOrderListGroupMaximumWidth(); ui->patternEditor->setVisibleTracks(visTracks); } void MainWindow::assignADPCMSamples() { bt_->stopPlaySong(); lockWidgets(false); if (tickTimerForRealChip_) tickTimerForRealChip_->stop(); else { try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } bool isStoredAll = bt_->assignSampleADPCMRawSamples(); // Mutex register instDialogMan_->onInstrumentADPCMSampleMemoryUpdated(); if (!isStoredAll) { QMessageBox::warning(this, tr("Warning"), tr("Insufficient memory size to load ADPCM samples. Please delete the unused samples.")); } if (tickTimerForRealChip_) tickTimerForRealChip_->start(); else { try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } } /********** Play song **********/ void MainWindow::startPlaySong() { bt_->startPlaySong(); lockWidgets(true); firstViewUpdateRequest_ = true; } void MainWindow::startPlayFromStart() { bt_->startPlayFromStart(); lockWidgets(true); firstViewUpdateRequest_ = true; } void MainWindow::startPlayPattern() { bt_->startPlayPattern(); lockWidgets(true); firstViewUpdateRequest_ = true; } void MainWindow::startPlayFromCurrentStep() { bt_->startPlayFromCurrentStep(); lockWidgets(true); firstViewUpdateRequest_ = true; } void MainWindow::startPlayFromMarker() { if (bt_->startPlayFromMarker()) { lockWidgets(true); firstViewUpdateRequest_ = true; } } void MainWindow::playStep() { if (!bt_->isPlaySong()) { bt_->playStep(); firstViewUpdateRequest_ = true; ui->patternEditor->onPlayStepPressed(); } } void MainWindow::stopPlaySong() { bt_->stopPlaySong(); lockWidgets(false); ui->patternEditor->onStoppedPlaySong(); ui->orderList->onStoppedPlaySong(); } void MainWindow::lockWidgets(bool isLock) { hasLockedWigets_ = isLock; ui->songComboBox->setEnabled(!isLock); } /********** Octave change **********/ void MainWindow::changeOctave(bool upFlag) { if (upFlag) octave_->stepUp(); else octave_->stepDown(); statusOctave_->setText(tr("Octave: %1").arg(bt_->getCurrentOctave())); } /********** Configuration change **********/ void MainWindow::changeConfiguration() { // Real chip interface bool streamState = false; RealChipInterfaceType intf = config_.lock()->getRealChipInterface(); if (intf == RealChipInterfaceType::NONE) { tickTimerForRealChip_.reset(); bt_->connectToRealChip(RealChipInterfaceType::NONE); try { QString streamErr; streamState = stream_->initialize( config_.lock()->getSampleRate(), config_.lock()->getBufferLength(), bt_->getModuleTickFrequency(), gui_utils::utf8ToQString(config_.lock()->getSoundAPI()), gui_utils::utf8ToQString(config_.lock()->getSoundDevice()), &streamErr); if (!streamState) showStreamFailedDialog(streamErr); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } else { try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } if (tickTimerForRealChip_) { tickTimerForRealChip_->stop(); } else { tickTimerForRealChip_ = std::make_unique(); tickTimerForRealChip_->setInterval(1000000 / bt_->getModuleTickFrequency()); tickEventMethod_ = metaObject()->indexOfSlot("onNewTickSignaledRealChip()"); Q_ASSERT(tickEventMethod_ != -1); tickTimerForRealChip_->setFunction([&]{ QMetaMethod method = this->metaObject()->method(this->tickEventMethod_); method.invoke(this, Qt::QueuedConnection); }); } setRealChipInterface(intf); tickTimerForRealChip_->start(); } setMidiConfiguration(); NoteNameManager::getManager().setNotationSystem(config_.lock()->getNotationSystem()); updateFonts(); ui->orderList->setHorizontalScrollMode(config_.lock()->getMoveCursorByHorizontalScroll()); ui->patternEditor->setHorizontalScrollMode(config_.lock()->getMoveCursorByHorizontalScroll()); instDialogMan_->updateByConfiguration(); bt_->changeConfiguration(config_); if (streamState) { uint32_t sr = stream_->getStreamRate(); if (config_.lock()->getSampleRate() != sr) { showStreamRateWarningDialog(sr); bt_->setStreamRate(sr); } } setShortcuts(); updateInstrumentListColors(); bmManForm_->onConfigurationChanged(config_.lock()->getShowRowNumberInHex()); ksManForm_->onConfigurationChanged(config_.lock()->getShowRowNumberInHex()); visualTimer_->stop(); visualTimer_->start(static_cast(std::round(1000. / config_.lock()->getWaveViewFrameRate()))); update(); } void MainWindow::setRealChipInterface(RealChipInterfaceType intf) { if (intf == bt_->getRealChipInterfaceType()) return; if (isWindowModified() && QMessageBox::warning(this, tr("Warning"), tr("The module has been changed. Do you want to save it?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes) { on_actionSave_As_triggered(); } struct Pair { std::weak_ptr lib; const char* symbol; }; static std::unordered_map RCI_DIC = { { RealChipInterfaceType::SCCI, { scciDll_, "getSoundInterfaceManager" } }, { RealChipInterfaceType::C86CTL, { c86ctlDll_, "CreateInstance" } } }; auto& dll = RCI_DIC.at(intf).lib; dll.lock()->load(); if (dll.lock()->isLoaded()) bt_->connectToRealChip(intf, new RealChipInterfaceGeneratorFunc(dll.lock()->resolve(RCI_DIC[intf].symbol))); else bt_->connectToRealChip(RealChipInterfaceType::NONE); bt_->assignSampleADPCMRawSamples(); // Mutex register instDialogMan_->onInstrumentADPCMSampleMemoryUpdated(); } void MainWindow::setMidiConfiguration() { MidiInterface &midiIntf = MidiInterface::getInstance(); std::string midiApi = config_.lock()->getMidiAPI(); std::string midiInPortName = config_.lock()->getMidiInputPort(); if (config_.lock()->getMidiEnabled()) { std::string errDetail; if (midiApi.empty()) { config_.lock()->setMidiEnabled(false); midiIntf.switchApi(""); // Clear } else { if (!midiIntf.isAvailableApi(midiApi)) { showMidiFailedDialog("Invalid API name."); midiIntf.switchApi(""); // Clear return; } if (midiIntf.switchApi(midiApi, &errDetail)) { bool resPort = true; if (!midiInPortName.empty()) resPort = midiIntf.openInputPortByName(midiInPortName, &errDetail); else if (midiIntf.supportsVirtualPort()) resPort = midiIntf.openInputPort(~0u, &errDetail); else config_.lock()->setMidiEnabled(false); if (!resPort) { showMidiFailedDialog(QString::fromStdString(errDetail)); midiIntf.switchApi(""); // Clear } } else { showMidiFailedDialog(QString::fromStdString(errDetail)); midiIntf.switchApi(""); // Clear } } } } void MainWindow::updateFonts() { QFont ptnHeader, ptnRows, odrHeader, odrRows; if (!ptnHeader.fromString(gui_utils::utf8ToQString(config_.lock()->getPatternEditorHeaderFont()))) { ptnHeader = ui->patternEditor->getDefaultHeaderFont(); config_.lock()->setPatternEditorHeaderFont(ptnHeader.toString().toUtf8().toStdString()); } if (!ptnRows.fromString(gui_utils::utf8ToQString(config_.lock()->getPatternEditorRowsFont()))) { ptnRows = ui->patternEditor->getDefaultRowsFont(); config_.lock()->setPatternEditorRowsFont(ptnRows.toString().toUtf8().toStdString()); } if (!odrHeader.fromString(gui_utils::utf8ToQString(config_.lock()->getOrderListHeaderFont()))) { odrHeader = ui->orderList->getDefaultHeaderFont(); config_.lock()->setOrderListHeaderFont(odrHeader.toString().toUtf8().toStdString()); } if (!odrRows.fromString(gui_utils::utf8ToQString(config_.lock()->getOrderListRowsFont()))) { odrRows = ui->orderList->getDefaultRowsFont(); config_.lock()->setOrderListRowsFont(odrRows.toString().toUtf8().toStdString()); } ui->patternEditor->setFonts(ptnHeader, ptnRows); ui->orderList->setFonts(odrHeader, odrRows); } /********** History change **********/ void MainWindow::changeFileHistory(QString file) { fileHistory_->addFile(file); for (int i = ui->menu_Recent_Files->actions().count() - 1; 1 < i; --i) ui->menu_Recent_Files->removeAction(ui->menu_Recent_Files->actions().at(i)); for (size_t i = 0; i < fileHistory_->size(); ++i) { // Leave Before Qt5.7.0 style due to windows xp QAction* action = ui->menu_Recent_Files->addAction(QString("&%1 %2").arg(i + 1).arg(fileHistory_->at(i))); action->setData(fileHistory_->at(i)); } } /********** Backup **********/ bool MainWindow::backupModule(QString srcFile) { if (!isSavedModBefore_ && config_.lock()->getBackupModules()) { bool err = false; QString backup = srcFile + ".bak"; if (QFile::exists(backup)) err = !QFile::remove(backup); if (err || !QFile::copy(srcFile, backup)) { QMessageBox::critical(this, tr("Error"), tr("Failed to backup module.")); return false; } } return true; } /******************************/ void MainWindow::setWindowTitle() { int n = bt_->getCurrentSongNumber(); QString filePath = QString::fromStdString(bt_->getModulePath()); QString fileName = filePath.isEmpty() ? tr("Untitled") : QFileInfo(filePath).fileName(); QString songTitle = gui_utils::utf8ToQString(bt_->getSongTitle(n)); if (songTitle.isEmpty()) songTitle = tr("Untitled"); QMainWindow::setWindowTitle(QString("%1[*] [#%2 %3] - BambooTracker") .arg(fileName, QString::number(n), songTitle)); } void MainWindow::setModifiedTrue() { isModifiedForNotCommand_ = true; setWindowModified(true); } void MainWindow::setInitialSelectedInstrument() { if (bt_->getInstrumentIndices().empty()) { bt_->setCurrentInstrument(-1); statusInst_->setText(tr("No instrument")); } else { ui->instrumentList->setCurrentRow(0); } } QString MainWindow::getModuleFileBaseName() const { auto filePathStd = bt_->getModulePath(); QString filePath = QString::fromStdString(filePathStd); return (filePath.isEmpty() ? tr("Untitled") : QFileInfo(filePath).completeBaseName()); } /******************************/ /********** Instrument list events **********/ void MainWindow::on_instrumentList_customContextMenuRequested(const QPoint &pos) { auto& list = ui->instrumentList; QPoint globalPos = list->mapToGlobal(pos); QMenu menu; // Leave Before Qt5.7.0 style due to windows xp menu.addActions({ ui->actionNew_Instrument, ui->actionNew_Drumki_t, ui->actionRemove_Instrument }); menu.addSeparator(); menu.addAction(ui->actionRename_Instrument); menu.addSeparator(); menu.addActions({ ui->actionClone_Instrument, ui->actionDeep_Clone_Instrument }); menu.addSeparator(); menu.addActions({ ui->actionLoad_From_File, ui->actionSave_To_File }); menu.addSeparator(); menu.addActions({ ui->actionImport_From_Bank_File, ui->actionExport_To_Bank_File }); menu.addSeparator(); menu.addAction(ui->actionEdit); menu.exec(globalPos); } void MainWindow::on_instrumentList_itemDoubleClicked(QListWidgetItem *) { openInstrumentEditor(); } void MainWindow::on_instrumentList_itemSelectionChanged() { int num = (ui->instrumentList->currentRow() == -1) ? -1 : ui->instrumentList->currentItem()->data(Qt::UserRole).toInt(); bt_->setCurrentInstrument(num); if (num == -1) statusInst_->setText(tr("No instrument")); else statusInst_->setText( tr("Instrument: %1").arg(QString("%1").arg(num, 2, 16, QChar('0')).toUpper())); bool canAdd = (bt_->findFirstFreeInstrumentNumber() != -1); ui->actionLoad_From_File->setEnabled(canAdd); ui->actionImport_From_Bank_File->setEnabled(canAdd); bool isSelected = (num != -1); ui->actionRemove_Instrument->setEnabled(isSelected); ui->actionClone_Instrument->setEnabled(isSelected); ui->actionDeep_Clone_Instrument->setEnabled(isSelected); ui->actionSave_To_File->setEnabled(isSelected); ui->actionExport_To_Bank_File->setEnabled(isSelected); ui->actionRename_Instrument->setEnabled(isSelected); ui->actionEdit->setEnabled(isSelected); } void MainWindow::on_grooveCheckBox_stateChanged(int arg1) { if (arg1 == Qt::Checked) { ui->tempoSpinBox->setEnabled(false); ui->speedSpinBox->setEnabled(false); ui->grooveSpinBox->setEnabled(true); bt_->toggleTempoOrGrooveInSong(bt_->getCurrentSongNumber(), false); } else { ui->tempoSpinBox->setEnabled(true); ui->speedSpinBox->setEnabled(true); ui->grooveSpinBox->setEnabled(false); bt_->toggleTempoOrGrooveInSong(bt_->getCurrentSongNumber(), true); } setModifiedTrue(); } void MainWindow::on_actionExit_triggered() { close(); } void MainWindow::on_actionUndo_triggered() { undo(); } void MainWindow::on_actionRedo_triggered() { redo(); } void MainWindow::on_actionCut_triggered() { if (isEditedPattern_) ui->patternEditor->cutSelectedCells(); } void MainWindow::on_actionCopy_triggered() { if (isEditedPattern_) ui->patternEditor->copySelectedCells(); else if (isEditedOrder_) ui->orderList->copySelectedCells(); } void MainWindow::on_actionPaste_triggered() { if (isEditedPattern_) ui->patternEditor->onPastePressed(); else if (isEditedOrder_) ui->orderList->onPastePressed(); } void MainWindow::on_actionDelete_triggered() { if (isEditedPattern_) ui->patternEditor->onDeletePressed(); else if (isEditedOrder_) ui->orderList->deleteOrder(); else if (isEditedInstList_) on_actionRemove_Instrument_triggered(); } void MainWindow::updateMenuByPattern() { isEditedPattern_ = true; isEditedOrder_ = false; isEditedInstList_ = false; if (bt_->isJamMode()) { // Edit ui->actionPaste->setEnabled(false); ui->actionMix->setEnabled(false); ui->actionOverwrite->setEnabled(false); ui->action_Insert->setEnabled(false); ui->actionDelete->setEnabled(false); // Pattern ui->actionInterpolate->setEnabled(false); ui->actionReverse->setEnabled(false); ui->actionReplace_Instrument->setEnabled(false); ui->actionExpand->setEnabled(false); ui->actionShrink->setEnabled(false); ui->actionDecrease_Note->setEnabled(false); ui->actionIncrease_Note->setEnabled(false); ui->actionDecrease_Octave->setEnabled(false); ui->actionIncrease_Octave->setEnabled(false); ui->actionFine_Decrease_Values->setEnabled(false); ui->actionFine_Increase_Values->setEnabled(false); ui->actionCoarse_D_ecrease_Values->setEnabled(false); ui->actionCoarse_I_ncrease_Values->setEnabled(false); } else { // Edit bool enabled = QApplication::clipboard()->text().startsWith("PATTERN_"); ui->actionPaste->setEnabled(enabled); ui->actionMix->setEnabled(enabled); ui->actionOverwrite->setEnabled(enabled); ui->action_Insert->setEnabled(enabled); ui->actionDelete->setEnabled(true); // Pattern ui->actionInterpolate->setEnabled(isSelectedPattern_); ui->actionReverse->setEnabled(isSelectedPattern_); ui->actionReplace_Instrument->setEnabled( isSelectedPattern_ && ui->instrumentList->currentRow() != -1); ui->actionExpand->setEnabled(isSelectedPattern_); ui->actionShrink->setEnabled(isSelectedPattern_); ui->actionDecrease_Note->setEnabled(true); ui->actionIncrease_Note->setEnabled(true); ui->actionDecrease_Octave->setEnabled(true); ui->actionIncrease_Octave->setEnabled(true); ui->actionFine_Decrease_Values->setEnabled(true); ui->actionFine_Increase_Values->setEnabled(true); ui->actionCoarse_D_ecrease_Values->setEnabled(true); ui->actionCoarse_I_ncrease_Values->setEnabled(true); } updateMenuByPatternSelection(isSelectedPattern_); } void MainWindow::updateMenuByOrder() { isEditedPattern_ = false; isEditedOrder_ = true; isEditedInstList_ = false; // Edit bool enabled = QApplication::clipboard()->text().startsWith("ORDER_"); ui->actionCut->setEnabled(false); ui->actionPaste->setEnabled(enabled); ui->actionMix->setEnabled(false); ui->actionOverwrite->setEnabled(false); ui->action_Insert->setEnabled(false); ui->actionDelete->setEnabled(true); // Song bool canAdd = bt_->canAddNewOrder(bt_->getCurrentSongNumber()); ui->actionInsert_Order->setEnabled(canAdd); //ui->actionRemove_Order->setEnabled(true); ui->actionDuplicate_Order->setEnabled(canAdd); //ui->actionMove_Order_Up->setEnabled(true); //ui->actionMove_Order_Down->setEnabled(true); ui->actionClone_Patterns->setEnabled(canAdd); ui->actionClone_Order->setEnabled(canAdd); // Pattern ui->actionInterpolate->setEnabled(false); ui->actionReverse->setEnabled(false); ui->actionReplace_Instrument->setEnabled(false); ui->actionExpand->setEnabled(false); ui->actionShrink->setEnabled(false); ui->actionDecrease_Note->setEnabled(false); ui->actionIncrease_Note->setEnabled(false); ui->actionDecrease_Octave->setEnabled(false); ui->actionIncrease_Octave->setEnabled(false); ui->actionFine_Decrease_Values->setEnabled(false); ui->actionFine_Increase_Values->setEnabled(false); ui->actionCoarse_D_ecrease_Values->setEnabled(false); ui->actionCoarse_I_ncrease_Values->setEnabled(false); updateMenuByOrderSelection(isSelectedOrder_); } void MainWindow::onCurrentTrackChanged() { SoundSource src = bt_->getCurrentTrackAttribute().source; bool space = (bt_->findFirstFreeInstrumentNumber() != -1); ui->actionNew_Instrument->setEnabled((src != SoundSource::RHYTHM) && space); ui->actionNew_Drumki_t->setEnabled((src == SoundSource::ADPCM) && space); } void MainWindow::updateMenuByInstrumentList() { isEditedPattern_ = false; isEditedOrder_ = false; isEditedInstList_ = true; // Edit ui->actionPaste->setEnabled(false); ui->actionMix->setEnabled(false); ui->actionOverwrite->setEnabled(false); ui->action_Insert->setEnabled(false); ui->actionDelete->setEnabled(true); // Pattern ui->actionInterpolate->setEnabled(false); ui->actionReverse->setEnabled(false); ui->actionReplace_Instrument->setEnabled(false); ui->actionExpand->setEnabled(false); ui->actionShrink->setEnabled(false); ui->actionDecrease_Note->setEnabled(false); ui->actionIncrease_Note->setEnabled(false); ui->actionDecrease_Octave->setEnabled(false); ui->actionIncrease_Octave->setEnabled(false); ui->actionFine_Decrease_Values->setEnabled(false); ui->actionFine_Increase_Values->setEnabled(false); ui->actionCoarse_D_ecrease_Values->setEnabled(false); ui->actionCoarse_I_ncrease_Values->setEnabled(false); } void MainWindow::updateMenuByPatternSelection(bool isSelected) { isSelectedPattern_ = isSelected; if (bt_->isJamMode()) { // Edit ui->actionCopy->setEnabled(false); ui->actionCut->setEnabled(false); // Pattern ui->actionInterpolate->setEnabled(false); ui->actionReverse->setEnabled(false); ui->actionReplace_Instrument->setEnabled(false); ui->actionExpand->setEnabled(false); ui->actionShrink->setEnabled(false); } else { // Edit ui->actionCopy->setEnabled(isSelected); ui->actionCut->setEnabled(isEditedPattern_ ? isSelected : false); // Pattern bool enabled = (isEditedPattern_ && isEditedPattern_) ? isSelected : false; ui->actionInterpolate->setEnabled(enabled); ui->actionReverse->setEnabled(enabled); ui->actionReplace_Instrument->setEnabled( enabled && ui->instrumentList->currentRow() != -1); ui->actionExpand->setEnabled(enabled); ui->actionShrink->setEnabled(enabled); } } void MainWindow::updateMenuByOrderSelection(bool isSelected) { isSelectedOrder_ = isSelected; // Edit ui->actionCopy->setEnabled(isSelected); } void MainWindow::on_actionAll_triggered() { if (isEditedPattern_) ui->patternEditor->onSelectPressed(1); else if (isEditedOrder_) ui->orderList->onSelectPressed(1); } void MainWindow::on_actionNone_triggered() { if (isEditedPattern_) ui->patternEditor->onSelectPressed(0); else if (isEditedOrder_) ui->orderList->onSelectPressed(0); } void MainWindow::on_actionDecrease_Note_triggered() { if (isEditedPattern_) ui->patternEditor->onTransposePressed(false, false); } void MainWindow::on_actionIncrease_Note_triggered() { if (isEditedPattern_) ui->patternEditor->onTransposePressed(false, true); } void MainWindow::on_actionDecrease_Octave_triggered() { if (isEditedPattern_) ui->patternEditor->onTransposePressed(true, false); } void MainWindow::on_actionIncrease_Octave_triggered() { if (isEditedPattern_) ui->patternEditor->onTransposePressed(true, true); } void MainWindow::on_actionInsert_Order_triggered() { ui->orderList->insertOrderBelow(); } void MainWindow::on_actionRemove_Order_triggered() { ui->orderList->deleteOrder(); } void MainWindow::on_actionModule_Properties_triggered() { ModulePropertiesDialog dialog(bt_, config_.lock()->getMixerVolumeFM(), config_.lock()->getMixerVolumeSSG(), this); if (dialog.exec() == QDialog::Accepted && showUndoResetWarningDialog(tr("Do you want to change song properties?"))) { int instRow = ui->instrumentList->currentRow(); bt_->stopPlaySong(); lockWidgets(false); dialog.onAccepted(); freezeViews(); if (!tickTimerForRealChip_) { try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } loadModule(); setModifiedTrue(); setWindowTitle(); ui->instrumentList->setCurrentRow(instRow); if (!tickTimerForRealChip_) { try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } assignADPCMSamples(); } } void MainWindow::on_actionNew_Instrument_triggered() { addInstrument(); } void MainWindow::on_actionRemove_Instrument_triggered() { removeInstrument(ui->instrumentList->currentRow()); } void MainWindow::on_actionClone_Instrument_triggered() { cloneInstrument(); } void MainWindow::on_actionDeep_Clone_Instrument_triggered() { deepCloneInstrument(); } void MainWindow::on_actionEdit_triggered() { openInstrumentEditor(); } void MainWindow::on_actionPlay_triggered() { startPlaySong(); } void MainWindow::on_actionPlay_Pattern_triggered() { startPlayPattern(); } void MainWindow::on_actionPlay_From_Start_triggered() { startPlayFromStart(); } void MainWindow::on_actionPlay_From_Cursor_triggered() { startPlayFromCurrentStep(); } void MainWindow::on_actionStop_triggered() { stopPlaySong(); } void MainWindow::on_actionEdit_Mode_triggered() { bt_->toggleJamMode(); ui->orderList->changeEditable(); ui->patternEditor->changeEditable(); if (isEditedOrder_) updateMenuByOrder(); else if (isEditedPattern_) updateMenuByPattern(); bool editable = !bt_->isJamMode(); ui->statusBar->showMessage(editable ? tr("Change to edit mode") : tr("Change to jam mode"), STATUS_DISPLAY_TIMEOUT); ui->action_Toggle_Bookmark->setEnabled(editable); } void MainWindow::on_actionToggle_Track_triggered() { ui->patternEditor->onToggleTrackPressed(); } void MainWindow::on_actionSolo_Track_triggered() { ui->patternEditor->onSoloTrackPressed(); } void MainWindow::on_actionKill_Sound_triggered() { bt_->killSound(); } void MainWindow::on_actionAbout_triggered() { static const QString APP_NAME = "BambooTracker v" + QString::fromStdString(Version::ofApplicationInString()); static const QString APP_DESC = tr("YM2608 Music Tracker"); static constexpr char COPY[] = "Copyright (C) 2018 Rerrah"; static const QString WEB = tr("Web:") + R"( https://bambootracker.github.io/BambooTracker/)"; static const QString LICENSE = tr("This software is licensed under the GNU General Public License v2.0 or later."); static const QString SOURCE = tr("Source is available at:"); static const QString REPO = R"(https://github.com/BambooTracker/BambooTracker)"; static const QString LIB_HEAD = tr("Libraries:"); static const QString CONTRIBUTORS = tr("Also see changelog which lists contributors."); static const QString ACKNOWLEGEMENT = tr("Thank you to everyone who reports bugs, makes suggestions, and contributes to this project!"); static const QStringList LIBS = { tr("blip_buf by (C) Shay Green (LGPL v2.1)"), #ifdef USE_REAL_CHIP tr("C86CTL by (C) honet (BSD 3-Clause)"), #endif tr("emu2149 by (C) Mitsutaka Okazaki (MIT License)"), tr("fmopn by (C) Tatsuyuki Satoh, Jarek Burczynski, ValleyBell (GPL v2+)"), tr("libOPNMIDI by (C) Vitaly Novichkov (MIT License part)"), tr("Nuked OPN-MOD by (C) Alexey Khokholov (Nuke.YKT), Jean Pierre Cimalando (LGPL v2.1+)"), tr("Qt (GPL v2+ or LGPL v3)"), tr("RtAudio by (C) Gary P. Scavone (RtAudio License)"), tr("RtMidi by (C) Gary P. Scavone (RtMidi License)"), #ifdef USE_REAL_CHIP tr("SCCI by (C) gasshi (SCCI License)"), #endif tr("Silk icons by (C) Mark James (CC BY 2.5 or 3.0)"), tr("ymdeltat by (C) Tatsuyuki Satoh, Jarek Burczynski, ValleyBell (GPL v2+)"), tr("ymfm by (C) Aaron Giles (BSD 3-Clause)") }; static const QString FORMATTED_TEXT = "

" + APP_NAME + "

" "

" + APP_DESC + "

" "

" + COPY + "

" "

" + WEB + "

" "

" + LICENSE + "
" + SOURCE + "
" + REPO + "

" "
" "

" + LIB_HEAD + "

    " + (QStringList { "" } + LIBS).join("
  • ") + "
  • " + "

" "

" + CONTRIBUTORS + "
" + ACKNOWLEGEMENT +"

"; QMessageBox dialog(QMessageBox::NoIcon, tr("About"), FORMATTED_TEXT, QMessageBox::Ok, this); dialog.setTextFormat(Qt::RichText); dialog.setIconPixmap(QIcon(":/icon/app_icon").pixmap(QSize(44, 44))); dialog.exec(); } void MainWindow::on_actionFollow_Mode_triggered() { bt_->setFollowPlay(ui->actionFollow_Mode->isChecked()); config_.lock()->setFollowMode(ui->actionFollow_Mode->isChecked()); ui->orderList->onFollowModeChanged(); ui->patternEditor->onFollowModeChanged(); } void MainWindow::on_actionGroove_Settings_triggered() { std::vector> seqs(bt_->getGrooveCount()); std::generate(seqs.begin(), seqs.end(), [&, i = 0]() mutable { return bt_->getGroove(i++); }); GrooveSettingsDialog dialog(this); dialog.setGrooveSquences(seqs); if (dialog.exec() == QDialog::Accepted) { bt_->stopPlaySong(); lockWidgets(false); bt_->setGrooves(dialog.getGrooveSequences()); ui->grooveSpinBox->setMaximum(static_cast(bt_->getGrooveCount()) - 1); setModifiedTrue(); } } void MainWindow::on_actionConfiguration_triggered() { ConfigurationDialog dialog(config_.lock(), palette_, stream_, this); QObject::connect(&dialog, &ConfigurationDialog::applyPressed, this, &MainWindow::changeConfiguration); if (dialog.exec() == QDialog::Accepted) { changeConfiguration(); io::saveConfiguration(config_.lock()); io::savePalette(palette_.get()); } } void MainWindow::on_actionExpand_triggered() { ui->patternEditor->onExpandPressed(); } void MainWindow::on_actionShrink_triggered() { ui->patternEditor->onShrinkPressed(); } void MainWindow::on_actionDuplicate_Order_triggered() { ui->orderList->onDuplicatePressed(); } void MainWindow::on_actionMove_Order_Up_triggered() { ui->orderList->onMoveOrderPressed(true); } void MainWindow::on_actionMove_Order_Down_triggered() { ui->orderList->onMoveOrderPressed(false); } void MainWindow::on_actionClone_Patterns_triggered() { ui->orderList->onClonePatternsPressed(); } void MainWindow::on_actionClone_Order_triggered() { ui->orderList->onCloneOrderPressed(); } void MainWindow::on_actionNew_triggered() { if (isWindowModified()) { switch (ModuleSaveCheckDialog(bt_->getModuleTitle(), this).exec()) { case QMessageBox::Yes: if (!on_actionSave_triggered()) return; break; case QMessageBox::No: break; case QMessageBox::Cancel: default: return; } } bt_->stopPlaySong(); lockWidgets(false); freezeViews(); if (!tickTimerForRealChip_) { try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } bt_->makeNewModule(); loadModule(); setInitialSelectedInstrument(); isModifiedForNotCommand_ = false; setWindowModified(false); if (!tickTimerForRealChip_) { try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } assignADPCMSamples(); } void MainWindow::on_actionComments_triggered() { if (commentDialog_) { if (commentDialog_->isVisible()) commentDialog_->activateWindow(); else commentDialog_->show(); } else { commentDialog_ = std::make_unique(gui_utils::utf8ToQString(bt_->getModuleComment()), this); commentDialog_->show(); QObject::connect(commentDialog_.get(), &CommentEditDialog::commentChanged, this, [&](const QString text) { bt_->setModuleComment(text.toUtf8().toStdString()); setModifiedTrue(); }); } } bool MainWindow::on_actionSave_triggered() { auto path = QString::fromStdString(bt_->getModulePath()); if (!path.isEmpty() && QFileInfo::exists(path) && QFileInfo(path).isFile()) { if (!backupModule(path)) return false; try { QByteArray bytes; { io::BinaryContainer container; bt_->saveModule(container); bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } QFile fp(path); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(path, false, io::FileType::Mod, this); return false; } fp.write(bytes); fp.close(); isModifiedForNotCommand_ = false; isSavedModBefore_ = true; setWindowModified(false); setWindowTitle(); return true; } catch (io::FileIOError& e) { FileIOErrorMessageBox(path, false, e, this).exec(); return false; } catch (std::exception& e) { FileIOErrorMessageBox(path, false, io::FileType::Mod, QString(e.what()), this).exec(); return false; } } else { return on_actionSave_As_triggered(); } } bool MainWindow::on_actionSave_As_triggered() { QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); QString file = QFileDialog::getSaveFileName( this, tr("Save module"), QString("%1/%2.btm").arg(dir.isEmpty() ? "." : dir, getModuleFileBaseName()), tr("BambooTracker module (*.btm)") + ";;" + tr("All files (*)"), nullptr #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (file.isNull()) return false; if (!file.endsWith(".btm")) file += ".btm"; // For linux if (QFile::exists(file)) { // Backup if the module already exists if (!backupModule(file)) return false; } bt_->setModulePath(file.toStdString()); try { QByteArray bytes; { io::BinaryContainer container; bt_->saveModule(container); bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } QFile fp(file); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(file, false, io::FileType::Mod, this); return false; } fp.write(bytes); fp.close(); isModifiedForNotCommand_ = false; isSavedModBefore_ = true; setWindowModified(false); setWindowTitle(); config_.lock()->setWorkingDirectory(QFileInfo(file).dir().path().toStdString()); changeFileHistory(file); return true; } catch (io::FileIOError& e) { FileIOErrorMessageBox(file, false, e, this).exec(); return false; } catch (std::exception& e) { FileIOErrorMessageBox(file, false, io::FileType::Mod, QString(e.what()), this).exec(); return false; } } void MainWindow::on_actionOpen_triggered() { if (isWindowModified()) { switch (ModuleSaveCheckDialog(bt_->getModuleTitle(), this).exec()) { case QMessageBox::Yes: if (!on_actionSave_triggered()) return; break; case QMessageBox::No: break; case QMessageBox::Cancel: return; default: break; } } QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); QString file = QFileDialog::getOpenFileName(this, tr("Open module"), (dir.isEmpty() ? "./" : dir), tr("BambooTracker module (*.btm)") + ";;" + tr("All files (*)"), nullptr #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (file.isNull()) return; bt_->stopPlaySong(); lockWidgets(false); openModule(file); } void MainWindow::on_actionLoad_From_File_triggered() { loadInstrument(); } void MainWindow::on_actionSave_To_File_triggered() { saveInstrument(); } void MainWindow::on_actionImport_From_Bank_File_triggered() { importInstrumentsFromBank(); } void MainWindow::on_actionInterpolate_triggered() { ui->patternEditor->onInterpolatePressed(); } void MainWindow::on_actionReverse_triggered() { ui->patternEditor->onReversePressed(); } void MainWindow::on_actionReplace_Instrument_triggered() { ui->patternEditor->onReplaceInstrumentPressed(); } void MainWindow::on_actionRow_triggered() { if (isEditedPattern_) ui->patternEditor->onSelectPressed(2); else if (isEditedOrder_) ui->orderList->onSelectPressed(2); } void MainWindow::on_actionColumn_triggered() { if (isEditedPattern_) ui->patternEditor->onSelectPressed(3); else if (isEditedOrder_) ui->orderList->onSelectPressed(3); } void MainWindow::on_actionPattern_triggered() { if (isEditedPattern_) ui->patternEditor->onSelectPressed(4); else if (isEditedOrder_) ui->orderList->onSelectPressed(4); } void MainWindow::on_actionOrder_triggered() { if (isEditedPattern_) ui->patternEditor->onSelectPressed(5); else if (isEditedOrder_) ui->orderList->onSelectPressed(5); } void MainWindow::on_actionRemove_Unused_Instruments_triggered() { if (showUndoResetWarningDialog(tr("Do you want to remove all unused instruments?"))) { bt_->stopPlaySong(); lockWidgets(false); auto list = ui->instrumentList; for (auto& n : bt_->getUnusedInstrumentIndices()) { for (int i = 0; i < list->count(); ++i) { if (list->item(i)->data(Qt::UserRole).toInt() == n) { removeInstrument(i); } } } bt_->clearUnusedInstrumentProperties(); bt_->clearCommandHistory(); comStack_->clear(); setModifiedTrue(); } } void MainWindow::on_actionRemove_Unused_Patterns_triggered() { if (showUndoResetWarningDialog(tr("Do you want to remove all unused patterns?"))) { bt_->stopPlaySong(); lockWidgets(false); bt_->clearUnusedPatterns(); bt_->clearCommandHistory(); comStack_->clear(); setModifiedTrue(); } } void MainWindow::on_actionWAV_triggered() { // Record current mute states const auto& style = bt_->getSongStyle(bt_->getCurrentSongNumber()); const auto& attribs = style.trackAttribs; std::vector muteStates(attribs.size()); std::vector unmuteTracks; for (size_t i = 0; i < attribs.size(); ++i) { muteStates[i] = bt_->isMute(attribs[i].number); if (!muteStates[i]) unmuteTracks.push_back(static_cast(i)); } unmuteTracks = gui_utils::adaptVisibleTrackList(unmuteTracks, style.type, SongType::Standard); WaveExportSettingsDialog dialog(unmuteTracks, this); if (dialog.exec() != QDialog::Accepted) return; QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); QString path = QFileDialog::getSaveFileName( this, tr("Export to WAV"), QString("%1/%2.wav").arg(dir.isEmpty() ? "." : dir, getModuleFileBaseName()), tr("WAV signed 16-bit PCM (*.wav)") + ";;" + tr("All files (*)"), nullptr #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (path.isNull()) return; if (!path.endsWith(".wav")) path += ".wav"; // For linux QString exDir = QFileInfo(path).dir().path(); int max = static_cast(bt_->getTotalStepCount( bt_->getCurrentSongNumber(), static_cast(dialog.getLoopCount()))) + 3; QProgressDialog progress("", tr("Cancel"), 0, max, this); progress.setWindowModality(Qt::ApplicationModal); progress.setWindowFlags(progress.windowFlags() & ~Qt::WindowContextHelpButtonHint & ~Qt::WindowCloseButtonHint); auto bar = [&progress] { QApplication::processEvents(); progress.setValue(progress.value() + 1); return progress.wasCanceled(); }; unmuteTracks = dialog.getSoloExportTracks(); unmuteTracks.insert(unmuteTracks.begin(), -1); bt_->stopPlaySong(); lockWidgets(false); try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } for (size_t i = 0; i < unmuteTracks.size(); ++i) { int curTrack = unmuteTracks[i]; QString text, name; if (curTrack == -1) text = tr("Export to WAV"); // Mixed all else { if (curTrack < 6) name = gui_utils::getTrackName(SongType::Standard, SoundSource::FM, curTrack); else if (curTrack < 9) name = gui_utils::getTrackName(SongType::Standard, SoundSource::SSG, curTrack - 6); else if (curTrack < 15) name = gui_utils::getTrackName(SongType::Standard, SoundSource::RHYTHM, curTrack - 9); else name = gui_utils::getTrackName(SongType::Standard, SoundSource::ADPCM, 0); text = tr("Export %1 to WAV").arg(name); } progress.setLabelText(text); progress.setValue(0); progress.open(); // Update mute states if (i == 1) { for (const TrackAttribute& attrib : attribs) bt_->setTrackMuteState(attrib.number, attrib.number != unmuteTracks[i]); } else if (i > 1) { int prevTrack = unmuteTracks[i - 1]; if (style.type == SongType::FM3chExpanded) { if (prevTrack == 2) { bt_->setTrackMuteState(2, true); bt_->setTrackMuteState(3, true); bt_->setTrackMuteState(4, true); bt_->setTrackMuteState(5, true); } else if (prevTrack < 2) { bt_->setTrackMuteState(prevTrack, true); } else { bt_->setTrackMuteState(prevTrack + 3, true); } if (curTrack == 2) { bt_->setTrackMuteState(2, false); bt_->setTrackMuteState(3, false); bt_->setTrackMuteState(4, false); bt_->setTrackMuteState(5, false); } else if (curTrack < 2) { bt_->setTrackMuteState(curTrack, false); } else { bt_->setTrackMuteState(curTrack + 3, false); } } else { bt_->setTrackMuteState(prevTrack, true); bt_->setTrackMuteState(curTrack, false); } } try { QByteArray bytes; { const uint32_t rate = static_cast(dialog.getSampleRate()); const uint16_t nCh = 2; const int loopCnt = dialog.getLoopCount(); io::WavContainer container(rate, nCh, 16); if (!bt_->exportToWav(container, loopCnt, bar)) break; // Jump if cancelled bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } if (curTrack > -1) path = QString("%1/%2 - %3.wav").arg(exDir).arg(curTrack + 1, 2, 10, QChar('0')).arg(name); QFile fp(path); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(path, false, io::FileType::WAV, this); break; // Jump to post process } fp.write(bytes); fp.close(); bar(); config_.lock()->setWorkingDirectory(QFileInfo(path).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(path, false, e, this).exec(); break; } catch (std::exception& e) { FileIOErrorMessageBox(path, false, io::FileType::WAV, QString(e.what()), this).exec(); break; } } // Restore states for (size_t i = 0 ; i < attribs.size(); ++i) { bt_->setTrackMuteState(attribs[i].number, muteStates[i]); } try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } void MainWindow::on_actionVGM_triggered() { VgmExportSettingsDialog dialog(this); if (dialog.exec() != QDialog::Accepted) return; io::GD3Tag tag = dialog.getGD3Tag(); QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); QString path = QFileDialog::getSaveFileName( this, tr("Export to VGM"), QString("%1/%2.vgm").arg(dir.isEmpty() ? "." : dir, getModuleFileBaseName()), tr("VGM file (*.vgm)") + ";;" + tr("All files (*)"), nullptr #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (path.isNull()) return; if (!path.endsWith(".vgm")) path += ".vgm"; // For linux int max = static_cast(bt_->getTotalStepCount(bt_->getCurrentSongNumber(), 1)) + 3; QProgressDialog progress(tr("Export to VGM"), tr("Cancel"), 0, max, this); progress.setValue(0); progress.setWindowFlags(progress.windowFlags() & ~Qt::WindowContextHelpButtonHint & ~Qt::WindowCloseButtonHint); progress.setWindowModality(Qt::ApplicationModal); progress.open(); bt_->stopPlaySong(); lockWidgets(false); try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } try { auto bar = [&progress]() -> bool { QApplication::processEvents(); progress.setValue(progress.value() + 1); return progress.wasCanceled(); }; QByteArray bytes; { io::BinaryContainer container; if (!bt_->exportToVgm(container, dialog.getExportTarget(), dialog.enabledGD3(), tag, dialog.isEnabledMix(), dialog.getGain(), bar)) goto AFTER_VGM_WRITE; // Jump if cancelled bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } QFile fp(path); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(path, false, io::FileType::VGM, this); goto AFTER_VGM_WRITE; // Jump if cancelled } fp.write(bytes); fp.close(); bar(); config_.lock()->setWorkingDirectory(QFileInfo(path).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(path, false, e, this).exec(); } catch (std::exception& e) { FileIOErrorMessageBox(path, false, io::FileType::VGM, QString(e.what()), this).exec(); } AFTER_VGM_WRITE: try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } void MainWindow::on_actionS98_triggered() { S98ExportSettingsDialog dialog(this); if (dialog.exec() != QDialog::Accepted) return; io::S98Tag tag = dialog.getS98Tag(); QString dir = QString::fromStdString(config_.lock()->getWorkingDirectory()); QString path = QFileDialog::getSaveFileName( this, tr("Export to S98"), QString("%1/%2.s98").arg(dir.isEmpty() ? "." : dir, getModuleFileBaseName()), tr("S98 file (*.s98)") + ";;" + tr("All files (*)"), nullptr #if defined(Q_OS_LINUX) || (defined(Q_OS_BSD4) && !defined(Q_OS_DARWIN)) , QFileDialog::DontUseNativeDialog #endif ); if (path.isNull()) return; if (!path.endsWith(".s98")) path += ".s98"; // For linux int max = static_cast(bt_->getTotalStepCount(bt_->getCurrentSongNumber(), 1)) + 3; QProgressDialog progress(tr("Export to S98"), tr("Cancel"), 0, max, this); progress.setValue(0); progress.setWindowFlags(progress.windowFlags() & ~Qt::WindowContextHelpButtonHint & ~Qt::WindowCloseButtonHint); progress.setWindowModality(Qt::ApplicationModal); progress.open(); bt_->stopPlaySong(); lockWidgets(false); try { stream_->stop(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } try { auto bar = [&progress]() -> bool { QApplication::processEvents(); progress.setValue(progress.value() + 1); return progress.wasCanceled(); }; QByteArray bytes; { io::BinaryContainer container; if (!bt_->exportToS98(container, dialog.getExportTarget(), dialog.enabledTag(), tag, dialog.getResolution(), bar)) goto AFTER_S98_WRITE; // Jump if cancelled bytes.reserve(container.size()); std::move(container.begin(), container.end(), std::back_inserter(bytes)); } QFile fp(path); if (!fp.open(QIODevice::WriteOnly)) { FileIOErrorMessageBox::openError(path, false, io::FileType::S98, this); goto AFTER_S98_WRITE; // Jump to post process } fp.write(bytes); fp.close(); bar(); config_.lock()->setWorkingDirectory(QFileInfo(path).dir().path().toStdString()); } catch (io::FileIOError& e) { FileIOErrorMessageBox(path, false, e, this).exec(); } catch (std::exception& e) { FileIOErrorMessageBox(path, false, io::FileType::S98, QString(e.what()), this).exec(); } AFTER_S98_WRITE: try { stream_->start(); } catch (std::exception& e) { showStreamFailedDialog(e.what()); } } void MainWindow::on_actionMix_triggered() { if (isEditedPattern_) ui->patternEditor->onPasteMixPressed(); } void MainWindow::on_actionOverwrite_triggered() { if (isEditedPattern_) ui->patternEditor->onPasteOverwritePressed(); } void MainWindow::onNewTickSignaledRealChip() { onNewTickSignaled(bt_->streamCountUp()); } void MainWindow::onNewTickSignaled(int state) { if (!state) { // New step int order = bt_->getPlayingOrderNumber(); if (order > -1) { // Playing if (isVisible() && !isMinimized()) { ui->orderList->updatePositionByOrderUpdate(firstViewUpdateRequest_); ui->patternEditor->updatePositionByStepUpdate(firstViewUpdateRequest_); firstViewUpdateRequest_ = false; } int width, base; if (config_.lock()->getShowRowNumberInHex()) { width = 2; base = 16; } else { width = 3; base = 10; } statusPlayPos_->setText( QString("%1/%2") .arg(order, width, base, QChar('0')) .arg(bt_->getPlayingStepNumber(), width, base, QChar('0')).toUpper()); } } else if (state == -1) { if (hasLockedWigets_) lockWidgets(false); } // Update BPM status if (bt_->getStreamGrooveEnabled()) { statusBpm_->setText(tr("Groove")); } else { // BPM = tempo * 6 / speed * 4 / 1st highlight double bpm = 24.0 * bt_->getStreamTempo() / bt_->getStreamSpeed() / highlight1_->value(); statusBpm_->setText(QString::number(bpm, 'f', 2) + QString(" BPM")); } } void MainWindow::on_actionClear_triggered() { fileHistory_->clearHistory(); for (int i = ui->menu_Recent_Files->actions().count() - 1; 1 < i; --i) ui->menu_Recent_Files->removeAction(ui->menu_Recent_Files->actions().at(i)); } void MainWindow::on_keyRepeatCheckBox_stateChanged(int arg1) { config_.lock()->setKeyRepetition(arg1 == Qt::Checked); } void MainWindow::updateVisuals() { int16_t wave[2 * bt_defs::OUTPUT_HISTORY_SIZE]; bt_->getOutputHistory(wave); ui->waveVisual->setStereoSamples(wave, bt_defs::OUTPUT_HISTORY_SIZE); } void MainWindow::on_action_Effect_List_triggered() { if (effListDialog_) { if (effListDialog_->isVisible()) effListDialog_->activateWindow(); else effListDialog_->show(); } else { effListDialog_ = std::make_unique(this); effListDialog_->show(); } } void MainWindow::on_actionShortcuts_triggered() { if (shortcutsDialog_) { if (shortcutsDialog_->isVisible()) shortcutsDialog_->activateWindow(); else shortcutsDialog_->show(); } else { shortcutsDialog_ = std::make_unique(this); shortcutsDialog_->show(); } } void MainWindow::on_actionExport_To_Bank_File_triggered() { exportInstrumentsToBank(); } void MainWindow::on_actionRemove_Duplicate_Instruments_triggered() { if (showUndoResetWarningDialog(tr("Do you want to remove all duplicate instruments?"))) { bt_->stopPlaySong(); lockWidgets(false); std::unordered_map rplMap = bt_->replaceDuplicateInstrumentsInPatterns(); auto list = ui->instrumentList; for (auto& pairs : rplMap) { for (int j = 0; j < list->count(); ++j) { if (list->item(j)->data(Qt::UserRole).toInt() == pairs.first) removeInstrument(j); } } bt_->clearUnusedInstrumentProperties(); bt_->clearCommandHistory(); comStack_->clear(); ui->patternEditor->onDuplicateInstrumentsRemoved(); setModifiedTrue(); } } void MainWindow::on_actionRename_Instrument_triggered() { renameInstrument(); } void MainWindow::on_action_Bookmark_Manager_triggered() { if (bmManForm_->isVisible()) bmManForm_->activateWindow(); else bmManForm_->show(); } void MainWindow::on_actionFine_Decrease_Values_triggered() { if (isEditedPattern_) ui->patternEditor->onChangeValuesPressed(false, false); } void MainWindow::on_actionFine_Increase_Values_triggered() { if (isEditedPattern_) ui->patternEditor->onChangeValuesPressed(false, true); } void MainWindow::on_actionCoarse_D_ecrease_Values_triggered() { if (isEditedPattern_) ui->patternEditor->onChangeValuesPressed(true, false); } void MainWindow::on_actionCoarse_I_ncrease_Values_triggered() { if (isEditedPattern_) ui->patternEditor->onChangeValuesPressed(true, true); } void MainWindow::on_action_Toggle_Bookmark_triggered() { bmManForm_->onBookmarkToggleRequested(bt_->getCurrentOrderNumber(), bt_->getCurrentStepNumber()); } void MainWindow::on_action_Next_Bookmark_triggered() { bmManForm_->onBookmarkJumpRequested(true, bt_->getCurrentOrderNumber(), bt_->getCurrentStepNumber()); } void MainWindow::on_action_Previous_Bookmark_triggered() { bmManForm_->onBookmarkJumpRequested(false, bt_->getCurrentOrderNumber(), bt_->getCurrentStepNumber()); } void MainWindow::on_action_Instrument_Mask_triggered() { config_.lock()->setInstrumentMask(ui->action_Instrument_Mask->isChecked()); } void MainWindow::on_action_Volume_Mask_triggered() { config_.lock()->setVolumeMask(ui->action_Volume_Mask->isChecked()); } void MainWindow::on_actionSet_Ro_w_Marker_triggered() { bt_->setMarker(bt_->getCurrentOrderNumber(), bt_->getCurrentStepNumber()); ui->patternEditor->changeMarker(); } void MainWindow::on_actionPlay_From_Marker_triggered() { startPlayFromMarker(); } void MainWindow::on_action_Go_To_triggered() { GoToDialog dialog(bt_, this); if (dialog.exec() == QDialog::Accepted) { if (!bt_->isPlaySong() || !bt_->isFollowPlay()) { bt_->setCurrentOrderNumber(dialog.getOrder()); bt_->setCurrentStepNumber(dialog.getStep()); bt_->setCurrentTrack(dialog.getTrack()); ui->orderList->updatePositionByPositionJump(true); ui->patternEditor->updatepositionByPositionJump(true); } } } void MainWindow::on_actionRemove_Unused_ADPCM_Samples_triggered() { if (showUndoResetWarningDialog(tr("Do you want to remove all unused ADPCM samples?"))) { bt_->stopPlaySong(); lockWidgets(false); bt_->clearUnusedADPCMSamples(); assignADPCMSamples(); bt_->clearCommandHistory(); comStack_->clear(); setModifiedTrue(); } } void MainWindow::on_action_Status_Bar_triggered() { ui->statusBar->setVisible(ui->action_Status_Bar->isChecked()); } void MainWindow::on_action_Toolbar_triggered() { bool visible = ui->action_Toolbar->isChecked(); ui->mainToolBar->setVisible(visible); ui->subToolBar->setVisible(visible); } void MainWindow::on_actionNew_Drumki_t_triggered() { addDrumkit(); } void MainWindow::on_action_Wave_View_triggered(bool checked) { config_.lock()->setVisibleWaveView(checked); ui->waveVisual->setVisible(checked); if (checked) visualTimer_->start(static_cast(std::round(1000. / config_.lock()->getWaveViewFrameRate()))); else visualTimer_->stop(); } void MainWindow::on_action_Transpose_Song_triggered() { TransposeSongDialog dialog(this); if (dialog.exec() == QDialog::Accepted) { if (showUndoResetWarningDialog(tr("Do you want to transpose a song?"))) { bt_->stopPlaySong(); lockWidgets(false); bt_->transposeSong(bt_->getCurrentSongNumber(), dialog.getTransposeSemitones(), dialog.getExcludeInstruments()); ui->patternEditor->onPatternDataGlobalChanged(); bt_->clearCommandHistory(); comStack_->clear(); setModifiedTrue(); } } } void MainWindow::on_action_Swap_Tracks_triggered() { SwapTracksDialog dialog(bt_->getSongStyle(bt_->getCurrentSongNumber()), this); if (dialog.exec() == QDialog::Accepted) { int track1 = dialog.getTrack1(); int track2 = dialog.getTrack2(); if ((track1 != track2) && showUndoResetWarningDialog(tr("Do you want to swap tracks?"))) { bt_->stopPlaySong(); lockWidgets(false); bt_->swapTracks(bt_->getCurrentSongNumber(), track1, track2); ui->orderList->onOrderDataGlobalChanged(); ui->patternEditor->onPatternDataGlobalChanged(); bt_->clearCommandHistory(); comStack_->clear(); setModifiedTrue(); } } } void MainWindow::on_action_Insert_triggered() { if (isEditedPattern_) ui->patternEditor->onPasteInsertPressed(); } void MainWindow::on_action_Hide_Tracks_triggered() { HideTracksDialog dialog(bt_->getSongStyle(bt_->getCurrentSongNumber()), ui->patternEditor->getVisibleTracks(), this); if (dialog.exec() == QDialog::Accepted) { std::vector visTracks = dialog.getVisibleTracks(); ui->orderList->setVisibleTracks(visTracks); setOrderListGroupMaximumWidth(); ui->patternEditor->setVisibleTracks(visTracks); int song = bt_->getCurrentSongNumber(); int all = static_cast(bt_->getSongStyle(song).trackAttribs.size()); for (int i = 0; i < all; ++i) { if (std::any_of(visTracks.begin(), visTracks.end(), [i](int n) { return i == n; })) { bt_->setTrackVisibility(song, i, true); } else { bt_->setTrackVisibility(song, i, false); if (config_.lock()->getMuteHiddenTracks()) { bt_->setTrackMuteState(i, true); } } } setModifiedTrue(); } } void MainWindow::on_action_Estimate_Song_Length_triggered() { double time = bt_->estimateSongLength(bt_->getCurrentSongNumber()); int seconds = static_cast(std::round(time)); QMessageBox dialog; dialog.setIcon(QMessageBox::Information); dialog.setText(tr("Approximate song length: %1m%2s") .arg(seconds / 60).arg(seconds % 60, 2, 10, QChar('0'))); dialog.exec(); } void MainWindow::on_action_Key_Signature_Manager_triggered() { if (ksManForm_->isVisible()) ksManForm_->activateWindow(); else ksManForm_->show(); } void MainWindow::on_action_Welcome_triggered() { welcomeDialog_->open(); }