//--------------------------------------------------------- // 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); }