//-------------------------------------------------------------- void PartyCLApp::keyPressed(int key) { switch (key) { case ' ': bPaused ^= 1; break; case '`': bGuiVisible ^= 1; break; case 'p': case 'P': displayMode = (ParticleRenderer::DisplayMode)((displayMode + 1) % ParticleRenderer::PARTICLE_NUM_MODES); break; case 'r': case 'R': bReset = true; break; case '[': presetIndex = (presetIndex == 0) ? presets.size() - 1 : (presetIndex - 1) % presets.size(); loadPreset(); resetSimulation(); break; case ']': presetIndex = (presetIndex + 1) % presets.size(); loadPreset(); resetSimulation(); break; case 'f': case 'F': ofToggleFullscreen(); break; case '1': activeConfig = NBODY_CONFIG_SHELL; resetSimulation(); break; case '2': activeConfig = NBODY_CONFIG_RANDOM; resetSimulation(); break; case '3': activeConfig = NBODY_CONFIG_EXPAND; resetSimulation(); break; } }
void LLWaterParamManager::loadAllPresets(const std::string& file_name) { std::string path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", "")); LL_INFOS2("AppInit", "Shaders") << "Loading Default water settings from " << path_name << LL_ENDL; bool found = true; LLDirIterator app_settings_iter(path_name, "*.xml"); while(found) { std::string name; found = app_settings_iter.next(name); if(found) { name=name.erase(name.length()-4); // bugfix for SL-46920: preventing filenames that break stuff. char * curl_str = curl_unescape(name.c_str(), name.size()); std::string unescaped_name(curl_str); curl_free(curl_str); curl_str = NULL; LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL; loadPreset(unescaped_name,FALSE); } } // And repeat for user presets, note the user presets will modify any system presets already loaded std::string path_name2(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/water", "")); LL_INFOS2("AppInit", "Shaders") << "Loading User water settings from " << path_name2 << LL_ENDL; found = true; LLDirIterator user_settings_iter(path_name2, "*.xml"); while(found) { std::string name; found = user_settings_iter.next(name); if(found) { name=name.erase(name.length()-4); // bugfix for SL-46920: preventing filenames that break stuff. char * curl_str = curl_unescape(name.c_str(), name.size()); std::string unescaped_name(curl_str); curl_free(curl_str); curl_str = NULL; LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL; loadPreset(unescaped_name,FALSE); } } }
void AscentDayCycleManager::loadPresets(const std::string& file_name) { std::string path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/days", "")); LL_INFOS2("AppInit", "Shaders") << "Loading Default Day Cycle preset from " << path_name << LL_ENDL; bool found = true; while(found) { std::string name; found = gDirUtilp->getNextFileInDir(path_name, "*.xml", name, false); if(found) { name=name.erase(name.length()-4); // bugfix for SL-46920: preventing filenames that break stuff. char * curl_str = curl_unescape(name.c_str(), name.size()); std::string unescaped_name(curl_str); curl_free(curl_str); curl_str = NULL; LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL; loadPreset(unescaped_name,FALSE); } } // And repeat for user presets, note the user presets will modify any system presets already loaded std::string path_name2(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/days", "")); LL_INFOS2("AppInit", "Shaders") << "Loading User Daycycle preset from " << path_name2 << LL_ENDL; found = true; while(found) { std::string name; found = gDirUtilp->getNextFileInDir(path_name2, "*.xml", name, false); if(found) { name=name.erase(name.length()-4); // bugfix for SL-46920: preventing filenames that break stuff. char * curl_str = curl_unescape(name.c_str(), name.size()); std::string unescaped_name(curl_str); curl_free(curl_str); curl_str = NULL; LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL; loadPreset(unescaped_name,FALSE); } } }
void TestTubeSegmentationFramework::testLoadParameterFile() { paramList preset = loadPreset(QString("Neuro-Vessels-USA")); INFO("sphere-segmentation not set to true in Neuro-Vessels-USA"); REQUIRE(getParamBool(preset,"sphere-segmentation") == true); }
void AddFxContextMenu::loadFx(TIStream *is, QMenu *insertFxGroup, QMenu *addFxGroup, QMenu *replaceFxGroup) { while (!is->eos()) { string fxName; *is >> fxName; if (!fxName.empty()) { if (!loadPreset(fxName, insertFxGroup, addFxGroup, replaceFxGroup)) { QString translatedName = QString::fromStdWString(TStringTable::translate(fxName)); QAction *insertAction = new QAction(translatedName, insertFxGroup); QAction *addAction = new QAction(translatedName, addFxGroup); QAction *replaceAction = new QAction(translatedName, replaceFxGroup); insertAction->setData(QVariant(QString::fromStdString(fxName))); addAction->setData(QVariant(QString::fromStdString(fxName))); replaceAction->setData(QVariant(QString::fromStdString(fxName))); insertFxGroup->addAction(insertAction); addFxGroup->addAction(addAction); replaceFxGroup->addAction(replaceAction); m_insertActionGroup->addAction(insertAction); m_addActionGroup->addAction(addAction); m_replaceActionGroup->addAction(replaceAction); } } } }
bool FullColorBrushTool::onPropertyChanged(string propertyName) { m_minThick = m_thickness.getValue().first; m_maxThick = m_thickness.getValue().second; if (propertyName == "Hardness:" || propertyName == "Thickness") { m_brushPad = ToolUtils::getBrushPad(m_thickness.getValue().second, m_hardness.getValue() * 0.01); TRectD rect(m_brushPos - TPointD(m_maxThick + 2, m_maxThick + 2), m_brushPos + TPointD(m_maxThick + 2, m_maxThick + 2)); invalidate(rect); } /*if(propertyName == "Hardness:" || propertyName == "Opacity:") setWorkAndBackupImages();*/ FullcolorBrushMinSize = m_minThick; FullcolorBrushMaxSize = m_maxThick; FullcolorPressureSensibility = m_pressure.getValue(); FullcolorBrushHardness = m_hardness.getValue(); FullcolorMinOpacity = m_opacity.getValue().first; FullcolorMaxOpacity = m_opacity.getValue().second; if (propertyName == "Preset:") { loadPreset(); getApplication()->getCurrentTool()->notifyToolChanged(); return true; } if (m_preset.getValue() != CUSTOM_WSTR) { m_preset.setValue(CUSTOM_WSTR); getApplication()->getCurrentTool()->notifyToolChanged(); } return true; }
TEST_F(MidiControllerTest, ReceiveMessage_PotMeterCO_14BitPitchBend) { ConfigKey key("[Channel1]", "rate"); const double kMinValue = -1234.5; const double kMaxValue = 678.9; const double kMiddleValue = (kMinValue + kMaxValue) * 0.5; ControlPotmeter potmeter(key, kMinValue, kMaxValue); unsigned char channel = 0x01; // The control is ignored in mappings for messages where the control is part // of the payload. addMapping(MidiInputMapping(MidiKey(MIDI_PITCH_BEND | channel, 0xFF), MidiOptions(), key)); loadPreset(m_preset); // Receive a 0x0000, MIDI parameter should map to the min value. receive(MIDI_PITCH_BEND | channel, 0x00, 0x00); EXPECT_DOUBLE_EQ(kMinValue, potmeter.get()); // Receive a 0x3FFF, MIDI parameter should map to the potmeter max value. receive(MIDI_PITCH_BEND | channel, 0x7F, 0x7F); EXPECT_DOUBLE_EQ(kMaxValue, potmeter.get()); // Receive a 0x2000, MIDI parameter should map to the potmeter middle value. receive(MIDI_PITCH_BEND | channel, 0x00, 0x40); EXPECT_DOUBLE_EQ(kMiddleValue, potmeter.get()); // Check the 14-bit resolution is actually present. Receive a 0x2001, MIDI // parameter should map to the middle value plus a tiny amount. Scaling is // not quite linear for MIDI parameters so just check that incrementing the // LSB by 1 is greater than the middle value. receive(MIDI_PITCH_BEND | channel, 0x01, 0x40); EXPECT_LT(kMiddleValue, potmeter.get()); }
TEST_F(MidiControllerTest, ReceiveMessage_ToggleCO_PushCC) { // Some MIDI controllers (e.g. Korg nanoKONTROL) send momentary push-buttons // as (CC, 0x7f) for press and (CC, 0x00) for release. ConfigKey key("[Channel1]", "keylock"); ControlPushButton cpb(key); cpb.setButtonMode(ControlPushButton::TOGGLE); unsigned char channel = 0x01; unsigned char control = 0x10; addMapping(MidiInputMapping(MidiKey(MIDI_CC | channel, control), MidiOptions(), key)); loadPreset(m_preset); // Receive an on/off, toggles the control. receive(MIDI_CC | channel, control, 0x7F); receive(MIDI_CC | channel, control, 0x00); EXPECT_LT(0.0, cpb.get()); // Receive an on/off, toggles the control. receive(MIDI_CC | channel, control, 0x7F); receive(MIDI_CC | channel, control, 0x00); EXPECT_DOUBLE_EQ(0.0, cpb.get()); }
TEST_F(MidiControllerTest, ReceiveMessage_PotMeterCO_7BitCC) { ConfigKey key("[Channel1]", "playposition"); const double kMinValue = -1234.5; const double kMaxValue = 678.9; const double kMiddleValue = (kMinValue + kMaxValue) * 0.5; ControlPotmeter potmeter(key, kMinValue, kMaxValue); unsigned char channel = 0x01; unsigned char control = 0x10; addMapping(MidiInputMapping(MidiKey(MIDI_CC | channel, control), MidiOptions(), key)); loadPreset(m_preset); // Receive a 0, MIDI parameter should map to the min value. receive(MIDI_CC | channel, control, 0x00); EXPECT_DOUBLE_EQ(kMinValue, potmeter.get()); // Receive a 0x7F, MIDI parameter should map to the potmeter max value. receive(MIDI_CC | channel, control, 0x7F); EXPECT_DOUBLE_EQ(kMaxValue, potmeter.get()); // Receive a 0x40, MIDI parameter should map to the potmeter middle value. receive(MIDI_CC | channel, control, 0x40); EXPECT_DOUBLE_EQ(kMiddleValue, potmeter.get()); }
TEST_F(MidiControllerTest, ReceiveMessage_ToggleCO_ToggleOnOff_ButtonMidiOption) { // Using the button MIDI option allows you to use a MIDI toggle button as a // push button. ConfigKey key("[Channel1]", "keylock"); ControlPushButton cpb(key); cpb.setButtonMode(ControlPushButton::TOGGLE); unsigned char channel = 0x01; unsigned char control = 0x10; MidiOptions options; options.button = true; addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_ON | channel, control), options, key)); addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_OFF | channel, control), options, key)); loadPreset(m_preset); // NOTE(rryan): If the intended behavior of the button MIDI option is to // make a toggle MIDI button act like a push button then this isn't // working. The toggle on toggles the CO but the toggle off does nothing. // Toggle the switch on, since it is interpreted as a button press it // toggles the button on. receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_LT(0.0, cpb.get()); // Toggle the switch off, since it is interpreted as a button release it // does nothing to the toggle button. receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_LT(0.0, cpb.get()); }
TEST_F(MidiControllerTest, ReceiveMessage_PushButtonCO_PushOnOn) { // Some MIDI controllers send push-buttons as (NOTE_ON, 0x7f) for press and // (NOTE_ON, 0x00) for release. ConfigKey key("[Channel1]", "hotcue_1_activate"); ControlPushButton cpb(key); unsigned char channel = 0x01; unsigned char control = 0x10; addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_ON | channel, control), MidiOptions(), key)); loadPreset(m_preset); // Receive an on/off, sets the control on/off with each press. receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_LT(0.0, cpb.get()); receive(MIDI_NOTE_ON | channel, control, 0x00); EXPECT_DOUBLE_EQ(0.0, cpb.get()); // Receive an on/off, sets the control on/off with each press. receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_LT(0.0, cpb.get()); receive(MIDI_NOTE_ON | channel, control, 0x00); EXPECT_DOUBLE_EQ(0.0, cpb.get()); }
TEST_F(MidiControllerTest, ReceiveMessage_ToggleCO_PushOnOff) { // Most MIDI controller send push-buttons as (NOTE_ON, 0x7F) for press and // (NOTE_OFF, 0x00) for release. ConfigKey key("[Channel1]", "keylock"); ControlPushButton cpb(key); cpb.setButtonMode(ControlPushButton::TOGGLE); unsigned char channel = 0x01; unsigned char control = 0x10; addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_ON | channel, control), MidiOptions(), key)); addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_OFF | channel, control), MidiOptions(), key)); loadPreset(m_preset); // Receive an on/off, toggles the control. receive(MIDI_NOTE_ON | channel, control, 0x7F); receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_LT(0.0, cpb.get()); // Receive an on/off, toggles the control. receive(MIDI_NOTE_ON | channel, control, 0x7F); receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_DOUBLE_EQ(0.0, cpb.get()); }
TEST_F(MidiControllerTest, ReceiveMessage_PushButtonCO_ToggleOnOff_ButtonMidiOption) { // Using the button MIDI option allows you to use a MIDI toggle button as a // push button. ConfigKey key("[Channel1]", "hotcue_1_activate"); ControlPushButton cpb(key); unsigned char channel = 0x01; unsigned char control = 0x10; MidiOptions options; options.button = true; addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_ON | channel, control), options, key)); addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_OFF | channel, control), options, key)); loadPreset(m_preset); // NOTE(rryan): This behavior is broken! // Toggle the switch on, sets the push button on. receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_LT(0.0, cpb.get()); // The push button is stuck down here! // Toggle the switch off, sets the push button off. receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_DOUBLE_EQ(0.0, cpb.get()); }
// Preset control. void synthv1widget_preset::initPreset (void) { synthv1_config *pConfig = synthv1_config::getInstance(); if (pConfig && !pConfig->sPreset.isEmpty()) loadPreset(pConfig->sPreset); else newPreset(); }
void ClassSpaceChecker::onJarFileCurrentIndexChanged(int index) { if(initJarFileComboFlag_) return; QString presetId = ui.comboBox_JarFile->itemData(index).toString(); loadPreset(presetId); }
void AbstractProducerWidget::setProducer(Mlt::Producer* producer) { delete m_producer; m_producer = 0; if (producer) { loadPreset(*producer); m_producer = new Mlt::Producer(producer); } }
void LLWaterParamManager::loadAllPresets(const std::string& file_name) { std::string path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", "")); LL_DEBUGS2("AppInit", "ShaderLoading") << "Loading Default water settings from " << path_name << LL_ENDL; bool found = true; while(found) { std::string name; found = gDirUtilp->getNextFileInDir(path_name, "*.xml", name, false); if(found) { name=name.erase(name.length()-4); std::string unescaped_name = LLCurl::unescapeSafe(name); LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL; loadPreset(unescaped_name,FALSE); } } // And repeat for user presets, note the user presets will modify any system presets already loaded std::string path_name2(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/water", "")); LL_DEBUGS2("AppInit", "ShaderLoading") << "Loading User water settings from " << path_name2 << LL_ENDL; found = true; while(found) { std::string name; found = gDirUtilp->getNextFileInDir(path_name2, "*.xml", name, false); if(found) { name=name.erase(name.length()-4); std::string unescaped_name = LLCurl::unescapeSafe(name); LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL; loadPreset(unescaped_name,FALSE); } } }
void togglePreset(){ if (CURRENT_PRESET >= (MAX_PRESETS - 1)) { CURRENT_PRESET = 0; } else { CURRENT_PRESET++; } eeprom_write_byte(&EEPROM_PRESET, CURRENT_PRESET); loadPreset(); }
void KinectV2Classifier::eventLoad(ofxControlButtonEventArgs & evt) { if (!foundUser) { ofSystem("Error! You must have a skeleton detected first before loading the preset."); return; } ofFileDialogResult result = ofSystemLoadDialog("Select preset", false, ofToDataPath("")); if (result.bSuccess) { loadPreset(result.filePath); } }
void DlgPrefController::slotApply() { if (m_bDirty) { // Apply the presets and load the resulting preset. if (m_pInputTableModel != NULL) { m_pInputTableModel->apply(); } if (m_pOutputTableModel != NULL) { m_pOutputTableModel->apply(); } // Load script info from the script table. m_pPreset->scripts.clear(); for (int i = 0; i < m_ui.m_pScriptsTableWidget->rowCount(); ++i) { QString scriptFile = m_ui.m_pScriptsTableWidget->item(i, 0)->text(); // Skip empty rows. if (scriptFile.isEmpty()) { continue; } QString scriptPrefix = m_ui.m_pScriptsTableWidget->item(i, 1)->text(); bool builtin = m_ui.m_pScriptsTableWidget->item(i, 2) ->checkState() == Qt::Checked; ControllerPreset::ScriptFileInfo info; info.name = scriptFile; info.functionPrefix = scriptPrefix; info.builtin = builtin; m_pPreset->scripts.append(info); } // Load the resulting preset (which has been mutated by the input/output // table models). The controller clones the preset so we aren't touching // the same preset. emit(loadPreset(m_pController, m_pPreset)); //Select the "..." item again in the combobox. m_ui.comboBoxPreset->setCurrentIndex(0); bool wantEnabled = m_ui.chkEnabledDevice->isChecked(); bool enabled = m_pController->isOpen(); if (wantEnabled && !enabled) { enableDevice(); } else if (!wantEnabled && enabled) { disableDevice(); } m_bDirty = false; } }
void PMUICanvasRibbonRenderer::init(int posX, int posY, bool autosize, int width, int height) { PMUICanvasBaseRenderer::init(posX, posY, autosize, width, height); gradientImage.load("./gradients/gradient4x_512x160.png"); numGradients = 4; setGlobalSliderHeight(10); setGlobalButtonDimension(14); { // Brush (basic) addSpacer(); addLabel(STR_BRUSH_BASIC); addIntSlider(STR_BRUSH_BASIC_NUMPAINTERS, 1, 100, &numPainters); addIntSlider(STR_BRUSH_BASIC_WIDTH, 1, 10, &strokeWidth); addSlider(STR_BRUSH_BASIC_SPEED, 1.01f, 100, &speed); addToggle(STR_BRUSH_BASIC_ENABLEBOUNCE, &enableBounce); } { // Brush (advanced) addSpacer(); addLabel(STR_BRUSH_ADVANCED); addSlider(STR_BRUSH_ADVANCED_DIVISIONS, 0.001, 4.5, &divisions); // addSlider(STR_BRUSH_ADVANCED_EASE, -1.0, 10.0, &ease); // addSlider("Ease Randomness",0.0,1.0,&easeRandomness); // addIntSlider(STR_BRUSH_ADVANCED_MAXVERT,3, 4000, &pathMaxVertices); addSlider("Next Position Delta",0.0,1.0,&nextPositionDelta); } { // Color mode addSpacer(); addLabel(STR_BRUSH_COLORMODE); vector<string> colorModesNames; colorModesNames.push_back(STR_BRUSH_COLORMODE_MFIXEDCOLOR); colorModesNames.push_back(STR_BRUSH_COLORMODE_MGRSPEED); colorModesNames.push_back(STR_BRUSH_COLORMODE_MGREDGES); addRadio(STR_BRUSH_COLORMODE_RADIO, colorModesNames, OFX_UI_ORIENTATION_VERTICAL); addImageSampler(STR_BRUSH_COLORMODE_GRIMAGE, &gradientImage); addIntSlider(STR_BRUSH_COLORMODE_GRID, 1, 4, &gradientId); addIntSlider(STR_BRUSH_COLORMODE_GRSPEED, 1, 500, &gradientSpeed); addIntSlider(STR_BRUSH_COLORMODE_R, 0, 255, &colorR); addIntSlider(STR_BRUSH_COLORMODE_G, 0, 255, &colorG); addIntSlider(STR_BRUSH_COLORMODE_B, 0, 255, &colorB); } if (autosize) autoSizeToFitWidgets(); loadPreset(selectedPreset); }
void PresetManager::setFactoryDefaults() { SurfaceControlManager::displayOut.isOutputOn = false; for (curPreset=0; curPreset < 128; curPreset++) { setDefaultPreset(); storePreset(0); } loadPreset(0); SurfaceControlManager::displayOut.clear(); SurfaceControlManager::displayOut.writeEepromString(factoryDefaultsStr, 0, 0); SurfaceControlManager::displayOut.writeEepromString(restoredStr, 1, 4); SurfaceControlManager::displayOut.isOutputOn = true; }
void ClassSpaceChecker::checkAndJarFilePreset(const QString &jarPath) { CPresetData preset = gSettingManager.getPresetDataWithKeyName(jarPath); if(preset.isEmpty()) { ui.comboBox_JarFile->setEditText(jarPath); ui.lineEdit_MapFile->setText(""); } else { loadPreset(preset.getId()); } }
void preset_user_interface(UniversalInterface& ui, stdx::fun_ref<void(UniversalInterface&)> target , char const* defaultFile, char const* activeFilePath, ui::UniversalInterface::InteractionParam<char const*> activeFileChange , char const* groupName, UniqueElementIdentifier id) { if (!id.value) id = UEI(preset_user_interface); if (auto presetGroup = ui::Group(ui, id)) { uintptr_t controlIdentifier = 0; ui.addText(controlIdentifier++, (groupName) ? groupName : "Preset", "", nullptr); auto&& loadPreset = [&](char const* file) { try { activeFilePath = defaultFile = nullptr; // warning: everything may change if (activeFileChange) activeFileChange->updateValue(file); load_ini_file(file, target); } catch(...) { stdx::prompt(appx::exception_string().c_str(), "Error applying preset"); } }; if (activeFilePath) { auto hiddenIdentifier = controlIdentifier++; if (activeFilePath[0]) ui.addHidden(hiddenIdentifier, "active", activeFilePath, loadPreset); } ui.addButton(controlIdentifier++, (activeFilePath && activeFilePath[0] && defaultFile && defaultFile[0]) ? defaultFile : "load", [&]() { auto mf = stdx::prompt_file_compat(defaultFile, "Ini files=*.ini|All files=*.*", stdx::dialog::open, true); for (auto&&f : mf) loadPreset(f.c_str()); }); ui.addButton(controlIdentifier++, "save", [&]() { auto mf = stdx::prompt_file_compat(defaultFile, "Ini files=*.ini|All files=*.*", stdx::dialog::save); for (auto&&f : mf) { try { activeFilePath = defaultFile = nullptr; // warning: everything may change if (activeFileChange) activeFileChange->updateValue(f.c_str()); save_ini_file(f.c_str(), target); } catch(...) { stdx::prompt(appx::exception_string().c_str(), "Error saving preset"); } } }); } }
TEST_F(MidiControllerTest, ReceiveMessage_ToggleCO_ToggleOnOff_SwitchMidiOption) { // Using the switch MIDI option interprets a MIDI toggle button as a toggle // button rather than a momentary push button. ConfigKey key("[Channel1]", "keylock"); ControlPushButton cpb(key); cpb.setButtonMode(ControlPushButton::TOGGLE); unsigned char channel = 0x01; unsigned char control = 0x10; MidiOptions options; options.sw = true; addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_ON | channel, control), options, key)); addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_OFF | channel, control), options, key)); loadPreset(m_preset); // NOTE(rryan): If the intended behavior of switch MIDI option is to make a // toggle MIDI button act like a toggle button then this isn't working. The // toggle on presses the CO and the toggle off presses the CO. This toggles // the control but allows it to get out of sync. // Toggle the switch on, since it is interpreted as a button press it // toggles the control on. receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_LT(0.0, cpb.get()); // Toggle the switch off, since it is interpreted as a button press it // toggles the control off. receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_DOUBLE_EQ(0.0, cpb.get()); // Meanwhile, the GUI toggles the control on again. // NOTE(rryan): Now the MIDI toggle button is out of sync with the toggle // CO. cpb.set(1.0); // Toggle the switch on, since it is interpreted as a button press it // toggles the control off (since it was on). receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_DOUBLE_EQ(0.0, cpb.get()); // Toggle the switch off, since it is interpreted as a button press it // toggles the control on (since it was off). receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_LT(0.0, cpb.get()); }
void togglePreset(){ if (CURRENT_PRESET[currentSelector] >= (MAX_PRESETS - 1)) { CURRENT_PRESET[currentSelector] = 0; } else { CURRENT_PRESET[currentSelector]++; } if (currentSelector == 0) { eeprom_write_byte(&EEPROM_PRESET_1, CURRENT_PRESET[0]); } else { eeprom_write_byte(&EEPROM_PRESET_2, CURRENT_PRESET[1]); } loadPreset(); }
TEST_F(MidiControllerTest, ReceiveMessage_PushButtonCO_ToggleOnOff_SwitchMidiOption) { // Using the switch MIDI option interprets a MIDI toggle button as a toggle // button rather than a momentary push button. ConfigKey key("[Channel1]", "hotcue_1_activate"); ControlPushButton cpb(key); unsigned char channel = 0x01; unsigned char control = 0x10; MidiOptions options; options.sw = true; addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_ON | channel, control), options, key)); addMapping(MidiInputMapping(MidiKey(MIDI_NOTE_OFF | channel, control), options, key)); loadPreset(m_preset); // NOTE(rryan): This behavior is broken! // Toggle the switch on, sets the push button on. receive(MIDI_NOTE_ON | channel, control, 0x7F); EXPECT_LT(0.0, cpb.get()); // The push button is stuck down here! // Toggle the switch off, sets the push button on again. receive(MIDI_NOTE_OFF | channel, control, 0x00); EXPECT_LT(0.0, cpb.get()); // NOTE(rryan): What is supposed to happen in this case? It's an open // question I think. I think if you want to connect a switch MIDI control to // a push button CO then the switch should directly set the CO. After all, // the preset author asked for the switch to be interpreted as a switch. If // they want the switch to act like a push button, they should use the // button MIDI option. // // Most of our push buttons trigger behavior on press and do nothing on // release, and most don't care about being "stuck down" except for hotcue // and cue controls that have preview behavior. // "reverse" is an example of a push button that is a push button because we // want the default behavior to be momentary press and not toggle. If I // mapped a switch to it, I would expect the switch to enable it (set it to // 1) when the switch was enabled and set it to 0 when the switch was // disabled. So I think we should change the switch option to behave like // this. }
void soundBank::loadPresetsOrInitialise(){ string filename = ""; ofxXmlSettings settings; for(int i = 0; i <= TOTAL_SLOTS; i++) { // initialise the 2d vector vector<msp::avUgen*> row; presetSlots.push_back(row); filename = "avUgen/" + avUgenNames.at(i) + ".xml"; if(settings.loadFile(filename)){ ofLogNotice() << filename + " loaded! +++++++++++++++++"; settings.pushTag("avUgens", 0); ofLogNotice() << "Found presets in file: " << settings.getNumTags("avUgen") << endl; for (int j = 0; j <= TOTAL_PRESETS; j++){ std::ostringstream buf; buf << avUgenNames.at(i) << "-" << j; loadPreset(settings, j, buf.str(), i); } settings.popTag(); //avUgens } else { ofLogWarning() << "***********************************************************************************"; ofLogWarning() << "* unable to load "+ filename +" check data/ folder. Initialising defaults instead.*"; ofLogWarning() << "***********************************************************************************"; for (int j = 0; j <= TOTAL_PRESETS; j++){ std::ostringstream buf; buf << avUgenNames.at(i) << "-" << j; avUgen *preset = new msp::avUgen(settings.getValue("avUgen:name", buf.str(), i)); presetSlots[i].push_back(preset); } } } }
void synthv1widget_preset::resetPreset (void) { const QString& sPreset = m_pComboBox->currentText(); const bool bLoadPreset = (!sPreset.isEmpty() && m_pComboBox->findText(sPreset) >= 0); if (bLoadPreset && !queryPreset()) return; if (bLoadPreset) { loadPreset(sPreset); } else { emit resetPresetFile(); m_iDirtyPreset = 0; stabilizePreset(); } }
void DlgPrefController::slotLoadPreset(int chosenIndex) { if (chosenIndex == 0) { // User picked ... return; } const QString presetPath = m_ui.comboBoxPreset->itemData(chosenIndex).toString(); // When loading the preset, we only want to load from the same dir as the // preset itself, otherwise when loading from the system-wide dir we'll // start the search in the user's dir find the existing script, // and do nothing. const QFileInfo presetFileInfo(presetPath); QList<QString> presetDirs; presetDirs.append(presetFileInfo.canonicalPath()); ControllerPresetPointer pPreset = ControllerPresetFileHandler::loadPreset( presetPath, ControllerManager::getPresetPaths(m_pConfig)); // Import the preset scripts to the user scripts folder. for (QList<ControllerPreset::ScriptFileInfo>::iterator it = pPreset->scripts.begin(); it != pPreset->scripts.end(); ++it) { // No need to import builtin scripts. if (it->builtin) { continue; } QString scriptPath = ControllerManager::getAbsolutePath( it->name, presetDirs); QString importedScriptFileName; // If a conflict exists then importScript will provide a new filename to // use. If importing fails then load the preset anyway without the // import. if (m_pControllerManager->importScript(scriptPath, &importedScriptFileName)) { it->name = importedScriptFileName; } } // TODO(rryan): We really should not load the preset here. We should load it // into the preferences GUI and then load it to the actual controller once // the user hits apply. emit(loadPreset(m_pController, pPreset)); slotDirty(); }