//---------------------------------------------------------
// processEvent
// All events from the sequencer go here
//---------------------------------------------------------
bool ISynth::processEvent(const MusECore::MidiPlayEvent& ev)
{
switch(ev.type()) {
case MusECore::ME_CONTROLLER:
setController(ev.channel(), ev.dataA(), ev.dataB());
//return true; // ??
break;
case MusECore::ME_NOTEON:
return playNote(ev.channel(), ev.dataA(), ev.dataB());
case MusECore::ME_NOTEOFF:
return playNote(ev.channel(), ev.dataA(), 0);
case MusECore::ME_SYSEX:
return sysex(ev.len(), ev.data());
case MusECore::ME_PITCHBEND:
setController(ev.channel(), MusECore::CTRL_PITCH, ev.dataA());
break;
// Synths are not allowed to receive ME_PROGRAM, CTRL_HBANK, or CTRL_LBANK alone anymore - only CTRL_PROGRAM.
//case MusECore::ME_PROGRAM:
// setController(ev.channel(), MusECore::CTRL_PROGRAM, ev.dataA());
// break;
default:
break;
}
return false;
}
void RegistersManager::architectureParsedSlot(Architecture arch)
{
qCDebug(DEBUGGERGDB) << " Current controller: " << m_registerController << "Current arch " << m_currentArchitecture;
if (m_registerController || m_currentArchitecture != undefined) {
return;
}
switch (arch) {
case x86:
m_registerController.reset(new RegisterController_x86(m_debugSession)) ;
qCDebug(DEBUGGERGDB) << "Found x86 architecture";
break;
case x86_64:
m_registerController.reset(new RegisterController_x86_64(m_debugSession));
qCDebug(DEBUGGERGDB) << "Found x86_64 architecture";
break;
case arm:
m_registerController.reset(new RegisterController_Arm(m_debugSession));
qCDebug(DEBUGGERGDB) << "Found Arm architecture";
break;
default:
m_registerController.reset();
qWarning() << "Unsupported architecture. Registers won't be available.";
break;
}
m_currentArchitecture = arch;
setController(m_registerController.data());
if (m_registerController) {
updateRegisters();
}
}
void MainWindow::switchActualPath(const QString& path)
{
if (path == actual_path)
{
return;
}
int ret = QMessageBox::Ok;
if (has_unsaved_changes)
{
ret = QMessageBox::warning(this, appName(),
tr("The file has been modified.\n"
"Do you want to discard your changes?"),
QMessageBox::Discard | QMessageBox::Cancel);
}
if (ret != QMessageBox::Cancel)
{
const QString& current_path = currentPath();
MainWindowController* const new_controller = MainWindowController::controllerForFile(current_path);
if (new_controller && new_controller->load(path, this))
{
setController(new_controller, current_path);
actual_path = path;
setHasUnsavedChanges(false);
}
}
emit actualPathChanged(actual_path);
activateWindow();
}
void MouseInput::updateFromPeer(Qt3DCore::QNode *peer)
{
QMouseInput *input = static_cast<QMouseInput *>(peer);
if (input->controller() != Q_NULLPTR)
setController(input->controller()->id());
m_enabled = input->isEnabled();
}
bool Mess::processEvent(const MidiPlayEvent& ev)
{
switch(ev.type()) {
case ME_NOTEON:
return playNote(ev.channel(), ev.dataA(), ev.dataB());
case ME_NOTEOFF:
return playNote(ev.channel(), ev.dataA(), 0);
case ME_SYSEX:
return sysex(ev.len(), ev.data());
case ME_CONTROLLER:
return setController(ev.channel(), ev.dataA(), ev.dataB());
case ME_PITCHBEND: // Tim.
return setController(ev.channel(), CTRL_PITCH, ev.dataA());
}
return false;
}
/**
* Creates a default controller for this object.
*
* @return the object's controller
*/
Controller* VehicleObject::createDefaultController(void)
{
Controller* controller = new VehicleController(this);
NOT_NULL(controller);
setController(controller);
return controller;
} // VehicleObject::createDefaultController
RegistersManager::RegistersManager(QWidget* parent)
: QObject(parent), m_registersView(new RegistersView(parent)), m_registerController(0), m_architectureParser(new ArchitectureParser(this)), m_debugSession(0), m_modelsManager(new ModelsManager(this)), m_currentArchitecture(undefined), m_needToCheckArch(false)
{
connect(m_architectureParser, &ArchitectureParser::architectureParsed, this, &RegistersManager::architectureParsedSlot);
m_registersView->setModel(m_modelsManager);
setController(0);
}
void
OrganSegmentationController::toggleMaskDrawing( bool aToggle )
{
if( aToggle ) {
setController( MaskDrawingMouseController::Ptr( new MaskDrawingMouseController( mMask, 255 ) ) );
} else {
resetController();//mMaskDrawingController.reset();
}
}
void Insteon::setcontroller_callback(RESTContext* context)
{
RESTParameters* params = context->params;
Dumais::JSON::JSON& json = context->returnData;
if (params->getParam("id")!="")
{
InsteonID id = strtoul(params->getParam("id").c_str(),0,16);
setController(id);
json.addValue("ok","status");
}
}
void MouseInput::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
{
if (e->type() == NodeUpdated) {
QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
if (propertyChange->propertyName() == QByteArrayLiteral("controller")) {
const QNodeId newId = propertyChange->value().value<QNodeId>();
if (m_mouseController != newId) {
setController(newId);
}
}
}
}
AbstractCardItem::AbstractCardItem(const QString &_name, Player *_owner, int _id, QGraphicsItem *parent)
: ArrowTarget(_owner, parent), infoWidget(0), id(_id), name(_name), tapped(false), facedown(false), tapAngle(0), isHovered(false), realZValue(0)
{
setCursor(Qt::OpenHandCursor);
setFlag(ItemIsSelectable);
setCacheMode(DeviceCoordinateCache);
setController(_owner);
connect(db, SIGNAL(cardListChanged()), this, SLOT(cardInfoUpdated()));
connect(settingsCache, SIGNAL(displayCardNamesChanged()), this, SLOT(callUpdate()));
cardInfoUpdated();
}
void RegistersManager::setSession(DebugSession* debugSession)
{
qCDebug(DEBUGGERGDB) << "Change session " << debugSession;
m_debugSession = debugSession;
if (m_registerController) {
m_registerController->setSession(debugSession);
}
if (!m_debugSession) {
qCDebug(DEBUGGERGDB) << "Will reparse arch";
m_needToCheckArch = true;
setController(0);
}
}
bool Organ::init(const char* name)
{
gui = new OrganGui;
gui->setWindowTitle(QString(name));
gui->show();
for (int i = 0; i < NUM_CONTROLLER; ++i)
setController(0, synthCtrl[i].num, synthCtrl[i].val);
for (int i = 0; i < VOICES; ++i)
voices[i].isOn = false;
return false;
}
ViewStyleStandardPixmap::ViewStyleStandardPixmap(QStyle::StandardPixmap standardPixmap, bool useDefaultController)
: m_standardPixmap(standardPixmap),
m_pushableTracker(this)
{
if (useDefaultController)
{
auto controller = makeShared<ControllerMousePushableCallback>();
controller->onApply = [this] (ID id, const ControllerContext& context) {
if (action)
action(id, context, this);
};
setController(controller);
}
}
//---------------------------------------------------------
// processEvent
// All events from the sequencer go here
//---------------------------------------------------------
bool ISynth::processEvent(const MusECore::MidiPlayEvent& ev)
{
switch(ev.type()) {
case MusECore::ME_CONTROLLER:
setController(ev.channel(), ev.dataA(), ev.dataB());
//return true; // ??
break;
case MusECore::ME_NOTEON:
return playNote(ev.channel(), ev.dataA(), ev.dataB());
case MusECore::ME_NOTEOFF:
return playNote(ev.channel(), ev.dataA(), 0);
case MusECore::ME_SYSEX:
return sysex(ev.len(), ev.data());
case MusECore::ME_PITCHBEND:
setController(ev.channel(), MusECore::CTRL_PITCH, ev.dataA());
break;
case MusECore::ME_PROGRAM:
setController(ev.channel(), MusECore::CTRL_PROGRAM, ev.dataA());
break;
default:
break;
}
return false;
}
ControllerConnection::ControllerConnection( Controller * _controller ) :
m_controller( NULL ),
m_controllerId( -1 ),
m_ownsController( false )
{
if( _controller != NULL )
{
setController( _controller );
}
else
{
m_controller = Controller::create( Controller::DummyController,
NULL );
}
s_connections.append( this );
}
void
OrganSegmentationController::toggleRegionMarking( bool aToggle )
{
if( aToggle ) {
ASSERT(mModule.getGraphCutSegmentationWrapper().mWatersheds);
setController( boost::make_shared<RegionMarkingMouseController>(
mModule.getGraphCutSegmentationWrapper().mWatersheds,
mIDMappingBuffer,
mModule.getGraphCutSegmentationWrapper().mForegroundMarkers,
boost::bind( &OrganSegmentationModule::update, mModule )
)
);
D_PRINT( "Switched to region marking controller" );
} else {
resetController();//mMaskDrawingController.reset();
}
}
bool MainWindow::closeFile()
{
bool closed = !has_opened_file || showSaveOnCloseDialog();
if (closed)
{
if (has_opened_file)
{
num_open_files--;
has_opened_file = false;
}
if (homescreen_disabled || num_open_files > 0)
close();
else
setController(new HomeScreenController());
}
return closed;
}
bool Organ::sysex(int n, const unsigned char* data)
{
#ifdef ORGAN_DEBUG
printf("Organ: sysex\n");
#endif
if (unsigned(n) != (NUM_INIT_CONTROLLER * sizeof(int))) {
printf("Organ: unknown sysex\n");
return false;
}
int* s = (int*) data;
for (int i = 0; i < NUM_INIT_CONTROLLER; ++i) {
int val = *s++;
#ifdef ORGAN_DEBUG
printf("Organ: sysex before setController num:%d val:%d\n", synthCtrl[i].num, val);
#endif
setController(0, synthCtrl[i].num, val);
}
return false;
}
ModelObject ZoneHVACEnergyRecoveryVentilator_Impl::clone(Model model) const
{
auto cloneObject = ZoneHVACComponent_Impl::clone(model).cast<ZoneHVACEnergyRecoveryVentilator>();
auto const supplyFanClone = supplyAirFan().clone(model).cast<HVACComponent>();
cloneObject.setSupplyAirFan(supplyFanClone);
auto const exhaustFanClone = exhaustAirFan().clone(model).cast<HVACComponent>();
cloneObject.setExhaustAirFan(exhaustFanClone);
auto const heatExchangerClone = heatExchanger().clone(model).cast<HVACComponent>();
cloneObject.setHeatExchanger(heatExchangerClone);
if (auto const controllerObj = controller()) {
auto const controllerClone = controllerObj->clone(model).cast<ZoneHVACEnergyRecoveryVentilatorController>();
cloneObject.setController(controllerClone);
}
return cloneObject;
}
void Organ::processMessages()
{
//Process messages from the gui
//
// get and process all pending events from the
// synthesizer GUI
//
while (gui->fifoSize())
{
MidiPlayEvent ev = gui->readEvent();
if (ev.type() == ME_CONTROLLER)
{
// process local?
setController(ev.dataA(), ev.dataB());
sendEvent(ev);
}
else
printf("Organ::process(): unknown event\n");
}
}
void ControllerConnection::loadSettings( const QDomElement & _this )
{
QDomNode node = _this.firstChild();
if( !node.isNull() )
{
setController( Controller::create( node.toElement(), Engine::getSong() ) );
}
else
{
if( _this.attribute( "id" ).toInt() >= 0 )
{
m_controllerId = _this.attribute( "id" ).toInt();
}
else
{
qWarning( "controller index invalid\n" );
m_controllerId = -1;
}
m_controller = Controller::create( Controller::DummyController, NULL );
}
}
HTTPSessionBase::HTTPSessionBase(
const SocketAddress& localAddr,
const SocketAddress& peerAddr,
HTTPSessionController* controller,
const TransportInfo& tinfo,
InfoCallback* infoCallback,
std::unique_ptr<HTTPCodec> codec) :
infoCallback_(infoCallback),
transportInfo_(tinfo),
codec_(std::move(codec)),
localAddr_(localAddr),
peerAddr_(peerAddr),
prioritySample_(false),
h2PrioritiesEnabled_(true) {
// If we receive IPv4-mapped IPv6 addresses, convert them to IPv4.
localAddr_.tryConvertToIPv4();
peerAddr_.tryConvertToIPv4();
setController(controller);
}
void RegistersManager::updateRegisters()
{
if (!m_debugSession || m_debugSession->stateIsOn(s_dbgNotStarted | s_shuttingDown)) {
return;
}
qCDebug(DEBUGGERGDB) << "Updating registers";
if (m_needToCheckArch) {
m_needToCheckArch = false;
m_currentArchitecture = undefined;
setController(0);
}
if (m_currentArchitecture == undefined) {
m_architectureParser->determineArchitecture(m_debugSession);
}
if (m_registerController) {
m_registersView->updateRegisters();
} else {
qCDebug(DEBUGGERGDB) << "No registerController, yet?";
}
}
bool Organ::setController(int channel, int ctrl, int data)
{
setController(ctrl, data);
switch (ctrl) {
case HARM0:
case HARM1:
case HARM2:
case HARM3:
case HARM4:
case HARM5:
case ATTACK_LO:
case DECAY_LO:
case SUSTAIN_LO:
case RELEASE_LO:
case ATTACK_HI:
case DECAY_HI:
case SUSTAIN_HI:
case RELEASE_HI:
case BRASS:
case FLUTE:
case REED:
case VELO:
{
MidiPlayEvent ev(0, 0, channel, ME_CONTROLLER, ctrl, data);
#ifdef ORGAN_DEBUG
fprintf(stderr, "OrganGui:setController before gui->writeEvent ctrl:%d data:%d\n", ctrl, data);
#endif
gui->writeEvent(ev);
}
break;
default:
break;
}
return false;
}
//-----------------------------------------------------------------------------
UIViewSwitchContainer::~UIViewSwitchContainer ()
{
setController (0);
}
void AlembicFloatController::GetValueLocalTime(TimeValue t, void* ptr,
Interval& valid,
GetSetMethod method)
{
ESS_CPP_EXCEPTION_REPORTING_START
Interval interval = FOREVER;
MCHAR const* strPath = NULL;
this->pblock->GetValue(AlembicFloatController::ID_PATH, t, strPath, interval);
MCHAR const* strIdentifier = NULL;
this->pblock->GetValue(AlembicFloatController::ID_IDENTIFIER, t,
strIdentifier, interval);
MCHAR const* strCategory = NULL;
this->pblock->GetValue(AlembicFloatController::ID_CATEGORY, t, strCategory,
interval);
MCHAR const* strProperty = NULL;
this->pblock->GetValue(AlembicFloatController::ID_PROPERTY, t, strProperty,
interval);
float fTime;
this->pblock->GetValue(AlembicFloatController::ID_TIME, t, fTime, interval);
BOOL bMuted;
this->pblock->GetValue(AlembicFloatController::ID_MUTED, t, bMuted, interval);
extern bool g_bVerboseLogging;
if (g_bVerboseLogging) {
ESS_LOG_WARNING("Param block at tick " << t << "-----------------------");
ESS_LOG_WARNING("PATH: " << strPath);
ESS_LOG_WARNING("IDENTIFIER: " << strIdentifier);
ESS_LOG_WARNING("PROPERTY: " << strProperty);
ESS_LOG_WARNING("TIME: " << fTime);
ESS_LOG_WARNING("MUTED: " << bMuted);
ESS_LOG_WARNING("Param block end -------------");
}
const float fDefaultVal = -1.0;
std::string szPath = EC_MCHAR_to_UTF8(strPath);
std::string szIdentifier = EC_MCHAR_to_UTF8(strIdentifier);
std::string szProperty = EC_MCHAR_to_UTF8(strProperty);
std::string szCategory = EC_MCHAR_to_UTF8(strCategory);
if (szCategory.empty()) { // default to standard properties for backwards
// compatibility
szCategory = std::string("standardProperties");
}
if (!strProperty || !strPath || !strIdentifier /*|| !strCategory*/) {
return setController("1", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
if (bMuted) {
return setController("2", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
// if( szCategory.size() == 0 ) {
// ESS_LOG_ERROR( "No category specified." );
// return setController("3a", szProperty, valid, interval, method, ptr,
// fDefaultVal);
//}
if (szProperty.size() == 0) {
ESS_LOG_ERROR("No property specified.");
return setController("3b", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
AbcG::IObject iObj = getObjectFromArchive(szPath, szIdentifier);
if (!iObj.valid()) {
return setController("4", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
TimeValue dTicks = GetTimeValueFromSeconds(fTime);
double sampleTime = GetSecondsFromTimeValue(dTicks);
float fSampleVal = fDefaultVal;
if (boost::iequals(szCategory, "standardProperties")) {
if (Alembic::AbcGeom::ICamera::matches(
iObj.getMetaData())) { // standard camera properties
Alembic::AbcGeom::ICamera objCamera =
Alembic::AbcGeom::ICamera(iObj, Alembic::Abc::kWrapExisting);
SampleInfo sampleInfo =
getSampleInfo(sampleTime, objCamera.getSchema().getTimeSampling(),
objCamera.getSchema().getNumSamples());
Alembic::AbcGeom::CameraSample sample;
objCamera.getSchema().get(sample, sampleInfo.floorIndex);
double sampleVal;
if (!getCameraSampleVal(objCamera, sampleInfo, sample, szProperty,
sampleVal)) {
return setController("5", szProperty, valid, interval, method, ptr,
fDefaultVal);
}
// Blend the camera values, if necessary
if (sampleInfo.alpha != 0.0) {
objCamera.getSchema().get(sample, sampleInfo.ceilIndex);
double sampleVal2 = 0.0;
if (getCameraSampleVal(objCamera, sampleInfo, sample, szProperty,
sampleVal2)) {
sampleVal = (1.0 - sampleInfo.alpha) * sampleVal +
sampleInfo.alpha * sampleVal2;
}
}
fSampleVal = (float)sampleVal;
}
else if (Alembic::AbcGeom::ILight::matches(
iObj.getMetaData())) { // ILight material properties
ESS_PROFILE_SCOPE(
"AlembicFloatController::GetValueLocalTime - read ILight shader "
"parameter");
Alembic::AbcGeom::ILight objLight =
Alembic::AbcGeom::ILight(iObj, Alembic::Abc::kWrapExisting);
SampleInfo sampleInfo =
getSampleInfo(sampleTime, objLight.getSchema().getTimeSampling(),
objLight.getSchema().getNumSamples());
AbcM::IMaterialSchema matSchema = getMatSchema(objLight);
std::string strProp = szProperty;
std::vector<std::string> parts;
boost::split(parts, strProp, boost::is_any_of("."));
if (parts.size() == 3) {
const std::string& target = parts[0];
const std::string& type = parts[1];
const std::string& prop = parts[2];
Abc::IFloatProperty fProp = readShaderScalerProp<Abc::IFloatProperty>(
matSchema, target, type, prop);
if (fProp.valid()) {
fProp.get(fSampleVal, sampleInfo.floorIndex);
}
else {
ESS_LOG_WARNING("Float Controller Error: could find shader parameter "
<< strProp);
}
}
else if (parts.size() == 5) {
const std::string& target = parts[0];
const std::string& type = parts[1];
const std::string& prop = parts[2];
const std::string& propInterp = parts[3];
const std::string& propComp = parts[4];
// ESS_LOG_WARNING("propInterp: "<<propInterp);
if (propInterp == "rgb") {
Abc::IC3fProperty fProp = readShaderScalerProp<Abc::IC3fProperty>(
matSchema, target, type, prop);
if (fProp.valid()) {
Abc::C3f v3f;
fProp.get(v3f, sampleInfo.floorIndex);
if (propComp == "x") {
fSampleVal = v3f.x;
}
else if (propComp == "y") {
fSampleVal = v3f.y;
}
else if (propComp == "z") {
fSampleVal = v3f.z;
}
else {
ESS_LOG_WARNING(
"Float Controller Error: invalid component: " << propComp);
}
}
else {
ESS_LOG_WARNING(
"Float Controller Error: could find shader parameter "
<< strProp);
}
}
else {
ESS_LOG_WARNING(
"Float Controller Error: unrecognized parameter interpretation: "
<< propInterp);
}
}
else {
ESS_LOG_WARNING(
"Float Controller Error: could not parse property field: "
<< strProperty);
}
}
}
else if (boost::iequals(szCategory, "userProperties")) {
// AbcA::TimeSamplingPtr timeSampling = obj.getSchema().getTimeSampling();
// int nSamples = (int)obj.getSchema().getNumSamples();
AbcA::TimeSamplingPtr timeSampling;
int nSamples = 0;
Abc::ICompoundProperty propk =
AbcNodeUtils::getUserProperties(iObj, timeSampling, nSamples);
if (propk.valid()) {
SampleInfo sampleInfo = getSampleInfo(sampleTime, timeSampling, nSamples);
std::vector<std::string> parts;
boost::split(parts, szProperty, boost::is_any_of("."));
if (parts.size() == 1) {
Abc::IFloatProperty fProp =
readScalarProperty<Abc::IFloatProperty>(propk, szProperty);
if (fProp.valid()) {
fProp.get(fSampleVal, sampleInfo.floorIndex);
}
else {
Abc::IInt32Property intProp =
readScalarProperty<Abc::IInt32Property>(propk, szProperty);
if (intProp.valid()) {
int intVal;
intProp.get(intVal, sampleInfo.floorIndex);
fSampleVal = (float)intVal;
}
else {
ESS_LOG_WARNING(
"Float Controller Error: could not read user property "
<< szProperty);
}
}
}
else if (parts.size() == 3) {
const std::string& prop = parts[0];
const std::string& propInterp = parts[1];
const std::string& propComp = parts[2];
// ESS_LOG_WARNING("interpretation: "<<propInterp);
if (propInterp == "rgb") {
fSampleVal = readScalarPropertyExt3<Abc::IC3fProperty, Abc::C3f>(
propk, sampleInfo, prop, propComp);
}
else if (propInterp == "vector") {
fSampleVal = readScalarPropertyExt3<Abc::IV3fProperty, Abc::V3f>(
propk, sampleInfo, prop, propComp);
}
else {
ESS_LOG_WARNING(
"Float Controller Error: unrecognized parameter interpretation: "
<< propInterp);
}
}
}
}
// else if( boost::iequals(szCategory, "arbGeomParams") ){
//}
return setController("6", szProperty, valid, interval, method, ptr,
fSampleVal);
ESS_CPP_EXCEPTION_REPORTING_END
}
void IGUIElement::init()
{
IManager* manager = ISathraDevice::getInstance()->getManager();
setController(manager->getController(this));
manager->addElement(this);
}
void Organ::setController(int ctrl, int data)
{
int sr = sampleRate();
// Changed By T356.
// Because of oom's auto-bias controllers, some of these negative-range
// controls need to apply the auto-bias correction.
switch (ctrl) {
case HARM0:
//harm0 = cb2amp(-data);
harm0 = cb2amp(-data + 8192);
break;
case HARM1:
//harm1 = cb2amp(-data);
harm1 = cb2amp(-data + 8192);
break;
case HARM2:
//harm2 = cb2amp(-data);
harm2 = cb2amp(-data + 8192);
break;
case HARM3:
//harm3 = cb2amp(-data);
harm3 = cb2amp(-data + 8192);
break;
case HARM4:
//harm4 = cb2amp(-data);
harm4 = cb2amp(-data + 8192);
break;
case HARM5:
//harm5 = cb2amp(-data);
harm5 = cb2amp(-data + 8192);
break;
case ATTACK_LO: // maxval -> 500msec
attack0 = (data * sr) / 1000;
break;
case DECAY_LO: // maxval -> 5000msec
decay0 = (data * sr) / 1000;
break;
case SUSTAIN_LO:
//sustain0 = -data;
sustain0 = -data + 8192;
break;
case RELEASE_LO:
release0 = (data * sr) / 1000;
break;
case ATTACK_HI:
attack1 = (data * sr) / 1000;
break;
case DECAY_HI:
decay1 = (data * sr) / 1000;
break;
case SUSTAIN_HI:
//sustain1 = -data;
sustain1 = -data + 8192;
break;
case RELEASE_HI:
release1 = (data * sr) / 1000;
break;
case BRASS:
brass = data;
break;
case FLUTE:
flute = data;
break;
case REED:
reed = data;
break;
case VELO:
velo = data;
break;
case CTRL_VOLUME:
data &= 0x7f;
volume = data == 0 ? 0.0 : cb2amp(int(200 * log10((127.0 * 127)/(data*data))));
break;
case CTRL_ALL_SOUNDS_OFF:
for (int i = 0; i < VOICES; ++i)
voices[i].isOn = false;
break;
case CTRL_RESET_ALL_CTRL:
for (int i = 0; i < NUM_CONTROLLER; ++i)
setController(0, synthCtrl[i].num, synthCtrl[i].val);
break;
default:
fprintf(stderr, "Organ:set unknown Ctrl 0x%x to 0x%x\n", ctrl, data);
return;
}
for (int i = 0; i < NUM_CONTROLLER; ++i) {
if (synthCtrl[i].num == ctrl) {
synthCtrl[i].val = data;
break;
}
}
}
void MainWindow::setController(MainWindowController* new_controller, const QString& path)
{
setController(new_controller, true);
setCurrentPath(path);
}
