void LogVariablesWidget::on_logVariableTable_itemChanged(QTableWidgetItem *item) { if ( item->column() == 1 ) // Frequency { setFrequency(item->row(), item->text().toDouble()); } else if ( item->column() == 2 ) // Start Time { setStartTime(item->row(), item->text().toDouble()); } else if ( item->column() == 3 ) // Duration { setDuration(item->row(), item->text().toDouble()); } }
void SynthEvent::applyModules( SynthInstrument* instrument ) { bool hasOSC2 = _osc2 != 0; float OSC2freq = hasOSC2 ? _osc2->_baseFrequency : _baseFrequency; if ( instrument->arpeggiatorActive ) { if ( _arpeggiator == 0 ) _arpeggiator = instrument->arpeggiator->clone(); else instrument->arpeggiator->cloneProperties( _arpeggiator ); } else if ( _arpeggiator != 0 ) { delete _arpeggiator; _arpeggiator = 0; } if ( hasOSC2 ) _osc2->applyModules( instrument ); // pitch shift module active ? make sure current frequency // matches the current arpeggiator step if ( instrument->arpeggiatorActive ) { setFrequency( _arpeggiator->getPitchForStep( _arpeggiator->getStep(), _baseFrequency ), true, false ); } else { // restore base frequency upon deactivation of pitch shift modules setFrequency( _baseFrequency, false, true ); if ( hasOSC2 ) _osc2->setFrequency( OSC2freq, false, true ); } }
void sim_bandstack_cb(GtkWidget *widget, gpointer data) { BANDSTACK_ENTRY *entry; fprintf(stderr,"sim_bandstack_cb\n"); if(function) { entry=bandstack_entry_previous(); } else { entry=bandstack_entry_next(); } setFrequency(entry->frequencyA); setMode(entry->mode); FILTER* band_filters=filters[entry->mode]; FILTER* band_filter=&band_filters[entry->filter]; setFilter(band_filter->low,band_filter->high); vfo_update(NULL); }
void CubicSDR::setDevice(SDRDeviceInfo *dev) { if (!sdrThread->isTerminated()) { sdrThread->terminate(); if (t_SDR) { t_SDR->join(); delete t_SDR; } } for (SoapySDR::Kwargs::const_iterator i = settingArgs.begin(); i != settingArgs.end(); i++) { sdrThread->writeSetting(i->first, i->second); } sdrThread->setStreamArgs(streamArgs); sdrThread->setDevice(dev); DeviceConfig *devConfig = config.getDevice(dev->getDeviceId()); SoapySDR::Device *soapyDev = dev->getSoapyDevice(); if (soapyDev) { //long long freqHigh, freqLow; //SoapySDR::RangeList freqRange = soapyDev->getFrequencyRange(SOAPY_SDR_RX, 0); //freqLow = freqRange[0].minimum(); //freqHigh = freqRange[freqRange.size()-1].maximum(); // Try for a reasonable default sample rate. if (!sampleRateInitialized.load()) { sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, DEFAULT_SAMPLE_RATE); sampleRateInitialized.store(true); } else { sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, sampleRate); } if (frequency < sampleRate/2) { frequency = sampleRate/2; } setFrequency(frequency); setSampleRate(sampleRate); setPPM(devConfig->getPPM()); setOffset(devConfig->getOffset()); t_SDR = new std::thread(&SDRThread::threadMain, sdrThread); } }
/* * This thread performs a scan operation based on the scanDirection value. * * scanDirection = 0: scan forward continuously, pausing at each found station * scanDirection = 1: scan forward until a station is found * scanDirection = -1: scan backward until a station is found */ void RadioWidget::run() { threadRunning = TRUE; int signal = 0; // loop while no station found or the mode is 'continuous scan' while ((signal <= 0) || (scanDirection == 0)) { if (scanDirection >= 0) { frequency = frequency + 0.2; if (frequency > 107.9) frequency = 87.9; } else { frequency = frequency - 0.2; if (frequency < 87.9) frequency = 107.9; } setFrequency(frequency); // don't know why, but lcd must be told to repaint to show the freq. QThread::postEvent( lcd, new QPaintEvent( QRect(0, 0, 580, 300) ) ); // check it thread cancel was requested if (threadRunning == FALSE) break; // pause is necessary for a correct reading of the signal strength QThread::msleep(200); signal = getSignalStrength(); // if in 'continuous scan' mode and station pause, stay here for 3 sec. if ((scanDirection == 0) && (signal > 0)) QThread::sleep(3); // check again to see if thread cancel was requested if (threadRunning == FALSE) break; } // untoggle all the control buttons scan->untoggle(); scanForward->untoggle(); scanBackward->untoggle(); threadRunning = FALSE; }
boolean VCNL4010::begin(uint8_t addr) { _i2caddr = addr; Wire.begin(); uint8_t rev = read8(VCNL4010_PRODUCTID); //Serial.println(rev, HEX); if ((rev & 0xF0) != 0x20) { return false; } setLEDcurrent(20); setFrequency(VCNL4010_390K625); write8(VCNL4010_INTCONTROL, 0x08); return true; }
////////////////////////////////////////////////////////////////////////////// // Increment the frequency by this digit active in edit mode ////////////////////////////////////////////////////////////////////////////// void CFreqCtrl::incFreq() { if (m_ActiveEditDigit >= 0) { if (m_DigitInfo[m_ActiveEditDigit].editmode) { m_freq += m_DigitInfo[m_ActiveEditDigit].incval; if (m_ResetLowerDigits) { /* Set digits below the active one to 0 */ m_freq = m_freq - m_freq%m_DigitInfo[m_ActiveEditDigit].weight; } setFrequency(m_freq); m_LastEditDigit = m_ActiveEditDigit; } } }
void setLoRaMode(int Channel) { double Frequency; // LogMessage("Setting LoRa Mode\n"); setMode(Channel, RF96_MODE_SLEEP); writeRegister(Channel, REG_OPMODE,0x80); setMode(Channel, RF96_MODE_SLEEP); if (sscanf(Config.LoRaDevices[Channel].Frequency, "%lf", &Frequency)) { // LogMessage("Set Default Frequency\n"); setFrequency(Channel, Frequency); } }
void wsMessageReceived(WebSocket& socket, const String& message) { WebSocketsList &clients = server.getActiveWebSockets(); StaticJsonBuffer<200> jsonBuffer; JsonObject& root = jsonBuffer.parseObject(message); String actionName = root["name"].asString(); if(actionName=="enhance"){ setEnhance(!enhance); }else if(actionName=="power"){ setPower(!power); }else if(actionName=="mute"){ setMmute(!mute); }else if(actionName=="mixing"){ setMixing(!mixing); }else if(actionName=="frequency"){ setFrequency(root["val"]); }else if(actionName=="source"){ setSource(root["val"]); }else if (actionName == "volumeFR") { setVolume(CHAN_FR, root["val"]); } else if (actionName == "volumeFL") { setVolume(CHAN_FL, root["val"]); } else if (actionName == "volumeRR") { setVolume(CHAN_RR, root["val"]); } else if (actionName == "volumeRL") { setVolume(CHAN_RL, root["val"]); } else if (actionName == "volumeCEN") { setVolume(CHAN_CEN, root["val"]); } else if (actionName == "volumeSW") { setVolume(CHAN_SW, root["val"]); } else if (actionName == "volumeALLCH") { setVolume(CHAN_ALL, root["val"]); } else if (actionName == "volumeSW") { setVolume(CHAN_SW, root["val"]); } else if (actionName == "lcdText") { setLcd(root["line"], root["val"]); } sendUpdate(); Serial.printf("WebSocket message received:\r\n%s\r\n", actionName); }
// BGG -- eliminated the ADSR (breath amp now comes in through // the tick() method) and the vibrato Brass :: Brass(MY_FLOAT lowestFrequency) { length = (long) (Stk::sampleRate() / lowestFrequency + 1); delayLine = new DelayA( 0.5 * length, length ); lipFilter = new BiQuad(); lipFilter->setGain( 0.03 ); dcBlock = new PoleZero(); dcBlock->setBlockZero(); this->clear(); maxPressure = (MY_FLOAT) 0.0; lipTarget = 0.0; // Necessary to initialize variables. setFrequency( 220.0 ); }
bool Hamlib::handleRequest(Session::ref session, Request::ref request, Reply::ref reply) { std::string uri = request->getURI(); if (uri == "/hamlib") { if (request->getMethod() == "POST") { setFrequency(session, request, reply); } else { sendFrequency(session, request, reply); } } else { return false; } return true; }
// This command is complex because it only allows setting of frequency for channel 1 // This is because only the tilt motor can be controlled by frequency void onCommandFrequencyOutput() { if (isChannelCorrect(gParameters[0])) { uint8_t channel = convertToInt(gParameters[0]); uint16_t frequency = convertToUint(gParameters[1]); if (channel == TILT_CHANNEL) { if (isReadCommand(gParameters[1])) { sendInt(currentFrequency); sendAck(); } else { if (!isSafetyOn) { if (isIntWithinRange(frequency, MOTOR_MIN_FREQUENCY, MOTOR_MAX_FREQUENCY)) { setFrequency(frequency); sendAck(); } else { sendIntRangeError(MOTOR_MIN_FREQUENCY, MOTOR_MAX_FREQUENCY, HERTZ_UNIT); } } else { Serial.println(F("Cannot change frequency output while safety is on.")); sendNack(); } } } else { Serial.println(F("Changing or reading of frequency only applies to channel 1")); sendNack(); } } else { sendChannelError(); } }
void sim_band_cb(GtkWidget *widget, gpointer data) { BAND* band; BANDSTACK_ENTRY *entry; fprintf(stderr,"sim_band_cb\n"); int b=band_get_current(); if(function) { b--; if(b<0) { b=BANDS-1; } #ifdef LIMESDR if(protocol!=LIMESDR_PROTOCOL) { if(b==band3400) { b=band6; } } #endif } else { b++; if(b>=BANDS) { b=0; } #ifdef LIMESDR if(protocol!=LIMESDR_PROTOCOL) { if(b==band70) { b=bandGen; } } #endif } band=band_set_current(b); entry=bandstack_entry_get_current(); setFrequency(entry->frequencyA); setMode(entry->mode); FILTER* band_filters=filters[entry->mode]; FILTER* band_filter=&band_filters[entry->filter]; setFilter(band_filter->low,band_filter->high); band=band_get_current_band(); set_alex_rx_antenna(band->alexRxAntenna); set_alex_tx_antenna(band->alexTxAntenna); set_alex_attenuation(band->alexAttenuation); vfo_update(NULL); }
////////////////////////////////////////////////////////////////////////////// // Clear the selected digit and the digits below (i.e. set them to 0) ////////////////////////////////////////////////////////////////////////////// void CFreqCtrl::clearFreq() { if (m_ActiveEditDigit >= 0) { if (m_DigitInfo[m_ActiveEditDigit].editmode) { m_freq -= m_DigitInfo[m_ActiveEditDigit].val * m_DigitInfo[m_ActiveEditDigit].incval; /* digits below the active one are reset to 0 */ m_freq -= m_freq % m_DigitInfo[m_ActiveEditDigit].weight; setFrequency(m_freq); m_LastEditDigit = m_ActiveEditDigit; } } }
//*************************************************************************** void Kwave::PitchShiftPlugin::updateFilter(Kwave::SampleSource *filter, bool force) { double sr = signalRate(); if (!filter) return; if (!qFuzzyCompare(m_frequency, m_last_freq) || force) filter->setAttribute(SLOT(setFrequency(QVariant)), QVariant((m_frequency * 2.0 * M_PI) / sr)); if (!qFuzzyCompare(m_speed, m_last_speed) || force) filter->setAttribute(SLOT(setSpeed(QVariant)), QVariant(m_speed)); m_last_freq = m_frequency; m_last_speed = m_speed; }
//*************************************************************************** void Kwave::NotchFilterPlugin::updateFilter(Kwave::SampleSource *filter, bool force) { double sr = signalRate(); if (!filter) return; if (!qFuzzyCompare(m_frequency, m_last_freq) || force) filter->setAttribute(SLOT(setFrequency(QVariant)), QVariant((m_frequency * 2.0 * M_PI) / sr)); if (!qFuzzyCompare(m_bw, m_last_bw) || force) filter->setAttribute(SLOT(setBandwidth(QVariant)), QVariant((m_bw * 2.0 * M_PI) / sr)); m_last_freq = m_frequency; m_last_bw = m_bw; }
int qtMonitor::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: band_160_buttonPressed(); break; case 1: band_80_buttonPressed(); break; case 2: band_60_buttonPressed(); break; case 3: band_40_buttonPressed(); break; case 4: band_30_buttonPressed(); break; case 5: band_20_buttonPressed(); break; case 6: band_17_buttonPressed(); break; case 7: band_15_buttonPressed(); break; case 8: band_12_buttonPressed(); break; case 9: band_10_buttonPressed(); break; case 10: band_6_buttonPressed(); break; case 11: band_gen_buttonPressed(); break; case 12: mode_lsb_buttonPressed(); break; case 13: mode_usb_buttonPressed(); break; case 14: mode_dsb_buttonPressed(); break; case 15: mode_cwl_buttonPressed(); break; case 16: mode_cwu_buttonPressed(); break; case 17: mode_am_buttonPressed(); break; case 18: connect_buttonPressed(); break; case 19: socketError((*reinterpret_cast< QAbstractSocket::SocketError(*)>(_a[1]))); break; case 20: connected(); break; case 21: socketData(); break; case 22: update(); break; case 23: setMode((*reinterpret_cast< int(*)>(_a[1]))); break; case 24: setFilter((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; case 25: setFrequency((*reinterpret_cast< long long(*)>(_a[1]))); break; case 26: moveFrequency((*reinterpret_cast< int(*)>(_a[1]))); break; case 27: vfo_dialMoved((*reinterpret_cast< int(*)>(_a[1]))); break; case 28: afgain_dialMoved((*reinterpret_cast< int(*)>(_a[1]))); break; case 29: setGain((*reinterpret_cast< int(*)>(_a[1]))); break; case 30: audioChanged((*reinterpret_cast< int(*)>(_a[1]))); break; default: ; } _id -= 31; } return _id; }
Oscillator::Oscillator() : AudioNode() { FrequencyIn = new AudioNodeInput(); FMSourceIn = new AudioNodeInput(); FMAmountIn = new AudioNodeInput(); _period = 0; _phase = 0; _osc = 0; _accumulator = 0; _sample = 0; setFrequency(110.0f); setDetune(0.0f); setBend(0.0f); setPortamento(1); setSemitone(0); setGain(1.0f); // this extends the standard midi frequencies from 128 to 256 discrete values, // extending the frequency range with -117 positions below to 0.00949 Hz // and +11 above to 23679 Hz. for (int i=0; i<=128; i++) { _expFrequency[i] = (int64_t(pow(2,((float(i) - 69.0) / 12.0)) * 440.0) << 32) / SAMPLE_RATE; // divide by sample rate? // Serial.print("_expFrequency["); // Serial.print(i); // Serial.print("] = "); // Serial.println(int(_expFrequency[i] >> 32)); } for (int i=0; i<=128; i++) { _lfoFrequency[i] = (int64_t(pow(2,((double(i) - 117.0 - 69.0) / 12.0)) * 440.0) << 32) / SAMPLE_RATE; // divide by sample rate? } _dir = 1; _indx = 0; _ifrac = 0; _freq0 = 0; _freq1 = 0; _dfreq = 0; _ffrac = 0; _dPhase = 0; _lfo = false; }
ofxSynth::ofxSynth(){ currentFrequency = startFrequency = targetFrequency = 440; setFrequency(440); currentAmp = 0; noteTime = 0; usesEnv = false; gain = 0.1; sustain = 0.5; modEnv.setADSR(44100*0.01, 44100*0.2, 0.0, 44100.0*0.1); env.setADSR(0.01*44100, 0.1*44100, 0.5, 0.93*44100); filter.setup(); setFilter(0.7, 0.5); setFilterLowPass(); waveMode = 0; }
VoiceGenerator::VoiceGenerator(const QAudioFormat &format, qreal frequency, qreal amplitude, QObject *parent) : QIODevice(parent), m_format(format), m_amplitude(0.5) { Q_ASSERT(m_format.sampleSize() % 8 == 0); int sampleBytes = m_format.channels() * (m_format.sampleSize() / 8); // + 1 to round up, just to be sure that all samples fit. qint64 samplesInBuffer = m_format.sampleRate() * BufferSizeMilliseconds / 1000 + 1; qint64 length = samplesInBuffer * sampleBytes; m_buffer.resize(length); m_max_position = 0; m_position = 0; m_amplitude = amplitude; setFrequency(frequency); }
void CubicSDR::setSampleRate(long long rate_in) { sampleRate = rate_in; sdrThread->setSampleRate(sampleRate); setFrequency(frequency); if (rate_in <= CHANNELIZER_RATE_MAX / 8) { appframe->setMainWaterfallFFTSize(512); appframe->getWaterfallDataThread()->getProcessor()->setHideDC(false); spectrumVisualThread->getProcessor()->setHideDC(false); } else if (rate_in <= CHANNELIZER_RATE_MAX) { appframe->setMainWaterfallFFTSize(1024); appframe->getWaterfallDataThread()->getProcessor()->setHideDC(false); spectrumVisualThread->getProcessor()->setHideDC(false); } else if (rate_in > CHANNELIZER_RATE_MAX) { appframe->setMainWaterfallFFTSize(2048); appframe->getWaterfallDataThread()->getProcessor()->setHideDC(true); spectrumVisualThread->getProcessor()->setHideDC(true); } }
DueTimer& DueTimer::start(long microseconds){ /* Start the timer If a period is set, then sets the period and start the timer */ if(microseconds > 0) setPeriod(microseconds); if(_frequency[timer] <= 0) setFrequency(1); NVIC_ClearPendingIRQ(Timers[timer].irq); NVIC_EnableIRQ(Timers[timer].irq); TC_Start(Timers[timer].tc, Timers[timer].channel); return *this; }
void SPIClass::begin() { pinMode(pinSCK, OUTPUT); pinMode(pinMOSI, OUTPUT); pinMode(pinMISO, INPUT); spi->PSELSCK = pinSCK; spi->PSELMOSI = pinMOSI; spi->PSELMISO = pinMISO; // Default speed set to 4Mhz setFrequency(4000); setDataMode(SPI_MODE0); setBitOrder(MSBFIRST); spi->EVENTS_READY = 0; spi->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos); }
void ProcessCallingMessage(int Channel, char *Message) { char Payload[16]; double Frequency; int ImplicitOrExplicit, ErrorCoding, Bandwidth, SpreadingFactor, LowDataRateOptimize; ChannelPrintf(Channel, 4, 1, "Calling message %d bytes ", strlen(Message)); if (sscanf(Message+2, "%15[^,],%lf,%d,%d,%d,%d,%d,%*d", Payload, &Frequency, &ImplicitOrExplicit, &ErrorCoding, &Bandwidth, &SpreadingFactor, &LowDataRateOptimize) == 7) { if (Config.LoRaDevices[Channel].AFC) { double MasterFrequency; sscanf(Config.LoRaDevices[Channel].Frequency, "%lf", &MasterFrequency); Frequency += Config.LoRaDevices[Channel].activeFreq - MasterFrequency; } LogMessage("Ch %d: Calling message, new frequency %7.3lf\n", Channel, Frequency); // Decoded OK setMode(Channel, RF96_MODE_SLEEP); // setFrequency(Channel, Config.LoRaDevices[Channel].activeFreq + ); setFrequency(Channel, Frequency); SetLoRaParameters(Channel, ImplicitOrExplicit, ErrorCoding, Bandwidth, SpreadingFactor, LowDataRateOptimize); setMode(Channel, RF96_MODE_RX_CONTINUOUS); Config.LoRaDevices[Channel].InCallingMode = 1; // ChannelPrintf(Channel, 1, 1, "Channel %d %7.3lfMHz ", Channel, Frequency); } }
/* Enables all the trackers and sets the streaming frequency. Note: Trackers according to VRPN and Trackers as defined by OWL are two entirely different things. */ bool vrpn_Tracker_PhaseSpace::enableTracker(bool enable) { #ifdef DEBUG printf("%s %d\n", __PRETTY_FUNCTION__, enable); #endif if(!owlRunning) return false; // Scale the reports for this tracker to be in meters rather than // in MM, to match the VRPN standard. owlScale(MM_TO_METERS); if(!slave) { int option = enable ? OWL_ENABLE : OWL_DISABLE; owlTracker(0,option); //enables/disables the point tracker if(!owlGetStatus()) return false; //enable/disable the rigid trackers for(int i = 1; i <= numRigids; i++) { owlTracker(i,option); if(!owlGetStatus()) return false; } } if(enable) { setFrequency(frequency); owlSetInteger(OWL_EVENTS, OWL_ENABLE); owlSetInteger(OWL_STREAMING,OWL_ENABLE); if(!owlGetStatus()) return false; printf("Streaming enabled.\n"); } else { owlSetInteger(OWL_EVENTS, OWL_DISABLE); owlSetInteger(OWL_STREAMING,OWL_DISABLE); if(!owlGetStatus()) return false; printf("Streaming disabled.\n"); } return true; }
int testFrequency() { int result = PASS; int hvox = voiceFactory(60, 64, ZEROBIAS, RATE); float freq; int hz; int voxFreq; /* look inside the box */ for (freq = 60; freq < 3200; freq *= 1.1) { hz = (int) freq; setFrequency(hvox, hz, RATE); voxFreq = getFrequency(hvox, RATE); if (abs(hz - voxFreq) > 20) result = FAIL; printf("Test frequency: %i", hz); printf("\tVoice Frequency: %i", voxFreq); printf("\n"); } freeVoice(hvox); return result; }
WirelessAccessPoint::WirelessAccessPoint(const QDBusObjectPath &objectPath, QObject *parent) : QObject(parent), m_objectPath(objectPath), m_securityFlags(0) { QDBusInterface accessPointInterface(serviceString, m_objectPath.path(), accessPointInterfaceString, QDBusConnection::systemBus()); if(!accessPointInterface.isValid()) { qCWarning(dcNetworkManager()) << "Invalid access point dbus interface"; return; } // Init properties setSsid(accessPointInterface.property("Ssid").toString()); setMacAddress(accessPointInterface.property("HwAddress").toString()); setFrequency(accessPointInterface.property("Frequency").toDouble() / 1000); setSignalStrength(accessPointInterface.property("Strength").toUInt()); setSecurityFlags(WirelessAccessPoint::ApSecurityModes(accessPointInterface.property("WpaFlags").toUInt())); setIsProtected((bool)accessPointInterface.property("Flags").toUInt()); QDBusConnection::systemBus().connect(serviceString, objectPath.path(), accessPointInterfaceString, "PropertiesChanged", this, SLOT(onPropertiesChanged(QVariantMap))); }
void LogVariablesWidget::loadSettings(QSettings &pSettings) { pSettings.beginGroup("logVariablesWidget"); restoreGeometry( pSettings.value("geometry").toByteArray() ); setVisible( pSettings.value("visible").toBool() ); for ( int i = 0; i < ui->logVariableTable->rowCount(); ++i ) { if ( pSettings.childGroups().contains(ui->logVariableTable->item(i, 0)->text()) ) { pSettings.beginGroup(ui->logVariableTable->item(i, 0)->text()); setLogVariableChecked( i, true ); setFrequency(i, pSettings.value("frequency", DataRepository::instance()->frequency()).toDouble()); setStartTime(i, pSettings.value("startTime", 0).toDouble()); setDuration(i, pSettings.value("duration", DataRepository::instance()->duration()).toDouble()); pSettings.endGroup(); } } pSettings.endGroup(); }
void RecurrenceWidget::set(bool recurring, int frequency, QString period, QDateTime start, QDateTime end, int max) { if (DEBUG) qDebug() << objectName() << "::set(" << recurring << ", " << frequency << ", " << period << ", " << start << ", " << end << ", " << max << ") entered"; setRecurring(recurring); setPeriod(period); setFrequency(frequency); setStartDateTime(start); setEndDateTime(end); setMax(max); _prevEndDateTime = end.isValid() ? end : _eot ; _prevFrequency = frequency; _prevPeriod = stringToPeriod(period); _prevRecurring = recurring; _prevStartDateTime = start; _prevMax = max; }
GtkWidget* vfo_init(int width,int height,GtkWidget *parent) { fprintf(stderr,"vfo_init: width=%d height=%d\n", width, height); parent_window=parent; my_width=width; my_height=height; vfo = gtk_drawing_area_new (); gtk_widget_set_size_request (vfo, width, height); /* Signals used to handle the backing surface */ g_signal_connect (vfo, "draw", G_CALLBACK (vfo_draw_cb), NULL); g_signal_connect (vfo,"configure-event", G_CALLBACK (vfo_configure_event_cb), NULL); /* Event signals */ g_signal_connect (vfo, "button-press-event", G_CALLBACK (vfo_press_event_cb), NULL); g_signal_connect(vfo,"scroll_event", G_CALLBACK(vfo_scroll_event_cb),NULL); gtk_widget_set_events (vfo, gtk_widget_get_events (vfo) | GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK); fprintf(stderr,"vfo_init: set Frequency,Mode,Filter\n"); BAND *band=band_get_current_band(); BANDSTACK_ENTRY* entry=bandstack_entry_get_current(); setFrequency(entry->frequencyA); setMode(entry->mode); FILTER* band_filters=filters[entry->mode]; FILTER* band_filter=&band_filters[entry->filter]; setFilter(band_filter->low,band_filter->high); set_alex_rx_antenna(band->alexRxAntenna); set_alex_tx_antenna(band->alexTxAntenna); set_alex_attenuation(band->alexAttenuation); return vfo; }