From 91661c1d951fb9aba67632d449b388bb5029c13d Mon Sep 17 00:00:00 2001
From: Brian Moran <brianmoran@gmail.com>
Date: Tue, 3 Sep 2024 13:09:36 -0700
Subject: [PATCH] show freq of regular fox verification msg
---
Network/FoxVerifier.cpp | 14 +-
Network/FoxVerifier.hpp | 9 +-
widgets/mainwindow.cpp | 29 +-
widgets/mainwindow.cppNEW | 11459 ++++++++++++++++++++++++++++++++++++
widgets/mainwindow.h | 2 +-
5 files changed, 11492 insertions(+), 21 deletions(-)
create mode 100644 widgets/mainwindow.cppNEW
diff --git a/Network/FoxVerifier.cpp b/Network/FoxVerifier.cpp
index 87d0715e8..51cdddf23 100644
--- a/Network/FoxVerifier.cpp
+++ b/Network/FoxVerifier.cpp
@@ -1,7 +1,7 @@
#include "FoxVerifier.hpp"
#include "Logger.hpp"
-FoxVerifier::FoxVerifier(QString user_agent, QNetworkAccessManager *manager,QString base_url, QString callsign, QDateTime timestamp, QString code) : QObject(nullptr)
+FoxVerifier::FoxVerifier(QString user_agent, QNetworkAccessManager *manager,QString base_url, QString callsign, QDateTime timestamp, QString code, unsigned int hz=750) : QObject(nullptr)
{
manager_ = manager;
finished_ = false;
@@ -9,6 +9,7 @@ FoxVerifier::FoxVerifier(QString user_agent, QNetworkAccessManager *manager,QStr
callsign_ = callsign;
code_ = code;
ts_ = timestamp;
+ hz_ = hz;
QString url = QString("%1/check/%2/%3/%4.text").arg(base_url).arg(callsign).arg(timestamp.toString(Qt::ISODate)).arg(code);
LOG_INFO(QString("FoxVerifier: url %1").arg(url).toStdString());
@@ -72,14 +73,14 @@ void FoxVerifier::httpFinished()
if (reply_->error() != QNetworkReply::NoError) {
LOG_INFO(QString("FoxVerifier: httpFinished error:[%1 - %2] msg:[%3]").arg(status).arg(reason).arg(reply_->errorString()).toStdString());
reply_->abort();
- emit verifyError(status, ts_, callsign_, code_, reply_->errorString());
+ emit verifyError(status, ts_, callsign_, code_, hz_, reply_->errorString());
}
return_value = reply_->read(1024); // limit amount we get
LOG_INFO(QString("FoxVerifier: httpFinished status:[%1 - %2] body:[%3] ").arg(status).arg(reason).arg(return_value).toStdString());
finished_ = true;
reply_->deleteLater();
if (status >= 200 && status <= 299) {
- emit verifyComplete(status, ts_, callsign_, code_, return_value);
+ emit verifyComplete(status, ts_, callsign_, code_, hz_, return_value);
}
}
@@ -97,15 +98,16 @@ void FoxVerifier::httpEncrypted() {
LOG_INFO("FoxVerifier: httpEncrypted");
}
-QString FoxVerifier::formatDecodeMessage(QDateTime ts, QString callsign, QString const& verify_message) {
+QString FoxVerifier::formatDecodeMessage(QDateTime ts, QString callsign, unsigned int hz_, QString const& verify_message) {
//"172100 -00 0.0 750 ~ K8R VERIFIED"
QTime rx_time = ts.time();
+ QString hz=QString("%1").arg(hz_, 4, 10 ); // insert Hz
if (verify_message.endsWith(" VERIFIED")) {
- return QString("%1 -00 0.0 750 ~ %2 VERIFIED").arg(rx_time.toString("hhmmss")).arg(callsign);
+ return QString("%1 0 0.0 %2 ~ %3 VERIFIED").arg(rx_time.toString("hhmmss")).arg(hz).arg(callsign);
} else
if (verify_message.endsWith(" INVALID"))
{
- return QString("%1 0 0.0 750 ~ %2 INVALID").arg(rx_time.toString("hhmmss")).arg(callsign);
+ return QString("%1 0 0.0 %2 ~ %3 INVALID").arg(rx_time.toString("hhmmss")).arg(hz).arg(callsign);
}
else
return QString{};
diff --git a/Network/FoxVerifier.hpp b/Network/FoxVerifier.hpp
index 920fbf0bf..8a867f1ef 100644
--- a/Network/FoxVerifier.hpp
+++ b/Network/FoxVerifier.hpp
@@ -16,12 +16,12 @@ class FoxVerifier : public QObject {
QMutex mutex_;
public:
- explicit FoxVerifier(QString user_agent, QNetworkAccessManager *manager, QString base_url, QString callsign, QDateTime timestamp, QString code);
+ explicit FoxVerifier(QString user_agent, QNetworkAccessManager *manager, QString base_url, QString callsign, QDateTime timestamp, QString code, unsigned int);
~FoxVerifier();
QString return_value;
bool finished();
- static QString formatDecodeMessage(QDateTime ts, QString callsign, QString const& verify_message);
+ static QString formatDecodeMessage(QDateTime ts, QString callsign, unsigned int hz, QString const& verify_message);
static QString default_url();
private:
@@ -31,6 +31,7 @@ private:
QUrl q_url_;
bool finished_;
bool errored_;
+ unsigned int hz_;
QString error_reason_;
QDateTime ts_;
QString callsign_;
@@ -54,8 +55,8 @@ private slots:
public slots:
signals:
- void verifyComplete(int status, QDateTime ts, QString callsign, QString code, QString const& response);
- void verifyError(int status, QDateTime ts, QString callsign, QString code, QString const& response);
+ void verifyComplete(int status, QDateTime ts, QString callsign, QString code, unsigned int hz, QString const& response);
+ void verifyError(int status, QDateTime ts, QString callsign, QString code, unsigned int hz, QString const& response);
};
diff --git a/widgets/mainwindow.cpp b/widgets/mainwindow.cpp
index cd1503011..7ffee16be 100644
--- a/widgets/mainwindow.cpp
+++ b/widgets/mainwindow.cpp
@@ -2494,11 +2494,10 @@ void MainWindow::keyPressEvent (QKeyEvent * e)
QMainWindow::keyPressEvent (e);
}
-void MainWindow::handleVerifyMsg(int status, QDateTime ts, QString callsign, QString code, QString const &response) {
- (void)status;
+void MainWindow::handleVerifyMsg(int status, QDateTime ts, QString callsign, QString code, unsigned int hz, QString const &response) { (void)status;
(void)code;
if (response.length() > 0) {
- QString msg = FoxVerifier::formatDecodeMessage(ts, callsign, response);
+ QString msg = FoxVerifier::formatDecodeMessage(ts, callsign, hz, response);
if (msg.length() > 0)
ui->decodedTextBrowser->displayDecodedText(DecodedText{msg}, m_config.my_callsign(), m_mode, m_config.DXCC(),
m_logBook, m_currentBand, m_config.ppfx());
@@ -4293,6 +4292,7 @@ void MainWindow::readFromStdout() //readFromStdout
}
} else {
+#ifdef FOX_OTP
// remove verifications that are done
QMutableListIterator < FoxVerifier * > it(m_verifications);
while (it.hasNext()) {
@@ -4300,34 +4300,38 @@ void MainWindow::readFromStdout() //readFromStdout
it.remove();
}
}
-
+#endif
DecodedText decodedtext1 = decodedtext0;
if ((m_mode == "FT4" or m_mode == "FT8") and bDisplayPoints and decodedtext1.isStandardMessage()) {
ARRL_Digi_Update(decodedtext1);
}
+#ifdef FOX_OTP
if ((SpecOp::HOUND == m_specOp) &&
((m_config.superFox() && (decodedtext0.mid(24, 8) == "$VERIFY$")) || // $VERIFY$ K8R 920749
- (decodedtext0.mid(24, 8).contains(QRegularExpression{"^[A-Z0-9]{2,5}\\.V[0-9]{6}$"})))) // K8R.V920749
+ (decodedtext0.mid(24,-1).contains(QRegularExpression{"^[A-Z0-9]{2,5}\\.V[0-9]{6}"})))) // K8R.V920749
{
// two cases:
// QString test_return = QString{"203630 -12 0.1 775 ~ K8R.V920749"};
// $VERIFY$ foxcall otp
// QString test_return = QString{"203630 -12 0.1 775 ~ $VERIFY$ K8R 920749"};
QStringList lineparts;
- QStringList otp_parts;
QString callsign, otp;
+ unsigned int hz;
lineparts = decodedtext0.string().split(' ', SkipEmptyParts);
if (lineparts.length() <= 6) {
+ QStringList otp_parts;
// split K8R.V920749 into K8R and 920749
otp_parts = lineparts[5].split('.', SkipEmptyParts);
callsign = otp_parts[0];
otp = otp_parts[1].mid(1); // remove the V
+ hz = lineparts[3].toInt();
} else
{
// split $VERIFY$ K8R 920749 into K8R and 920749
callsign = lineparts[6];
otp = lineparts[7];
+ hz = 750; // SF is 750
}
QDateTime verifyDateTime;
if (m_diskData) {
@@ -4341,11 +4345,13 @@ void MainWindow::readFromStdout() //readFromStdout
FOXVERIFIER_DEFAULT_BASE_URL,
callsign, // foxcall
verifyDateTime,
- otp); // otp
+ otp,
+ hz); // freq
connect(fv, &FoxVerifier::verifyComplete, this, &MainWindow::handleVerifyMsg);
m_verifications << fv;
- } else {
-
+ }
+#endif
+ {
if (ui->labDXped->text() == "Super Hound" && decodedtext0.mid(3, 18).contains(" verified")) {
verified = true;
write_all("Vf",decodedtext0.string());
@@ -10201,7 +10207,7 @@ void MainWindow::on_comboBoxHoundSort_activated(int index)
{
if(index!=-99) houndCallers(); //Silence compiler warning
}
-
+#ifdef FOX_OTP
QString MainWindow::foxOTPcode()
{
QString code;
@@ -10228,6 +10234,7 @@ QString MainWindow::foxOTPcode()
}
return code;
}
+#endif
//------------------------------------------------------------------------------
QString MainWindow::sortHoundCalls(QString t, int isort, int max_dB)
@@ -10602,6 +10609,7 @@ void MainWindow::foxTxSequencer()
goto Transmit;
}
+#ifdef FOX_OTP
// Send OTP message maybe for regular fox mode
if (!m_config.superFox() && m_config.OTPEnabled() && (islot < m_Nslots) && (m_tFoxTxSinceOTP >= m_config.OTPinterval()))
{
@@ -10612,6 +10620,7 @@ void MainWindow::foxTxSequencer()
islot++;
foxGenWaveform(islot - 1, fm);
}
+#endif
//Compile list1: up to NSLots Hound calls to be sent RR73
for(QString hc: m_foxQSO.keys()) { //Check all Hound calls: First priority
diff --git a/widgets/mainwindow.cppNEW b/widgets/mainwindow.cppNEW
new file mode 100644
index 000000000..b4ed39448
--- /dev/null
+++ b/widgets/mainwindow.cppNEW
@@ -0,0 +1,11459 @@
+//---------------------------------------------------------- MainWindow
+#include "mainwindow.h"
+
+#include <cinttypes>
+#include <cstring>
+#include <cmath>
+#include <limits>
+#include <functional>
+#include <fstream>
+#include <iterator>
+#include <algorithm>
+#include <fftw3.h>
+#include <QApplication>
+#include <QStringListModel>
+#include <QSettings>
+#include <QKeyEvent>
+#include <QProcessEnvironment>
+#include <QSharedMemory>
+#include <QFileDialog>
+#include <QTextBlock>
+#include <QProgressBar>
+#include <QLineEdit>
+#include <QRegExpValidator>
+#include <QRegExp>
+#include <QRegularExpression>
+#include <QDesktopServices>
+#include <QUrl>
+#include <QStandardPaths>
+#include <QDir>
+#include <QDebug>
+#include <QtConcurrent/QtConcurrentRun>
+#include <QProgressDialog>
+#include <QHostInfo>
+#include <QVector>
+#include <QCursor>
+#include <QToolTip>
+#include <QAction>
+#include <QButtonGroup>
+#include <QActionGroup>
+#include <QSplashScreen>
+#include <QUdpSocket>
+#include <QAbstractItemView>
+#include <QInputDialog>
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+#include <QRandomGenerator>
+#endif
+
+#include "helper_functions.h"
+#include "revision_utils.hpp"
+#include "qt_helpers.hpp"
+#include "Network/NetworkAccessManager.hpp"
+#include "Audio/soundout.h"
+#include "Audio/soundin.h"
+#include "Modulator/Modulator.hpp"
+#include "Detector/Detector.hpp"
+#include "plotter.h"
+#include "echoplot.h"
+#include "echograph.h"
+#include "fastplot.h"
+#include "fastgraph.h"
+#include "foxotpcode.h"
+#include "about.h"
+#include "messageaveraging.h"
+#include "activeStations.h"
+#include "colorhighlighting.h"
+#include "widegraph.h"
+#include "sleep.h"
+#include "logqso.h"
+#include "Decoder/decodedtext.h"
+#include "Radio.hpp"
+#include "models/Bands.hpp"
+#include "Transceiver/TransceiverFactory.hpp"
+#include "models/StationList.hpp"
+#include "validators/LiveFrequencyValidator.hpp"
+#include "Network/MessageClient.hpp"
+#include "Network/FoxVerifier.hpp"
+#include "Network/wsprnet.h"
+#include "signalmeter.h"
+#include "HelpTextWindow.hpp"
+#include "SampleDownloader.hpp"
+#include "Audio/BWFFile.hpp"
+#include "MultiSettings.hpp"
+#include "validators/MaidenheadLocatorValidator.hpp"
+#include "validators/CallsignValidator.hpp"
+#include "EqualizationToolsDialog.hpp"
+#include "Network/LotWUsers.hpp"
+#include "logbook/AD1CCty.hpp"
+#include "models/FoxLog.hpp"
+#include "models/CabrilloLog.hpp"
+#include "FoxLogWindow.hpp"
+#include "CabrilloLogWindow.hpp"
+#include "ExportCabrillo.h"
+#include "ui_mainwindow.h"
+#include "moc_mainwindow.cpp"
+#include "Logger.hpp"
+
+#define FCL fortran_charlen_t
+
+extern "C" {
+ //----------------------------------------------------- C and Fortran routines
+ void symspec_(struct dec_data *, int* k, double* trperiod, int* nsps, int* ingain,
+ bool* bLowSidelobes, int* minw, float* px, float s[], float* df3,
+ int* nhsym, int* npts8, float *m_pxmax, int* npct);
+
+ void hspec_(short int d2[], int* k, int* nutc0, int* ntrperiod, int* nrxfreq, int* ntol,
+ bool* bmsk144, bool* btrain, double const pcoeffs[], int* ingain,
+ char const * mycall, char const * hiscall, bool* bshmsg, bool* bswl,
+ char const * ddir, float green[],
+ float s[], int* jh, float *pxmax, float *rmsNoGain, char line[],
+ fortran_charlen_t, fortran_charlen_t, fortran_charlen_t, fortran_charlen_t);
+
+ void genft8_(char* msg, int* i3, int* n3, char* msgsent, char ft8msgbits[],
+ int itone[], fortran_charlen_t, fortran_charlen_t);
+
+ void genft4_(char* msg, int* ichk, char* msgsent, char ft4msgbits[], int itone[],
+ fortran_charlen_t, fortran_charlen_t);
+
+ void genfst4_(char* msg, int* ichk, char* msgsent, char fst4msgbits[],
+ int itone[], int* iwspr, fortran_charlen_t, fortran_charlen_t);
+
+ void gen_ft8wave_(int itone[], int* nsym, int* nsps, float* bt, float* fsample, float* f0,
+ float xjunk[], float wave[], int* icmplx, int* nwave);
+
+ void gen_ft4wave_(int itone[], int* nsym, int* nsps, float* fsample, float* f0,
+ float xjunk[], float wave[], int* icmplx, int* nwave);
+
+ void gen_fst4wave_(int itone[], int* nsym, int* nsps, int* nwave, float* fsample,
+ int* hmod, float* f0, int* icmplx, float xjunk[], float wave[]);
+
+ void genwave_(int itone[], int* nsym, int* nsps, int* nwave, float* fsample,
+ int* hmod, float* f0, int* icmplx, float xjunk[], float wave[]);
+
+ void gen4_(char* msg, int* ichk, char* msgsent, int itone[],
+ int* itext, fortran_charlen_t, fortran_charlen_t);
+
+ void gen9_(char* msg, int* ichk, char* msgsent, int itone[],
+ int* itext, fortran_charlen_t, fortran_charlen_t);
+
+ void genmsk_128_90_(char* msg, int* ichk, char* msgsent, int itone[], int* itype,
+ fortran_charlen_t, fortran_charlen_t);
+
+ void gen65(char* msg, int* ichk, char msgsent[], int itone[], int* itext);
+
+ void genq65_(char* msg, int* ichk, char* msgsent, int itone[],
+ int* i3, int* n3, fortran_charlen_t, fortran_charlen_t);
+
+ void genwspr_(char* msg, char* msgsent, int itone[], fortran_charlen_t, fortran_charlen_t);
+
+ void azdist_(char* MyGrid, char* HisGrid, double* utch, int* nAz, int* nEl,
+ int* nDmiles, int* nDkm, int* nHotAz, int* nHotABetter,
+ fortran_charlen_t, fortran_charlen_t);
+
+ void morse_(char* msg, int* icw, int* ncw, fortran_charlen_t);
+
+ void wspr_downsample_(short int d2[], int* k);
+
+ int savec2_(char const * fname, int* TR_seconds, double* dial_freq, fortran_charlen_t);
+
+ void save_echo_params_(int* ndoptotal, int* ndop, int* nfrit, float* f1, float* fspread, short id2[], int* idir);
+
+ void avecho_( short id2[], int* dop, int* nfrit, int* nauto, int* navg, int* nqual, float* f1,
+ float* level, float* sigdb, float* snr, float* dfreq,
+ float* width, bool* bDiskData);
+
+ void fast_decode_(short id2[], int narg[], double * trperiod,
+ char msg[], char mycall[], char hiscall[],
+ fortran_charlen_t, fortran_charlen_t, fortran_charlen_t);
+ void degrade_snr_(short d2[], int* n, float* db, float* bandwidth);
+
+ void wav12_(short d2[], short d1[], int* nbytes, short* nbitsam2);
+
+ void refspectrum_(short int d2[], bool* bclearrefspec,
+ bool* brefspec, bool* buseref, const char* c_fname, fortran_charlen_t);
+
+ void freqcal_(short d2[], int* k, int* nkhz,int* noffset, int* ntol,
+ char line[], fortran_charlen_t);
+
+ void calibrate_(char const * data_dir, int* iz, double* a, double* b, double* rms,
+ double* sigmaa, double* sigmab, int* irc, fortran_charlen_t);
+
+ void foxgen_(bool* bSuperFox, char const * fname, FCL len);
+
+ void sfox_wave_gfsk_(char const * fname, FCL len);
+
+ void plotsave_(float swide[], int* m_w , int* m_h1, int* irow);
+
+ void chk_samples_(int* m_ihsym,int* k, int* m_hsymStop);
+
+ void save_dxbase_(char* dxbase, FCL len);
+
+ void indexx_(float arr[], int* n, int indx[]);
+
+ void get_q3list_(char* fname, bool* bDiskData, int* nlist, char* list, FCL len1, FCL len2);
+
+ void rm_q3list_(char* callsign, FCL len);
+
+ void jpl_setup_(char* fname, FCL len);
+}
+QList<FoxVerifier *> m_verifications;
+int volatile itone[MAX_NUM_SYMBOLS]; //Audio tones for all Tx symbols
+int volatile itone0[MAX_NUM_SYMBOLS]; //Dummy array, data not actually used
+int volatile icw[NUM_CW_SYMBOLS]; //Dits for CW ID
+dec_data_t dec_data; // for sharing with Fortran
+int outBufSize;
+int rc;
+qint32 g_iptt {0};
+wchar_t buffer[256];
+float fast_green[703];
+float fast_green2[703];
+float fast_s[44992]; //44992=64*703
+float fast_s2[44992];
+int fast_jh {0};
+int fast_jhpeak {0};
+int fast_jh2 {0};
+int narg[15];
+QVector<QColor> g_ColorTbl;
+
+using SpecOp = Configuration::SpecialOperatingActivity;
+
+bool verified = false;
+bool blocked = false;
+bool m_displayBand = false;
+bool no_a7_decodes = false;
+bool keep_frequency = false;
+int m_Nslots0 {1};
+int m_TxFreqFox {300};
+
+QSharedMemory mem_qmap("mem_qmap"); //Memory segment to be shared (optionally) with QMAP
+struct {
+ int ndecodes; //Number of QMAP decodes available (so far)
+ int ncand; //Number of QMAP candidates considered for decoding
+ int nQDecoderDone; //QMAP decoder is finished (0 or 1)
+ int nWDecoderBusy; //WSJT-X decoder is busy (0 or 1)
+ int nWTransmitting; //WSJT-X is transmitting (0 or 1)
+ int kHzRequested; //Integer kHz dial frequency requested from QMAP
+ char result[50][64]; //Decodes as character*64 arrays
+} qmapcom;
+int* ipc_qmap;
+
+namespace
+{
+ Radio::Frequency constexpr default_frequency {14074000};
+ QRegExp message_alphabet {"[- @A-Za-z0-9+./?#<>;$]*"};
+ // grid exact match excluding RR73
+ QRegularExpression grid_regexp {"\\A(?![Rr]{2}73)[A-Ra-r]{2}[0-9]{2}([A-Xa-x]{2}){0,1}\\z"};
+ QRegularExpression non_r_db_regexp {"\\A[-+]{1}[0-9]{1,2}\\z"};
+ auto quint32_max = std::numeric_limits<quint32>::max ();
+ constexpr int N_WIDGETS {38};
+ constexpr int default_rx_audio_buffer_frames {-1}; // lets Qt decide
+ constexpr int default_tx_audio_buffer_frames {-1}; // lets Qt decide
+
+ bool message_is_73 (int type, QStringList const& msg_parts)
+ {
+ return type >= 0
+ && (((type < 6 || 7 == type)
+ && (msg_parts.contains ("73") || msg_parts.contains ("RR73")))
+ || (type == 6 && !msg_parts.filter ("73").isEmpty ()));
+ }
+
+ int ms_minute_error ()
+ {
+ auto const& now = QDateTime::currentDateTimeUtc ();
+ auto const& time = now.time ();
+ auto second = time.second ();
+ return now.msecsTo (now.addSecs (second > 30 ? 60 - second : -second)) - time.msec ();
+ }
+}
+
+//--------------------------------------------------- MainWindow constructor
+MainWindow::MainWindow(QDir const& temp_directory, bool multiple,
+ MultiSettings * multi_settings, QSharedMemory *shdmem,
+ unsigned downSampleFactor,
+ QSplashScreen * splash, QProcessEnvironment const& env, QWidget *parent) :
+ MultiGeometryWidget {parent},
+ m_env {env},
+ m_network_manager {this},
+ m_valid {true},
+ m_splash {splash},
+ m_revision {revision ()},
+ m_multiple {multiple},
+ m_multi_settings {multi_settings},
+ m_configurations_button {0},
+ m_settings {multi_settings->settings ()},
+ ui(new Ui::MainWindow),
+ m_config {&m_network_manager, temp_directory, m_settings, &m_logBook, this},
+ m_logBook {&m_config},
+ m_WSPR_band_hopping {m_settings, &m_config, this},
+ m_WSPR_tx_next {false},
+ m_rigErrorMessageBox {MessageBox::Critical, tr ("Rig Control Error")
+ , MessageBox::Cancel | MessageBox::Ok | MessageBox::Retry},
+ m_wideGraph (new WideGraph(m_settings)),
+ m_echoGraph (new EchoGraph(m_settings)),
+ m_fastGraph (new FastGraph(m_settings)),
+ // no parent so that it has a taskbar icon
+ m_logDlg (new LogQSO (program_title (), m_settings, &m_config, &m_logBook, nullptr)),
+ m_lastDialFreq {0},
+ m_dialFreqRxWSPR {0},
+ m_detector {new Detector {RX_SAMPLE_RATE, double(NTMAX), downSampleFactor}},
+ m_FFTSize {6192 / 2}, // conservative value to avoid buffer overruns
+ m_soundInput {new SoundInput},
+ m_modulator {new Modulator {TX_SAMPLE_RATE, NTMAX}},
+ m_soundOutput {new SoundOutput},
+ m_rx_audio_buffer_frames {0},
+ m_tx_audio_buffer_frames {0},
+ m_msErase {0},
+ m_secBandChanged {0},
+ m_freqNominal {0},
+ m_freqNominalPeriod {0},
+ m_freqTxNominal {0},
+ m_reverse_Doppler {"1" == env.value ("WSJT_REVERSE_DOPPLER", "0")},
+ m_tRemaining {0.},
+ m_TRperiod {60.0},
+ m_DTtol {3.0},
+ m_waterfallAvg {1},
+ m_ntx {1},
+ m_gen_message_is_cq {false},
+ m_send_RR73 {false},
+ m_XIT {0},
+ m_sec0 {-1},
+ m_RxLog {1}, //Write Date and Time to RxLog
+ m_nutc0 {999999},
+ m_ntr {0},
+ m_tx {0},
+ m_inGain {0},
+ m_secID {0},
+ m_idleMinutes {0},
+ m_nSubMode {0},
+ m_nSubMode_Q65 {0},
+ m_nSubMode_JT65 {0},
+ m_nSubMode_JT4 {0},
+ m_nclearave {1},
+ m_nWSPRdecodes {0},
+ m_k0 {9999999},
+ m_nPick {0},
+ m_frequency_list_fcal_iter {m_config.frequencies ()->begin ()},
+ m_nTx73 {0},
+ m_btxok {false},
+ m_diskData {false},
+ m_loopall {false},
+ m_txFirst {false},
+ m_auto {false},
+ m_restart {false},
+ m_startAnother {false},
+ m_saveDecoded {false},
+ m_saveAll {false},
+ m_widebandDecode {false},
+ m_dataAvailable {false},
+ m_decodedText2 {false},
+ m_freeText {false},
+ m_sentFirst73 {false},
+ m_currentMessageType {-1},
+ m_lastMessageType {-1},
+ m_bShMsgs {false},
+ m_bSWL {false},
+ m_uploading {false},
+ m_grid6 {false},
+ m_tuneup {false},
+ m_bTxTime {false},
+ m_rxDone {true},
+ m_bSimplex {false},
+ m_bEchoTxOK {false},
+ m_bTransmittedEcho {false},
+ m_bEchoTxed {false},
+ m_bFastDecodeCalled {false},
+ m_bDoubleClickAfterCQnnn {false},
+ m_bRefSpec {false},
+ m_bClearRefSpec {false},
+ m_bTrain {false},
+ m_bAutoReply {false},
+ m_QSOProgress {CALLING},
+ m_ihsym {0},
+ m_nzap {0},
+ m_px {0.0},
+ m_iptt0 {0},
+ m_btxok0 {false},
+ m_nsendingsh {0},
+ m_onAirFreq0 {0.0},
+ m_first_error {true},
+ tx_status_label {tr ("Receiving")},
+ wsprNet {new WSPRNet {&m_network_manager, this}},
+ m_baseCall {Radio::base_callsign (m_config.my_callsign ())},
+ m_appDir {QApplication::applicationDirPath ()},
+ m_cqStr {""},
+ m_palette {"Linrad"},
+ m_mode {"FT8"},
+ m_rpt {"-15"},
+ m_pfx {
+ "1A", "1S",
+ "3A", "3B6", "3B8", "3B9", "3C", "3C0", "3D2", "3D2C",
+ "3D2R", "3DA", "3V", "3W", "3X", "3Y", "3YB", "3YP",
+ "4J", "4L", "4S", "4U1I", "4U1U", "4W", "4X",
+ "5A", "5B", "5H", "5N", "5R", "5T", "5U", "5V", "5W", "5X", "5Z",
+ "6W", "6Y",
+ "7O", "7P", "7Q", "7X",
+ "8P", "8Q", "8R",
+ "9A", "9G", "9H", "9J", "9K", "9L", "9M2", "9M6", "9N",
+ "9Q", "9U", "9V", "9X", "9Y",
+ "A2", "A3", "A4", "A5", "A6", "A7", "A9", "AP",
+ "BS7", "BV", "BV9", "BY",
+ "C2", "C3", "C5", "C6", "C9", "CE", "CE0X", "CE0Y",
+ "CE0Z", "CE9", "CM", "CN", "CP", "CT", "CT3", "CU",
+ "CX", "CY0", "CY9",
+ "D2", "D4", "D6", "DL", "DU",
+ "E3", "E4", "E5", "EA", "EA6", "EA8", "EA9", "EI", "EK",
+ "EL", "EP", "ER", "ES", "ET", "EU", "EX", "EY", "EZ",
+ "F", "FG", "FH", "FJ", "FK", "FKC", "FM", "FO", "FOA",
+ "FOC", "FOM", "FP", "FR", "FRG", "FRJ", "FRT", "FT5W",
+ "FT5X", "FT5Z", "FW", "FY",
+ "M", "MD", "MI", "MJ", "MM", "MU", "MW",
+ "H4", "H40", "HA", "HB", "HB0", "HC", "HC8", "HH",
+ "HI", "HK", "HK0", "HK0M", "HL", "HM", "HP", "HR",
+ "HS", "HV", "HZ",
+ "I", "IS", "IS0",
+ "J2", "J3", "J5", "J6", "J7", "J8", "JA", "JDM",
+ "JDO", "JT", "JW", "JX", "JY",
+ "K", "KC4", "KG4", "KH0", "KH1", "KH2", "KH3", "KH4", "KH5",
+ "KH5K", "KH6", "KH7", "KH8", "KH9", "KL", "KP1", "KP2",
+ "KP4", "KP5",
+ "LA", "LU", "LX", "LY", "LZ",
+ "OA", "OD", "OE", "OH", "OH0", "OJ0", "OK", "OM", "ON",
+ "OX", "OY", "OZ",
+ "P2", "P4", "PA", "PJ2", "PJ7", "PY", "PY0F", "PT0S", "PY0T", "PZ",
+ "R1F", "R1M",
+ "S0", "S2", "S5", "S7", "S9", "SM", "SP", "ST", "SU",
+ "SV", "SVA", "SV5", "SV9",
+ "T2", "T30", "T31", "T32", "T33", "T5", "T7", "T8", "T9", "TA",
+ "TF", "TG", "TI", "TI9", "TJ", "TK", "TL", "TN", "TR", "TT",
+ "TU", "TY", "TZ",
+ "UA", "UA2", "UA9", "UK", "UN", "UR",
+ "V2", "V3", "V4", "V5", "V6", "V7", "V8", "VE", "VK", "VK0H",
+ "VK0M", "VK9C", "VK9L", "VK9M", "VK9N", "VK9W", "VK9X", "VP2E",
+ "VP2M", "VP2V", "VP5", "VP6", "VP6D", "VP8", "VP8G", "VP8H",
+ "VP8O", "VP8S", "VP9", "VQ9", "VR", "VU", "VU4", "VU7",
+ "XE", "XF4", "XT", "XU", "XW", "XX9", "XZ",
+ "YA", "YB", "YI", "YJ", "YK", "YL", "YN", "YO", "YS", "YU", "YV", "YV0",
+ "Z2", "Z3", "ZA", "ZB", "ZC4", "ZD7", "ZD8", "ZD9", "ZF", "ZK1N",
+ "ZK1S", "ZK2", "ZK3", "ZL", "ZL7", "ZL8", "ZL9", "ZP", "ZS", "ZS8"
+ },
+ m_sfx {"P", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A"},
+ mem_jt9 {shdmem},
+ m_downSampleFactor (downSampleFactor),
+ m_audioThreadPriority (QThread::HighPriority),
+ m_bandEdited {false},
+ m_splitMode {false},
+ m_monitoring {false},
+ m_tx_when_ready {false},
+ m_transmitting {false},
+ m_tune {false},
+ m_tx_watchdog {false},
+ m_block_pwr_tooltip {false},
+ m_PwrBandSetOK {true},
+ m_lastMonitoredFrequency {default_frequency},
+ m_toneSpacing {0.},
+ m_firstDecode {0},
+ m_optimizingProgress {"Optimizing decoder FFTs for your CPU.\n"
+ "Please be patient,\n"
+ "this may take a few minutes", QString {}, 0, 1, this},
+ m_messageClient {new MessageClient {QApplication::applicationName (),
+ version (), revision (),
+ m_config.udp_server_name (), m_config.udp_server_port (),
+ m_config.udp_interface_names (), m_config.udp_TTL (),
+ this}},
+ m_psk_Reporter {&m_config, QString {"WSJT-X v" + version () + " " + m_revision}.simplified ()},
+ m_manual {&m_network_manager},
+ m_block_udp_status_updates {false}
+{
+ ui->setupUi(this);
+ setUnifiedTitleAndToolBarOnMac (true);
+ createStatusBar();
+ add_child_to_event_filter (this);
+ ui->dxGridEntry->setValidator (new MaidenheadLocatorValidator {this});
+ ui->dxCallEntry->setValidator (new CallsignValidator {this});
+ ui->sbTR->values ({5, 10, 15, 30, 60, 120, 300, 900, 1800});
+ ui->sbTR_FST4W->values ({120, 300, 900, 1800});
+ ui->decodedTextBrowser->set_configuration (&m_config, true);
+ ui->decodedTextBrowser2->set_configuration (&m_config);
+
+ m_optimizingProgress.setWindowModality (Qt::WindowModal);
+ m_optimizingProgress.setAutoReset (false);
+ m_optimizingProgress.setMinimumDuration (15000); // only show after 15s delay
+
+ //Attach or create a memory segment to be shared with QMAP.
+ int memSize=4096;
+ if(!mem_qmap.attach()) mem_qmap.create(memSize);
+ ipc_qmap = (int*)mem_qmap.data();
+ mem_qmap.lock();
+ memset(ipc_qmap,0,memSize); //Zero all of QMAP shared memory
+ mem_qmap.unlock();
+
+ // Closedown.
+ connect (ui->actionExit, &QAction::triggered, this, &QMainWindow::close);
+
+ // parts of the rig error message box that are fixed
+ m_rigErrorMessageBox.setInformativeText (tr ("Do you want to reconfigure the radio interface?"));
+ m_rigErrorMessageBox.setDefaultButton (MessageBox::Ok);
+
+ // start audio thread and hook up slots & signals for shutdown management
+ // these objects need to be in the audio thread so that invoking
+ // their slots is done in a thread safe way
+ m_soundOutput->moveToThread (&m_audioThread);
+ m_modulator->moveToThread (&m_audioThread);
+ m_soundInput->moveToThread (&m_audioThread);
+ m_detector->moveToThread (&m_audioThread);
+ bool ok;
+ auto buffer_size = env.value ("WSJT_RX_AUDIO_BUFFER_FRAMES", "0").toInt (&ok);
+ m_rx_audio_buffer_frames = ok && buffer_size ? buffer_size : default_rx_audio_buffer_frames;
+ buffer_size = env.value ("WSJT_TX_AUDIO_BUFFER_FRAMES", "0").toInt (&ok);
+ m_tx_audio_buffer_frames = ok && buffer_size ? buffer_size : default_tx_audio_buffer_frames;
+
+ // hook up sound output stream slots & signals and disposal
+ connect (this, &MainWindow::initializeAudioOutputStream, m_soundOutput, &SoundOutput::setFormat);
+ connect (m_soundOutput, &SoundOutput::error, this, &MainWindow::showSoundOutError);
+ connect (m_soundOutput, &SoundOutput::error, &m_config, &Configuration::invalidate_audio_output_device);
+ // connect (m_soundOutput, &SoundOutput::status, this, &MainWindow::showStatusMessage);
+ connect (this, &MainWindow::outAttenuationChanged, m_soundOutput, &SoundOutput::setAttenuation);
+ connect (&m_audioThread, &QThread::finished, m_soundOutput, &QObject::deleteLater);
+
+ // hook up Modulator slots and disposal
+ connect (this, &MainWindow::transmitFrequency, m_modulator, &Modulator::setFrequency);
+ connect (this, &MainWindow::endTransmitMessage, m_modulator, &Modulator::stop);
+ connect (this, &MainWindow::tune, m_modulator, &Modulator::tune);
+ connect (this, &MainWindow::sendMessage, m_modulator, &Modulator::start);
+ connect (&m_audioThread, &QThread::finished, m_modulator, &QObject::deleteLater);
+
+ // hook up the audio input stream signals, slots and disposal
+ connect (this, &MainWindow::startAudioInputStream, m_soundInput, &SoundInput::start);
+ connect (this, &MainWindow::suspendAudioInputStream, m_soundInput, &SoundInput::suspend);
+ connect (this, &MainWindow::resumeAudioInputStream, m_soundInput, &SoundInput::resume);
+ connect (this, &MainWindow::reset_audio_input_stream, m_soundInput, &SoundInput::reset);
+ connect (this, &MainWindow::finished, m_soundInput, &SoundInput::stop);
+ connect(m_soundInput, &SoundInput::error, this, &MainWindow::showSoundInError);
+ connect(m_soundInput, &SoundInput::error, &m_config, &Configuration::invalidate_audio_input_device);
+ // connect(m_soundInput, &SoundInput::status, this, &MainWindow::showStatusMessage);
+ connect (&m_audioThread, &QThread::finished, m_soundInput, &QObject::deleteLater);
+
+ connect (this, &MainWindow::finished, this, &MainWindow::close);
+
+ // hook up the detector signals, slots and disposal
+ connect (this, &MainWindow::FFTSize, m_detector, &Detector::setBlockSize);
+ connect(m_detector, &Detector::framesWritten, this, &MainWindow::dataSink);
+ connect (&m_audioThread, &QThread::finished, m_detector, &QObject::deleteLater);
+
+ // setup the waterfall
+ connect(m_wideGraph.data (), SIGNAL(freezeDecode2(int)),this,SLOT(freezeDecode(int)));
+ connect(m_wideGraph.data (), SIGNAL(f11f12(int)),this,SLOT(bumpFqso(int)));
+ connect(m_wideGraph.data (), SIGNAL(setXIT2(int)),this,SLOT(setXIT(int)));
+
+ connect (m_fastGraph.data (), &FastGraph::fastPick, this, &MainWindow::fastPick);
+
+ connect (this, &MainWindow::finished, m_wideGraph.data (), &WideGraph::close);
+ connect (this, &MainWindow::finished, m_echoGraph.data (), &EchoGraph::close);
+ connect (this, &MainWindow::finished, m_fastGraph.data (), &FastGraph::close);
+
+ // setup the log QSO dialog
+ connect (m_logDlg.data (), &LogQSO::acceptQSO, this, &MainWindow::acceptQSO);
+ connect (this, &MainWindow::finished, m_logDlg.data (), &LogQSO::close);
+
+ // hook up the log book
+ connect (&m_logBook, &LogBook::finished_loading, [this] (int record_count, QString cty_version, QString const& error) {
+ if (error.size ())
+ {
+ MessageBox::warning_message (this, tr ("Error Scanning ADIF Log"), error);
+ }
+ else
+ {
+ m_config.set_CTY_DAT_version(cty_version);
+ showStatusMessage (tr ("Scanned ADIF log, %1 worked-before records created. CTY: %2").arg (record_count).arg (cty_version));
+ }
+ });
+
+ // Network message handlers
+ m_messageClient->enable (m_config.accept_udp_requests ());
+ connect (m_messageClient, &MessageClient::clear_decodes, [this] (quint8 window) {
+ ++window;
+ if (window & 1)
+ {
+ ui->decodedTextBrowser->erase ();
+ }
+ if (window & 2)
+ {
+ ui->decodedTextBrowser2->erase ();
+ }
+ });
+ connect (m_messageClient, &MessageClient::reply, this, &MainWindow::replyToCQ);
+ connect (m_messageClient, &MessageClient::close, this, &MainWindow::close);
+ connect (m_messageClient, &MessageClient::replay, this, &MainWindow::replayDecodes);
+ connect (m_messageClient, &MessageClient::location, this, &MainWindow::locationChange);
+ connect (m_messageClient, &MessageClient::halt_tx, [this] (bool auto_only) {
+ if (auto_only) {
+ if (ui->autoButton->isChecked ()) {
+ ui->autoButton->click();
+ }
+ } else {
+ ui->stopTxButton->click();
+ }
+ });
+ connect (m_messageClient, &MessageClient::error, this, &MainWindow::networkError);
+ connect (m_messageClient, &MessageClient::free_text, [this] (QString const& text, bool send) {
+ tx_watchdog (false);
+ // send + non-empty text means set and send the free text
+ // message, !send + non-empty text means set the current free
+ // text message, send + empty text means send the current free
+ // text message without change, !send + empty text means clear
+ // the current free text message
+ if (0 == ui->tabWidget->currentIndex ()) {
+ if (!text.isEmpty ()) {
+ ui->tx5->setCurrentText (text);
+ }
+ if (send) {
+ ui->txb5->click ();
+ } else if (text.isEmpty ()) {
+ ui->tx5->setCurrentText (text);
+ }
+ }
+ QApplication::alert (this);
+ });
+
+ connect (m_messageClient, &MessageClient::highlight_callsign, ui->decodedTextBrowser, &DisplayText::highlight_callsign);
+ connect (m_messageClient, &MessageClient::switch_configuration, m_multi_settings, &MultiSettings::select_configuration);
+ connect (m_messageClient, &MessageClient::configure, this, &MainWindow::remote_configure);
+
+ // Hook up WSPR band hopping
+ connect (ui->band_hopping_schedule_push_button, &QPushButton::clicked
+ , &m_WSPR_band_hopping, &WSPRBandHopping::show_dialog);
+ connect (ui->sbTxPercent, static_cast<void (QSpinBox::*) (int)> (&QSpinBox::valueChanged)
+ , &m_WSPR_band_hopping, &WSPRBandHopping::set_tx_percent);
+
+ on_EraseButton_clicked ();
+
+ QActionGroup* modeGroup = new QActionGroup(this);
+ ui->actionFST4->setActionGroup(modeGroup);
+ ui->actionFST4W->setActionGroup(modeGroup);
+ ui->actionFT4->setActionGroup(modeGroup);
+ ui->actionFT8->setActionGroup(modeGroup);
+ ui->actionJT9->setActionGroup(modeGroup);
+ ui->actionJT65->setActionGroup(modeGroup);
+ ui->actionJT4->setActionGroup(modeGroup);
+ ui->actionWSPR->setActionGroup(modeGroup);
+ ui->actionEcho->setActionGroup(modeGroup);
+ ui->actionMSK144->setActionGroup(modeGroup);
+ ui->actionQ65->setActionGroup(modeGroup);
+ ui->actionFreqCal->setActionGroup(modeGroup);
+
+ QActionGroup* saveGroup = new QActionGroup(this);
+ ui->actionNone->setActionGroup(saveGroup);
+ ui->actionSave_decoded->setActionGroup(saveGroup);
+ ui->actionSave_all->setActionGroup(saveGroup);
+
+ QActionGroup* alltxtGroup = new QActionGroup(this);
+ ui->actionDon_t_split_ALL_TXT->setActionGroup(alltxtGroup);
+ ui->actionSplit_ALL_TXT_yearly->setActionGroup(alltxtGroup);
+ ui->actionSplit_ALL_TXT_monthly->setActionGroup(alltxtGroup);
+ ui->actionDisable_writing_of_ALL_TXT->setActionGroup(alltxtGroup);
+
+ QActionGroup* DepthGroup = new QActionGroup(this);
+ ui->actionQuickDecode->setActionGroup(DepthGroup);
+ ui->actionMediumDecode->setActionGroup(DepthGroup);
+ ui->actionDeepestDecode->setActionGroup(DepthGroup);
+
+ connect (ui->download_samples_action, &QAction::triggered, [this] () {
+ if (!m_sampleDownloader)
+ {
+ m_sampleDownloader.reset (new SampleDownloader {m_settings, &m_config, &m_network_manager, this});
+ }
+ m_sampleDownloader->show ();
+ });
+
+ connect (ui->view_phase_response_action, &QAction::triggered, [this] () {
+ if (!m_equalizationToolsDialog)
+ {
+ m_equalizationToolsDialog.reset (new EqualizationToolsDialog {m_settings, m_config.writeable_data_dir (), m_phaseEqCoefficients, this});
+ connect (m_equalizationToolsDialog.data (), &EqualizationToolsDialog::phase_equalization_changed,
+ [this] (QVector<double> const& coeffs) {
+ m_phaseEqCoefficients = coeffs;
+ });
+ }
+ m_equalizationToolsDialog->show ();
+ });
+
+ connect (&m_config.lotw_users (), &LotWUsers::LotW_users_error, this, [this] (QString const& reason) {
+ MessageBox::warning_message (this, tr ("Error Loading LotW Users Data"), reason);
+ }, Qt::QueuedConnection);
+
+
+ QButtonGroup* txMsgButtonGroup = new QButtonGroup {this};
+ txMsgButtonGroup->addButton(ui->txrb1,1);
+ txMsgButtonGroup->addButton(ui->txrb2,2);
+ txMsgButtonGroup->addButton(ui->txrb3,3);
+ txMsgButtonGroup->addButton(ui->txrb4,4);
+ txMsgButtonGroup->addButton(ui->txrb5,5);
+ txMsgButtonGroup->addButton(ui->txrb6,6);
+ set_dateTimeQSO(-1);
+ connect(txMsgButtonGroup,SIGNAL(buttonClicked(int)),SLOT(set_ntx(int)));
+ connect (ui->decodedTextBrowser, &DisplayText::selectCallsign, this, &MainWindow::doubleClickOnCall2);
+ connect (ui->decodedTextBrowser2, &DisplayText::selectCallsign, this, &MainWindow::doubleClickOnCall);
+ connect (ui->houndQueueTextBrowser, &DisplayText::selectCallsign, this, &MainWindow::doubleClickOnFoxQueue);
+ connect (ui->foxTxListTextBrowser, &DisplayText::selectCallsign, this, &MainWindow::doubleClickOnFoxInProgress);
+ connect (ui->decodedTextBrowser, &DisplayText::erased, this, &MainWindow::band_activity_cleared);
+ connect (ui->decodedTextBrowser2, &DisplayText::erased, this, &MainWindow::rx_frequency_activity_cleared);
+
+ // initialize decoded text font and hook up font change signals
+ // defer initialization until after construction otherwise menu fonts do not get set
+ // with 50 ms delay we are on the safe side
+ QTimer::singleShot (50, this, SLOT (initialize_fonts ()));
+ connect (&m_config, &Configuration::text_font_changed, [this] (QFont const& font) {
+ set_application_font (font);
+ });
+ connect (&m_config, &Configuration::decoded_text_font_changed, [this] (QFont const& font) {
+ setDecodedTextFont (font);
+ });
+
+ setWindowTitle (program_title ());
+
+ connect(&proc_jt9, &QProcess::readyReadStandardOutput, this, &MainWindow::readFromStdout);
+#if QT_VERSION < QT_VERSION_CHECK (5, 6, 0)
+ connect(&proc_jt9, static_cast<void (QProcess::*) (QProcess::ProcessError)> (&QProcess::error),
+ [this] (QProcess::ProcessError error) {
+ subProcessError (&proc_jt9, error);
+ });
+#else
+ connect(&proc_jt9, &QProcess::errorOccurred, [this] (QProcess::ProcessError error) {
+ subProcessError (&proc_jt9, error);
+ });
+#endif
+ connect(&proc_jt9, static_cast<void (QProcess::*) (int, QProcess::ExitStatus)> (&QProcess::finished),
+ [this] (int exitCode, QProcess::ExitStatus status) {
+ if (subProcessFailed (&proc_jt9, exitCode, status))
+ {
+ m_valid = false; // ensures exit if still
+ // constructing
+ QTimer::singleShot (0, this, SLOT (close ()));
+ }
+ });
+ connect(&p1, &QProcess::started, [this] () {
+ showStatusMessage (QString {"Started: %1 \"%2\""}.arg (p1.program ()).arg (p1.arguments ().join ("\" \"")));
+ });
+ connect(&p1, &QProcess::readyReadStandardOutput, this, &MainWindow::p1ReadFromStdout);
+#if QT_VERSION < QT_VERSION_CHECK (5, 6, 0)
+ connect(&p1, static_cast<void (QProcess::*) (QProcess::ProcessError)> (&QProcess::error),
+ [this] (QProcess::ProcessError error) {
+ subProcessError (&p1, error);
+ });
+#else
+ connect(&p1, &QProcess::errorOccurred, [this] (QProcess::ProcessError error) {
+ subProcessError (&p1, error);
+ });
+#endif
+ connect(&p1, static_cast<void (QProcess::*) (int, QProcess::ExitStatus)> (&QProcess::finished),
+ [this] (int exitCode, QProcess::ExitStatus status) {
+ if (subProcessFailed (&p1, exitCode, status))
+ {
+ m_valid = false; // ensures exit if still
+ // constructing
+ QTimer::singleShot (0, this, SLOT (close ()));
+ }
+ });
+
+#if QT_VERSION < QT_VERSION_CHECK (5, 6, 0)
+ connect(&p3, static_cast<void (QProcess::*) (QProcess::ProcessError)> (&QProcess::error),
+ [this] (QProcess::ProcessError error) {
+#else
+ connect(&p3, &QProcess::errorOccurred, [this] (QProcess::ProcessError error) {
+#endif
+#if !defined(Q_OS_WIN)
+ if (QProcess::FailedToStart != error)
+#else
+ if (QProcess::Crashed != error)
+#endif
+ {
+ subProcessError (&p3, error);
+ }
+ });
+ connect(&p3, &QProcess::started, [this] () {
+ showStatusMessage (QString {"Started: %1 \"%2\""}.arg (p3.program ()).arg (p3.arguments ().join ("\" \"")));
+ });
+ connect(&p3, static_cast<void (QProcess::*) (int, QProcess::ExitStatus)> (&QProcess::finished),
+ [this] (int exitCode, QProcess::ExitStatus status) {
+#if defined(Q_OS_WIN)
+ // We forgo detecting user_hardware failures with exit
+ // code 1 on Windows. This is because we use CMD.EXE to
+ // run the executable. CMD.EXE returns exit code 1 when it
+ // can't find the target executable.
+ if (exitCode != 1) // CMD.EXE couldn't find file to execute
+#else
+ // We forgo detecting user_hardware failures with exit
+ // code 127 non-Windows. This is because we use /bin/sh to
+ // run the executable. /bin/sh returns exit code 127 when it
+ // can't find the target executable.
+ if (exitCode != 127) // /bin/sh couldn't find file to execute
+#endif
+ {
+ subProcessFailed (&p3, exitCode, status);
+ }
+ });
+
+ // hook up save WAV file exit handling
+ connect (&m_saveWAVWatcher, &QFutureWatcher<QString>::finished, [this] {
+ // extract the promise from the future
+ auto const& result = m_saveWAVWatcher.future ().result ();
+ if (!result.isEmpty ()) // error
+ {
+ MessageBox::critical_message (this, tr("Error Writing WAV File"), result);
+ }
+ });
+
+ // Hook up working frequencies.
+ ui->bandComboBox->setModel (m_config.frequencies ());
+ ui->bandComboBox->setModelColumn (FrequencyList_v2_101::frequency_mhz_column);
+
+ // Enable live band combo box entry validation and action.
+ auto band_validator = new LiveFrequencyValidator {ui->bandComboBox
+ , m_config.bands ()
+ , m_config.frequencies ()
+ , &m_freqNominal
+ , this};
+ ui->bandComboBox->setValidator (band_validator);
+
+ // Hook up signals.
+ connect (band_validator, &LiveFrequencyValidator::valid, this, &MainWindow::band_changed);
+ connect (ui->bandComboBox->lineEdit (), &QLineEdit::textEdited, [this] (QString const&) {m_bandEdited = true;});
+
+ // hook up configuration signals
+ connect (&m_config, &Configuration::transceiver_update, this, &MainWindow::handle_transceiver_update);
+ connect (&m_config, &Configuration::transceiver_failure, this, &MainWindow::handle_transceiver_failure);
+ connect (&m_config, &Configuration::udp_server_changed, m_messageClient, &MessageClient::set_server);
+ connect (&m_config, &Configuration::udp_server_port_changed, m_messageClient, &MessageClient::set_server_port);
+ connect (&m_config, &Configuration::udp_TTL_changed, m_messageClient, &MessageClient::set_TTL);
+ connect (&m_config, &Configuration::accept_udp_requests_changed, m_messageClient, &MessageClient::enable);
+ connect (&m_config, &Configuration::enumerating_audio_devices, [this] () {
+ showStatusMessage (tr ("Enumerating audio devices"));
+ });
+
+ // set up configurations menu
+ connect (m_multi_settings, &MultiSettings::configurationNameChanged, [this] (QString const& name) {
+ if ("Default" != name) {
+ config_label.setText (name);
+ config_label.show ();
+ }
+ else {
+ config_label.hide ();
+ }
+ statusUpdate ();
+#if defined(Q_OS_WIN)
+ QTimer::singleShot (250, [=] {setRig (m_lastMonitoredFrequency);}); // This is needed for Hamradio Deluxe
+#endif
+ });
+ m_multi_settings->create_menu_actions (this, ui->menuConfig);
+ m_configurations_button = m_rigErrorMessageBox.addButton (tr ("Configurations...")
+ , QMessageBox::ActionRole);
+
+ // set up message text validators
+ ui->tx1->setValidator (new QRegExpValidator {message_alphabet, this});
+ ui->tx2->setValidator (new QRegExpValidator {message_alphabet, this});
+ ui->tx3->setValidator (new QRegExpValidator {message_alphabet, this});
+ ui->tx4->setValidator (new QRegExpValidator {message_alphabet, this});
+ ui->tx5->setValidator (new QRegExpValidator {message_alphabet, this});
+ ui->tx6->setValidator (new QRegExpValidator {message_alphabet, this});
+
+ // Free text macros model to widget hook up.
+ ui->tx5->setModel (m_config.macros ());
+ connect (ui->tx5->lineEdit(), &QLineEdit::editingFinished,
+ [this] () {on_tx5_currentTextChanged (ui->tx5->lineEdit()->text());});
+ connect(&m_guiTimer, &QTimer::timeout, this, &MainWindow::guiUpdate);
+ m_guiTimer.start(100); //### Don't change the 100 ms! ###
+
+ stopWRTimer.setSingleShot(true);
+ connect(&stopWRTimer, &QTimer::timeout, this, &MainWindow::stopWRTimeout);
+
+ ptt0Timer.setSingleShot(true);
+ connect(&ptt0Timer, &QTimer::timeout, this, &MainWindow::stopTx2);
+
+ ptt1Timer.setSingleShot(true);
+ connect(&ptt1Timer, &QTimer::timeout, this, &MainWindow::startTx2);
+
+ p1Timer.setSingleShot(true);
+ connect(&p1Timer, &QTimer::timeout, this, &MainWindow::startP1);
+
+ logQSOTimer.setSingleShot(true);
+ connect(&logQSOTimer, &QTimer::timeout, this, &MainWindow::on_logQSOButton_clicked);
+
+ tuneButtonTimer.setSingleShot(true);
+ connect(&tuneButtonTimer, &QTimer::timeout, this, &MainWindow::end_tuning);
+
+ tuneATU_Timer.setSingleShot(true);
+ connect(&tuneATU_Timer, &QTimer::timeout, this, &MainWindow::stopTuneATU);
+
+ killFileTimer.setSingleShot(true);
+ connect(&killFileTimer, &QTimer::timeout, this, &MainWindow::killFile);
+
+ uploadTimer.setSingleShot(true);
+ connect(&uploadTimer, &QTimer::timeout, [this] () {uploadWSPRSpots ();});
+
+ TxAgainTimer.setSingleShot(true);
+ connect(&TxAgainTimer, SIGNAL(timeout()), this, SLOT(TxAgain()));
+
+ connect(m_wideGraph.data (), SIGNAL(setFreq3(int,int)),this,
+ SLOT(setFreq4(int,int)));
+
+ decodeBusy(false);
+
+ m_msg[0][0]=0;
+
+ char const * const power[] = {"1 mW","2 mW","5 mW","10 mW","20 mW","50 mW","100 mW","200 mW","500 mW",
+ "1 W","2 W","5 W","10 W","20 W","50 W","100 W","200 W","500 W","1 kW"};
+ for(auto i = 0u; i < sizeof power / sizeof power[0]; ++i) { //Initialize dBm values
+ auto dBm = int ((10. * i / 3.) + .5);
+ ui->TxPowerComboBox->addItem (QString {"%1 dBm %2"}.arg (dBm).arg (power[i]), dBm);
+ }
+ ui->respondComboBox->addItem("CQ: None");
+ ui->respondComboBox->addItem("CQ: First");
+ ui->respondComboBox->addItem("CQ: Max Dist");
+
+ m_dateTimeRcvdRR73=QDateTime::currentDateTimeUtc();
+ m_dateTimeSentTx3=QDateTime::currentDateTimeUtc();
+
+ ui->labAz->setStyleSheet("border: 0px;");
+ ui->labAz->setText("");
+ auto t = "UTC dB DT Freq " + tr ("Message");
+ ui->lh_decodes_headings_label->setText(t);
+ ui->rh_decodes_headings_label->setText(t);
+ readSettings(); //Restore user's setup parameters
+ if(m_mode=="Q65") {
+ m_score=0;
+ read_log();
+ }
+ m_audioThread.start (m_audioThreadPriority);
+
+#ifdef WIN32
+ if (!m_multiple)
+ {
+ while(true)
+ {
+ int iret=killbyname("jt9.exe");
+ if(iret == 603) break;
+ if(iret != 0)
+ MessageBox::warning_message (this, tr ("Error Killing jt9.exe Process")
+ , tr ("KillByName return code: %1")
+ .arg (iret));
+ }
+ }
+#endif
+
+ {
+ //delete any .quit file that might have been left lying around
+ //since its presence will cause jt9 to exit a soon as we start it
+ //and decodes will hang
+ QFile quitFile {m_config.temp_dir ().absoluteFilePath (".quit")};
+ while (quitFile.exists ())
+ {
+ if (!quitFile.remove ())
+ {
+ MessageBox::query_message (this, tr ("Error removing \"%1\"").arg (quitFile.fileName ())
+ , tr ("Click OK to retry"));
+ }
+ }
+ }
+
+ to_jt9(0,0,0); //initialize IPC variables
+
+ QStringList jt9_args {
+ "-s", QApplication::applicationName () // shared memory key,
+ // includes rig
+#ifdef NDEBUG
+ , "-w", "1" //FFTW patience - release
+#else
+ , "-w", "1" //FFTW patience - debug builds for speed
+#endif
+ // The number of threads for FFTW specified here is chosen as
+ // three because that gives the best throughput of the large
+ // FFTs used in jt9. The count is the minimum of (the number
+ // available CPU threads less one) and three. This ensures that
+ // there is always at least one free CPU thread to run the other
+ // mode decoder in parallel.
+ , "-m", QString::number (qMin (qMax (QThread::idealThreadCount () - 1, 1), 3)) //FFTW threads
+
+ , "-e", QDir::toNativeSeparators (m_appDir)
+ , "-a", QDir::toNativeSeparators (m_config.writeable_data_dir ().absolutePath ())
+ , "-t", QDir::toNativeSeparators (m_config.temp_dir ().absolutePath ())
+ };
+ QProcessEnvironment new_env {m_env};
+ new_env.insert ("OMP_STACKSIZE", "4M");
+ proc_jt9.setProcessEnvironment (new_env);
+ proc_jt9.start(QDir::toNativeSeparators (m_appDir) + QDir::separator () +
+ "jt9", jt9_args, QIODevice::ReadWrite | QIODevice::Unbuffered);
+
+ auto fname {QDir::toNativeSeparators(m_config.writeable_data_dir ().absoluteFilePath ("wsjtx_wisdom.dat"))};
+ fftwf_import_wisdom_from_filename (fname.toLocal8Bit ());
+
+ m_ntx = 6;
+ ui->txrb6->setChecked(true);
+
+ connect (&m_wav_future_watcher, &QFutureWatcher<void>::finished, this, &MainWindow::diskDat);
+
+ connect(&watcher3, SIGNAL(finished()),this,SLOT(fast_decode_done()));
+ if (!m_config.audio_input_device ().isNull ())
+ {
+ Q_EMIT startAudioInputStream (m_config.audio_input_device ()
+ , m_rx_audio_buffer_frames
+ , m_detector, m_downSampleFactor, m_config.audio_input_channel ());
+ }
+ if (!m_config.audio_output_device ().isNull ())
+ {
+ Q_EMIT initializeAudioOutputStream (m_config.audio_output_device ()
+ , AudioDevice::Mono == m_config.audio_output_channel () ? 1 : 2
+ , m_tx_audio_buffer_frames);
+ }
+ Q_EMIT transmitFrequency (ui->TxFreqSpinBox->value () - m_XIT);
+
+ enable_DXCC_entity (m_config.DXCC ()); // sets text window proportions and (re)inits the logbook
+
+ // this must be done before initializing the mode as some modes need
+ // to turn off split on the rig e.g. WSPR
+ m_config.transceiver_online ();
+ bool vhf {m_config.enable_VHF_features ()};
+
+ ui->txFirstCheckBox->setChecked(m_txFirst);
+ morse_(const_cast<char *> (m_config.my_callsign ().toLatin1().constData()),
+ const_cast<int *> (icw), &m_ncw, (FCL)m_config.my_callsign().length());
+ on_actionWide_Waterfall_triggered();
+ ui->cbShMsgs->setChecked(m_bShMsgs);
+ ui->cbSWL->setChecked(m_bSWL);
+ if(m_bFast9) m_bFastMode=true;
+ ui->cbFast9->setChecked(m_bFast9 or m_bFastMode);
+
+ set_mode (m_mode);
+ if(m_mode=="Echo") monitor(false); //Don't auto-start Monitor in Echo mode.
+ ui->sbSubmode->setValue (vhf ? m_nSubMode : 0); //Submodes require VHF features
+ if(m_mode=="MSK144") {
+ Q_EMIT transmitFrequency (1000.0);
+ } else {
+ Q_EMIT transmitFrequency (ui->TxFreqSpinBox->value() - m_XIT);
+ }
+ m_saveDecoded=ui->actionSave_decoded->isChecked();
+ m_saveAll=ui->actionSave_all->isChecked();
+ ui->TxPowerComboBox->setCurrentIndex(int(.3 * m_dBm + .2));
+ ui->cbUploadWSPR_Spots->setChecked(m_uploadWSPRSpots);
+ if((m_ndepth&7)==1) ui->actionQuickDecode->setChecked(true);
+ if((m_ndepth&7)==2) ui->actionMediumDecode->setChecked(true);
+ if((m_ndepth&7)==3) ui->actionDeepestDecode->setChecked(true);
+ ui->actionInclude_averaging->setChecked(m_ndepth&16);
+ ui->actionInclude_correlation->setChecked(m_ndepth&32);
+ ui->actionEnable_AP_DXcall->setChecked(m_ndepth&64);
+ ui->actionAuto_Clear_Avg->setChecked(m_ndepth&128);
+
+ m_UTCdisk=-1;
+ m_UTCdiskDateTime=QDateTime{}; // UTCDateTime of file being read from disk.
+ m_fCPUmskrtd=0.0;
+ m_bFastDone=false;
+ m_bAltV=false;
+ m_bNoMoreFiles=false;
+ m_bDoubleClicked=false;
+ m_bCallingCQ=false;
+ m_bCheckedContest=false;
+ m_bDisplayedOnce=false;
+ m_wait=0;
+ m_isort=-3;
+ m_max_dB=70;
+ m_CQtype="CQ";
+ fixStop();
+ VHF_features_enabled(m_config.enable_VHF_features());
+ m_wideGraph->setVHF(m_config.enable_VHF_features());
+
+ connect( wsprNet, SIGNAL(uploadStatus(QString)), this, SLOT(uploadResponse(QString)));
+
+ statusChanged();
+
+ m_fastGraph->setMode(m_mode);
+ m_wideGraph->setMode(m_mode);
+
+ connect (&minuteTimer, &QTimer::timeout, this, &MainWindow::on_the_minute);
+ connect (&minuteTimer, &QTimer::timeout, this, &MainWindow::invalidate_frequencies_filter);
+
+ minuteTimer.setSingleShot (true);
+ minuteTimer.start (ms_minute_error () + 60 * 1000);
+
+ connect (&splashTimer, &QTimer::timeout, this, &MainWindow::splash_done);
+ splashTimer.setSingleShot (true);
+ splashTimer.start (20 * 1000);
+
+ if(QCoreApplication::applicationVersion().contains("-devel") or
+ QCoreApplication::applicationVersion().contains("-rc")) {
+ QTimer::singleShot (0, this, SLOT (not_GA_warning_message ()));
+ }
+
+ m_specOp=m_config.special_op_id();
+ // Starting in FT8 Hound mode needs this initialization
+ if (m_specOp==SpecOp::HOUND) {
+ on_ft8Button_clicked();
+ ui->houndButton->click();
+ }
+
+ ui->labDXped->setVisible(SpecOp::NONE != m_specOp);
+ ui->labDXped->setStyleSheet("QLabel {background-color: red; color: white;}");
+ ui->pbBestSP->setVisible(m_mode=="FT4");
+
+ update_foxLogWindow_rate(); // update the rate on the window
+
+ QString jpleph = m_config.data_dir().absoluteFilePath("JPLEPH");
+ jpl_setup_(const_cast<char *>(jpleph.toLocal8Bit().constData()),256);
+
+#ifdef WIN32
+ // backup libhamlib-4.dll file, so it is still available after the next program update
+ QDir dataPath = QCoreApplication::applicationDirPath();
+ QFile f {dataPath.absolutePath() + "/" + "libhamlib-4_old.dll"};
+ if (!f.exists()) {
+ QFile::copy(dataPath.absolutePath() + "/" + "libhamlib-4.dll", dataPath.absolutePath() + "/" + "libhamlib-4_old.dll");
+ QTimer::singleShot (5000, [=] { //wait until hamlib has been started
+ extern char* hamlib_version2;
+ QString hamlib = QString(QLatin1String(hamlib_version2));
+ m_settings->beginGroup("Configuration");
+ m_settings->setValue ("HamlibBackedUp", hamlib);
+ m_settings->endGroup();
+ });
+ }
+#endif
+
+// this must be the last statement of constructor
+ if (!m_valid) throw std::runtime_error {"Fatal initialization exception"};
+}
+
+void MainWindow::not_GA_warning_message ()
+{
+ if(m_config.my_callsign()=="K1JT" or m_config.my_callsign()=="W2ZQ") return;
+ MessageBox::critical_message (this,
+ "This is a pre-release version of WSJT-X " + version (false) + " made\n"
+ "available for testing purposes. By design it will\n"
+ "be nonfunctional after December 31, 2024.");
+ auto now = QDateTime::currentDateTimeUtc ();
+ if (now >= QDateTime {{2024, 12, 31}, {23, 59, 59, 999}, Qt::UTC}) {
+ Q_EMIT finished ();
+ }
+}
+
+void MainWindow::initialize_fonts ()
+{
+ set_application_font (m_config.text_font ());
+ setDecodedTextFont (m_config.decoded_text_font ());
+}
+
+void MainWindow::splash_done ()
+{
+ m_splash && m_splash->close ();
+}
+
+void MainWindow::invalidate_frequencies_filter ()
+{
+ // every interval, invalidate the frequency filter, so that if any
+ // working frequency goes in/out of scope, we pick it up.
+ m_config.frequencies ()->filter_refresh ();
+ ui->bandComboBox->update ();
+}
+
+void MainWindow::on_the_minute ()
+{
+ if (minuteTimer.isSingleShot ())
+ {
+ minuteTimer.setSingleShot (false);
+ minuteTimer.start (60 * 1000); // run free
+ }
+ else
+ {
+ auto const& ms_error = ms_minute_error ();
+ if (qAbs (ms_error) > 1000) // keep drift within +-1s
+ {
+ minuteTimer.setSingleShot (true);
+ minuteTimer.start (ms_error + 60 * 1000);
+ }
+ }
+
+ if (m_config.watchdog () && m_mode!="WSPR" && m_mode!="FST4W") {
+ if (m_idleMinutes < m_config.watchdog ()) ++m_idleMinutes;
+ update_watchdog_label ();
+ } else {
+ tx_watchdog (false);
+ }
+ update_foxLogWindow_rate(); // update the rate on the window
+ if ((!verified && ui->labDXped->isVisible()) or ui->labDXped->text()!="Super Hound")
+ ui->labDXped->setStyleSheet("QLabel {background-color: red; color: white;}");
+ verified = false;
+}
+
+//--------------------------------------------------- MainWindow destructor
+MainWindow::~MainWindow()
+{
+ if(m_astroWidget) m_astroWidget.reset ();
+ auto fname {QDir::toNativeSeparators(m_config.writeable_data_dir ().absoluteFilePath ("wsjtx_wisdom.dat"))};
+ fftwf_export_wisdom_to_filename (fname.toLocal8Bit ());
+ m_audioThread.quit ();
+ m_audioThread.wait ();
+ remove_child_from_event_filter (this);
+ memset(ipc_qmap,0,4096); //Zero all of QMAP shared memory
+}
+
+//-------------------------------------------------------- writeSettings()
+void MainWindow::writeSettings()
+{
+ m_settings->beginGroup("MainWindow");
+ if (ui->actionSWL_Mode->isChecked ())
+ {
+ m_settings->setValue ("SWLView", true);
+ m_settings->setValue ("ShowMenus", ui->cbMenus->isChecked ());
+ m_settings->setValue ("geometry", geometries ()[0]);
+ m_settings->setValue ("SWLModeGeometry", saveGeometry ());
+ m_settings->setValue ("geometryNoControls", geometries ()[2]);
+ }
+ else
+ {
+ if (ui->cbMenus->isChecked())
+ {
+ m_settings->setValue ("SWLView", ui->actionSWL_Mode->isChecked ());
+ m_settings->setValue ("ShowMenus", true);
+ m_settings->setValue ("geometry", saveGeometry ());
+ m_settings->setValue ("SWLModeGeometry", geometries ()[1]);
+ m_settings->setValue ("geometryNoControls", geometries ()[2]);
+ }
+ else
+ {
+ m_settings->setValue ("SWLView", ui->actionSWL_Mode->isChecked ());
+ m_settings->setValue ("ShowMenus", false);
+ m_settings->setValue ("geometry", geometries ()[0]);
+ m_settings->setValue ("SWLModeGeometry", geometries ()[1]);
+ m_settings->setValue ("geometryNoControls", saveGeometry ());
+ }
+ }
+ m_settings->setValue ("state", saveState ());
+ m_settings->setValue("MRUdir", m_path);
+ m_settings->setValue("TxFirst",m_txFirst);
+ m_settings->setValue("DXcall",ui->dxCallEntry->text());
+ m_settings->setValue("DXgrid",ui->dxGridEntry->text());
+ m_settings->setValue ("AstroDisplayed", m_astroWidget && m_astroWidget->isVisible());
+ m_settings->setValue ("MsgAvgDisplayed", m_msgAvgWidget && m_msgAvgWidget->isVisible ());
+ m_settings->setValue ("FoxLogDisplayed", m_foxLogWindow && m_foxLogWindow->isVisible ());
+ m_settings->setValue ("ContestLogDisplayed", m_contestLogWindow && m_contestLogWindow->isVisible ());
+ m_settings->setValue ("ActiveStationsDisplayed", m_ActiveStationsWidget && m_ActiveStationsWidget->isVisible ());
+ m_settings->setValue("RespondCQ",ui->respondComboBox->currentIndex());
+ m_settings->setValue("HoundSort",ui->comboBoxHoundSort->currentIndex());
+ m_settings->setValue("FoxNlist",ui->sbNlist->value());
+ m_settings->setValue("FoxNslots",m_Nslots0);
+ m_settings->setValue("FoxMaxDB_v2",ui->sbMax_dB->value()); // original key abandoned
+ m_settings->setValue ("SerialNumber",ui->sbSerialNumber->value ());
+ m_settings->setValue("FoxTextMsg", m_freeTextMsg0);
+ m_settings->setValue("WorkDupes", ui->cbWorkDupes->isChecked());
+ m_settings->endGroup();
+
+ // do this in the General group because we save the parameters from various places
+ if(m_mode=="JT9") {
+ m_settings->setValue("SubMode",ui->sbSubmode->value());
+ m_settings->setValue("TRPeriod", ui->sbTR->value());
+ }
+ if(m_mode=="MSK144") m_settings->setValue("ShMsgs_MSK144",m_bShMsgs);
+ if(m_mode=="Q65") m_settings->setValue("ShMsgs_Q65",m_bShMsgs);
+ if(m_mode=="JT65") m_settings->setValue("ShMsgs_JT65",m_bShMsgs);
+ if(m_mode=="JT4") m_settings->setValue("ShMsgs_JT4",m_bShMsgs);
+
+ m_settings->beginGroup("Common");
+ m_settings->setValue("Mode",m_mode);
+ m_settings->setValue("SaveNone",ui->actionNone->isChecked());
+ m_settings->setValue("SaveDecoded",ui->actionSave_decoded->isChecked());
+ m_settings->setValue("SaveAll",ui->actionSave_all->isChecked());
+ m_settings->setValue("NDepth",m_ndepth);
+ m_settings->setValue("RxFreq",ui->RxFreqSpinBox->value());
+ if(m_specOp!=SpecOp::FOX) m_settings->setValue("TxFreq",ui->TxFreqSpinBox->value());
+ m_settings->setValue("TxFreqFox",m_TxFreqFox);
+ m_settings->setValue("WSPRfreq",ui->WSPRfreqSpinBox->value());
+ m_settings->setValue("FST4W_RxFreq",ui->sbFST4W_RxFreq->value());
+ m_settings->setValue("FST4W_FTol",ui->sbFST4W_FTol->value());
+ m_settings->setValue("FST4_FLow",ui->sbF_Low->value());
+ m_settings->setValue("FST4_FHigh",ui->sbF_High->value());
+ m_settings->setValue("DTtol",m_DTtol);
+ m_settings->setValue("Ftol", ui->sbFtol->value ());
+ m_settings->setValue("MinSync",m_minSync);
+ m_settings->setValue ("AutoSeq", ui->cbAutoSeq->isChecked ());
+ m_settings->setValue ("RxAll", ui->cbRxAll->isChecked ());
+// m_settings->setValue("ShMsgs",m_bShMsgs);
+ m_settings->setValue("SWL",ui->cbSWL->isChecked());
+ m_settings->setValue ("DialFreq", QVariant::fromValue(m_lastMonitoredFrequency));
+ m_settings->setValue("OutAttenuation", ui->outAttenuation->value ());
+ m_settings->setValue("NoSuffix",m_noSuffix);
+ m_settings->setValue("GUItab",ui->tabWidget->currentIndex());
+ m_settings->setValue("OutBufSize",outBufSize);
+ m_settings->setValue ("HoldTxFreq", ui->cbHoldTxFreq->isChecked ());
+ m_settings->setValue("PctTx", ui->sbTxPercent->value ());
+ m_settings->setValue("RoundRobin",ui->RoundRobin->currentText());
+ m_settings->setValue("dBm",m_dBm);
+ m_settings->setValue("RR73",m_send_RR73);
+ m_settings->setValue ("WSPRPreferType1", ui->WSPR_prefer_type_1_check_box->isChecked ());
+ m_settings->setValue("UploadSpots",m_uploadWSPRSpots);
+ m_settings->setValue("NoOwnCall",ui->cbNoOwnCall->isChecked());
+ m_settings->setValue ("BandHopping", ui->band_hopping_group_box->isChecked ());
+ m_settings->setValue ("MaxDrift", ui->sbMaxDrift->value());
+ m_settings->setValue ("TRPeriod_FST4W", ui->sbTR_FST4W->value ());
+ m_settings->setValue("FastMode",m_bFastMode);
+ m_settings->setValue("Fast9",m_bFast9);
+ m_settings->setValue ("CQTxfreq", ui->sbCQTxFreq->value ());
+ m_settings->setValue("pwrBandTxMemory",m_pwrBandTxMemory);
+ m_settings->setValue("pwrBandTuneMemory",m_pwrBandTuneMemory);
+ m_settings->setValue ("FT8AP", ui->actionEnable_AP_FT8->isChecked ());
+ m_settings->setValue ("JT65AP", ui->actionEnable_AP_JT65->isChecked ());
+ m_settings->setValue ("AutoClearAvg", ui->actionAuto_Clear_Avg->isChecked ());
+ m_settings->setValue("SplitterState",ui->decodes_splitter->saveState());
+ m_settings->setValue("Blanker",ui->sbNB->value());
+ m_settings->setValue("Score",m_score);
+ m_settings->setValue("labDXpedText",ui->labDXped->text());
+ m_settings->setValue("EchoAvg",ui->sbEchoAvg->value());
+
+ {
+ QList<QVariant> coeffs; // suitable for QSettings
+ for (auto const& coeff : m_phaseEqCoefficients)
+ {
+ coeffs << coeff;
+ }
+ m_settings->setValue ("PhaseEqualizationCoefficients", QVariant {coeffs});
+ }
+ m_settings->setValue ("actionDontSplitALLTXT", ui->actionDon_t_split_ALL_TXT->isChecked() );
+ m_settings->setValue ("splitAllTxtYearly", ui->actionSplit_ALL_TXT_yearly->isChecked() );
+ m_settings->setValue ("splitAllTxtMonthly", ui->actionSplit_ALL_TXT_monthly->isChecked() );
+ m_settings->setValue ("disableWritingOfAllTxt", ui->actionDisable_writing_of_ALL_TXT->isChecked() );
+ m_settings->endGroup();
+}
+
+//---------------------------------------------------------- readSettings()
+void MainWindow::readSettings()
+{
+ ui->cbAutoSeq->setVisible(false);
+ ui->respondComboBox->setVisible(false);
+ m_settings->beginGroup("MainWindow");
+ std::array<QByteArray, 3> the_geometries;
+ the_geometries[0] = m_settings->value ("geometry", saveGeometry ()).toByteArray ();
+ the_geometries[1] = m_settings->value ("SWLModeGeometry", saveGeometry ()).toByteArray ();
+ the_geometries[2] = m_settings->value ("geometryNoControls", saveGeometry ()).toByteArray ();
+ auto SWL_mode = m_settings->value ("SWLView", false).toBool ();
+ auto show_menus = m_settings->value ("ShowMenus", true).toBool ();
+ ui->actionSWL_Mode->setChecked (SWL_mode);
+ ui->cbMenus->setChecked (show_menus);
+ auto current_view_mode = SWL_mode ? 1 : show_menus ? 0 : 2;
+ change_layout (current_view_mode);
+ geometries (current_view_mode, the_geometries);
+ restoreState (m_settings->value ("state", saveState ()).toByteArray ());
+ ui->dxCallEntry->setText (m_settings->value ("DXcall", QString {}).toString ());
+ ui->dxGridEntry->setText (m_settings->value ("DXgrid", QString {}).toString ());
+ m_path = m_settings->value("MRUdir", m_config.save_directory ().absolutePath ()).toString ();
+ m_txFirst = m_settings->value("TxFirst",false).toBool();
+ auto displayAstro = m_settings->value ("AstroDisplayed", false).toBool ();
+ auto displayMsgAvg = m_settings->value ("MsgAvgDisplayed", false).toBool ();
+ auto displayFoxLog = m_settings->value ("FoxLogDisplayed", false).toBool ();
+ auto displayContestLog = m_settings->value ("ContestLogDisplayed", false).toBool ();
+ bool displayActiveStations = m_settings->value ("ActiveStationsDisplayed", false).toBool ();
+ ui->respondComboBox->setCurrentIndex(m_settings->value("RespondCQ",0).toInt());
+ ui->comboBoxHoundSort->setCurrentIndex(m_settings->value("HoundSort",3).toInt());
+ ui->sbNlist->setValue(m_settings->value("FoxNlist",12).toInt());
+ m_Nslots=m_settings->value("FoxNslots",3).toInt();
+ m_Nslots0=m_Nslots;
+ if(!m_config.superFox()) ui->sbNslots->setValue(m_Nslots);
+ ui->sbMax_dB->setValue(m_settings->value("FoxMaxDB_v2",70).toInt());
+ ui->sbSerialNumber->setValue (m_settings->value ("SerialNumber", 1).toInt ());
+ m_freeTextMsg0=m_settings->value("FoxTextMsg","").toString();
+ m_freeTextMsg=m_freeTextMsg0;
+ ui->cbWorkDupes->setChecked(m_settings->value("WorkDupes",false).toBool());
+ m_settings->endGroup();
+
+ m_settings->beginGroup("Common");
+ m_mode=m_settings->value("Mode","FT8").toString();
+ m_settings->endGroup();
+
+
+ // do this outside of settings group because it uses groups internally
+ ui->actionAstronomical_data->setChecked (displayAstro);
+
+ // do this in the General group because we save the parameters from various places
+ if(m_mode=="JT9") {
+ blocked=true;
+ m_nSubMode=m_settings->value("SubMode",0).toInt();
+ ui->sbSubmode->setValue(m_nSubMode);
+ ui->sbFtol->setValue (m_settings->value("Ftol_JT9", 50).toInt());
+ ui->sbTR->setValue (m_settings->value ("TRPeriod", 15).toInt());
+ QTimer::singleShot (50, [=] {blocked = false;});
+ }
+ if (m_mode=="FT8") {
+ ui->sbFtol->setValue (m_settings->value("Ftol_SF", 50).toInt());
+ }
+ if (m_mode=="Q65") {
+ m_nSubMode=m_settings->value("SubMode_Q65",0).toInt();
+ ui->sbSubmode->setValue(m_nSubMode_Q65);
+ ui->sbFtol->setValue (m_settings->value("Ftol_Q65", 50).toInt());
+ ui->sbTR->setValue (m_settings->value ("TRPeriod_Q65", 30).toInt());
+ }
+ if (m_mode=="JT65") {
+ m_nSubMode=m_settings->value("SubMode_JT65",0).toInt();
+ ui->sbSubmode->setValue(m_nSubMode_JT65);
+ ui->sbFtol->setValue (m_settings->value("Ftol_JT65", 50).toInt());
+ }
+ if (m_mode=="JT4") {
+ m_nSubMode=m_settings->value("SubMode_JT4",0).toInt();
+ ui->sbSubmode->setValue(m_nSubMode_JT4);
+ ui->sbFtol->setValue (m_settings->value("Ftol_JT4", 50).toInt());
+ ui->sbTR->setValue (m_settings->value ("TRPeriod_FST4", 60).toInt());
+ }
+ if (m_mode=="MSK144") {
+ ui->sbFtol->setValue (m_settings->value("Ftol_MSK144",50).toInt());
+ if (!(m_currentBand=="6m" or m_currentBand=="4m" or m_currentBand=="2m")) ui->sbTR->setValue (m_settings->value ("TRPeriod_MSK144", 30).toInt());
+ if (m_currentBand=="6m" or m_currentBand=="4m") ui->sbTR->setValue (m_settings->value ("TRPeriod_MSK144_6m", 15).toInt());
+ if (m_currentBand=="2m") ui->sbTR->setValue (m_settings->value ("TRPeriod_MSK144_2m", 30).toInt());
+ }
+ if (m_mode=="MSK144") m_bShMsgs=m_settings->value("ShMsgs_MSK144",false).toBool();
+ if (m_mode=="Q65") m_bShMsgs=m_settings->value("ShMsgs_Q65",false).toBool();
+ if (m_mode=="JT65") m_bShMsgs=m_settings->value("ShMsgs_JT65",false).toBool();
+ if (m_mode=="JT4") m_bShMsgs=m_settings->value("ShMsgs_JT4",false).toBool();
+
+ m_settings->beginGroup("Common");
+ ui->labDXped->setText(m_settings->value("labDXpedText",QString {}).toString ());
+ ui->actionDon_t_split_ALL_TXT->setChecked(m_settings->value("actionDontSplitALLTXT", true).toBool());
+ ui->actionSplit_ALL_TXT_yearly->setChecked(m_settings->value("splitAllTxtYearly", false).toBool());
+ ui->actionSplit_ALL_TXT_monthly->setChecked(m_settings->value("splitAllTxtMonthly", false).toBool());
+ ui->actionDisable_writing_of_ALL_TXT->setChecked(m_settings->value("disableWritingOfAllTxt", false).toBool());
+// m_mode=m_settings->value("Mode","FT8").toString();
+ ui->actionNone->setChecked(m_settings->value("SaveNone",true).toBool());
+ ui->actionSave_decoded->setChecked(m_settings->value("SaveDecoded",false).toBool());
+ ui->actionSave_all->setChecked(m_settings->value("SaveAll",false).toBool());
+ ui->RxFreqSpinBox->setValue(0); // ensure a change is signaled
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq",1500).toInt());
+ ui->sbFST4W_RxFreq->setValue(0);
+ ui->sbFST4W_RxFreq->setValue(m_settings->value("FST4W_RxFreq",1500).toInt());
+ ui->sbF_Low->setValue(m_settings->value("FST4_FLow",600).toInt());
+ ui->sbF_High->setValue(m_settings->value("FST4_FHigh",1400).toInt());
+ ui->sbFtol->setValue (m_settings->value("Ftol", 50).toInt());
+ ui->sbFST4W_FTol->setValue(m_settings->value("FST4W_FTol",100).toInt());
+ m_minSync=m_settings->value("MinSync",0).toInt();
+ ui->syncSpinBox->setValue(m_minSync);
+ ui->cbAutoSeq->setChecked (m_settings->value ("AutoSeq", false).toBool());
+ ui->cbRxAll->setChecked (m_settings->value ("RxAll", false).toBool());
+// m_bShMsgs=m_settings->value("ShMsgs",false).toBool();
+ m_bSWL=m_settings->value("SWL",false).toBool();
+ m_bFast9=m_settings->value("Fast9",false).toBool();
+ m_bFastMode=m_settings->value("FastMode",false).toBool();
+ ui->sbMaxDrift->setValue (m_settings->value ("MaxDrift",0).toInt());
+ ui->sbTR_FST4W->setValue (m_settings->value ("TRPeriod_FST4W", 15).toInt());
+ m_lastMonitoredFrequency = m_settings->value ("DialFreq",
+ QVariant::fromValue<Frequency> (default_frequency)).value<Frequency> ();
+ ui->WSPRfreqSpinBox->setValue(0); // ensure a change is signaled
+ ui->WSPRfreqSpinBox->setValue(m_settings->value("WSPRfreq",1500).toInt());
+ ui->TxFreqSpinBox->setValue(0); // ensure a change is signaled
+ if(m_specOp!=SpecOp::FOX) ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq",1500).toInt());
+ m_TxFreqFox=m_settings->value("TxFreqFox",300).toInt();
+ if(m_specOp==SpecOp::FOX && !m_config.superFox()) ui->TxFreqSpinBox->setValue(m_TxFreqFox);
+ m_ndepth=m_settings->value("NDepth",3).toInt();
+ ui->sbTxPercent->setValue (m_settings->value ("PctTx", 20).toInt ());
+ on_sbTxPercent_valueChanged (ui->sbTxPercent->value ());
+ ui->RoundRobin->setCurrentText(m_settings->value("RoundRobin",tr("Random")).toString());
+ m_dBm=m_settings->value("dBm",37).toInt();
+ m_send_RR73=m_settings->value("RR73",false).toBool();
+ m_score=m_settings->value("Score",0).toInt();
+ if(m_send_RR73) {
+ m_send_RR73=false;
+ on_txrb4_doubleClicked();
+ }
+ ui->WSPR_prefer_type_1_check_box->setChecked (m_settings->value ("WSPRPreferType1", true).toBool ());
+ m_uploadWSPRSpots=m_settings->value("UploadSpots",false).toBool();
+ ui->cbNoOwnCall->setChecked(m_settings->value("NoOwnCall",false).toBool());
+ ui->band_hopping_group_box->setChecked (m_settings->value ("BandHopping", false).toBool());
+ // setup initial value of tx attenuator
+ m_block_pwr_tooltip = true;
+ ui->outAttenuation->setValue (m_settings->value ("OutAttenuation", 0).toInt ());
+ m_block_pwr_tooltip = false;
+ ui->sbCQTxFreq->setValue (m_settings->value ("CQTxFreq", 260).toInt());
+ m_noSuffix=m_settings->value("NoSuffix",false).toBool();
+ int n=m_settings->value("GUItab",0).toInt();
+ if (SpecOp::FOX==m_specOp) {
+ ui->tabWidget->setCurrentIndex(n);
+ } else {
+ ui->tabWidget->setCurrentIndex(1); // needed for GUI initialisation when SuperFox controls are invisible
+ ui->tabWidget->setCurrentIndex(n);
+ }
+ outBufSize=m_settings->value("OutBufSize",4096).toInt();
+ ui->cbHoldTxFreq->setChecked (m_settings->value ("HoldTxFreq", false).toBool ());
+ m_pwrBandTxMemory=m_settings->value("pwrBandTxMemory").toHash();
+ m_pwrBandTuneMemory=m_settings->value("pwrBandTuneMemory").toHash();
+ ui->actionEnable_AP_FT8->setChecked (m_settings->value ("FT8AP", false).toBool());
+ ui->actionEnable_AP_JT65->setChecked (m_settings->value ("JT65AP", false).toBool());
+ ui->actionAuto_Clear_Avg->setChecked (m_settings->value ("AutoClearAvg", false).toBool());
+ ui->decodes_splitter->restoreState(m_settings->value("SplitterState").toByteArray());
+ ui->sbNB->setValue(m_settings->value("Blanker",0).toInt());
+ ui->sbEchoAvg->setValue(m_settings->value("EchoAvg",10).toInt());
+ {
+ auto const& coeffs = m_settings->value ("PhaseEqualizationCoefficients"
+ , QList<QVariant> {0., 0., 0., 0., 0.}).toList ();
+ m_phaseEqCoefficients.clear ();
+ for (auto const& coeff : coeffs)
+ {
+ m_phaseEqCoefficients.append (coeff.value<double> ());
+ }
+ }
+ m_settings->endGroup();
+
+ // use these initialisation settings to tune the audio o/p buffer
+ // size and audio thread priority
+ m_settings->beginGroup ("Tune");
+ m_audioThreadPriority = static_cast<QThread::Priority> (m_settings->value ("Audio/ThreadPriority", QThread::TimeCriticalPriority).toInt () % 8);
+ m_settings->endGroup ();
+
+ m_specOp=m_config.special_op_id();
+ checkMSK144ContestType();
+ if (displayMsgAvg) on_actionMessage_averaging_triggered();
+ if (displayFoxLog) on_fox_log_action_triggered ();
+ if (displayContestLog) on_contest_log_action_triggered ();
+ if (displayActiveStations) on_actionActiveStations_triggered();
+}
+
+void MainWindow::checkMSK144ContestType()
+{
+ if(SpecOp::NONE != m_specOp)
+ {
+ if(m_mode=="MSK144" && SpecOp::EU_VHF < m_specOp)
+ {
+ MessageBox::warning_message (this, tr ("Improper mode"),
+ "Mode will be changed to FT8. MSK144 not available if Fox, Hound, Field Day, FT Roundup, WW Digi. or ARRL Digi contest is selected.");
+ on_actionFT8_triggered();
+ }
+ }
+}
+
+void MainWindow::set_application_font (QFont const& font)
+{
+ qApp->setFont (font);
+ // set font in the application style sheet as well in case it has
+ // been modified in the style sheet which has priority
+ QString ss;
+ if (qApp->styleSheet ().size ())
+ {
+ auto sheet = qApp->styleSheet ();
+ sheet.remove ("file:///");
+ QFile sf {sheet};
+ if (sf.open (QFile::ReadOnly | QFile::Text))
+ {
+ QString tmp = sf.readAll();
+ if (tmp != NULL) ss = sf.readAll () + tmp;
+ else qDebug() << "tmp==NULL at sf.readAll";
+ }
+ }
+ qApp->setStyleSheet (ss + "* {" + font_as_stylesheet (font) + '}');
+ // ensure a balanced layout of the mode buttons
+ qreal pointSize = m_config.text_font().pointSizeF();
+ if (pointSize < 11) {
+ ui->houndButton->setMaximumWidth(40);
+ ui->ft8Button->setMaximumWidth(40);
+ ui->ft4Button->setMaximumWidth(40);
+ ui->msk144Button->setMaximumWidth(40);
+ ui->q65Button->setMaximumWidth(40);
+ ui->jt65Button->setMaximumWidth(40);
+ ui->houndButton->setMinimumWidth(0);
+ ui->ft8Button->setMinimumWidth(0);
+ ui->ft4Button->setMinimumWidth(0);
+ ui->msk144Button->setMinimumWidth(0);
+ ui->q65Button->setMinimumWidth(0);
+ ui->jt65Button->setMinimumWidth(0);
+ } else {
+ ui->houndButton->setMinimumWidth(50);
+ ui->ft8Button->setMinimumWidth(50);
+ ui->ft4Button->setMinimumWidth(50);
+ ui->msk144Button->setMinimumWidth(50);
+ ui->q65Button->setMinimumWidth(50);
+ ui->jt65Button->setMinimumWidth(50);
+ }
+ for (auto& widget : qApp->topLevelWidgets ())
+ {
+ widget->updateGeometry ();
+ }
+}
+
+void MainWindow::setDecodedTextFont (QFont const& font)
+{
+ ui->decodedTextBrowser->setContentFont (font);
+ ui->decodedTextBrowser2->setContentFont (font);
+ ui->houndQueueTextBrowser->setContentFont(font);
+ ui->houndQueueTextBrowser->displayHoundToBeCalled(" ");
+ ui->houndQueueTextBrowser->setText("");
+
+ ui->foxTxListTextBrowser->setContentFont(font);
+ ui->foxTxListTextBrowser->displayHoundToBeCalled(" ");
+ ui->foxTxListTextBrowser->setText("");
+
+ auto style_sheet = "QLabel {" + font_as_stylesheet (font) + '}';
+ ui->lh_decodes_headings_label->setStyleSheet (ui->lh_decodes_headings_label->styleSheet () + style_sheet);
+ ui->rh_decodes_headings_label->setStyleSheet (ui->rh_decodes_headings_label->styleSheet () + style_sheet);
+ if (m_msgAvgWidget) {
+ m_msgAvgWidget->changeFont (font);
+ }
+ if (m_foxLogWindow) {
+ m_foxLogWindow->set_log_view_font (font);
+ }
+ if (m_contestLogWindow) {
+ m_contestLogWindow->set_log_view_font (font);
+ m_contestLogWindow->set_nQSO(m_logBook.contest_log()->n_qso());
+ }
+ if(m_ActiveStationsWidget != NULL) {
+ m_ActiveStationsWidget->changeFont(font);
+ }
+ updateGeometry ();
+}
+
+void MainWindow::fixStop()
+{
+ m_hsymStop=179;
+ if(m_mode=="WSPR") {
+ m_hsymStop=396;
+ } else if(m_mode=="Echo") {
+ m_hsymStop=9;
+ } else if (m_mode=="JT4"){
+ m_hsymStop=176;
+ if(m_config.decode_at_52s()) m_hsymStop=179;
+ } else if (m_mode=="JT9"){
+ m_hsymStop=173;
+ if(m_config.decode_at_52s()) m_hsymStop=179;
+ } else if (m_mode=="JT65"){
+ m_hsymStop=174;
+ if(m_config.decode_at_52s()) m_hsymStop=179;
+ } else if (m_mode=="Q65"){
+ m_hsymStop=48; // 13.8 s
+ if(m_TRperiod==30) {
+ m_hsymStop=96; // 27.6 s
+ if(m_config.decode_at_52s()) m_hsymStop=100; // 28.8 s
+ }
+ if(m_TRperiod==60) m_hsymStop=196; // 56.4 s
+ if(m_TRperiod==120) m_hsymStop=408; // 117.5 s
+ if(m_TRperiod==300) m_hsymStop=1030; // 296.6 s
+ } else if (m_mode=="FreqCal"){
+ m_hsymStop=((int(m_TRperiod/0.288))/8)*8;
+ } else if (m_mode=="FT8") {
+ m_hsymStop=50;
+ } else if (m_mode=="FT4") {
+ m_hsymStop=21;
+ } else if(m_mode=="FST4" or m_mode=="FST4W") {
+ int stop[] = {39,85,187,387,1003,3107,6232};
+ int stop_EME[] = {48,95,197,396,1012,3107,6232};
+ int i=0;
+ if(m_TRperiod==30) i=1;
+ if(m_TRperiod==60) i=2;
+ if(m_TRperiod==120) i=3;
+ if(m_TRperiod==300) i=4;
+ if(m_TRperiod==900) i=5;
+ if(m_TRperiod==1800) i=6;
+ if(m_config.decode_at_52s()) {
+ m_hsymStop=stop_EME[i];
+ } else {
+ m_hsymStop=stop[i];
+ }
+ }
+}
+
+//-------------------------------------------------------------- dataSink()
+void MainWindow::dataSink(qint64 frames)
+{
+ static float s[NSMAX];
+ char line[80];
+ int k(frames);
+ auto fname {QDir::toNativeSeparators(m_config.writeable_data_dir ().absoluteFilePath ("refspec.dat")).toLocal8Bit ()};
+
+ if(m_diskData) {
+ dec_data.params.ndiskdat=1;
+ } else {
+ dec_data.params.ndiskdat=0;
+ m_wideGraph->setDiskUTC(-1);
+ }
+
+ m_bUseRef=m_wideGraph->useRef();
+ if(!m_diskData) {
+ refspectrum_(&dec_data.d2[k-m_nsps/2],&m_bClearRefSpec,&m_bRefSpec,
+ &m_bUseRef, fname.constData (), (FCL)fname.size ());
+ }
+ m_bClearRefSpec=false;
+
+ if(m_mode=="MSK144" or m_bFast9) {
+ fastSink(frames);
+ if(m_bFastMode) return;
+ }
+
+// Get power, spectrum, and ihsym
+ dec_data.params.nfa=m_wideGraph->nStartFreq();
+ dec_data.params.nfb=m_wideGraph->Fmax();
+ if(m_mode=="FST4") {
+ dec_data.params.nfa=ui->sbF_Low->value();
+ dec_data.params.nfb=ui->sbF_High->value();
+ }
+ int nsps=m_nsps;
+ if(m_bFastMode) nsps=6912;
+ int nsmo=m_wideGraph->smoothYellow()-1;
+ bool bLowSidelobes=m_config.lowSidelobes();
+ int npct=0;
+ if(m_mode.startsWith("FST4")) npct=ui->sbNB->value();
+ symspec_(&dec_data,&k,&m_TRperiod,&nsps,&m_inGain,&bLowSidelobes,&nsmo,&m_px,s,
+ &m_df3,&m_ihsym,&m_npts8,&m_pxmax,&npct);
+ if(m_mode=="WSPR" or m_mode=="FST4W") wspr_downsample_(dec_data.d2,&k);
+ if(m_ihsym <=0) return;
+ if(ui) ui->signal_meter_widget->setValue(m_px,m_pxmax); // Update thermometer
+ if(m_monitoring || m_diskData) {
+ m_wideGraph->dataSink2(s,m_df3,m_ihsym,m_diskData,m_px);
+ }
+ if(m_mode=="MSK144") return;
+
+ fixStop();
+ if (m_mode == "FreqCal"
+ // only calculate after 1st chunk, also skip chunk where rig
+ // changed frequency
+ && !(m_ihsym % 8) && m_ihsym > 8 && m_ihsym <= m_hsymStop) {
+ int RxFreq=ui->RxFreqSpinBox->value ();
+ int nkhz=(m_freqNominal+RxFreq)/1000;
+ int ftol = ui->sbFtol->value ();
+ freqcal_(&dec_data.d2[0], &k, &nkhz, &RxFreq, &ftol, &line[0], (FCL)80);
+ QString t=QString::fromLatin1(line);
+ DecodedText decodedtext {t};
+ ui->decodedTextBrowser->displayDecodedText (decodedtext, m_config.my_callsign(),
+ m_mode, m_config.DXCC(), m_logBook, m_currentBand, m_config.ppfx());
+ if (ui->measure_check_box->isChecked ()) {
+ // Append results text to file "fmt.all".
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("fmt.all")};
+ if (f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append)) {
+ QTextStream out(&f);
+ out << t
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f.close();
+ } else {
+ MessageBox::warning_message (this, tr ("File Open Error")
+ , tr ("Cannot open \"%1\" for append: %2")
+ .arg (f.fileName ()).arg (f.errorString ()));
+ }
+ }
+ if(m_ihsym==m_hsymStop && ui->actionFrequency_calibration->isChecked()) {
+ freqCalStep();
+ }
+ }
+
+ if(m_ihsym==3*m_hsymStop/4) {
+ m_dialFreqRxWSPR=m_freqNominal;
+ }
+
+ if(m_mode=="FT8") {
+ to_jt9(m_ihsym,-1,-1); //Allow jt9 to bail out early, if necessary
+ if(m_ihsym==40 and m_decoderBusy) {
+ qDebug() << "Clearing hung decoder status";
+ decodeDone(); //Clear a hung decoder status
+ }
+ }
+
+ bool bCallDecoder=false;
+ if(m_ihsym==m_hsymStop) bCallDecoder=true;
+ if(m_mode=="FT8" and !m_diskData) {
+ if(m_ihsym==m_earlyDecode) bCallDecoder=true;
+ if(m_ihsym==m_earlyDecode2) bCallDecoder=true;
+ }
+ if(bCallDecoder) {
+ if(m_mode=="Echo") {
+ float dBerr=0.0;
+ int nfrit=0;
+ if(m_astroWidget) nfrit=m_astroWidget->nfRIT();
+ int nauto=0;
+ if(m_auto) nauto=1;
+ int nqual=0;
+ float f1=1500.0 + m_fDither;
+ float xlevel=0.0;
+ float sigdb=0.0;
+ float dfreq=0.0;
+ float width=m_fSpread;
+ echocom_.nclearave=m_nclearave;
+ int nDop=m_fAudioShift;
+ if(m_astroWidget->DopplerMethod()==2) nDop=0; //Using CFOM
+ int nDopTotal=m_fDop;
+ int navg=ui->sbEchoAvg->value();
+ if(m_diskData) {
+ int idir=-1;
+ save_echo_params_(&nDopTotal,&nDop,&nfrit,&f1,&width,dec_data.d2,&idir);
+ }
+ avecho_(dec_data.d2,&nDop,&nfrit,&nauto,&navg,&nqual,&f1,&xlevel,&sigdb,
+ &dBerr,&dfreq,&width,&m_diskData);
+ //Don't restart Monitor after an Echo transmission
+ if(m_bEchoTxed and !m_auto) {
+ monitor(false);
+ m_bEchoTxed=false;
+ }
+
+ if(m_monitoring or m_auto or m_diskData) {
+ QString t0,t1;
+ if(m_diskData) {
+ t0=t0.asprintf("%06d ",m_UTCdisk);
+ } else {
+ QDateTime now=QDateTime::currentDateTimeUtc();
+ int ihr=now.toString("hh").toInt();
+ int imin=now.toString("mm").toInt();
+ int isec=now.toString("ss").toInt();
+ if(m_auto) isec=isec - isec%6;
+ if(!m_auto) isec=isec - isec%3;
+ t0=t0.asprintf("%02d%02d%02d ",ihr,imin,isec);
+ t1=now.toString("yyMMdd_");
+ }
+ int n=t0.toInt();
+ int nsec=((n/10000)*3600) + (((n/100)%100)*60) + (n%100);
+ if(!m_echoRunning or echocom_.nsum<2) m_echoSec0=nsec;
+ float hour=n/10000 + ((n/100)%100)/60.0 + (n%100)/3600.0;
+ m_echoRunning=true;
+ QString t;
+ t = t.asprintf("%9.6f %5.2f %7d %7.1f %7d %7d %7d %7.1f %7.1f",hour,xlevel,
+ nDopTotal,width,echocom_.nsum,nqual,qRound(dfreq),sigdb,dBerr);
+ t = t0 + t;
+ if (ui) ui->decodedTextBrowser->insertText(t);
+ t=t1+t;
+ write_all("Rx",t);
+ }
+
+ if(m_echoGraph->isVisible()) m_echoGraph->plotSpec();
+ if(m_saveAll and !m_diskData) {
+ int idir=1;
+ save_echo_params_(&m_fDop,&nDop,&nfrit,&f1,&width,dec_data.d2,&idir);
+ m_fSpread=width;
+ }
+ m_nclearave=0;
+ }
+ if(m_mode=="FreqCal") return;
+
+ if(m_dialFreqRxWSPR==0) m_dialFreqRxWSPR=m_freqNominal;
+ m_dataAvailable=true;
+ dec_data.params.npts8=(m_ihsym*m_nsps)/16;
+ dec_data.params.newdat=1;
+ dec_data.params.nagain=0;
+ dec_data.params.nzhsym=m_hsymStop;
+ if(m_mode=="FT8" and m_ihsym==m_earlyDecode and !m_diskData) dec_data.params.nzhsym=m_earlyDecode;
+ if(m_mode=="FT8" and m_ihsym==m_earlyDecode2 and !m_diskData) dec_data.params.nzhsym=m_earlyDecode2;
+ QDateTime now {QDateTime::currentDateTimeUtc ()};
+ m_dateTime = now.toString ("yyyy-MMM-dd hh:mm");
+ if(m_mode!="WSPR") decode(); //Start decoder
+
+ if(m_mode=="FT8" and !m_diskData and (m_ihsym==m_earlyDecode or m_ihsym==m_earlyDecode2)) return;
+ if (!m_diskData)
+ {
+ Q_EMIT reset_audio_input_stream (true); // reports dropped samples
+ }
+ if(!m_diskData and (m_saveAll or m_saveDecoded or m_mode=="WSPR")) {
+ //Always save unless "Save None"; may delete later
+ if(m_TRperiod < 60) {
+ int n=fmod(double(now.time().second()),m_TRperiod);
+ if(n<(m_TRperiod/2)) n=n+m_TRperiod;
+ auto const& period_start=now.addSecs(-n);
+ m_fnameWE=m_config.save_directory().absoluteFilePath (period_start.toString("yyMMdd_hhmmss"));
+ } else {
+ auto const& period_start = now.addSecs (-(now.time ().minute () % (int(m_TRperiod) / 60)) * 60);
+ m_fnameWE=m_config.save_directory ().absoluteFilePath (period_start.toString ("yyMMdd_hhmm"));
+ }
+ int samples=m_TRperiod*12000;
+ if(m_mode=="FT4") samples=21*3456;
+
+ // the following is potential a threading hazard - not a good
+ // idea to pass pointer to be processed in another thread
+ m_saveWAVWatcher.setFuture (QtConcurrent::run (std::bind (&MainWindow::save_wave_file,
+ this, m_fnameWE, &dec_data.d2[0], samples, m_config.my_callsign(),
+ m_config.my_grid(), m_mode, m_nSubMode, m_freqNominalPeriod, m_hisCall, m_hisGrid)));
+ if (m_mode=="WSPR") {
+ auto c2name {(m_fnameWE + ".c2").toLocal8Bit ()};
+ int nsec=120;
+ int nbfo=1500;
+ double f0m1500=m_freqNominal/1000000.0 + nbfo - 1500;
+ int err = savec2_(c2name.constData (),&nsec,&f0m1500, (FCL)c2name.size());
+ if (err!=0) MessageBox::warning_message (this, tr ("Error saving c2 file"), c2name);
+ }
+ }
+
+ if(m_mode=="WSPR") {
+ QStringList t2;
+ QStringList depth_args;
+ t2 << "-f" << QString {"%1"}.arg (m_dialFreqRxWSPR / 1e6, 0, 'f', 6);
+ if((m_ndepth&7)==1) depth_args << "-qB"; //2 pass w subtract, no Block detection, no shift jittering
+ if((m_ndepth&7)==2) depth_args << "-C" << "500" << "-o" << "4"; //3 pass, subtract, Block detection, OSD
+ if((m_ndepth&7)==3) depth_args << "-C" << "500" << "-o" << "4" << "-d"; //3 pass, subtract, Block detect, OSD, more candidates
+ QStringList degrade;
+ degrade << "-d" << QString {"%1"}.arg (m_config.degrade(), 4, 'f', 1);
+ m_cmndP1.clear ();
+ if(m_diskData) {
+ m_cmndP1 << depth_args << "-a"
+ << QDir::toNativeSeparators (m_config.writeable_data_dir ().absolutePath()) << m_path;
+ } else {
+ m_cmndP1 << depth_args << "-a"
+ << QDir::toNativeSeparators (m_config.writeable_data_dir ().absolutePath())
+ << t2 << m_fnameWE + ".wav";
+ }
+ if (ui) ui->DecodeButton->setChecked (true);
+ p1Timer.start(1000);
+ m_decoderBusy = true;
+ statusUpdate ();
+ }
+
+ m_rxDone=true;
+ }
+}
+
+void MainWindow::startP1()
+{
+ p1.start (QDir::toNativeSeparators (QDir {QApplication::applicationDirPath ()}.absoluteFilePath ("wsprd")), m_cmndP1);
+}
+
+QString MainWindow::save_wave_file (QString const& name, short const * data, int samples,
+ QString const& my_callsign, QString const& my_grid, QString const& mode, qint32 sub_mode,
+ Frequency frequency, QString const& his_call, QString const& his_grid) const
+{
+ //
+ // This member function runs in a thread and should not access
+ // members that may be changed in the GUI thread or any other thread
+ // without suitable synchronization.
+ //
+ QAudioFormat format;
+ format.setCodec ("audio/pcm");
+ format.setSampleRate (12000);
+ format.setChannelCount (1);
+ format.setSampleSize (16);
+ format.setSampleType (QAudioFormat::SignedInt);
+ auto source = QString {"%1; %2"}.arg (my_callsign).arg (my_grid);
+ auto comment = QString {"Mode=%1%2; Freq=%3%4"}
+ .arg (mode)
+ .arg (QString {(mode.contains ('J') && !mode.contains ('+'))
+ || mode.startsWith ("FST4") || mode.startsWith ('Q')
+ ? QString {"; Sub Mode="} + QString::number (int (samples / 12000)) + QChar {'A' + sub_mode}
+ : QString {}})
+ .arg (Radio::frequency_MHz_string (frequency))
+ .arg (QString {mode!="WSPR" ? QString {"; DXCall=%1; DXGrid=%2"}
+ .arg (his_call)
+ .arg (his_grid).toLocal8Bit () : ""});
+ BWFFile::InfoDictionary list_info {
+ {{{'I','S','R','C'}}, source.toLocal8Bit ()},
+ {{{'I','S','F','T'}}, program_title (revision ()).simplified ().toLocal8Bit ()},
+ {{{'I','C','R','D'}}, QDateTime::currentDateTimeUtc ()
+ .toString ("yyyy-MM-ddTHH:mm:ss.zzzZ").toLocal8Bit ()},
+ {{{'I','C','M','T'}}, comment.toLocal8Bit ()},
+ };
+ auto file_name = name + ".wav";
+ BWFFile wav {format, file_name, list_info};
+ if (!wav.open (BWFFile::WriteOnly)
+ || 0 > wav.write (reinterpret_cast<char const *> (data)
+ , sizeof (short) * samples))
+ {
+ return file_name + ": " + wav.errorString ();
+ }
+ return QString {};
+}
+
+//-------------------------------------------------------------- fastSink()
+void MainWindow::fastSink(qint64 frames)
+{
+ int k (frames);
+ bool decodeNow=false;
+ if(k < m_k0) { //New sequence ?
+ memcpy(fast_green2,fast_green,4*703); //Copy fast_green[] to fast_green2[]
+ memcpy(fast_s2,fast_s,4*703*64); //Copy fast_s[] into fast_s2[]
+ fast_jh2=fast_jh;
+ if(!m_diskData) memset(dec_data.d2,0,2*30*12000); //Zero the d2[] array
+ m_bFastDecodeCalled=false;
+ m_bDecoded=false;
+ }
+
+ QDateTime tnow=QDateTime::currentDateTimeUtc();
+ int ihr=tnow.toString("hh").toInt();
+ int imin=tnow.toString("mm").toInt();
+ int isec=tnow.toString("ss").toInt();
+ isec=isec - fmod(double(isec),m_TRperiod);
+ int nutc0=10000*ihr + 100*imin + isec;
+ if(m_diskData) nutc0=m_UTCdisk;
+ char line[80];
+ bool bmsk144=((m_mode=="MSK144") and (m_monitoring or m_diskData));
+ line[0]=0;
+
+ int RxFreq=ui->RxFreqSpinBox->value ();
+ int nTRpDepth=m_TRperiod + 1000*(m_ndepth & 3);
+ qint64 ms0 = QDateTime::currentMSecsSinceEpoch();
+// ::memcpy(dec_data.params.mycall, (m_baseCall+" ").toLatin1(),sizeof dec_data.params.mycall);
+ ::memcpy(dec_data.params.mycall,(m_config.my_callsign () + " ").toLatin1(),sizeof dec_data.params.mycall);
+ QString hisCall {ui->dxCallEntry->text ()};
+ bool bshmsg=ui->cbShMsgs->isChecked();
+ bool bswl=ui->cbSWL->isChecked();
+// ::memcpy(dec_data.params.hiscall,(Radio::base_callsign (hisCall) + " ").toLatin1 ().constData (), sizeof dec_data.params.hiscall);
+ ::memcpy(dec_data.params.hiscall,(hisCall + " ").toLatin1 ().constData (), sizeof dec_data.params.hiscall);
+ ::memcpy(dec_data.params.mygrid, (m_config.my_grid()+" ").toLatin1(), sizeof dec_data.params.mygrid);
+ auto data_dir {m_config.writeable_data_dir ().absolutePath ().toLocal8Bit ()};
+ float pxmax = 0;
+ float rmsNoGain = 0;
+ int ftol = ui->sbFtol->value ();
+ hspec_(dec_data.d2,&k,&nutc0,&nTRpDepth,&RxFreq,&ftol,&bmsk144,
+ &m_bTrain,m_phaseEqCoefficients.constData(),&m_inGain,&dec_data.params.mycall[0],
+ &dec_data.params.hiscall[0],&bshmsg,&bswl,
+ data_dir.constData (),fast_green,fast_s,&fast_jh,&pxmax,&rmsNoGain,&line[0],(FCL)12,
+ (FCL)12,(FCL)data_dir.size (),(FCL)80);
+ float px = fast_green[fast_jh];
+ QString t;
+ t = t.asprintf(" Rx noise: %5.1f ",px);
+ ui->signal_meter_widget->setValue(rmsNoGain,pxmax); // Update thermometer
+ m_fastGraph->plotSpec(m_diskData,m_UTCdisk);
+
+ if(bmsk144 and (line[0]!=0)) {
+ QString message {QString::fromLatin1 (line)};
+ DecodedText decodedtext {message.replace (QChar::LineFeed, "")};
+ ui->decodedTextBrowser->displayDecodedText (decodedtext, m_config.my_callsign (), m_mode, m_config.DXCC(),
+ m_logBook, m_currentBand, m_config.ppfx ());
+ m_bDecoded=true;
+ auto_sequence (decodedtext, ui->sbFtol->value (), std::numeric_limits<unsigned>::max ());
+ postDecode (true, decodedtext.string ());
+// writeAllTxt(message);
+ write_all("Rx",message);
+ bool stdMsg = decodedtext.report(m_baseCall,
+ Radio::base_callsign(ui->dxCallEntry->text()),m_rptRcvd);
+ if (stdMsg) pskPost (decodedtext);
+ }
+
+ float fracTR=float(k)/(12000.0*m_TRperiod);
+ decodeNow=false;
+ if(fracTR>0.92) {
+ m_dataAvailable=true;
+ fast_decode_done();
+ m_bFastDone=true;
+ }
+
+ m_k0=k;
+ if(m_diskData and m_k0 >= dec_data.params.kin - 7 * 512) decodeNow=true;
+ if(!m_diskData and m_tRemaining<0.35 and !m_bFastDecodeCalled) decodeNow=true;
+ if(m_mode=="MSK144") decodeNow=false;
+
+ if(decodeNow) {
+ m_dataAvailable=true;
+ m_t0=0.0;
+ m_t1=k/12000.0;
+ m_kdone=k;
+ dec_data.params.newdat=1;
+ if(!m_decoderBusy) {
+ m_bFastDecodeCalled=true;
+ decode();
+ }
+ }
+
+ if(decodeNow or m_bFastDone) {
+ if(!m_diskData and (m_saveAll or m_saveDecoded)) {
+ QDateTime now {QDateTime::currentDateTimeUtc()};
+ int n=fmod(double(now.time().second()),m_TRperiod);
+ if(n<(m_TRperiod/2)) n=n+m_TRperiod;
+ auto const& period_start = now.addSecs (-n);
+ m_fnameWE = m_config.save_directory ().absoluteFilePath (period_start.toString ("yyMMdd_hhmmss"));
+ if(m_saveAll or m_bAltV or (m_bDecoded and m_saveDecoded) or (m_mode!="MSK144")) {
+ m_bAltV=false;
+ // the following is potential a threading hazard - not a good
+ // idea to pass pointer to be processed in another thread
+ m_saveWAVWatcher.setFuture (QtConcurrent::run (std::bind (&MainWindow::save_wave_file,
+ this, m_fnameWE, &dec_data.d2[0], int(m_TRperiod*12000.0), m_config.my_callsign(),
+ m_config.my_grid(), m_mode, m_nSubMode, m_freqNominal, m_hisCall, m_hisGrid)));
+ }
+ if(m_mode!="MSK144") {
+ killFileTimer.start (int(750.0*m_TRperiod)); //Kill 3/4 period from now
+ }
+ }
+ m_bFastDone=false;
+ }
+ float tsec=0.001*(QDateTime::currentMSecsSinceEpoch() - ms0);
+ m_fCPUmskrtd=0.9*m_fCPUmskrtd + 0.1*tsec;
+}
+
+void MainWindow::showSoundInError(const QString& errorMsg)
+{
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ MessageBox::critical_message (this, tr ("Error in Sound Input"), errorMsg);
+}
+
+void MainWindow::showSoundOutError(const QString& errorMsg)
+{
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ MessageBox::critical_message (this, tr ("Error in Sound Output"), errorMsg);
+}
+
+void MainWindow::showStatusMessage(const QString& statusMsg)
+{
+ statusBar()->showMessage(statusMsg, 5000);
+}
+
+void MainWindow::on_actionSettings_triggered() //Setup Dialog
+{
+ // things that might change that we need know about
+ auto callsign = m_config.my_callsign ();
+ auto my_grid = m_config.my_grid ();
+ SpecOp nContest0=m_specOp;
+ auto psk_on = m_config.spot_to_psk_reporter ();
+ if (QDialog::Accepted == m_config.exec ()) {
+ checkMSK144ContestType();
+ if (m_config.my_callsign () != callsign) {
+ m_baseCall = Radio::base_callsign (m_config.my_callsign ());
+ ui->tx1->setEnabled (elide_tx1_not_allowed () || ui->tx1->isEnabled ());
+ morse_(const_cast<char *> (m_config.my_callsign ().toLatin1().constData()),
+ const_cast<int *> (icw), &m_ncw, (FCL)m_config.my_callsign().length());
+ }
+ if (m_config.my_callsign () != callsign || m_config.my_grid () != my_grid) {
+ statusUpdate ();
+ }
+ on_dxGridEntry_textChanged (m_hisGrid); // recalculate distances in case of units change
+ enable_DXCC_entity (m_config.DXCC ()); // sets text window proportions and (re)inits the logbook
+
+ pskSetLocal ();
+ // this will close the connection to PSKReporter if it has been
+ // disabled
+ if (psk_on && !m_config.spot_to_psk_reporter ())
+ {
+ m_psk_Reporter.sendReport (true);
+ }
+
+ if(m_config.restart_audio_input () && !m_config.audio_input_device ().isNull ()) {
+ Q_EMIT startAudioInputStream (m_config.audio_input_device ()
+ , m_rx_audio_buffer_frames
+ , m_detector, m_downSampleFactor
+ , m_config.audio_input_channel ());
+ }
+
+ if(m_config.restart_audio_output () && !m_config.audio_output_device ().isNull ()) {
+ Q_EMIT initializeAudioOutputStream (m_config.audio_output_device ()
+ , AudioDevice::Mono == m_config.audio_output_channel () ? 1 : 2
+ , m_tx_audio_buffer_frames);
+ }
+
+ displayDialFrequency ();
+ bool vhf {m_config.enable_VHF_features()};
+ m_wideGraph->setVHF(vhf);
+ if (!vhf) ui->sbSubmode->setValue (0);
+
+ setup_status_bar (vhf);
+ bool b = vhf && (m_mode=="JT4" or m_mode=="JT65" or
+ m_mode=="JT9" or m_mode=="MSK144" or m_mode=="Q65");
+ if(b) VHF_features_enabled(b);
+ set_mode (m_mode);
+ if(b) VHF_features_enabled(b);
+
+ m_config.transceiver_online ();
+ if(!m_bFastMode) setXIT (ui->TxFreqSpinBox->value ());
+ if ((m_config.single_decode () && !m_mode.startsWith ("FST4")) || m_mode=="JT4") {
+ ui->lh_decodes_title_label->setText(tr ("Single-Period Decodes"));
+ ui->rh_decodes_title_label->setText(tr ("Average Decodes"));
+ }
+
+ update_watchdog_label ();
+ if(!m_splitMode) ui->cbCQTx->setChecked(false);
+ if(!m_config.enable_VHF_features()) {
+ ui->actionInclude_averaging->setVisible(false);
+ ui->actionInclude_correlation->setVisible (false);
+ ui->actionInclude_averaging->setChecked(false);
+ ui->actionInclude_correlation->setChecked(false);
+ ui->actionEnable_AP_JT65->setVisible(false);
+ ui->actionAuto_Clear_Avg->setVisible(false);
+ }
+ m_specOp=m_config.special_op_id();
+ if(m_specOp!=nContest0) {
+ ui->tx1->setEnabled(true);
+ ui->txb1->setEnabled(true);
+ set_mode(m_mode);
+ }
+ chkFT4();
+ if(SpecOp::EU_VHF==m_specOp and m_config.my_grid().size()<6) {
+ MessageBox::information_message (this,
+ "EU VHF Contest messages require a 6-character locator.");
+ }
+ if((m_specOp==SpecOp::FOX or m_specOp==SpecOp::HOUND) and
+ m_mode!="FT8") {
+ MessageBox::information_message (this,
+ "Fox-and-Hound operation is available only in FT8 mode.\nGo back and change your selection.");
+ }
+ ui->labDXped->setVisible(SpecOp::NONE != m_specOp);
+ if ((!verified && ui->labDXped->isVisible()) or ui->labDXped->text()!="Super Hound")
+ ui->labDXped->setStyleSheet("QLabel {background-color: red; color: white;}");
+ set_mode(m_mode);
+ configActiveStations();
+ }
+ if(m_mode=="FT8") on_actionFT8_triggered(); //in case we need to reset some things for Fox/Hound
+}
+
+void MainWindow::on_monitorButton_clicked (bool checked)
+{
+ if (!m_transmitting) {
+ auto prior = m_monitoring;
+ monitor (checked);
+ if (checked && !prior) {
+ if (m_config.monitor_last_used ()) {
+ // put rig back where it was when last in control
+ setRig (m_lastMonitoredFrequency);
+ setXIT (ui->TxFreqSpinBox->value ());
+ }
+ // ensure FreqCal triggers
+ if(m_mode=="FST4W") {
+ on_sbFST4W_RxFreq_valueChanged(ui->sbFST4W_RxFreq->value());
+ } else {
+ on_RxFreqSpinBox_valueChanged (ui->RxFreqSpinBox->value ());
+ }
+ }
+ //Get Configuration in/out of strict split and mode checking
+ m_config.sync_transceiver (true, checked);
+ } else {
+ ui->monitorButton->setChecked (false); // disallow
+ }
+ if(m_mode=="Echo") m_echoRunning=false;
+}
+
+void MainWindow::monitor (bool state)
+{
+ ui->monitorButton->setChecked (state);
+ if (state) {
+ m_diskData = false; // no longer reading WAV files
+ if (!m_monitoring) Q_EMIT resumeAudioInputStream ();
+ } else {
+ Q_EMIT suspendAudioInputStream ();
+ }
+ m_monitoring = state;
+}
+
+void MainWindow::on_actionAbout_triggered() //Display "About"
+{
+ CAboutDlg {this}.exec ();
+}
+
+void MainWindow::on_autoButton_clicked (bool checked)
+{
+ stopWRTimer.stop(); // stop a running Tx3 timer
+ m_auto = checked;
+ m_maxPoints=-1;
+ if (checked
+ && ui->respondComboBox->isVisible () && ui->respondComboBox->currentText() != "CQ: None"
+ && CALLING == m_QSOProgress) {
+ m_bAutoReply = false; // ready for next
+ m_bCallingCQ = true; // allows tail-enders to be picked up
+ }
+ if (!checked) m_bCallingCQ = false;
+ statusUpdate ();
+ m_bEchoTxOK=false;
+ if(m_mode=="Echo" and m_auto) {
+ m_nclearave=1;
+ echocom_.nsum=0;
+ }
+ m_tAutoOn=QDateTime::currentMSecsSinceEpoch()/1000;
+ if(m_mode=="Echo") m_echoRunning=false;
+}
+
+void MainWindow::on_sbTxPercent_valueChanged (int n)
+{
+ update_dynamic_property (ui->sbTxPercent, "notx", !n);
+}
+
+void MainWindow::auto_tx_mode (bool state)
+{
+ ui->autoButton->setChecked (state);
+ on_autoButton_clicked (state);
+}
+
+void MainWindow::keyPressEvent (QKeyEvent * e)
+{
+ if(SpecOp::FOX == m_specOp) {
+ switch (e->key()) {
+ case Qt::Key_Return:
+ doubleClickOnCall2(Qt::KeyboardModifier(Qt::ShiftModifier + Qt::ControlModifier + Qt::AltModifier));
+ return;
+ case Qt::Key_Enter:
+ doubleClickOnCall2(Qt::KeyboardModifier(Qt::ShiftModifier + Qt::ControlModifier + Qt::AltModifier));
+ return;
+ case Qt::Key_Backspace:
+ qDebug() << "Key Backspace";
+ return;
+ case Qt::Key_X:
+ if(e->modifiers() & Qt::AltModifier) {
+ foxTest();
+ return;
+ }
+ }
+ QMainWindow::keyPressEvent (e);
+ }
+ // Why shall RETURN switch Tx on when in Hound mode? Makes little sense and confuses many OMs!
+// if(SpecOp::HOUND == m_specOp) {
+// switch (e->key()) {
+// case Qt::Key_Return:
+// auto_tx_mode(true);
+// return;
+// case Qt::Key_Enter:
+// auto_tx_mode(true);
+// return;
+// }
+// QMainWindow::keyPressEvent (e);
+// }
+
+ int n;
+ bool bAltF1F6=m_config.alternate_bindings();
+ switch(e->key())
+ {
+ case Qt::Key_A:
+ if(m_mode=="Q65" && e->modifiers() & Qt::AltModifier) {
+ m_EMECall.clear();
+ qmapcom.ndecodes=0;
+ readWidebandDecodes();
+ }
+ return;
+ case Qt::Key_B:
+ if(m_mode=="FT4" && e->modifiers() & Qt::AltModifier) {
+ on_pbBestSP_clicked();
+ }
+ return;
+ case Qt::Key_C:
+ if(e->modifiers() & Qt::AltModifier) {
+ int n=ui->respondComboBox->currentIndex()+1;
+ if(n>2) n=0;
+ ui->respondComboBox->setCurrentIndex(n);
+ }
+ return;
+ case Qt::Key_D:
+ if(m_mode != "WSPR" && e->modifiers() & Qt::ShiftModifier) {
+ if(!m_decoderBusy) {
+ dec_data.params.newdat=0;
+ dec_data.params.nagain=0;
+ decode();
+ return;
+ }
+ }
+ break;
+ case Qt::Key_F1:
+ if(bAltF1F6) {
+ auto_tx_mode(true);
+ on_txb6_clicked();
+ return;
+ } else {
+ on_actionOnline_User_Guide_triggered();
+ return;
+ }
+ case Qt::Key_F2:
+ if(bAltF1F6) {
+ auto_tx_mode(true);
+ on_txb2_clicked();
+ return;
+ } else {
+ on_actionSettings_triggered();
+ return;
+ }
+ case Qt::Key_F3:
+ if(bAltF1F6) {
+ auto_tx_mode(true);
+ on_txb3_clicked();
+ return;
+ } else {
+ on_actionKeyboard_shortcuts_triggered();
+ return;
+ }
+ case Qt::Key_F4:
+ if(bAltF1F6) {
+ auto_tx_mode(true);
+ on_txb4_clicked();
+ return;
+ } else {
+ clearDX ();
+ ui->dxCallEntry->setFocus();
+ return;
+ }
+ case Qt::Key_F5:
+ if(bAltF1F6) {
+ auto_tx_mode(true);
+ on_txb5_clicked();
+ return;
+ } else {
+ on_actionSpecial_mouse_commands_triggered();
+ return;
+ }
+ case Qt::Key_F6:
+ if(bAltF1F6) {
+ int n=ui->respondComboBox->currentIndex()+1;
+ if(n>2) n=0;
+ ui->respondComboBox->setCurrentIndex(n);
+ } else {
+ if(e->modifiers() & Qt::ShiftModifier) {
+ on_actionDecode_remaining_files_in_directory_triggered();
+ } else {
+ on_actionOpen_next_in_directory_triggered();
+ }
+ }
+ return;
+ case Qt::Key_F11:
+ if((e->modifiers() & Qt::ControlModifier) and (e->modifiers() & Qt::ShiftModifier)) {
+ m_bandEdited = true;
+ band_changed(m_freqNominal-1000);
+ } else {
+ n=11;
+ if(e->modifiers() & Qt::ControlModifier) n+=100;
+ if(e->modifiers() & Qt::ShiftModifier) {
+ int offset=60;
+ if(m_mode=="FT4") offset=90;
+ ui->TxFreqSpinBox->setValue(ui->TxFreqSpinBox->value()-offset);
+ } else{
+ bumpFqso(n);
+ }
+ }
+ return;
+ case Qt::Key_F12:
+ if((e->modifiers() & Qt::ControlModifier) and (e->modifiers() & Qt::ShiftModifier)) {
+ m_bandEdited = true;
+ band_changed(m_freqNominal+1000);
+ } else {
+ n=12;
+ if(e->modifiers() & Qt::ControlModifier) n+=100;
+ if(e->modifiers() & Qt::ShiftModifier) {
+ int offset=60;
+ if(m_mode=="FT4") offset=90;
+ ui->TxFreqSpinBox->setValue(ui->TxFreqSpinBox->value()+offset);
+ } else {
+ bumpFqso(n);
+ }
+ }
+ return;
+ case Qt::Key_Escape:
+ m_nextCall="";
+ on_stopTxButton_clicked();
+ abortQSO();
+ return;
+ case Qt::Key_E:
+ if((e->modifiers() & Qt::ShiftModifier) and m_specOp!=SpecOp::FOX and m_specOp!=SpecOp::HOUND) {
+ ui->txFirstCheckBox->setChecked(false);
+ return;
+ }
+ else if((e->modifiers() & Qt::ControlModifier) and m_specOp!=SpecOp::FOX and m_specOp!=SpecOp::HOUND) {
+ ui->txFirstCheckBox->setChecked(true);
+ return;
+ }
+ break;
+ case Qt::Key_F:
+ if(e->modifiers() & Qt::ControlModifier) {
+ if(ui->tabWidget->currentIndex()==0) {
+ ui->tx5->clearEditText();
+ ui->tx5->setFocus();
+ }
+ return;
+ }
+ break;
+ case Qt::Key_G:
+ if(e->modifiers() & Qt::AltModifier) {
+ genStdMsgs (m_rpt, true);
+ return;
+ }
+ break;
+ case Qt::Key_H:
+ if(e->modifiers() & Qt::AltModifier) {
+ on_stopTxButton_clicked();
+ return;
+ }
+ break;
+ case Qt::Key_L:
+ if(e->modifiers() & Qt::ControlModifier) {
+ lookup();
+ genStdMsgs(m_rpt);
+ return;
+ }
+ break;
+ case Qt::Key_O:
+ if(e->modifiers() & Qt::ControlModifier) {
+ on_actionOpen_triggered();
+ return;
+ }
+ else if(e->modifiers() & Qt::AltModifier) {
+ bool ok;
+ auto call = QInputDialog::getText (this, tr ("Change Operator"), tr ("New operator:"),
+ QLineEdit::Normal, m_config.opCall (), &ok);
+ if (ok) {
+ m_config.opCall (call);
+ }
+ return;
+ }
+ break;
+ case Qt::Key_R:
+ if(m_mode=="Q65" and e->modifiers() & Qt::ShiftModifier and
+ e->modifiers() & Qt::ControlModifier) {
+ if(m_specOp==SpecOp::Q65_PILEUP) {
+ refreshPileupList();
+ } else {
+ m_fetched=0;
+ readWidebandDecodes();
+ }
+ return;
+ }
+ if(e->modifiers() & Qt::AltModifier) {
+ if(!m_send_RR73) on_txrb4_doubleClicked();
+ return;
+ }
+ if(e->modifiers() & Qt::ControlModifier) {
+ if(m_send_RR73) on_txrb4_doubleClicked();
+ return;
+ }
+ break;
+ case Qt::Key_X:
+
+ if(e->modifiers() & Qt::AltModifier) {
+ //foxTest();
+ return;
+ }
+ }
+
+ QMainWindow::keyPressEvent (e);
+}
+
+void MainWindow::handleVerifyMsg(int status, QDateTime ts, QString callsign, QString code, unsigned int hz, QString const &response) {
+ (void)status;
+ (void)code;
+ if (response.length() > 0) {
+ QString msg = FoxVerifier::formatDecodeMessage(ts, callsign, hz, response);
+ if (msg.length() > 0)
+ ui->decodedTextBrowser->displayDecodedText(DecodedText{msg}, m_config.my_callsign(), m_mode, m_config.DXCC(),
+ m_logBook, m_currentBand, m_config.ppfx());
+ write_all("Ck",msg);
+ }
+ LOG_INFO(QString("FoxVerifier response for [%1]: - [%2]").arg(callsign).arg(response).toStdString());
+}
+
+QString MainWindow::userAgent() {
+ // see User-Agent format definition https://www.rfc-editor.org/rfc/rfc9110#name-user-agent
+ //
+ QString platform = "(" + QSysInfo::prettyProductName()+"; "+QSysInfo::productType() + " " + QSysInfo::productVersion() + "; " +
+ QSysInfo::currentCpuArchitecture() + "; " +
+ QString("rv:%1").arg(QSysInfo::kernelVersion()) + ")";
+ QString userAgent = QString{"WSJT-X/" + version() + "_" + m_revision}.simplified() + " " +platform;
+ return userAgent;
+ }
+
+void MainWindow::bumpFqso(int n) //bumpFqso()
+{
+ int i;
+ bool ctrl = (n>=100);
+ n=n%100;
+ i=ui->RxFreqSpinBox->value();
+ bool bTrackTx=ui->TxFreqSpinBox->value() == i;
+ if(n==11) i--;
+ if(n==12) i++;
+ if (ui->RxFreqSpinBox->isEnabled ()) {
+ ui->RxFreqSpinBox->setValue (i);
+ }
+ if(ctrl and m_mode=="WSPR") {
+ ui->WSPRfreqSpinBox->setValue(i);
+ } else {
+ if(ctrl and bTrackTx) {
+ ui->TxFreqSpinBox->setValue (i);
+ }
+ }
+}
+
+void MainWindow::displayDialFrequency ()
+{
+ Frequency dial_frequency {m_rigState.ptt () && m_rigState.split () ?
+ m_rigState.tx_frequency () : m_rigState.frequency ()};
+
+ // lookup band
+ auto const& band_name = m_config.bands ()->find (dial_frequency);
+ if (m_lastBand != band_name)
+ {
+ // only change this when necessary as we get called a lot and it
+ // would trash any user input to the band combo box line edit
+ ui->bandComboBox->setCurrentText (band_name.size () ? band_name : m_config.bands ()->oob ());
+ m_wideGraph->setRxBand (band_name);
+ m_lastBand = band_name;
+ band_changed(dial_frequency);
+ // prevent wrong frequencies for all.txt, PSK Reporter and highlighting for late decodes after band changes
+ m_displayBand = false;
+ QTimer::singleShot ((int(600.0*m_TRperiod)), [=] {
+ m_freqNominalPeriod = m_freqNominal;
+ m_currentBandPeriod = m_currentBand;
+ m_displayBand = true;
+ });
+ }
+
+ // search working frequencies for one we are within 10kHz of (1 Mhz
+ // of on VHF and up)
+ bool valid {false};
+ quint64 min_offset {99999999};
+ for (auto const& item : *m_config.frequencies ())
+ {
+ // we need to do specific checks for above and below here to
+ // ensure that we can use unsigned Radio::Frequency since we
+ // potentially use the full 64-bit unsigned range.
+ auto const& working_frequency = item.frequency_;
+ auto const& offset = dial_frequency > working_frequency ?
+ dial_frequency - working_frequency :
+ working_frequency - dial_frequency;
+ if (offset < min_offset) {
+ min_offset = offset;
+ }
+ }
+ if (min_offset < 10000u || (m_config.enable_VHF_features() && min_offset < 1000000u)) {
+ valid = true;
+ }
+
+ update_dynamic_property (ui->labDialFreq, "oob", !valid);
+ ui->labDialFreq->setText (Radio::pretty_frequency_MHz_string (dial_frequency));
+}
+
+ void MainWindow::stopWRTimeout()
+ {
+ auto_tx_mode(false);
+ }
+
+void MainWindow::statusChanged()
+{
+ if (m_specOp==SpecOp::Q65_PILEUP && m_mode != "Q65") on_actionQ65_triggered();
+ statusUpdate ();
+ QFile f {m_config.temp_dir ().absoluteFilePath ("wsjtx_status.txt")};
+ if(f.open(QFile::WriteOnly | QIODevice::Text)) {
+ QTextStream out(&f);
+ QString tmpGrid = m_hisGrid;
+ if (!tmpGrid.size ()) tmpGrid="n/a"; // Not Available
+ out << qSetRealNumberPrecision (12) << (m_freqNominal / 1.e6)
+ << ";" << m_mode << ";" << m_hisCall << ";"
+ << ui->rptSpinBox->value() << ";" << m_mode << ";" << tmpGrid
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f.close();
+ } else {
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ MessageBox::warning_message (this, tr ("Status File Error")
+ , tr ("Cannot open \"%1\" for writing: %2")
+ .arg (f.fileName ()).arg (f.errorString ()));
+ }
+ on_dxGridEntry_textChanged(m_hisGrid);
+ if (m_specOp!=SpecOp::HOUND) {
+ ui->txb2->setEnabled(true);
+ ui->txrb2->setEnabled(true);
+ ui->txb4->setEnabled(true);
+ ui->txrb4->setEnabled(true);
+ ui->txb5->setEnabled(true);
+ ui->txrb5->setEnabled(true);
+ ui->txb6->setEnabled(true);
+ ui->txrb6->setEnabled(true);
+ ui->houndButton->setChecked(false);
+ }
+ if (m_config.enable_VHF_features() && (m_mode=="JT4" or m_mode=="Q65" or m_mode=="JT65")) {
+ ui->actionInclude_averaging->setVisible(true);
+ ui->actionAuto_Clear_Avg->setVisible(true);
+ } else {
+ ui->actionInclude_averaging->setVisible(false);
+ ui->actionAuto_Clear_Avg->setVisible(false);
+ }
+ if (m_mode=="JT4" or m_mode=="Q65" or m_mode=="JT65") {
+ if (ui->actionInclude_averaging->isVisible() && ui->actionInclude_averaging->isChecked()) {
+ ui->lh_decodes_title_label->setText(tr ("Single-Period Decodes"));
+ ui->rh_decodes_title_label->setText(tr ("Average Decodes"));
+ } else {
+ if (m_config.enable_VHF_features()) {
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->rh_decodes_title_label->setText(tr ("Decodes containing My Call"));
+ } else {
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->rh_decodes_title_label->setText(tr ("Rx Frequency"));
+ }
+ }
+ }
+ if (SpecOp::FOX==m_specOp && m_config.superFox()) {
+ ui->sbNslots->setVisible(false);
+ ui->pbFreeText->setVisible(true);
+ ui->cbSendMsg->setVisible(true);
+ if(ui->cbSendMsg->isChecked()) {
+ ui->sbNslots->setValue(2);
+ } else {
+ ui->sbNslots->setValue(5);
+ }
+ } else {
+ ui->sbNslots->setVisible(true);
+ ui->pbFreeText->setVisible(false);
+ ui->cbSendMsg->setVisible(false);
+ ui->sbNslots->setValue(m_Nslots0);
+ }
+ if (SpecOp::HOUND==m_specOp) ui->cbRxAll->setVisible(!m_config.superFox());
+}
+
+bool MainWindow::eventFilter (QObject * object, QEvent * event)
+{
+ switch (event->type())
+ {
+ case QEvent::KeyPress:
+ // fall through
+ case QEvent::MouseButtonPress:
+ // reset the Tx watchdog
+ tx_watchdog (false);
+ break;
+
+ case QEvent::ChildAdded:
+ // ensure our child widgets get added to our event filter
+ add_child_to_event_filter (static_cast<QChildEvent *> (event)->child ());
+ break;
+
+ case QEvent::ChildRemoved:
+ // ensure our child widgets get d=removed from our event filter
+ remove_child_from_event_filter (static_cast<QChildEvent *> (event)->child ());
+ break;
+
+ default: break;
+ }
+ return QObject::eventFilter(object, event);
+}
+
+void MainWindow::createStatusBar() //createStatusBar
+{
+ tx_status_label.setAlignment (Qt::AlignHCenter);
+ tx_status_label.setMinimumSize (QSize {100, 18});
+ tx_status_label.setStyleSheet ("QLabel{color: #000000; background-color: #00ff00}");
+ tx_status_label.setFrameStyle (QFrame::Panel | QFrame::Sunken);
+ statusBar()->addWidget (&tx_status_label);
+
+ config_label.setAlignment (Qt::AlignHCenter);
+ config_label.setMinimumSize (QSize {80, 18});
+ config_label.setFrameStyle (QFrame::Panel | QFrame::Sunken);
+ statusBar()->addWidget (&config_label);
+ config_label.hide (); // only shown for non-default configuration
+
+ mode_label.setAlignment (Qt::AlignHCenter);
+ mode_label.setMinimumSize (QSize {80, 18});
+ mode_label.setFrameStyle (QFrame::Panel | QFrame::Sunken);
+ statusBar()->addWidget (&mode_label);
+
+ last_tx_label.setAlignment (Qt::AlignHCenter);
+ last_tx_label.setMinimumSize (QSize {150, 18});
+ last_tx_label.setFrameStyle (QFrame::Panel | QFrame::Sunken);
+ statusBar()->addWidget (&last_tx_label);
+
+ ndecodes_label.setAlignment (Qt::AlignHCenter);
+ ndecodes_label.setMinimumSize (QSize {30, 18});
+ ndecodes_label.setFrameStyle (QFrame::Panel | QFrame::Sunken);
+ statusBar()->addWidget (&ndecodes_label);
+
+ band_hopping_label.setAlignment (Qt::AlignHCenter);
+ band_hopping_label.setMinimumSize (QSize {90, 18});
+ band_hopping_label.setFrameStyle (QFrame::Panel | QFrame::Sunken);
+
+ statusBar()->addPermanentWidget(&progressBar);
+ progressBar.setMinimumSize (QSize {150, 18});
+
+ statusBar ()->addPermanentWidget (&watchdog_label);
+ update_watchdog_label ();
+}
+
+void MainWindow::setup_status_bar (bool vhf)
+{
+ auto submode = current_submode ();
+ if (vhf && submode != QChar::Null) {
+ QString t{m_mode + " " + submode};
+ if(m_mode=="Q65") t=m_mode + "-" + QString::number(m_TRperiod) + submode;
+ mode_label.setText (t);
+ } else {
+ mode_label.setText (m_mode);
+ }
+ if ("JT9" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff6ec7}");
+ } else if ("JT4" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #cc99ff}");
+ } else if ("Echo" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #66ffff}");
+ } else if ("JT65" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #66ff66}");
+ } else if ("Q65" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #99ff33}");
+ } else if ("MSK144" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff6666}");
+ } else if ("FT4" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff0099}");
+ } else if ("FT8" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff6699}");
+ } else if ("FST4" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #99ff66}");
+ } else if ("FST4W" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #6699ff}");
+ } else if ("FreqCal" == m_mode) {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff9933}");
+ }
+ last_tx_label.setText (QString {});
+ if (m_mode.contains (QRegularExpression {R"(^(Echo))"})) {
+ if (band_hopping_label.isVisible ()) statusBar ()->removeWidget (&band_hopping_label);
+ } else if (m_mode=="WSPR") {
+ mode_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff66ff}");
+ if (!band_hopping_label.isVisible ()) {
+ statusBar ()->addWidget (&band_hopping_label);
+ band_hopping_label.show ();
+ }
+ } else {
+ if (band_hopping_label.isVisible ()) statusBar ()->removeWidget (&band_hopping_label);
+ }
+}
+
+bool MainWindow::subProcessFailed (QProcess * process, int exit_code, QProcess::ExitStatus status)
+{
+ if (m_valid && (exit_code || QProcess::NormalExit != status))
+ {
+ QStringList arguments;
+ for (auto argument: process->arguments ())
+ {
+ if (argument.contains (' ')) argument = '"' + argument + '"';
+ arguments << argument;
+ }
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ MessageBox::critical_message (this, tr ("Subprocess Error")
+ , tr ("Subprocess failed with exit code %1")
+ .arg (exit_code)
+ , tr ("Running: %1\n%2")
+ .arg (process->program () + ' ' + arguments.join (' '))
+ .arg (QString {process->readAllStandardError()}));
+ return true;
+ }
+ return false;
+}
+
+void MainWindow::subProcessError (QProcess * process, QProcess::ProcessError)
+{
+ if (m_valid)
+ {
+ QStringList arguments;
+ for (auto argument: process->arguments ())
+ {
+ if (argument.contains (' ')) argument = '"' + argument + '"';
+ arguments << argument;
+ }
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ MessageBox::critical_message (this, tr ("Subprocess error")
+ , tr ("Running: %1\n%2")
+ .arg (process->program () + ' ' + arguments.join (' '))
+ .arg (process->errorString ()));
+ m_valid = false; // ensures exit if still constructing
+ QTimer::singleShot (0, this, SLOT (close ()));
+ }
+}
+
+void MainWindow::closeEvent(QCloseEvent * e)
+{
+ m_valid = false; // suppresses subprocess errors
+ m_config.transceiver_offline ();
+ writeSettings ();
+ if(m_astroWidget) m_astroWidget.reset ();
+ m_guiTimer.stop ();
+ m_prefixes.reset ();
+ m_shortcuts.reset ();
+ m_mouseCmnds.reset ();
+ m_colorHighlighting.reset ();
+ if(m_mode!="MSK144" and m_mode!="FT8") killFile();
+ float sw=0.0;
+ int nw=400;
+ int nh=100;
+ int irow=-99;
+ plotsave_(&sw,&nw,&nh,&irow);
+ to_jt9(m_ihsym,999,-1); //Tell jt9 to terminate
+ if (!proc_jt9.waitForFinished(1000)) proc_jt9.close();
+ mem_jt9->detach();
+ Q_EMIT finished ();
+ QMainWindow::closeEvent (e);
+}
+
+void MainWindow::on_stopButton_clicked() //stopButton
+{
+ monitor (false);
+ m_loopall=false;
+ if(m_bRefSpec) {
+ MessageBox::information_message (this, tr ("Reference spectrum saved"));
+ m_bRefSpec=false;
+ }
+ stopWRTimer.stop(); // stop a running Tx3 timer
+}
+
+void MainWindow::on_actionRelease_Notes_triggered ()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/Release_Notes.txt"});
+}
+
+void MainWindow::on_actionFT8_DXpedition_Mode_User_Guide_triggered()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/FT8_DXpedition_Mode.pdf"});
+}
+
+void MainWindow::on_actionSuperFox_User_Guide_triggered()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/SuperFox_User_Guide.pdf"});
+}
+
+void MainWindow::on_actionQSG_FST4_triggered()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/FST4_Quick_Start.pdf"});
+}
+
+void MainWindow::on_actionQSG_Q65_triggered()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/Q65_Quick_Start.pdf"});
+}
+
+void MainWindow::on_actionQSG_X250_M3_triggered()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/WSJTX_2.5.0_MAP65_3.0_Quick_Start.pdf"});
+}
+
+void MainWindow::on_actionQuick_Start_Guide_to_WSJT_X_2_7_and_QMAP_triggered()
+{
+ QDesktopServices::openUrl (QUrl {"https://wsjt.sourceforge.io/Quick_Start_WSJT-X_2.7_QMAP.pdf"});
+}
+
+void MainWindow::on_actionOnline_User_Guide_triggered() //Display manual
+{
+#if defined (CMAKE_BUILD)
+ m_manual.display_html_url (QUrl {PROJECT_MANUAL_DIRECTORY_URL}, PROJECT_MANUAL);
+#endif
+}
+
+//Display local copy of manual
+void MainWindow::on_actionLocal_User_Guide_triggered()
+{
+#if defined (CMAKE_BUILD)
+ m_manual.display_html_file (m_config.doc_dir (), PROJECT_MANUAL);
+#endif
+}
+
+void MainWindow::on_actionWide_Waterfall_triggered() //Display Waterfalls
+{
+ m_wideGraph->showNormal();
+}
+
+void MainWindow::on_actionEcho_Graph_triggered()
+{
+ m_echoGraph->showNormal();
+}
+
+void MainWindow::on_actionFast_Graph_triggered()
+{
+ m_fastGraph->showNormal();
+}
+
+void MainWindow::on_actionSolve_FreqCal_triggered()
+{
+ auto data_dir {QDir::toNativeSeparators(m_config.writeable_data_dir().absolutePath()).toLocal8Bit ()};
+ int iz,irc;
+ double a,b,rms,sigmaa,sigmab;
+ calibrate_(data_dir.constData(), &iz, &a, &b, &rms, &sigmaa, &sigmab, &irc, (FCL)data_dir.size());
+ QString t2;
+ if(irc==-1) t2="Cannot open " + data_dir + "/fmt.all";
+ if(irc==-2) t2="Cannot open " + data_dir + "/fcal2.out";
+ if(irc==-3) t2="Insufficient data in fmt.all";
+ if(irc==-4) t2 = tr ("Invalid data in fmt.all at line %1").arg (iz);
+ if(irc>0 or rms>1.0) t2="Check fmt.all for possible bad data.";
+ if (irc < 0 || irc > 0 || rms > 1.) {
+ MessageBox::warning_message (this, "Calibration Error", t2);
+ }
+ else if (MessageBox::Apply == MessageBox::query_message (this
+ , tr ("Good Calibration Solution")
+ , tr ("<pre>"
+ "%1%L2 ±%L3 ppm\n"
+ "%4%L5 ±%L6 Hz\n\n"
+ "%7%L8\n"
+ "%9%L10 Hz"
+ "</pre>")
+ .arg ("Slope: ", 12).arg (b, 0, 'f', 3).arg (sigmab, 0, 'f', 3)
+ .arg ("Intercept: ", 12).arg (a, 0, 'f', 2).arg (sigmaa, 0, 'f', 2)
+ .arg ("N: ", 12).arg (iz)
+ .arg ("StdDev: ", 12).arg (rms, 0, 'f', 2)
+ , QString {}
+ , MessageBox::Cancel | MessageBox::Apply)) {
+ m_config.set_calibration (Configuration::CalibrationParams {a, b});
+ if (MessageBox::Yes == MessageBox::query_message (this
+ , tr ("Delete Calibration Measurements")
+ , tr ("The \"fmt.all\" file will be renamed as \"fmt.bak\""))) {
+ // rename fmt.all as we have consumed the resulting calibration
+ // solution
+ auto const& backup_file_name = m_config.writeable_data_dir ().absoluteFilePath ("fmt.bak");
+ QFile::remove (backup_file_name);
+ QFile::rename (m_config.writeable_data_dir ().absoluteFilePath ("fmt.all"), backup_file_name);
+ }
+ }
+}
+
+void MainWindow::on_actionCopyright_Notice_triggered()
+{
+ auto const& message = tr("If you make fair use of any part of WSJT-X under terms of the GNU "
+ "General Public License, you must display the following copyright "
+ "notice prominently in your derivative work:\n\n"
+ "\"The algorithms, source code, look-and-feel of WSJT-X and related "
+ "programs, and protocol specifications for the modes FSK441, FST4, FT8, "
+ "JT4, JT6M, JT9, JT65, JTMS, QRA64, Q65, MSK144 are Copyright (C) "
+ "2001-2024 by one or more of the following authors: Joseph Taylor, "
+ "K1JT; Bill Somerville, G4WJS; Steven Franke, K9AN; Nico Palermo, "
+ "IV3NWV; Greg Beam, KI7MT; Michael Black, W9MDB; Edson Pereira, PY2SDR; "
+ "Philip Karn, KA9Q; Uwe Risse, DG2YCB; Brian Moran, N9ADG; "
+ "and other members of the WSJT Development Group.\"");
+ MessageBox::warning_message(this, message);
+}
+
+// Implement the MultiGeometryWidget::change_layout() operation.
+void MainWindow::change_layout (std::size_t n)
+{
+ switch (n)
+ {
+ case 1: // SWL view
+ ui->menuBar->show ();
+ ui->lower_panel_widget->hide ();
+ trim_view (false); // ensure we can switch back
+ break;
+
+ case 2: // hide menus view
+ ui->menuBar->hide ();
+ ui->lower_panel_widget->show ();
+ trim_view (true);
+ break;
+
+ default: // normal view
+ ui->menuBar->setVisible (ui->cbMenus->isChecked ());
+ ui->lower_panel_widget->show ();
+ trim_view (!ui->cbMenus->isChecked ());
+ break;
+ }
+}
+
+void MainWindow::on_actionSWL_Mode_triggered (bool checked)
+{
+ select_geometry (checked ? 1 : ui->cbMenus->isChecked () ? 0 : 2);
+}
+
+// This allows the window to shrink by removing certain things
+// and reducing space used by controls
+void MainWindow::trim_view (bool checked)
+{
+ int spacing = checked ? 1 : 6;
+ if (checked) {
+ statusBar ()->removeWidget (&auto_tx_label);
+ } else {
+ statusBar ()->addWidget(&auto_tx_label);
+ }
+ if (m_mode != "FreqCal" && m_mode != "WSPR" && m_mode != "FST4W") {
+ ui->lh_decodes_title_label->setVisible(!checked);
+ ui->rh_decodes_title_label->setVisible(!checked);
+ }
+ ui->lh_decodes_headings_label->setVisible(!checked);
+ ui->rh_decodes_headings_label->setVisible(!checked);
+ ui->gridLayout_5->layout()->setSpacing(spacing);
+ ui->horizontalLayout_2->layout()->setSpacing(spacing);
+ ui->horizontalLayout_5->layout()->setSpacing(spacing);
+ ui->horizontalLayout_6->layout()->setSpacing(spacing);
+ ui->horizontalLayout_7->layout()->setSpacing(spacing);
+ ui->horizontalLayout_8->layout()->setSpacing(spacing);
+ ui->horizontalLayout_9->layout()->setSpacing(spacing);
+ ui->horizontalLayout_10->layout()->setSpacing(spacing);
+ ui->horizontalLayout_11->layout()->setSpacing(spacing);
+ ui->horizontalLayout_12->layout()->setSpacing(spacing);
+ ui->horizontalLayout_13->layout()->setSpacing(spacing);
+ ui->horizontalLayout_14->layout()->setSpacing(spacing);
+ ui->rh_decodes_widget->layout()->setSpacing(spacing);
+ ui->verticalLayout_2->layout()->setSpacing(spacing);
+ ui->verticalLayout_3->layout()->setSpacing(spacing);
+ ui->verticalLayout_5->layout()->setSpacing(spacing);
+ ui->verticalLayout_7->layout()->setSpacing(spacing);
+ ui->verticalLayout_8->layout()->setSpacing(spacing);
+ ui->tab->layout()->setSpacing(spacing);
+}
+
+void MainWindow::on_actionAstronomical_data_toggled (bool checked)
+{
+ if (checked)
+ {
+ m_astroWidget.reset (new Astro {m_settings, &m_config});
+
+ // hook up termination signal
+ connect (this, &MainWindow::finished, m_astroWidget.data (), &Astro::close);
+ connect (m_astroWidget.data (), &Astro::tracking_update, [this] {
+ m_astroCorrection = {};
+ setRig ();
+ setXIT (ui->TxFreqSpinBox->value ());
+ displayDialFrequency ();
+ });
+ m_astroWidget->showNormal();
+ m_astroWidget->raise ();
+ m_astroWidget->activateWindow ();
+ m_astroWidget->nominal_frequency (m_freqNominal, m_freqTxNominal);
+ }
+ else
+ {
+ m_astroWidget.reset ();
+ }
+}
+
+void MainWindow::on_fox_log_action_triggered()
+{
+ if (!m_foxLogWindow)
+ {
+ m_foxLogWindow.reset (new FoxLogWindow {m_settings, &m_config, m_logBook.fox_log ()});
+
+ // Connect signals from fox log window
+ connect (this, &MainWindow::finished, m_foxLogWindow.data (), &FoxLogWindow::close);
+ connect (m_foxLogWindow.data (), &FoxLogWindow::reset_log_model, [this] () {
+ m_logBook.fox_log ()->reset ();
+ });
+ }
+ m_foxLogWindow->showNormal ();
+ m_foxLogWindow->raise ();
+ m_foxLogWindow->activateWindow ();
+}
+
+void MainWindow::on_contest_log_action_triggered()
+{
+ if (!m_contestLogWindow)
+ {
+ m_contestLogWindow.reset (new CabrilloLogWindow {m_settings, &m_config, m_logBook.contest_log ()->model ()});
+
+ // Connect signals from contest log window
+ connect (this, &MainWindow::finished, m_contestLogWindow.data (), &CabrilloLogWindow::close);
+ }
+ m_contestLogWindow->showNormal ();
+ m_contestLogWindow->raise ();
+ m_contestLogWindow->activateWindow ();
+ // connect signal from m_logBook.contest_log to m_contestLogWindow
+ connect(m_logBook.contest_log(), &CabrilloLog::qso_count_changed, m_contestLogWindow.data (), &CabrilloLogWindow::set_nQSO);
+ m_contestLogWindow->set_nQSO(m_logBook.contest_log()->n_qso());
+}
+
+void MainWindow::on_actionColors_triggered()
+{
+ if (!m_colorHighlighting)
+ {
+ m_colorHighlighting.reset (new ColorHighlighting {m_settings, m_config.decode_highlighting ()});
+ connect (&m_config, &Configuration::decode_highlighting_changed, m_colorHighlighting.data (), &ColorHighlighting::set_items);
+ }
+ m_colorHighlighting->showNormal ();
+ m_colorHighlighting->raise ();
+ m_colorHighlighting->activateWindow ();
+}
+
+void MainWindow::on_actionMessage_averaging_triggered()
+{
+ if(m_msgAvgWidget == NULL) {
+ m_msgAvgWidget.reset (new MessageAveraging {m_settings, m_config.decoded_text_font ()});
+
+ // Connect signals from Message Averaging window
+ connect (this, &MainWindow::finished, m_msgAvgWidget.data (), &MessageAveraging::close);
+ }
+ m_msgAvgWidget->showNormal();
+ m_msgAvgWidget->raise();
+ m_msgAvgWidget->activateWindow();
+}
+
+void MainWindow::on_actionActiveStations_triggered()
+{
+ if(m_ActiveStationsWidget == NULL) {
+ m_ActiveStationsWidget.reset (new ActiveStations {m_settings, m_config.decoded_text_font ()});
+
+ // Connect signals from Message Averaging window
+ connect (this, &MainWindow::finished, m_ActiveStationsWidget.data (), &ActiveStations::close);
+ }
+ m_ActiveStationsWidget->showNormal();
+ m_ActiveStationsWidget->raise();
+ m_ActiveStationsWidget->activateWindow();
+ configActiveStations();
+ connect(m_ActiveStationsWidget.data(), SIGNAL(callSandP(int)),this,SLOT(callSandP2(int)));
+ // connect up another signal to handle clicks in the Activity window when in Fox mode
+ connect(m_ActiveStationsWidget.data(), SIGNAL(queueActiveWindowHound(QString)),this,SLOT(queueActiveWindowHound2(QString)),static_cast<Qt::ConnectionType>(Qt::UniqueConnection));
+
+ connect(m_ActiveStationsWidget.data(), SIGNAL(activeStationsDisplay()),this,SLOT(ARRL_Digi_Display()));
+ m_ActiveStationsWidget->setScore(m_score);
+ if(m_mode=="Q65") m_ActiveStationsWidget->setRate(m_score);
+ QString as_mode = m_mode;
+ if(m_mode=="FT8" && SpecOp::FOX==m_specOp) as_mode="Fox Mode"; // TODO - active stations for hound mode?
+ m_ActiveStationsWidget->setupUi(as_mode);
+}
+
+void MainWindow::on_actionOpen_triggered() //Open File
+{
+ monitor (false);
+
+ QString fname;
+ fname=QFileDialog::getOpenFileName(this, "Open File", m_path,
+ "WSJT Files (*.wav)");
+ if(!fname.isEmpty ()) {
+ m_path=fname;
+ int i1=fname.lastIndexOf("/");
+ QString baseName=fname.mid(i1+1);
+ tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #99ffff}");
+ tx_status_label.setText(" " + baseName + " ");
+ on_stopButton_clicked();
+ m_diskData=true;
+ read_wav_file (fname);
+ }
+}
+
+void MainWindow::read_wav_file (QString const& fname)
+{
+ // call diskDat() when done
+ int i0=fname.lastIndexOf("_");
+ int i1=fname.indexOf(".wav");
+ m_nutc0=m_UTCdisk;
+ m_UTCdisk=fname.mid(i0+1,i1-i0-1).toInt();
+ if (i0 > 6) {
+ m_UTCdiskDateTime = QDateTime::fromString("20" + fname.mid(i0 - 6, 13) + "Z", "yyyyMMdd_hhmmsst").toUTC();
+ } else
+ m_UTCdiskDateTime = QDateTime{};
+
+ m_wav_future_watcher.setFuture (QtConcurrent::run ([this, fname] {
+ auto basename = fname.mid (fname.lastIndexOf ('/') + 1);
+ auto pos = fname.indexOf (".wav", 0, Qt::CaseInsensitive);
+ // global variables and threads do not mix well, this needs changing
+ dec_data.params.nutc = 0;
+ if (pos > 0) {
+ if (pos == fname.indexOf ('_', -11) + 7) {
+ dec_data.params.nutc = fname.mid (pos - 6, 6).toInt ();
+ m_fileDateTime=fname.mid(pos-13,13);
+ } else {
+ dec_data.params.nutc = 100 * fname.mid (pos - 4, 4).toInt ();
+ m_fileDateTime=fname.mid(pos-11,11);
+ }
+ }
+
+ BWFFile file {QAudioFormat {}, fname};
+ bool ok=file.open (BWFFile::ReadOnly);
+ if(ok) {
+ auto bytes_per_frame = file.format ().bytesPerFrame ();
+ int nsamples=m_TRperiod * RX_SAMPLE_RATE;
+ qint64 max_bytes = std::min (std::size_t (nsamples),
+ sizeof (dec_data.d2) / sizeof (dec_data.d2[0]))* bytes_per_frame;
+ auto n = file.read (reinterpret_cast<char *> (dec_data.d2),
+ std::min (max_bytes, file.size ()));
+ int frames_read = n / bytes_per_frame;
+ // zero unfilled remaining sample space
+ std::memset(&dec_data.d2[frames_read],0,max_bytes - n);
+ if (11025 == file.format ().sampleRate ()) {
+ short sample_size = file.format ().sampleSize ();
+ wav12_ (dec_data.d2, dec_data.d2, &frames_read, &sample_size);
+ }
+ dec_data.params.kin = frames_read;
+ dec_data.params.newdat = 1;
+ } else {
+ dec_data.params.kin = 0;
+ dec_data.params.newdat = 0;
+ }
+
+ dec_data.params.yymmdd=basename.left(6).toInt();
+ }));
+}
+
+void MainWindow::on_actionOpen_next_in_directory_triggered() //Open Next
+{
+ if(m_decoderBusy) return;
+ monitor (false);
+ int i,len;
+ QFileInfo fi(m_path);
+ QStringList list;
+ list= fi.dir().entryList().filter(".wav",Qt::CaseInsensitive);
+ for (i = 0; i < list.size()-1; ++i) {
+ len=list.at(i).length();
+ if(list.at(i)==m_path.right(len)) {
+ int n=m_path.length();
+ QString fname=m_path.replace(n-len,len,list.at(i+1));
+ m_path=fname;
+ int i1=fname.lastIndexOf("/");
+ QString baseName=fname.mid(i1+1);
+ tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #99ffff}");
+ tx_status_label.setText(" " + baseName + " ");
+ m_diskData=true;
+ read_wav_file (fname);
+ if(m_loopall and (i==list.size()-2)) {
+ m_loopall=false;
+ m_bNoMoreFiles=true;
+ }
+ return;
+ }
+ }
+}
+//Open all remaining files
+void MainWindow::on_actionDecode_remaining_files_in_directory_triggered()
+{
+ if(m_decoderBusy) return;
+ m_loopall=true;
+ on_actionOpen_next_in_directory_triggered();
+}
+
+void MainWindow::diskDat() //diskDat()
+{
+ m_wideGraph->setDiskUTC(dec_data.params.nutc);
+ if(dec_data.params.kin>0) {
+ int k;
+ int kstep=m_FFTSize;
+ m_diskData=true;
+ float db=m_config.degrade();
+ float bw=m_config.RxBandwidth();
+ if(db > 0.0) degrade_snr_(dec_data.d2,&dec_data.params.kin,&db,&bw);
+ for(int n=1; n<=m_hsymStop; n++) { // Do the waterfall spectra
+// k=(n+1)*kstep; //### Why was this (n+1) ??? ###
+ k=n*kstep;
+ if(k > dec_data.params.kin) break;
+ dec_data.params.npts8=k/8;
+ dataSink(k);
+ qApp->processEvents(); //Update the waterfall
+ }
+ } else {
+ MessageBox::information_message(this, tr("No data read from disk. Wrong file format?"));
+ }
+}
+
+//Delete ../save/*.wav
+void MainWindow::on_actionDelete_all_wav_files_in_SaveDir_triggered()
+{
+ auto button = MessageBox::query_message (this, tr ("Confirm Delete"),
+ tr ("Are you sure you want to delete all *.wav and *.c2 files in \"%1\"?")
+ .arg (QDir::toNativeSeparators (m_config.save_directory ().absolutePath ())));
+ if (MessageBox::Yes == button) {
+ Q_FOREACH (auto const& file
+ , m_config.save_directory ().entryList ({"*.wav", "*.c2"}, QDir::Files | QDir::Writable)) {
+ m_config.save_directory ().remove (file);
+ }
+ }
+}
+
+void MainWindow::on_actionNone_triggered() //Save None
+{
+ m_saveDecoded=false;
+ m_saveAll=false;
+ ui->actionNone->setChecked(true);
+}
+
+void MainWindow::on_actionSave_decoded_triggered()
+{
+ m_saveDecoded=true;
+ m_saveAll=false;
+ ui->actionSave_decoded->setChecked(true);
+}
+
+void MainWindow::on_actionSave_all_triggered() //Save All
+{
+ m_saveDecoded=false;
+ m_saveAll=true;
+ ui->actionSave_all->setChecked(true);
+}
+
+void MainWindow::on_actionKeyboard_shortcuts_triggered()
+{
+ if (!m_shortcuts)
+ {
+ QFont font;
+ font.setPointSize (10);
+ m_shortcuts.reset (new HelpTextWindow {tr ("Keyboard Shortcuts"),
+ //: Keyboard shortcuts help window contents
+ tr (R"(<table cellspacing=1>
+ <tr><td><b>Esc </b></td><td>Stop Tx, abort QSO, clear next-call queue</td></tr>
+ <tr><td><b>F1 </b></td><td>Online User's Guide (Alt: transmit Tx6)</td></tr>
+ <tr><td><b>Shift+F1 </b></td><td>Copyright Notice</td></tr>
+ <tr><td><b>Ctrl+F1 </b></td><td>About WSJT-X</td></tr>
+ <tr><td><b>F2 </b></td><td>Open settings window (Alt: transmit Tx2)</td></tr>
+ <tr><td><b>F3 </b></td><td>Display keyboard shortcuts (Alt: transmit Tx3)</td></tr>
+ <tr><td><b>F4 </b></td><td>Clear DX Call, DX Grid, Tx messages 1-4 (Alt: transmit Tx4)</td></tr>
+ <tr><td><b>Alt+F4 </b></td><td>Exit program</td></tr>
+ <tr><td><b>F5 </b></td><td>Display special mouse commands (Alt: transmit Tx5)</td></tr>
+ <tr><td><b>F6 </b></td><td>Open next file in directory (Alt: toggle "Call 1st")</td></tr>
+ <tr><td><b>Shift+F6 </b></td><td>Decode all remaining files in directory</td></tr>
+ <tr><td><b>F7 </b></td><td>Display Message Averaging window</td></tr>
+ <tr><td><b>F11 </b></td><td>Move Rx frequency down 1 Hz</td></tr>
+ <tr><td><b>Ctrl+F11 </b></td><td>Move identical Rx and Tx frequencies down 1 Hz</td></tr>
+ <tr><td><b>Shift+F11 </b></td><td>Move Tx frequency down 60 Hz (FT8) or 90 Hz (FT4)</td></tr>
+ <tr><td><b>Ctrl+Shift+F11 </b></td><td>Move dial frequency down 1000 Hz</td></tr>
+ <tr><td><b>F12 </b></td><td>Move Rx frequency up 1 Hz</td></tr>
+ <tr><td><b>Ctrl+F12 </b></td><td>Move identical Rx and Tx frequencies up 1 Hz</td></tr>
+ <tr><td><b>Shift+F12 </b></td><td>Move Tx frequency up 60 Hz (FT8) or 90 Hz (FT4)</td></tr>
+ <tr><td><b>Ctrl+Shift+F12 </b></td><td>Move dial frequency up 1000 Hz</td></tr>
+ <tr><td><b>Alt+1-6 </b></td><td>Set now transmission to this number on Tab 1</td></tr>
+ <tr><td><b>Ctl+1-6 </b></td><td>Set next transmission to this number on Tab 1</td></tr>
+ <tr><td><b>Alt+A </b></td><td>Clear Active Stations for QMAP</td></tr>
+ <tr><td><b>Alt+B </b></td><td>Toggle "Best S+P" status</td></tr>
+ <tr><td><b>Alt+C </b></td><td>Toggle "Call 1st" checkbox</td></tr>
+ <tr><td><b>Alt+D </b></td><td>Decode again at QSO frequency</td></tr>
+ <tr><td><b>Shift+D </b></td><td>Full decode (both windows)</td></tr>
+ <tr><td><b>Ctrl+E </b></td><td>Turn on TX even/1st</td></tr>
+ <tr><td><b>Shift+E </b></td><td>Turn off TX even/1st</td></tr>
+ <tr><td><b>Alt+E </b></td><td>Erase</td></tr>
+ <tr><td><b>Ctrl+F </b></td><td>Edit the free text message box</td></tr>
+ <tr><td><b>Alt+G </b></td><td>Generate standard messages</td></tr>
+ <tr><td><b>Alt+H </b></td><td>Halt Tx</td></tr>
+ <tr><td><b>Ctrl+L </b></td><td>Lookup callsign in database, generate standard messages</td></tr>
+ <tr><td><b>Alt+M </b></td><td>Monitor</td></tr>
+ <tr><td><b>Alt+N </b></td><td>Toggle "Enable Tx"</td></tr>
+ <tr><td><b>Ctrl+O </b></td><td>Open a .wav file</td></tr>
+ <tr><td><b>Alt+O </b></td><td>Change operator</td></tr>
+ <tr><td><b>Alt+Q </b></td><td>Open "Log QSO" window</td></tr>
+ <tr><td><b>Ctrl+R </b></td><td>Set Tx4 message to RRR (not in FT4)</td></tr>
+ <tr><td><b>Alt+R </b></td><td>Set Tx4 message to RR73</td></tr>
+ <tr><td><b>Ctrl+Shift+R </b></td><td>Refresh Active Stations window</td></tr>
+ <tr><td><b>Alt+S </b></td><td>Stop monitoring</td></tr>
+ <tr><td><b>Alt+T </b></td><td>Toggle Tune status</td></tr>
+ <tr><td><b>Alt+Z </b></td><td>Clear hung decoder status</td></tr>
+</table>)"), font});
+ }
+ m_shortcuts->showNormal ();
+ m_shortcuts->raise ();
+}
+
+void MainWindow::on_actionSpecial_mouse_commands_triggered()
+{
+ if (!m_mouseCmnds)
+ {
+ QFont font;
+ font.setPointSize (10);
+ m_mouseCmnds.reset (new HelpTextWindow {tr ("Special Mouse Commands"),
+ //: Mouse commands help window contents
+ tr (R"(<table cellpadding=5>
+ <tr>
+ <th align="right">Click on</th>
+ <th align="left">Action</th>
+ </tr>
+ <tr>
+ <td align="right">Waterfall:</td>
+ <td><b>Click</b> to set Rx frequency.<br/>
+ <b>Shift-click</b> to set Tx frequency.<br/>
+ <b>Ctrl-click</b> or <b>Right-click</b> to set Rx and Tx frequencies.<br/>
+ <b>Double-click</b> to also decode at Rx frequency.
+ </td>
+ </tr>
+ <tr>
+ <td align="right">Decoded text:</td>
+ <td><b>Double-click</b> to copy second callsign to Dx Call,<br/>
+ locator to Dx Grid, change Rx and Tx frequency to<br/>
+ decoded signal's frequency, and generate standard<br/>
+ messages.<br/>
+ If <b>Hold Tx Freq</b> is checked or first callsign in message<br/>
+ is your own call, Tx frequency is not changed unless <br/>
+ <b>Ctrl</b> is held down.
+ </td>
+ </tr>
+ <tr>
+ <td align="right">Erase button:</td>
+ <td><b>Click</b> to erase QSO window.<br/>
+ <b>Double-click</b> to erase QSO and Band Activity windows.
+ </td>
+ </tr>
+ <tr>
+ <td align="right">Q65 Button:</td>
+ <td><b>Click</b> to switch to Q65 Mode.<br/>
+ <b>Right-click</b> to switch to Q65 Pileup Mode.
+ </td>
+ </tr>
+ <tr>
+ <td align="right">JT65 Button:</td>
+ <td><b>Click</b> to switch to JT65 Mode.<br/>
+ <b>Right-click</b> to switch to JT9 Mode.
+ </td>
+ </tr>
+</table>)"), font});
+ }
+ m_mouseCmnds->showNormal ();
+ m_mouseCmnds->raise ();
+}
+
+void MainWindow::on_DecodeButton_clicked (bool /* checked */) //Decode request
+{
+ if(m_mode=="MSK144") {
+ ui->DecodeButton->setChecked(false);
+ } else {
+ if(m_mode!="WSPR" && !m_decoderBusy) {
+ dec_data.params.newdat=0;
+ dec_data.params.nagain=1;
+ decode();
+ }
+ }
+}
+
+void MainWindow::freezeDecode(int n) //freezeDecode()
+{
+ if((n%100)==2) {
+ if(m_mode=="FST4" and m_config.single_decode() and ui->sbFtol->value()>10) ui->sbFtol->setValue(10);
+ on_DecodeButton_clicked (true);
+ }
+}
+
+void MainWindow::on_ClrAvgButton_clicked()
+{
+ m_nclearave=1;
+ if(m_mode=="Echo") {
+ echocom_.nsum=0;
+ m_echoGraph->clearAvg();
+ m_wideGraph->restartTotalPower();
+ } else {
+ if(m_msgAvgWidget != NULL) {
+ if(m_msgAvgWidget->isVisible()) m_msgAvgWidget->displayAvg("");
+ }
+ if(m_mode=="Q65") ndecodes_label.setText("0 0");
+ }
+}
+
+void MainWindow::msgAvgDecode2()
+{
+ on_DecodeButton_clicked (true);
+}
+
+void MainWindow::decode() //decode()
+{
+ if(m_decoderBusy) return; //Don't start decoder if it's already busy.
+ m_fetched=0;
+ QDateTime now = QDateTime::currentDateTimeUtc ();
+ if( m_dateTimeLastTX.isValid () ) {
+ qint64 isecs_since_tx = m_dateTimeLastTX.secsTo(now);
+ dec_data.params.lapcqonly= (isecs_since_tx > 300);
+ } else {
+ m_dateTimeLastTX = now.addSecs(-900);
+ dec_data.params.lapcqonly=true;
+ }
+ if(m_diskData) {
+ dec_data.params.lapcqonly=false;
+ } else {
+ dec_data.params.yymmdd=-1;
+ }
+ if(!m_dataAvailable or m_TRperiod==0.0) return;
+ ui->DecodeButton->setChecked (true);
+ if(!dec_data.params.nagain && m_diskData && m_TRperiod >= 60.) {
+ dec_data.params.nutc=dec_data.params.nutc/100;
+ }
+ if(dec_data.params.nagain==0 && dec_data.params.newdat==1 && (!m_diskData)) {
+ m_dateTimeSeqStart = qt_truncate_date_time_to (QDateTime::currentDateTimeUtc (), m_TRperiod * 1.e3);
+ auto t = m_dateTimeSeqStart.time ();
+ dec_data.params.nutc = t.hour () * 100 + t.minute ();
+ if (m_TRperiod < 60.)
+ {
+ dec_data.params.nutc = dec_data.params.nutc * 100 + t.second ();
+ }
+ }
+
+ if(m_nPick==1 and !m_diskData) {
+ QDateTime t=QDateTime::currentDateTimeUtc();
+ int ihr=t.toString("hh").toInt();
+ int imin=t.toString("mm").toInt();
+ int isec=t.toString("ss").toInt();
+ isec=isec - fmod(double(isec),m_TRperiod);
+ dec_data.params.nutc=10000*ihr + 100*imin + isec;
+ }
+ if(m_nPick==2) dec_data.params.nutc=m_nutc0;
+ dec_data.params.nQSOProgress = m_QSOProgress;
+ dec_data.params.nfqso=m_wideGraph->rxFreq();
+ dec_data.params.nftx = ui->TxFreqSpinBox->value ();
+ qint32 depth {m_ndepth};
+ if (!ui->actionInclude_averaging->isVisible ()) depth &= ~16;
+ if (!ui->actionInclude_correlation->isVisible ()) depth &= ~32;
+ if (!ui->actionEnable_AP_DXcall->isVisible ()) depth &= ~64;
+ if (!ui->actionAuto_Clear_Avg->isVisible()) depth &= ~128;
+ dec_data.params.ndepth=depth;
+ dec_data.params.n2pass=1;
+ if(m_config.twoPass()) dec_data.params.n2pass=2;
+ dec_data.params.nranera=m_config.ntrials();
+ dec_data.params.naggressive=m_config.aggressive();
+ dec_data.params.nrobust=0;
+ dec_data.params.ndiskdat=0;
+ if(m_diskData) dec_data.params.ndiskdat=1;
+ dec_data.params.nfa=m_wideGraph->nStartFreq();
+ dec_data.params.nfSplit=m_wideGraph->Fmin(); // Not used any more?
+ if(dec_data.params.nfSplit==8) dec_data.params.nfSplit=1;
+
+ dec_data.params.nfb=m_wideGraph->Fmax();
+ if(m_mode=="FT8" and SpecOp::HOUND==m_specOp and !ui->cbRxAll->isChecked() and
+ !m_config.superFox()) dec_data.params.nfb=1000;
+ if(m_mode=="FT8" and SpecOp::FOX == m_specOp ) dec_data.params.nfqso=200;
+ dec_data.params.b_even_seq=(dec_data.params.nutc%10)==0;
+ dec_data.params.b_superfox=(m_config.superFox() and (SpecOp::FOX == m_specOp or SpecOp::HOUND == m_specOp));
+ if(dec_data.params.b_superfox and dec_data.params.b_even_seq and m_ihsym<50) return;
+
+ dec_data.params.ntol=ui->sbFtol->value ();
+ if(!m_config.enable_VHF_features()) {
+ dec_data.params.ntol=20;
+ dec_data.params.naggressive=0;
+ }
+ if(m_mode=="FST4") {
+ dec_data.params.ntol=ui->sbFtol->value();
+ if(m_config.single_decode()) {
+ dec_data.params.nfa=m_wideGraph->rxFreq() - ui->sbFtol->value();
+ dec_data.params.nfb=m_wideGraph->rxFreq() + ui->sbFtol->value();
+ } else {
+ dec_data.params.nfa=ui->sbF_Low->value();
+ dec_data.params.nfb=ui->sbF_High->value();
+ }
+ }
+ if(m_mode=="FST4W") dec_data.params.ntol=ui->sbFST4W_FTol->value();
+ if(dec_data.params.nutc < m_nutc0) m_RxLog = 1; //Date and Time to file "ALL.TXT".
+ if(dec_data.params.newdat==1 and !m_diskData) m_nutc0=dec_data.params.nutc;
+ dec_data.params.ntxmode=9;
+ dec_data.params.nmode=9;
+ if(m_mode=="JT65") dec_data.params.nmode=65;
+ if(m_mode=="JT65") dec_data.params.ljt65apon = ui->actionEnable_AP_JT65->isVisible () &&
+ ui->actionEnable_AP_JT65->isChecked ();
+ if(m_mode=="Q65") dec_data.params.nmode=66;
+ if(m_mode=="Q65") dec_data.params.ntxmode=66;
+ if(m_mode=="JT4") {
+ dec_data.params.nmode=4;
+ dec_data.params.ntxmode=4;
+ }
+ if(m_mode=="FT8") dec_data.params.nmode=8;
+ if(m_mode=="FT8") dec_data.params.lft8apon = ui->actionEnable_AP_FT8->isVisible () &&
+ ui->actionEnable_AP_FT8->isChecked ();
+ if(m_mode=="FT8") dec_data.params.napwid=50;
+ if(m_mode=="FT4") {
+ dec_data.params.nmode=5;
+ m_BestCQpriority="";
+ }
+ if(m_mode=="FST4") dec_data.params.nmode=240;
+ if(m_mode=="FST4W") dec_data.params.nmode=241;
+ dec_data.params.ntxmode=dec_data.params.nmode; // Is this used any more?
+ dec_data.params.ntrperiod=m_TRperiod;
+ dec_data.params.nsubmode=m_nSubMode;
+ dec_data.params.minw=0;
+ dec_data.params.nclearave=m_nclearave;
+ if(m_nclearave!=0) {
+ QFile f(m_config.temp_dir ().absoluteFilePath ("avemsg.txt"));
+ f.remove();
+ }
+ dec_data.params.dttol=m_DTtol;
+ dec_data.params.emedelay=0.0;
+ if(m_config.decode_at_52s()) dec_data.params.emedelay=2.5;
+ dec_data.params.minSync=ui->syncSpinBox->isVisible () ? m_minSync : 0;
+ dec_data.params.nexp_decode=int(m_specOp);
+ if(dec_data.params.nexp_decode==5) dec_data.params.nexp_decode=1; //NA VHF, WW Digi, ARRL Digi contests
+ if(dec_data.params.nexp_decode==8) dec_data.params.nexp_decode=1; //and Q65 Pileup all use 4-character
+ if(dec_data.params.nexp_decode==9) dec_data.params.nexp_decode=1; //grid exchange
+ if(m_config.single_decode()) dec_data.params.nexp_decode += 32;
+ if(m_config.enable_VHF_features()) dec_data.params.nexp_decode += 64;
+ if(m_mode.startsWith("FST4")) dec_data.params.nexp_decode += 256*(ui->sbNB->value()+3);
+ dec_data.params.max_drift=ui->sbMaxDrift->value();
+
+ ::memcpy(dec_data.params.datetime, m_dateTime.toLatin1()+" ", sizeof dec_data.params.datetime);
+ ::memcpy(dec_data.params.mycall, (m_config.my_callsign()+" ").toLatin1(), sizeof dec_data.params.mycall);
+ ::memcpy(dec_data.params.mygrid, (m_config.my_grid()+" ").toLatin1(), sizeof dec_data.params.mygrid);
+ QString hisCall {ui->dxCallEntry->text ()};
+ QString hisGrid {ui->dxGridEntry->text ()};
+ memcpy(dec_data.params.hiscall,(hisCall + " ").toLatin1 ().constData (), sizeof dec_data.params.hiscall);
+ memcpy(dec_data.params.hisgrid,(hisGrid + " ").toLatin1 ().constData (), sizeof dec_data.params.hisgrid);
+
+ //newdat=1 ==> this is new data, must do the big FFT
+ //nagain=1 ==> decode only at fQSO +/- Tol
+
+ if (auto * to = reinterpret_cast<char *> (mem_jt9->data()))
+ {
+ char *from = (char*) dec_data.ipc;
+ int size=sizeof(struct dec_data);
+ if(dec_data.params.newdat==0) {
+ int noffset {offsetof (struct dec_data, params.nutc)};
+ to += noffset;
+ from += noffset;
+ size -= noffset;
+ }
+ if(m_mode=="MSK144" or m_bFast9) {
+ float t0=m_t0;
+ float t1=m_t1;
+ qApp->processEvents(); //Update the waterfall
+ if(m_nPick > 0) {
+ t0=m_t0Pick;
+ t1=m_t1Pick;
+ }
+ static short int d2b[360000];
+ narg[0]=dec_data.params.nutc;
+ if(m_kdone>int(12000.0*m_TRperiod)) {
+ m_kdone=int(12000.0*m_TRperiod);
+ }
+ narg[1]=m_kdone;
+ narg[2]=m_nSubMode;
+ narg[3]=dec_data.params.newdat;
+ narg[4]=dec_data.params.minSync;
+ narg[5]=m_nPick;
+ narg[6]=1000.0*t0;
+ narg[7]=1000.0*t1;
+ narg[8]=2; //Max decode lines per decode attempt
+ if(dec_data.params.minSync<0) narg[8]=50;
+ if(m_mode=="JT9") narg[9]=102; //Fast JT9
+ if(m_mode=="MSK144") narg[9]=104; //MSK144
+ narg[10]=ui->RxFreqSpinBox->value();
+ narg[11]=ui->sbFtol->value ();
+ narg[12]=0;
+ narg[13]=-1;
+ narg[14]=m_config.aggressive();
+ memcpy(d2b,dec_data.d2,2*360000);
+ watcher3.setFuture (QtConcurrent::run (std::bind (fast_decode_, &d2b[0],
+ &narg[0],&m_TRperiod, &m_msg[0][0], dec_data.params.mycall,
+ dec_data.params.hiscall, (FCL)8000, (FCL)12, (FCL)12)));
+ } else {
+ mem_jt9->lock ();
+ memcpy(to, from, qMin(mem_jt9->size(), size));
+ mem_jt9->unlock ();
+ to_jt9(m_ihsym,1,-1); //Send m_ihsym to jt9[.exe] and start decoding
+ decodeBusy(true);
+ }
+ }
+ if((m_mode=="FT4" or (m_mode=="FT8" and m_ihsym==41) or m_diskData) and
+ m_ActiveStationsWidget != NULL) {
+ if(m_mode!="Q65") m_ActiveStationsWidget->erase(); //TEMP
+ }
+}
+
+void::MainWindow::fast_decode_done()
+{
+ float t,tmax=-99.0;
+ dec_data.params.nagain=false;
+ dec_data.params.ndiskdat=false;
+// if(m_msg[0][0]==0) m_bDecoded=false;
+ for(int i=0; m_msg[i][0] && i<100; i++) {
+ QString message=QString::fromLatin1(m_msg[i]);
+ m_msg[i][0]=0;
+ if(message.length()>80) message=message.left (80);
+ if(narg[13]/8==narg[12]) message=message.trimmed().replace("<...>",m_calls);
+
+//Left (Band activity) window
+ DecodedText decodedtext {message.replace (QChar::LineFeed, "")};
+ if(!m_bFastDone) {
+ ui->decodedTextBrowser->displayDecodedText (decodedtext, m_config.my_callsign (), m_mode, m_config.DXCC (),
+ m_logBook, m_currentBandPeriod, m_config.ppfx ());
+ }
+
+ t=message.mid(10,5).toFloat();
+ if(t>tmax) {
+ tmax=t;
+ m_bDecoded=true;
+ }
+ postDecode (true, decodedtext.string ());
+ write_all("Rx",message);
+
+ if(m_mode=="JT9" or m_mode=="MSK144") {
+// find and extract any report for myCall
+ bool stdMsg = decodedtext.report(m_baseCall,
+ Radio::base_callsign(ui->dxCallEntry->text()), m_rptRcvd);
+
+// extract details and send to PSKreporter
+ if (stdMsg) pskPost (decodedtext);
+ }
+ if (tmax >= 0.0) auto_sequence (decodedtext, ui->sbFtol->value (), ui->sbFtol->value ());
+ }
+ m_startAnother=m_loopall;
+ m_nPick=0;
+ ui->DecodeButton->setChecked (false);
+ m_bFastDone=false;
+}
+
+void MainWindow::to_jt9(qint32 n, qint32 istart, qint32 idone)
+{
+ if (auto * dd = reinterpret_cast<dec_data_t *> (mem_jt9->data()))
+ {
+ mem_jt9->lock ();
+ dd->ipc[0]=n;
+ if(istart>=0) dd->ipc[1]=istart;
+ if(idone>=0) dd->ipc[2]=idone;
+ mem_jt9->unlock ();
+ }
+}
+
+void MainWindow::decodeDone ()
+{
+ if(m_mode=="Q65") m_wideGraph->drawRed(0,0);
+ if ("FST4W" == m_mode)
+ {
+ if (m_uploadWSPRSpots
+ && m_config.is_transceiver_online ()) { // need working rig control
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ uploadTimer.start(QRandomGenerator::global ()->bounded (0, 20000)); // Upload delay
+#else
+ uploadTimer.start(20000 * qrand()/((double)RAND_MAX + 1.0)); // Upload delay
+#endif
+ }
+ }
+ auto tnow = QDateTime::currentDateTimeUtc ();
+ double tdone = fmod(double(tnow.time().second()),m_TRperiod);
+ int mswait;
+ if( tdone < 0.5*m_TRperiod ) {
+ mswait = 1000.0 * ( 0.6 * m_TRperiod - tdone );
+ } else {
+ mswait = 1000.0 * ( 1.6 * m_TRperiod - tdone );
+ }
+ m_bDecoded=m_nDecodes>0;
+ if(!m_diskData and !m_saveAll) {
+ if(m_saveDecoded and (m_nDecodes==0)) {
+ killFileTimer.start(mswait); //Kill at 3/4 period
+ }
+ }
+
+ dec_data.params.nagain=0;
+ dec_data.params.ndiskdat=0;
+ m_nclearave=0;
+// pause_jt9 ();
+ ui->DecodeButton->setChecked (false);
+ decodeBusy(false);
+ m_RxLog=0;
+ if(SpecOp::FOX == m_specOp) {
+ houndCallers();
+ if(ui->cbWorkDupes->isChecked()) QTimer::singleShot (5000, [=] {band_activity_cleared();});
+ }
+ to_jt9(m_ihsym,-1,1); //Tell jt9 we know it has finished
+
+ m_startAnother=m_loopall;
+ if(m_bNoMoreFiles) {
+ MessageBox::information_message(this, tr("No more files to open."));
+ m_bNoMoreFiles=false;
+ }
+
+ if((m_mode=="FT4" or m_mode=="FT8")
+ and m_latestDecodeTime>=0 and m_ActiveStationsWidget!=NULL) {
+ if(!m_diskData and (m_nDecodes==0)) {
+ m_latestDecodeTime = (QDateTime::currentMSecsSinceEpoch()/1000) % 86400;
+ m_latestDecodeTime = int(m_latestDecodeTime/m_TRperiod);
+ m_latestDecodeTime = int(m_latestDecodeTime*m_TRperiod);
+ }
+ ARRL_Digi_Display(); // Update the ARRL_DIGI display
+ }
+ if(m_mode!="FT8" or dec_data.params.nzhsym==50) m_nDecodes=0;
+
+ if(m_mode=="Q65" and (m_specOp==SpecOp::NA_VHF or m_specOp==SpecOp::ARRL_DIGI
+ or m_specOp==SpecOp::WW_DIGI or m_specOp==SpecOp::Q65_PILEUP)
+ and m_ActiveStationsWidget!=NULL) {
+ refreshPileupList();
+ }
+}
+
+void MainWindow::refreshPileupList()
+{
+ // Update the ActiveStations display for Q65 pileup situation...
+ int nlist=0;
+ char list[2000];
+ char line[36];
+ list[0]=0;
+ auto fname {QDir::toNativeSeparators(m_config.writeable_data_dir().absoluteFilePath("tsil.3q"))};
+ get_q3list_(const_cast<char *> (fname.toLatin1().constData()), &m_diskData, &nlist,
+ &list[0], (FCL)fname.length(), (FCL)2000);
+ QString t="";
+ QString t0="";
+ for(int i=0; i<nlist; i++) {
+ memcpy(line,&list[36*i],36);
+ t0=QString::fromLatin1(line)+"\n";
+ m_callers[i]=t0;
+ t+=t0;
+ }
+ m_ActiveStationsWidget->setClickOK(false);
+ m_ActiveStationsWidget->displayRecentStations("Q65-pileup",t);
+ m_ActiveStationsWidget->setClickOK(true);
+}
+
+void MainWindow::read_log()
+{
+ static QFile f {QDir {QStandardPaths::writableLocation (QStandardPaths::DataLocation)}.absoluteFilePath ("wsjtx.log")};
+ f.open(QIODevice::ReadOnly);
+ if(f.isOpen()) {
+ QTextStream in(&f);
+ QString line,callsign;
+ for(int i=0; i<99999; i++) {
+ line=in.readLine();
+ if(line.length()<=0) break;
+ callsign=line.mid(40,6);
+ int n=callsign.indexOf(",");
+ if(n>0) callsign=callsign.left(n);
+ m_EMEworked[callsign]=true;
+ m_score++;
+ }
+ f.close();
+ }
+ if(m_ActiveStationsWidget!=NULL) {
+ m_ActiveStationsWidget->setScore(m_score);
+ if(m_mode=="Q65") m_ActiveStationsWidget->setRate(m_score);
+ }
+}
+
+void MainWindow::ARRL_Digi_Update(DecodedText dt)
+{
+ if(m_mode=="Q65") {
+ m_fetched=0;
+ readWidebandDecodes();
+ return;
+ }
+
+ // Extract information relevant for the ARRL Digi contest
+ QString deCall;
+ QString deGrid;
+ dt.deCallAndGrid(/*out*/deCall,deGrid);
+ ActiveCall ac;
+ RecentCall rc;
+
+ if(deGrid.contains(grid_regexp)) {
+ if(!m_activeCall.contains(deCall) or deGrid!=m_activeCall.value(deCall).grid4) {
+ // Transmitting station's call is not already in QMap "m_activeCall", or grid has changed.
+ // Insert the call, grid, and associated fixed data into the list.
+
+ double utch=0.0;
+ int nAz,nEl,nDmiles,nDkm,nHotAz,nHotABetter;
+ azdist_(const_cast <char *> (m_config.my_grid().left(4).toLatin1().constData()),
+ const_cast <char *> (deGrid.left(4).toLatin1().constData()),&utch,
+ &nAz,&nEl,&nDmiles,&nDkm,&nHotAz,&nHotABetter,(FCL)6,(FCL)6);
+ int points=nDkm/500;
+ if(nDkm > 500*points) points += 1;
+ points += 1;
+ ac.grid4=deGrid;
+ ac.bands=".......";
+ ac.az=nAz;
+ ac.points=points;
+ m_activeCall[deCall]=ac;
+ }
+ }
+
+ m_points=-1;
+ if(m_activeCall.contains(deCall)) {
+
+// Don't display stations we already worked on this band.
+ QString band=m_config.bands()->find(m_freqNominal);
+ if(band=="160m" and m_activeCall[deCall].bands.indexOf("a")>=0) {m_recentCall.remove(deCall); return;}
+ if(band=="80m" and m_activeCall[deCall].bands.indexOf("b")>=0) {m_recentCall.remove(deCall); return;}
+ if(band=="40m" and m_activeCall[deCall].bands.indexOf("c")>=0) {m_recentCall.remove(deCall); return;}
+ if(band=="20m" and m_activeCall[deCall].bands.indexOf("d")>=0) {m_recentCall.remove(deCall); return;}
+ if(band=="15m" and m_activeCall[deCall].bands.indexOf("e")>=0) {m_recentCall.remove(deCall); return;}
+ if(band=="10m" and m_activeCall[deCall].bands.indexOf("f")>=0) {m_recentCall.remove(deCall); return;}
+ if(band=="6m" and m_activeCall[deCall].bands.indexOf("g")>=0) {m_recentCall.remove(deCall); return;}
+
+ // Update the variable data for this deCall
+ rc.dialFreq=m_freqNominal;
+ rc.audioFreq=dt.frequencyOffset();
+ rc.snr=dt.snr();
+ m_latestDecodeTime=dt.timeInSeconds();
+ rc.txEven = (m_latestDecodeTime % int(2*m_TRperiod)) > 0;
+ rc.ready2call=false;
+ bool bCQ=dt.messageWords()[0].left(3)=="CQ ";
+ if(bCQ or deGrid=="RR73" or deGrid=="73") rc.ready2call=true;
+ rc.decodeTime=m_latestDecodeTime;
+ m_recentCall[deCall]=rc;
+ m_points=m_activeCall.value(deCall).points;
+ }
+ updateRate();
+}
+
+void MainWindow::ARRL_Digi_Display()
+{
+ if(m_mode=="Q65") {
+ m_fetched=0;
+ readWidebandDecodes();
+ return;
+ }
+ if (m_mode == "Fox Mode") { // ARRL_Digi_Display can be shown for other modes
+ if (m_ActiveStationsWidget != NULL) {
+ m_ActiveStationsWidget->setClickOK(true);
+ }
+ return;
+ }
+ QMutableMapIterator<QString,RecentCall> icall(m_recentCall);
+ QString deCall,deGrid;
+ int age=0;
+ int i=0;
+ int maxAge=m_ActiveStationsWidget->maxAge();
+ int points=0;
+ int maxPoints=0;
+ int indx[1000];
+ float pts[1000];
+ QStringList list;
+
+ while (icall.hasNext()) {
+ icall.next();
+ deCall=icall.key();
+ age=int((m_latestDecodeTime - icall.value().decodeTime)/m_TRperiod + 0.5);
+ if(age<0) age=age + int(86400/m_TRperiod);
+ int itx=1;
+ if(icall.value().txEven) itx=0;
+ int snr=icall.value().snr;
+ int freq=icall.value().audioFreq;
+ if(age>maxAge) {
+ icall.remove();
+ } else {
+ bool bReady=false;
+ if(age==0 and m_recentCall.value(deCall).ready2call) bReady=true;
+
+ QString bands=m_activeCall[deCall].bands;
+ bool bWorkedOnBand=false;
+ if(m_currentBand=="160m" and bands.mid(0,1)!=".") bWorkedOnBand=true;
+ if(m_currentBand=="80m" and bands.mid(1,1)!=".") bWorkedOnBand=true;
+ if(m_currentBand=="40m" and bands.mid(2,1)!=".") bWorkedOnBand=true;
+ if(m_currentBand=="20m" and bands.mid(3,1)!=".") bWorkedOnBand=true;
+ if(m_currentBand=="15m" and bands.mid(4,1)!=".") bWorkedOnBand=true;
+ if(m_currentBand=="10m" and bands.mid(5,1)!=".") bWorkedOnBand=true;
+ if(m_currentBand=="6m" and bands.mid(6,1)!=".") bWorkedOnBand=true;
+
+ if((bReady or !m_ActiveStationsWidget->readyOnly()) and !bWorkedOnBand) {
+ i++;
+ int az=m_activeCall[deCall].az;
+ deGrid=m_activeCall[deCall].grid4;
+ points=m_activeCall[deCall].points;
+ if(points>maxPoints) maxPoints=points;
+ float x=float(age)/(maxAge+1);
+ if(x>1.0) x=0;
+ pts[i-1]=points - x;
+ QString t1;
+ if(!bReady) t1 = t1.asprintf(" %3d %+2.2d %4d %1d %2d %4d",az,snr,freq,itx,age,points);
+ if(bReady) t1 = t1.asprintf(" %3d %+2.2d %4d %1d %2d*%4d",az,snr,freq,itx,age,points);
+// t1 = (deCall + " ").left(6) + " " + m_activeCall[deCall].grid4 + t1 + " " + bands;
+ t1 = (deCall + " ").left(6) + " " + m_activeCall[deCall].grid4 + t1;
+ list.append(t1);
+ }
+ }
+ }
+ if(i==0) return;
+ int jz=i;
+ m_ActiveStationsWidget->setClickOK(false);
+ int maxRecent=qMin(i,m_ActiveStationsWidget->maxRecent());
+ indexx_(pts,&jz,indx);
+ QString t;
+ i=0;
+ for(int j=jz-1; j>=0; j--) {
+ int k=indx[j]-1;
+ m_ready2call[i]=list[k];
+ i++;
+ QString t1=QString::number(i) + ". ";
+ if(i<10) t1=" " + t1;
+ t += (t1 + list[k] + "\n");
+ if(i>=maxRecent) break;
+ }
+ bool is_fox_mode = (m_mode=="FT8" && m_specOp == SpecOp::FOX);
+ if(m_ActiveStationsWidget!=NULL && !is_fox_mode) m_ActiveStationsWidget->displayRecentStations(m_mode,t);
+ m_ActiveStationsWidget->setClickOK(true);
+}
+
+void MainWindow::queueActiveWindowHound2(QString line) {
+ // Active Window shows what's going on outside of current F/H display rules (calling below 1000Hz e.g.)
+ // TODO should we allow calling a station that's calling another station, not us?
+ if (m_mode == "FT8" and m_specOp == SpecOp::FOX) {
+ // process the line to get the callsign
+ QStringList w = line.split(' ', SkipEmptyParts);
+ // make sure our call is the first in the list, or the station is CQing (not a directed CQ)
+ if ( (w.size() > 7) &&
+ (w[5] == m_config.my_callsign() || w[5] == "<"+m_config.my_callsign()+">" || w[5]=="CQ") &&
+ ( w[7].contains(grid_regexp) || w[7].contains(non_r_db_regexp) )){
+ QString caller = w[6];
+ QString grid = "";
+ QString db = w[1];
+ int db_i = w[1].toInt();
+ db = (db_i >=0 ? "+":"") + QStringLiteral("%1").arg(db_i, (db_i >=0 ? 2:3), 10, QLatin1Char('0')); // +00, -01 etc.
+ // houndcall rpt grid
+ if (w[7].contains(grid_regexp)) grid = w[7];
+ if (w[7].contains(non_r_db_regexp)) {
+ LOG_INFO(QString("ActiveStations Window click: %1 called with signal report %2").arg(caller).arg(w[7]));
+ }
+ if (caller.length() > 2) {
+ // make sure it's not already in the queue
+ for ( QString hs : m_houndQueue) {
+ if (hs.startsWith(caller)) {
+ //LOG_INFO(QString("ActiveStations Window click: %1 already in queue. Skipping").arg(hs));
+ return;
+ }
+ }
+ // make sure caller is not in fox queue either
+ if(m_foxQSO.contains(caller)) {
+ //LOG_INFO(QString("ActiveStations Window click: %1 already in progress. Skipping").arg(caller));
+ return;
+ }
+
+ QString caller_rpt = (caller+" ").mid(0,12)+db;
+ if (m_houndQueue.count() < MAX_HOUNDS_IN_QUEUE) {
+ // add it to the queue
+ m_houndQueue.enqueue(caller_rpt + " " + grid);
+ refreshHoundQueueDisplay();
+ // TODO: remove from active stations window too?
+ }
+ removeHoundFromCallingList(caller);
+ }
+ } else {
+ LOG_INFO(QString("ActiveStations Window click: skipping %1").arg(line));
+ }
+ }
+}
+
+void MainWindow::callSandP2(int n)
+{
+ bool bCtrl = (n<0);
+ n=qAbs(n)-1;
+ if(m_mode!="Q65" and m_ready2call[n]=="") return;
+ QStringList w=m_ready2call[n].split(' ', SkipEmptyParts);
+ if(m_mode=="Q65" and m_specOp==SpecOp::Q65_PILEUP and n < 40) {
+ // This code is for 6m EME DXpedition operator
+ w=m_callers[n].split(' ', SkipEmptyParts);
+ m_deCall=w[2];
+ if(bCtrl) {
+ // Remove this call from q3list.
+ rm_q3list_(const_cast<char *> (m_deCall.toLatin1().constData()), m_deCall.size());
+ refreshPileupList();
+ return;
+ }
+ m_deGrid=w[3];
+ m_bDoubleClicked=true; //### needed?
+ m_txFirst=true;
+ ui->dxCallEntry->setText(m_deCall);
+ ui->dxGridEntry->setText(m_deGrid);
+ ui->txFirstCheckBox->setChecked(m_txFirst);
+ genStdMsgs("-22");
+ setTxMsg(3);
+ if (!ui->autoButton->isChecked()) ui->autoButton->click(); // Enable Tx
+ if(m_transmitting) m_restart=true;
+ return;
+ }
+
+ if(m_mode=="Q65") {
+ if(!bCtrl) { //Do not reset m_freqNominal if CTRL was down
+ double kHz=w[1].toDouble();
+ int nMHz=m_freqNominal/1000000;
+ m_freqNominal=(nMHz*1000 + kHz)* 1000;
+ }
+ m_deCall=w[4];
+ m_deGrid=w[5];
+ m_txFirst=(w[6]=="0");
+// ui->TxFreqSpinBox->setValue(1500);
+ } else {
+ m_deCall=w[0];
+ m_deGrid=w[1];
+ ui->RxFreqSpinBox->setValue(w[4].toInt());
+ m_txFirst = (w[5]=="0");
+ }
+
+ if(w[3].left(2)=="30") {
+ ui->sbTR->setValue(30);
+ } else {
+ ui->sbTR->setValue(60);
+ }
+ if(w[3].right(1)=="A") ui->sbSubmode->setValue(0);
+ if(w[3].right(1)=="B") ui->sbSubmode->setValue(1);
+ if(w[3].right(1)=="C") ui->sbSubmode->setValue(2);
+ if(w[3].right(1)=="D") ui->sbSubmode->setValue(3);
+ if(w[3].right(1)=="E") ui->sbSubmode->setValue(4);
+
+ m_bDoubleClicked=true; //### needed?
+ ui->dxCallEntry->setText(m_deCall);
+ ui->dxGridEntry->setText(m_deGrid);
+ if(m_mode=="Q65") {
+ ui->rptSpinBox->setValue(w[2].toInt());
+ genStdMsgs(w[2]);
+ } else {
+ genStdMsgs(w[3]);
+ }
+ setTxMsg(1);
+ ui->txFirstCheckBox->setChecked(m_txFirst);
+ static qint64 ms0=0;
+ qint64 ms=QDateTime::currentMSecsSinceEpoch();
+ if(ui->autoButton->isChecked()) {
+ if((ms-ms0)<=500) ui->autoButton->click(); // Disable Tx on double click
+ } else if((ms-ms0)>500) {
+ ui->autoButton->click(); // Enable Tx on single click
+ }
+ ms0=ms;
+ if(m_transmitting) m_restart=true;
+}
+
+void MainWindow::activeWorked(QString call, QString band)
+{
+ QString bands=m_activeCall[call].bands;
+ QByteArray ba=bands.toLatin1();
+ if(band=="160m") ba[0]='a';
+ if(band=="80m") ba[1]='b';
+ if(band=="40m") ba[2]='c';
+ if(band=="20m") ba[3]='d';
+ if(band=="15m") ba[4]='e';
+ if(band=="10m") ba[5]='f';
+ if(band=="6m") ba[6]='g';
+ m_activeCall[call].bands=QString::fromLatin1(ba);
+}
+
+void MainWindow::readFromStdout() //readFromStdout
+{
+ bool bDisplayPoints = false;
+ QString all_decodes;
+ if(m_ActiveStationsWidget!=NULL) {
+ bDisplayPoints=(m_mode=="FT4" or m_mode=="FT8") and
+ (m_specOp==SpecOp::ARRL_DIGI or m_ActiveStationsWidget->isVisible());
+ }
+ while(proc_jt9.canReadLine()) {
+ auto line_read = proc_jt9.readLine ();
+ if (m_mode == "FT8" and m_specOp == SpecOp::FOX and m_ActiveStationsWidget != NULL) { // see if we should add this to ActiveStations window
+ QString the_line = QString(line_read);
+ if (!m_ActiveStationsWidget->wantedOnly() ||
+ (the_line.contains(" " + m_config.my_callsign() + " ") ||
+ the_line.contains(" <" + m_config.my_callsign() + "> ")))
+ all_decodes.append(line_read);
+ }
+ if (auto p = std::strpbrk (line_read.constData (), "\n\r")) {
+ // truncate before line ending chars
+ line_read = line_read.left (p - line_read.constData ());
+ }
+ if(bDisplayPoints) line_read=line_read.replace("a7"," ");
+ bool haveFSpread {false};
+ float fSpread {0.};
+ if (m_mode.startsWith ("FST4"))
+ {
+ auto text = line_read.mid (64, 6).trimmed ();
+ if (text.size ())
+ {
+ fSpread = text.toFloat (&haveFSpread);
+ line_read = line_read.left (64);
+ }
+ auto const& cs = m_config.my_callsign ().toLocal8Bit ();
+ if ("FST4W" == m_mode && ui->cbNoOwnCall->isChecked ()
+ && (line_read.contains (" " + cs + " ")
+ || line_read.contains ("<" + cs + ">"))) {
+ continue;
+ }
+ }
+
+ // Don't allow a7 decodes during the first period because they can be leftovers from the previous band
+ if (!(no_a7_decodes && line_read.contains("a7")))
+ {
+
+ if (m_mode != "FT8" and m_mode != "FT4" and !m_mode.startsWith("FST4") and m_mode != "Q65")
+ {
+ //Pad 22-char msg to at least 37 chars
+ line_read = line_read.left(44) + " " + line_read.mid(44);
+ }
+ bool bAvgMsg = false;
+ int navg = 0;
+
+// qint64 ms = QDateTime::currentMSecsSinceEpoch() % 86400000;
+// double fTR=float((ms%int(1000.0*m_TRperiod)))/int(1000.0*m_TRperiod);
+ if (line_read.indexOf("<DecodeFinished>") >= 0)
+ {
+ m_bDecoded = line_read.mid(20).trimmed().toInt() > 0;
+ int n = line_read.trimmed().size();
+ int n2 = line_read.trimmed().mid(n - 7).toInt();
+ int n0 = n2 / 1000;
+ int n1 = n2 % 1000;
+ if (m_mode == "Q65")
+ {
+ ndecodes_label.setText(QString{"%1 %2"}.arg(n0).arg(n1));
+ } else
+ {
+ if (m_nDecodes == 0) ndecodes_label.setText("0");
+ }
+ decodeDone();
+ return;
+ } else
+ {
+ m_nDecodes += 1;
+ if (m_mode != "Q65") ndecodes_label.setText(QString::number(m_nDecodes));
+ if (m_mode == "JT4" or m_mode == "JT65" or m_mode == "Q65")
+ {
+ //### Do something about Q65 here ? ###
+ int nf = line_read.indexOf("f");
+ if (nf > 0)
+ {
+ navg = line_read.mid(nf + 1, 1).toInt();
+ if (line_read.indexOf("f*") > 0) navg = 10;
+ }
+ int nd = -1;
+ if (nf < 0) nd = line_read.indexOf("d");
+ if (nd > 0)
+ {
+ navg = line_read.mid(nd + 2, 1).toInt();
+ if (line_read.mid(nd + 2, 1) == "*") navg = 10;
+ }
+ int na = -1;
+ if (nf < 0 and nd < 0) na = line_read.indexOf("a");
+ if (na > 0)
+ {
+ navg = line_read.mid(na + 2, 1).toInt();
+ if (line_read.mid(na + 2, 1) == "*") navg = 10;
+ }
+ int nq = -1;
+ if (nf < 0 and nd < 0 and na < 0) nq = line_read.indexOf("q");
+ if (nq > 0)
+ {
+ navg = line_read.mid(nq + 2, 1).toInt();
+ if (line_read.mid(nq + 2, 1) == "*") navg = 10;
+ }
+ if (navg >= 2) bAvgMsg = true;
+ }
+ if (!line_read.trimmed().contains("$VERIFY$"))
+ {
+ write_all("Rx", line_read.trimmed());
+ }
+ int ntime = 6;
+ if (m_TRperiod >= 60) ntime = 4;
+ if (line_read.left(ntime) != m_tBlankLine &&
+ QString::fromUtf8(line_read.constData()).left(4).contains(QRegularExpression{"\\d\\d\\d\\d"}))
+ {
+ ui->decodedTextBrowser->new_period();
+ if (m_specOp == SpecOp::FOX and m_ActiveStationsWidget != NULL)
+ { // clear the ActiveStations window
+ m_ActiveStationsWidget->clearStations();
+ m_ActiveStationsWidget->displayRecentStations("Fox Mode", "");
+ }
+ if (m_config.insert_blank()
+ && SpecOp::FOX != m_specOp)
+ {
+ QString band;
+ if (((QDateTime::currentMSecsSinceEpoch() / 1000 - m_secBandChanged) > 4 * int(m_TRperiod) / 4)
+ or m_displayBand)
+ {
+ band = ' ' + m_config.bands()->find(m_freqNominal);
+ }
+ ui->decodedTextBrowser->insertLineSpacer(band.rightJustified(40, '-'));
+ }
+ m_tBlankLine = line_read.left(ntime);
+ }
+// if(m_mode=="FT8" && fTR>0.6 && fTR<0.75) decodeDone(); // Clear a hung decoder status
+ }
+ if ("FST4W" == m_mode)
+ {
+ uploadWSPRSpots(true, line_read);
+ }
+ DecodedText decodedtext0{QString::fromUtf8(line_read.constData())};
+ DecodedText decodedtext{QString::fromUtf8(line_read.constData()).remove("TU; ")};
+
+ if (m_mode == "FT8" and SpecOp::FOX == m_specOp and
+ (decodedtext.string().contains("R+") or decodedtext.string().contains("R-")))
+ {
+ auto for_us = decodedtext.string().contains(" " + m_config.my_callsign() + " ") or
+ decodedtext.string().contains(" " + m_baseCall) or
+ decodedtext.string().contains(m_baseCall + " ") or
+ decodedtext.string().contains(" <" + m_config.my_callsign() + "> ");
+ if (decodedtext.string().contains(" DE ")) for_us = true; //Hound with compound callsign
+ if (for_us)
+ {
+ QString houndCall, houndGrid;
+ decodedtext.deCallAndGrid(/*out*/houndCall, houndGrid);
+ foxRxSequencer(decodedtext.string(), houndCall, houndGrid);
+ }
+ }
+
+//Left (Band activity) window
+ if (!bAvgMsg)
+ {
+ if (m_mode == "FT8" and SpecOp::FOX == m_specOp)
+ {
+ if (!m_bDisplayedOnce)
+ {
+ // This hack sets the font. Surely there's a better way!
+ DecodedText dt{"."};
+ ui->decodedTextBrowser->displayDecodedText(dt, m_config.my_callsign(), m_mode, m_config.DXCC(),
+ m_logBook, m_currentBand, m_config.ppfx());
+ m_bDisplayedOnce = true;
+ }
+ } else
+ {
+#ifdef FOX_OTP
+ // remove verifications that are done
+ QMutableListIterator < FoxVerifier * > it(m_verifications);
+ while (it.hasNext()) {
+ if (it.next()->finished()) {
+ it.remove();
+ }
+ }
+#endif
+ DecodedText decodedtext1 = decodedtext0;
+ if ((m_mode == "FT4" or m_mode == "FT8") and bDisplayPoints and decodedtext1.isStandardMessage())
+ {
+ ARRL_Digi_Update(decodedtext1);
+ }
+#ifdef FOX_OTP
+ if ((SpecOp::HOUND == m_specOp) &&
+ ((m_config.superFox() && (decodedtext0.mid(24, 8) == "$VERIFY$")) || // $VERIFY$ K8R 920749
+ (decodedtext0.mid(24,-1).contains(QRegularExpression{"^[A-Z0-9]{2,5}\\.V[0-9]{6}"})))) // K8R.V920749
+ {
+ LOG_INFO(QString("Have a verification message"));
+ // two cases:
+ // QString test_return = QString{"203630 -12 0.1 775 ~ K8R.V920749"};
+ // $VERIFY$ foxcall otp
+ // QString test_return = QString{"203630 -12 0.1 775 ~ $VERIFY$ K8R 920749"};
+ QStringList lineparts;
+ QString callsign, otp;
+ unsigned int hz;
+ lineparts = decodedtext0.string().split(' ', SkipEmptyParts);
+ if (lineparts.length() <= 6) {
+ QStringList otp_parts;
+ // split K8R.V920749 into K8R and 920749
+ otp_parts = lineparts[5].split('.', SkipEmptyParts);
+ callsign = otp_parts[0];
+ otp = otp_parts[1].mid(1); // remove the V
+ hz = lineparts[3].toInt();
+ } else
+ {
+ // split $VERIFY$ K8R 920749 into K8R and 920749
+ callsign = lineparts[6];
+ otp = lineparts[7];
+ hz = 750; // SF is 750
+ }
+ QDateTime verifyDateTime;
+ if (m_diskData) {
+ verifyDateTime = m_UTCdiskDateTime; // get the date set from reading the wav file
+ } else {
+ verifyDateTime = QDateTime(QDateTime::currentDateTimeUtc().date(),
+ QTime::fromString(lineparts[0], "hhmmss"));
+ }
+ LOG_INFO(QString("Verifying: %1 %2").arg(callsign).arg(otp));
+ FoxVerifier *fv = new FoxVerifier(MainWindow::userAgent(),
+ &m_network_manager,
+ FOXVERIFIER_DEFAULT_BASE_URL,
+ callsign, // foxcall
+ verifyDateTime,
+ otp,
+ hz); // freq
+ connect(fv, &FoxVerifier::verifyComplete, this, &MainWindow::handleVerifyMsg);
+ m_verifications << fv;
+ }
+#endif
+ if (ui->labDXped->text() == "Super Hound" && decodedtext0.mid(3, 18).contains(" verified"))
+ {
+ verified = true;
+ write_all("Vf", decodedtext0.string());
+ ui->labDXped->setStyleSheet("QLabel {background-color: #00ff00; color: black;}");
+ } else
+ {
+ if (decodedtext0.mid(4, 2).contains("00") or decodedtext0.mid(4, 2).contains("30")) verified = false;
+ }
+ if ((!verified && ui->labDXped->isVisible()) or ui->labDXped->text() != "Super Hound")
+ ui->labDXped->setStyleSheet("QLabel {background-color: red; color: white;}");
+ ui->decodedTextBrowser->displayDecodedText(decodedtext1, m_config.my_callsign(), m_mode, m_config.DXCC(),
+ m_logBook, m_currentBandPeriod, m_config.ppfx(),
+ ui->cbCQonly->isVisible() && ui->cbCQonly->isChecked(),
+ haveFSpread, fSpread, bDisplayPoints, m_points);
+ if ((m_mode == "FT4" or m_mode == "FT8") and bDisplayPoints and decodedtext1.isStandardMessage())
+ {
+ QString deCall, deGrid;
+ decodedtext.deCallAndGrid(/*out*/deCall, deGrid);
+ bool bWorkedOnBand = (ui->decodedTextBrowser->CQPriority() != "New Call on Band") and
+ ui->decodedTextBrowser->CQPriority() != "";
+ if (bWorkedOnBand) activeWorked(deCall, m_currentBand);
+ }
+
+ if (m_config.highlight_DXcall() && (m_hisCall != "") &&
+ ((decodedtext.string().contains(QRegularExpression{"(\\w+) " + m_hisCall}))
+ || (decodedtext.string().contains(QRegularExpression{"(\\w+) <" + m_hisCall + ">"}))
+ || (decodedtext.string().contains(QRegularExpression{"<(\\w+)> " + m_hisCall}))
+ || (decodedtext.string().contains(QRegularExpression{"<...> " + m_hisCall}))))
+ {
+ ui->decodedTextBrowser->highlight_callsign(m_hisCall, QColor(255, 0, 0), QColor(255, 255, 255),
+ true); // highlight dxCallEntry
+ QTimer::singleShot(500, [=] { // repeated highlighting to override JTAlert
+ ui->decodedTextBrowser->highlight_callsign(m_hisCall, QColor(255, 0, 0), QColor(255, 255, 255), true);
+ });
+ QTimer::singleShot(1000, [=] { // repeated highlighting to override JTAlert
+ ui->decodedTextBrowser->highlight_callsign(m_hisCall, QColor(255, 0, 0), QColor(255, 255, 255), true);
+ });
+ QTimer::singleShot(2500, [=] { // repeated highlighting to override JTAlert
+ ui->decodedTextBrowser->highlight_callsign(m_hisCall, QColor(255, 0, 0), QColor(255, 255, 255), true);
+ });
+ }
+ if (m_config.highlight_DXgrid() && (m_hisGrid != "") && (decodedtext.string().contains(m_hisGrid)))
+ {
+ ui->decodedTextBrowser->highlight_callsign(m_hisGrid, QColor(0, 0, 255), QColor(255, 255, 255),
+ true); // highlight dxGridEntry
+ }
+
+ if (m_bBestSPArmed && m_mode == "FT4" && CALLING == m_QSOProgress)
+ {
+ QString messagePriority = ui->decodedTextBrowser->CQPriority();
+ if (messagePriority != "")
+ {
+ if (messagePriority == "New Call on Band"
+ and m_BestCQpriority != "New Call on Band"
+ and m_BestCQpriority != "New Multiplier")
+ {
+ m_BestCQpriority = "New Call on Band";
+ m_bDoubleClicked = true;
+ processMessage(decodedtext0);
+ }
+ if (messagePriority == "New DXCC"
+ and m_BestCQpriority != "New DXCC"
+ and m_BestCQpriority != "New Multiplier")
+ {
+ m_BestCQpriority = "New DXCC";
+ m_bDoubleClicked = true;
+ processMessage(decodedtext0);
+ }
+ }
+ }
+ }
+ }
+
+
+//Right (Rx Frequency) window
+ bool bDisplayRight=bAvgMsg;
+ int audioFreq=decodedtext.frequencyOffset();
+ if(m_mode=="FT8" or m_mode=="FT4" or m_mode=="FST4" or m_mode=="Q65") {
+ int ftol=10;
+ if(m_mode=="Q65") ftol=ui->sbFtol->value();
+ auto const& parts = decodedtext.string().remove("<").remove(">")
+ .split (' ', SkipEmptyParts);
+ if (parts.size() > 6) {
+ auto for_us = parts[5].contains (m_baseCall)
+ || ("DE" == parts[5] && qAbs (ui->RxFreqSpinBox->value () - audioFreq) <= ftol);
+ if(m_baseCall == m_config.my_callsign()) {
+ if (m_baseCall != parts[5]) for_us=false;
+ } else {
+ if (m_config.my_callsign () != parts[5]) {
+// Same base call as ours but different prefix or suffix. Rare but can happen with
+// multi-station special events.
+ for_us = false;
+ }
+ }
+ if(m_bCallingCQ && !m_bAutoReply && for_us && m_specOp!=SpecOp::FOX && m_specOp!=SpecOp::HOUND) {
+ bool bProcessMsgNormally=ui->respondComboBox->currentText()=="CQ: First" or
+ (ui->respondComboBox->currentText()=="CQ: Max Dist" and m_ActiveStationsWidget==NULL) or
+ (m_ActiveStationsWidget!=NULL and !m_ActiveStationsWidget->isVisible());
+ if (decodedtext.messageWords().length() >= 3) {
+ QString t=decodedtext.messageWords()[2];
+ if(t.contains("R+") or t.contains("R-") or t=="R" or t=="RRR" or t=="RR73") bProcessMsgNormally=true;
+ } else {
+ bProcessMsgNormally=true;
+ }
+ if(bProcessMsgNormally) {
+ m_bDoubleClicked=true;
+ m_bAutoReply = true;
+ processMessage (decodedtext);
+ }
+
+ if(!bProcessMsgNormally and m_ActiveStationsWidget and ui->respondComboBox->currentText()=="CQ: Max Dist") {
+ QString deCall;
+ QString deGrid;
+ decodedtext.deCallAndGrid(/*out*/deCall,deGrid);
+ // if they dont' send their grid we'll use ours and assume dx=0
+ if (deGrid.length() == 0) deGrid = m_config.my_grid();
+
+ if(deGrid.contains(grid_regexp) or
+ (deGrid.contains("+") or deGrid.contains("-"))) {
+ int points=0;
+ if(m_activeCall.contains(deCall)) {
+ points=m_activeCall[deCall].points;
+ deGrid=m_activeCall[deCall].grid4;
+ } else if(deGrid.contains(grid_regexp)) {
+ double utch=0.0;
+ int nAz,nEl,nDmiles,nDkm,nHotAz,nHotABetter;
+ azdist_(const_cast <char *> ((m_config.my_grid () + " ").left (6).toLatin1 ().constData ()),
+ const_cast <char *> ((deGrid + " ").left(6).toLatin1 ().constData ()),&utch,
+ &nAz,&nEl,&nDmiles,&nDkm,&nHotAz,&nHotABetter,(FCL)6,(FCL)6);
+ points=nDkm/500;
+ if(nDkm > 500*points) points += 1;
+ points += 1;
+ }
+ if(points>m_maxPoints) {
+ m_maxPoints=points;
+ m_deCall=deCall;
+ m_bDoubleClicked=true;
+ ui->dxCallEntry->setText(deCall);
+ int m_ntx=2;
+ bool bContest=m_specOp==SpecOp::NA_VHF or m_specOp==SpecOp::ARRL_DIGI;
+ if(bContest) m_ntx=3;
+ if(deGrid.contains(grid_regexp)) {
+ m_deGrid=deGrid;
+ ui->dxGridEntry->setText(deGrid);
+ } else {
+ m_ntx=3;
+ }
+ if(m_ntx==2) m_QSOProgress = REPORT;
+ if(m_ntx==3) m_QSOProgress = ROGER_REPORT;
+ genStdMsgs(QString::number(decodedtext.snr()));
+ ui->RxFreqSpinBox->setValue(decodedtext.frequencyOffset());
+ setTxMsg(m_ntx);
+ m_currentMessageType=m_ntx;
+ }
+ }
+ }
+
+ }
+ if(SpecOp::FOX==m_specOp and decodedtext.string().contains(" DE ")) for_us=true; //Hound with compound callsign
+ if(SpecOp::FOX==m_specOp and for_us and decodedtext.string().contains(QRegularExpression{" R\\W\\d"})) bDisplayRight=true;
+ if(SpecOp::FOX!=m_specOp and (for_us or (abs(audioFreq - m_wideGraph->rxFreq()) <= 10))) bDisplayRight=true;
+ if(SpecOp::HOUND==m_specOp and !for_us) bDisplayRight=false;
+ }
+ } else {
+ if((abs(audioFreq - m_wideGraph->rxFreq()) <= 10) and
+ !m_config.enable_VHF_features()) bDisplayRight=true;
+ }
+ if(m_mode=="Q65" and !bAvgMsg and !decodedtext.string().contains(m_baseCall)) bDisplayRight=false;
+ if((m_mode=="JT4" or m_mode=="Q65" or m_mode=="JT65") and decodedtext.string().contains(m_baseCall) && ui->actionInclude_averaging->isVisible() && !ui->actionInclude_averaging->isChecked()) bDisplayRight=true;
+ if((m_mode=="FT8" or m_mode=="FT4") and SpecOp::FOX!=m_specOp && decodedtext0.string().replace("<","").replace(">","").contains(m_baseCall + " " + m_hisCall)) bDisplayRight=true; // really all messages for us
+
+ if (bDisplayRight) {
+ // This msg is within 10 hertz of our tuned frequency, or a JT4 or JT65 avg,
+ // or contains MyCall
+ if(!m_bBestSPArmed or m_mode!="FT4") {
+ ui->decodedTextBrowser2->displayDecodedText (decodedtext0, m_config.my_callsign (), m_mode, m_config.DXCC (),
+ m_logBook, m_currentBand, m_config.ppfx (), false, false, 0.0, bDisplayPoints, m_points);
+ }
+ m_QSOText = decodedtext.string ().trimmed ();
+ }
+
+ postDecode (true, decodedtext.string ());
+
+ if(m_mode=="FT8" and SpecOp::HOUND==m_specOp) {
+ if(decodedtext.string().contains(";")) {
+ QStringList w=decodedtext.string().mid(24).split(" ",SkipEmptyParts);
+ QString foxCall=w.at(3);
+ foxCall=foxCall.remove("<").remove(">");
+ if(w.at(0)==m_config.my_callsign() or w.at(0)==Radio::base_callsign(m_config.my_callsign())) {
+ //### Check for ui->dxCallEntry->text()==foxCall before logging! ###
+ ui->stopTxButton->click ();
+ logQSOTimer.start(0);
+ }
+ if((w.at(2)==m_config.my_callsign() or w.at(2)==Radio::base_callsign(m_config.my_callsign()))
+ and ui->tx3->text().length()>0) {
+ m_rptRcvd=w.at(4);
+ m_rptSent=decodedtext.string().mid(7,3);
+ m_nFoxFreq=decodedtext.string().mid(16,4).toInt();
+ hound_reply ();
+ }
+ } else {
+ QString text = decodedtext.string().replace("<","").replace(">",""); // needed for MSHV multistream messages
+ QStringList w=text.mid(24).split(" ",SkipEmptyParts);
+ if(decodedtext.string().contains("/")) w.append(" +00"); //Add a dummy report
+ if(w.size()>=3) {
+ QString foxCall=w.at(1);
+ if((w.at(0)==m_config.my_callsign() or w.at(0)==Radio::base_callsign(m_config.my_callsign())) and
+ ui->tx3->text().length()>0) {
+ if(w.at(2)=="RR73") {
+ ui->stopTxButton->click ();
+ logQSOTimer.start(0);
+ } else {
+ if(w.at(1)==Radio::base_callsign(ui->dxCallEntry->text()) and
+ (w.at(2).mid(0,1)=="+" or w.at(2).mid(0,1)=="-")) {
+ m_rptRcvd=w.at(2);
+ m_rptSent=decodedtext.string().mid(7,3);
+ m_nFoxFreq=decodedtext.string().mid(16,4).toInt();
+ hound_reply ();
+ } else {
+ if (SpecOp::HOUND==m_specOp && (text.mid(4,2).contains("15") or text.mid(4,2).contains("45"))) return; // ignore stations calling in the wrong time slot
+ if (text.contains(" " + m_config.my_callsign() + " " + m_hisCall) && !text.contains("73 ")) processMessage(decodedtext0); // needed for MSHV multistream messages
+ }
+ }
+ }
+ }
+ }
+ }
+
+//### I think this is where we are preventing Hounds from spotting Fox ###
+ if(m_mode!="FT8" or (SpecOp::HOUND != m_specOp) or (SpecOp::HOUND == m_specOp and m_config.superFox())) {
+ if(m_mode=="FT8" or m_mode=="FT4" or m_mode=="Q65"
+ or m_mode=="JT4" or m_mode=="JT65" or m_mode=="JT9" or m_mode=="FST4") {
+ auto_sequence (decodedtext, 25, 50);
+ }
+
+// find and extract any report for myCall, but save in m_rptRcvd only if it's from DXcall
+ QString rpt;
+ bool stdMsg = decodedtext.report(m_baseCall,
+ Radio::base_callsign(ui->dxCallEntry->text()), rpt);
+ QString deCall;
+ QString grid;
+ decodedtext.deCallAndGrid(/*out*/deCall,grid);
+ {
+ auto t = Radio::base_callsign (ui->dxCallEntry->text ());
+ auto const& dx_call = decodedtext.call ();
+ if (rpt.size () // report in message
+ && (m_baseCall == Radio::base_callsign (dx_call) // for us
+ || "DE" == dx_call) // probably for us
+ && (t == deCall // DX station base call is QSO partner
+ || ui->dxCallEntry->text () == deCall // DX station full call is QSO partner
+ || !t.size ())) // not in QSO
+ {
+ m_rptRcvd = rpt;
+ }
+ }
+// extract details and send to PSKreporter
+ int nsec=QDateTime::currentMSecsSinceEpoch()/1000-m_secBandChanged;
+ bool okToPost=(nsec > int(4*m_TRperiod)/5);
+ if(m_mode=="FST4W" and okToPost) {
+ line_read=line_read.left(22) + " CQ " + line_read.trimmed().mid(22);
+ auto p = line_read.lastIndexOf (' ');
+ DecodedText FST4W_post {QString::fromUtf8 (line_read.left (p).constData ())};
+ pskPost(FST4W_post);
+ } else {
+ if (stdMsg && okToPost) pskPost(decodedtext);
+ }
+ if((m_mode=="JT4" or m_mode=="JT65" or m_mode=="Q65") and
+ m_msgAvgWidget!=NULL) {
+ if(m_msgAvgWidget->isVisible()) {
+ QFile f(m_config.temp_dir ().absoluteFilePath ("avemsg.txt"));
+ if(f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+ QTextStream s(&f);
+ QString t=s.readAll();
+ if (t != NULL) m_msgAvgWidget->displayAvg(t);
+ else qDebug() << "tmp==NULL at s.readAll";
+ }
+ }
+ }
+ }
+ }
+ }
+ if (m_mode == "FT8" and m_specOp == SpecOp::FOX and m_ActiveStationsWidget != NULL) {
+ m_ActiveStationsWidget->addLine(all_decodes);
+ }
+}
+
+//
+// start_tolerance - only respond to "DE ..." and free text 73
+// messages within +/- this value
+//
+// stop_tolerance - kill Tx if running station is seen to reply to
+// another caller and we are going to transmit within
+// +/- this value of the reply to another caller
+//
+void MainWindow::auto_sequence (DecodedText const& message, unsigned start_tolerance, unsigned stop_tolerance)
+{
+ auto const& message_words = message.messageWords ();
+ auto is_73 = message_words.filter (QRegularExpression {"^(73|RR73)$"}).size();
+ auto msg_no_hash = message.clean_string();
+ msg_no_hash = msg_no_hash.mid(22).remove("<").remove(">");
+ bool is_OK=false;
+ if(m_mode=="MSK144" && msg_no_hash.indexOf(ui->dxCallEntry->text()+" R ")>0) is_OK=true;
+ if (message_words.size () > 3 && (message.isStandardMessage() || (is_73 or is_OK))) {
+ auto df = message.frequencyOffset ();
+ auto within_tolerance = (qAbs (ui->RxFreqSpinBox->value () - df) <= int (start_tolerance)
+ || qAbs (ui->TxFreqSpinBox->value () - df) <= int (start_tolerance));
+ bool acceptable_73 = is_73
+ && m_QSOProgress >= ROGER_REPORT
+ && ((message.isStandardMessage ()
+ && (message_words.contains (m_baseCall)
+ || message_words.contains (m_config.my_callsign ())
+ || message_words.contains (ui->dxCallEntry->text ())
+ || message_words.contains (Radio::base_callsign (ui->dxCallEntry->text ()))
+ || message_words.contains ("DE")))
+ || (!message.isStandardMessage () && m_mode != "MSK144")); // free text 73/RR73 except for MSK
+
+ auto const& w = msg_no_hash.split(" ",SkipEmptyParts);
+ QString w2;
+ int nrpt=0;
+ if (w.size () > 2)
+ {
+ w2=w.at(2);
+ if(w.size()>3) {
+ nrpt=w2.toInt();
+ if(w2=="R") nrpt=w.at(3).toInt();
+ }
+ }
+ bool bEU_VHF=(nrpt>=520001 and nrpt<=594000);
+ if(bEU_VHF and message.clean_string ().contains("<"+m_config.my_callsign() + "> ")) {
+ m_xRcvd=message.clean_string ().trimmed().right(13);
+ }
+ if (m_auto
+ && (m_QSOProgress==REPLYING or (!ui->tx1->isEnabled () and m_QSOProgress==REPORT))
+ && !m_config.superFox() && (SpecOp::HOUND != m_specOp) && qAbs (ui->TxFreqSpinBox->value () - df) <= int (stop_tolerance) //
+ && message_words.at (2) != "DE"
+ && !message_words.at (2).contains (QRegularExpression {"(^(CQ|QRZ))|" + m_baseCall})
+ && message_words.at (3).contains (Radio::base_callsign (ui->dxCallEntry->text ()))) {
+ // auto stop to avoid accidental QRM
+ ui->stopTxButton->click (); // halt any transmission
+ } else if (m_auto // transmit allowed
+ && ui->cbAutoSeq->isVisible () && ui->cbAutoSeq->isEnabled () && ui->cbAutoSeq->isChecked () // auto-sequencing allowed
+ && ((!m_bCallingCQ // not calling CQ/QRZ
+ && !m_sentFirst73 // not finished QSO
+ && ((message_words.at (2).contains (m_baseCall)
+ // being called and not already in a QSO
+ && (message_words.at(3).contains(Radio::base_callsign(ui->dxCallEntry->text()))
+ or bEU_VHF))
+ || message_words.at(1) == m_baseCall // <de-call> RR73; ...
+ // type 2 compound replies
+ || (within_tolerance &&
+ (acceptable_73 ||
+ ("DE" == message_words.at (2) &&
+ w2.contains(Radio::base_callsign (m_hisCall)))))))
+ || (m_bCallingCQ && m_bAutoReply
+ // look for type 2 compound call replies on our Tx and Rx offsets
+ && ((within_tolerance && "DE" == message_words.at (2))
+ || message_words.at (2).contains (m_baseCall))))) {
+ if(SpecOp::FOX != m_specOp) processMessage (message);
+ }
+ }
+}
+
+void MainWindow::pskPost (DecodedText const& decodedtext)
+{
+ if (m_diskData || !m_config.spot_to_psk_reporter() || decodedtext.isLowConfidence ()
+ || (decodedtext.string().contains(m_baseCall) && decodedtext.string().contains(m_config.my_grid().left(4)))) return; // prevent self-spotting when running multiple instances
+
+ QString msgmode=m_mode;
+ QString deCall;
+ QString grid;
+ decodedtext.deCallAndGrid(/*out*/deCall,grid);
+ int audioFrequency = decodedtext.frequencyOffset();
+ if(m_mode=="FT8" or m_mode=="MSK144" or m_mode=="FT4") {
+ audioFrequency=decodedtext.string().mid(16,4).toInt();
+ }
+ int snr = decodedtext.snr();
+ Frequency frequency = m_freqNominalPeriod + audioFrequency; // prevent spotting wrong band
+ if(grid.contains (grid_regexp) || decodedtext.string().contains(" CQ ")) {
+// qDebug() << "To PSKreporter:" << deCall << grid << frequency << msgmode << snr;
+ if (!m_psk_Reporter.addRemoteStation (deCall, grid, frequency, msgmode, snr))
+ {
+ showStatusMessage (tr ("Spotting to PSK Reporter unavailable"));
+ }
+ }
+}
+
+void MainWindow::killFile ()
+{
+ if (m_fnameWE.size () && !(m_saveAll || (m_saveDecoded && m_bDecoded))) {
+ QFile f1 {m_fnameWE + ".wav"};
+ if(f1.exists()) f1.remove();
+ if(m_mode=="WSPR" or m_mode=="FST4W") {
+ QFile f2 {m_fnameWE + ".c2"};
+ if(f2.exists()) f2.remove();
+ }
+ }
+}
+
+void MainWindow::on_EraseButton_clicked ()
+{
+ qint64 ms=QDateTime::currentMSecsSinceEpoch();
+ ui->decodedTextBrowser2->erase ();
+ if(m_mode=="WSPR" or m_mode=="Echo" or m_mode=="FST4W") {
+ ui->decodedTextBrowser->erase ();
+ } else {
+ if((ms-m_msErase)<500) {
+ ui->decodedTextBrowser->erase ();
+ }
+ }
+ m_msErase=ms;
+}
+
+void MainWindow::band_activity_cleared ()
+{
+ m_messageClient->decodes_cleared ();
+ QFile f(m_config.temp_dir ().absoluteFilePath ("decoded.txt"));
+ if(f.exists()) f.remove();
+}
+
+void MainWindow::rx_frequency_activity_cleared ()
+{
+ m_QSOText.clear();
+ set_dateTimeQSO(-1); // G4WJS: why do we do this?
+}
+
+void MainWindow::decodeBusy(bool b) //decodeBusy()
+{
+ if (!b) {
+ m_optimizingProgress.reset ();
+ }
+ m_decoderBusy=b;
+ ui->DecodeButton->setEnabled(!b);
+ ui->actionOpen->setEnabled(!b);
+ ui->actionOpen_next_in_directory->setEnabled(!b);
+ ui->actionDecode_remaining_files_in_directory->setEnabled(!b);
+
+ statusUpdate ();
+}
+
+//------------------------------------------------------------- //guiUpdate()
+void MainWindow::guiUpdate()
+{
+ static char message[38];
+ static char msgsent[38];
+ double txDuration;
+
+ if(m_TRperiod==0) m_TRperiod=60.0;
+ txDuration=tx_duration(m_mode,m_TRperiod,m_nsps,m_bFast9);
+ if(m_mode=="FT8" and m_specOp==SpecOp::FOX and m_config.superFox()) txDuration=1.0+151*1024.0/12000.0;
+ // qDebug () << "DEBUG SF " << m_mode << m_TRperiod << m_nsps << (SpecOp::FOX==m_specOp) << m_config.superFox() << txDuration;
+ double tx1=0.0;
+ double tx2=txDuration;
+ if(m_mode=="FT8" or m_mode=="FT4") icw[0]=0; //No CW ID in FT4 or FT8 mode
+ if((icw[0]>0) and (!m_bFast9)) tx2 += icw[0]*2560.0/48000.0; //Full length including CW ID
+ if(tx2>m_TRperiod) tx2=m_TRperiod;
+ if(!m_txFirst and m_mode!="WSPR" and m_mode!="FST4W") {
+ tx1 += m_TRperiod;
+ tx2 += m_TRperiod;
+ }
+
+ qint64 ms = QDateTime::currentMSecsSinceEpoch() % 86400000;
+ int nsec=ms/1000;
+ double tsec=0.001*ms;
+ double t2p=fmod(tsec,2*m_TRperiod);
+ m_s6=fmod(tsec,6.0);
+ int nseq = fmod(double(nsec),m_TRperiod);
+ m_tRemaining=m_TRperiod - fmod(tsec,m_TRperiod);
+
+ if(m_mode=="Echo") {
+ tx1=0.0;
+ tx2=txDuration;
+ if(m_auto and m_s6>4.0) m_bEchoTxOK=true;
+ if(m_transmitting) m_bEchoTxed=true;
+ }
+
+ if(m_mode=="WSPR" or m_mode=="FST4W") {
+ if(nseq==0 and m_ntr==0) { //Decide whether to Tx or Rx
+ m_tuneup=false; //This is not an ATU tuneup
+ bool btx = m_auto && m_WSPR_tx_next; // To Tx, we need m_auto and
+ // scheduled transmit
+ m_WSPR_tx_next = false;
+ if(btx) {
+ m_ntr=-1; //This says we will have transmitted
+ ui->pbTxNext->setChecked (false);
+ m_bTxTime=true; //Start a WSPR or FST4W Tx sequence
+ } else {
+ // This will be a WSPR or FST4W Rx sequence.
+ m_ntr=1; //This says we will have received
+ m_bTxTime=false; //Start a WSPR or FST4W Rx sequence
+ }
+ }
+
+ } else {
+ // For all modes other than WSPR and FST4W
+ m_bTxTime = (t2p >= tx1) and (t2p < tx2);
+ if(m_mode=="Echo") m_bTxTime = m_bTxTime and m_bEchoTxOK;
+ if(m_mode=="FT8" and ui->tx5->currentText().contains("/B ")) {
+ //FT8 beacon transmission from Tx5 only at top of a UTC minute
+ double t4p=fmod(tsec,4*m_TRperiod);
+ if(t4p >= 30.0) m_bTxTime=false;
+ }
+ }
+ if(m_tune) m_bTxTime=true; //"Tune" takes precedence
+
+ if(m_transmitting or m_auto or m_tune) {
+ m_dateTimeLastTX = QDateTime::currentDateTimeUtc ();
+
+// Check for "txboth" (FT4 testing purposes only)
+ QFile f(m_appDir + "/txboth");
+ if(f.exists() and fmod(tsec,m_TRperiod) < (0.5 + 105.0*576.0/12000.0)) m_bTxTime=true;
+
+// Don't transmit another mode in the 30 m WSPR sub-band
+ Frequency onAirFreq = m_freqNominal + ui->TxFreqSpinBox->value();
+ if ((onAirFreq > 10139900 and onAirFreq < 10140320) and m_mode!="WSPR" and m_mode!="FST4W") {
+ m_bTxTime=false;
+ if (m_auto) auto_tx_mode (false);
+ if(onAirFreq!=m_onAirFreq0) {
+ m_onAirFreq0=onAirFreq;
+ auto const& message = tr ("Please choose another Tx frequency."
+ " WSJT-X will not knowingly transmit another"
+ " mode in the WSPR sub-band on 30m.");
+ QTimer::singleShot (0, [=] { // don't block guiUpdate
+ MessageBox::warning_message (this, tr ("WSPR Guard Band"), message);
+ });
+ }
+ }
+
+ if(m_mode=="FT8" and SpecOp::FOX==m_specOp) {
+// Don't allow Fox mode in any of the default FT8 sub-bands.
+ QVector<qint32> ft8Freq = {1840000,3573000,7074000,10136000,14074000,18100000,21074000,24915000,28074000,50313000,70154000};
+ for(int i=0; i<ft8Freq.length()-1; i++) {
+ int kHzdiff=m_freqNominal - ft8Freq[i];
+ if(qAbs(kHzdiff) < 3000 ) {
+ m_bTxTime=false;
+ if (m_auto) auto_tx_mode (false);
+ if (m_tune) stop_tuning();
+ auto const& message = tr ("Please choose another dial frequency.\n"
+ "Must be 3Khz away from %1.\n"
+ "WSJT-X will not operate in Fox mode\n"
+ "overlapping the standard FT8 sub-bands.").arg(ft8Freq[i]);
+ QTimer::singleShot (0, [=] { // don't block guiUpdate
+ MessageBox::warning_message (this, tr ("Fox Mode warning"), message);
+ });
+ break;
+ }
+ }
+ }
+
+ if (m_config.watchdog() && m_mode!="WSPR" && m_mode!="FST4W"
+ && m_idleMinutes >= m_config.watchdog ()) {
+ tx_watchdog (true); // disable transmit
+ }
+
+ double fTR=float((ms%int(1000.0*m_TRperiod)))/int(1000.0*m_TRperiod);
+
+ QString txMsg;
+ if(m_ntx == 1) txMsg=ui->tx1->text();
+ if(m_ntx == 2) txMsg=ui->tx2->text();
+ if(m_ntx == 3) txMsg=ui->tx3->text();
+ if(m_ntx == 4) txMsg=ui->tx4->text();
+ if(m_ntx == 5) txMsg=ui->tx5->currentText();
+ if(m_ntx == 6) txMsg=ui->tx6->text();
+ int msgLength=txMsg.trimmed().length();
+ if(msgLength==0 and !m_tune) on_stopTxButton_clicked();
+
+ if(g_iptt==0 and ((m_bTxTime and (fTR < 0.75) and (msgLength>0)) or m_tune)) {
+ //### Allow late starts
+ icw[0]=m_ncw;
+ g_iptt = 1;
+ setRig ();
+ if(m_mode=="FT8") {
+ if (SpecOp::FOX == m_specOp) {
+ if(m_config.superFox()) {
+ ui->TxFreqSpinBox->setValue(750); //SuperFox transmits at 750 Hz
+ } else {
+ if (ui->TxFreqSpinBox->value() > 900) {
+ ui->TxFreqSpinBox->setValue(500);
+ }
+ }
+ }
+ else if (SpecOp::HOUND == m_specOp && !m_config.superFox()) {
+ if(m_auto && !m_tune) {
+ if (ui->TxFreqSpinBox->value() < 999 && m_ntx != 3) {
+ // Hound randomized range: 1000-3000 Hz
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ ui->TxFreqSpinBox->setValue (QRandomGenerator::global ()->bounded (1000, 2999));
+#else
+ ui->TxFreqSpinBox->setValue ((qrand () % 2000) + 1000);
+#endif
+ }
+ }
+ if (m_nSentFoxRrpt==2 and m_ntx==3) {
+ // move off the original Fox frequency on subsequent tries of Tx3
+ int nfreq=m_nFoxFreq + 300;
+ if(m_nFoxFreq>600) nfreq=m_nFoxFreq - 300; //keep nfreq below 900 Hz
+ ui->TxFreqSpinBox->setValue(nfreq);
+ }
+ if (m_nSentFoxRrpt == 1) {
+ ++m_nSentFoxRrpt;
+ }
+ }
+ }
+
+
+// If HoldTxFreq is not checked, randomize Fox's Tx Freq
+// NB: Maybe this should be done no more than once every 5 minutes or so ?
+ if(m_mode=="FT8" and SpecOp::FOX==m_specOp and !ui->cbHoldTxFreq->isChecked()) {
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ ui->TxFreqSpinBox->setValue (QRandomGenerator::global ()->bounded (300, 599));
+#else
+ ui->TxFreqSpinBox->setValue(300.0 + 300.0*double(qrand())/RAND_MAX);
+#endif
+ }
+
+ setXIT (ui->TxFreqSpinBox->value ());
+ m_config.transceiver_ptt (true); //Assert the PTT
+ m_tx_when_ready = true;
+ }
+// if(!m_bTxTime and !m_tune and m_mode!="FT4") m_btxok=false; //Time to stop transmitting
+ if(!m_bTxTime and !m_tune) m_btxok=false; //Time to stop transmitting
+ }
+
+ if((m_mode=="WSPR" or m_mode=="FST4W") and
+ ((m_ntr==1 and m_rxDone) or (m_ntr==-1 and nseq>tx2))) {
+ if(m_monitoring) {
+ m_rxDone=false;
+ }
+ if(m_transmitting) {
+ WSPR_history(m_freqNominal,-1);
+ m_bTxTime=false; //Time to stop a WSPR or FST4W transmission
+ m_btxok=false;
+ }
+ else if (m_ntr != -1) {
+ WSPR_scheduling ();
+ m_ntr=0; //This WSPR or FST4W Rx sequence is complete
+ }
+ }
+
+
+ // Calculate Tx tones when needed
+ if((g_iptt==1 && m_iptt0==0) || m_restart) {
+//----------------------------------------------------------------------
+ QByteArray ba;
+ QByteArray ba0;
+
+ if(m_mode=="WSPR") {
+ ba=WSPR_message().toLatin1();
+ } else {
+ if(SpecOp::HOUND == m_specOp and m_ntx!=3) { //Hound transmits only Tx1 or Tx3
+ m_ntx=1;
+ ui->txrb1->setChecked(true);
+ }
+
+ if(m_mode=="FT4" and m_bBestSPArmed) {
+ m_BestCQpriority="";
+ m_bBestSPArmed=false;
+ ui->pbBestSP->setStyleSheet ("");
+ }
+
+ if(m_ntx == 1) ba=ui->tx1->text().toLocal8Bit();
+ if(m_ntx == 2) ba=ui->tx2->text().toLocal8Bit();
+ if(m_ntx == 3) ba=ui->tx3->text().toLocal8Bit();
+ if(m_ntx == 4) ba=ui->tx4->text().toLocal8Bit();
+ if(m_ntx == 5) ba=ui->tx5->currentText().toLocal8Bit();
+ if(m_ntx == 6) ba=ui->tx6->text().toLocal8Bit();
+ }
+
+ ba2msg(ba,message);
+ int ichk=0;
+ if (m_lastMessageSent != m_currentMessage
+ || m_lastMessageType != m_currentMessageType)
+ {
+ m_lastMessageSent = m_currentMessage;
+ m_lastMessageType = m_currentMessageType;
+ }
+ m_currentMessageType = 0;
+ if(m_tune or m_mode=="Echo") {
+ itone[0]=0;
+ } else {
+ if(m_QSOProgress==REPORT || m_QSOProgress==ROGER_REPORT) m_bSentReport=true;
+ if(m_bSentReport and (m_QSOProgress<REPORT or m_QSOProgress>ROGER_REPORT)) m_bSentReport=false;
+ if(m_mode=="JT4") gen4_(message, &ichk , msgsent, const_cast<int *> (itone),
+ &m_currentMessageType, (FCL)22, (FCL)22);
+ if(m_mode=="JT9") gen9_(message, &ichk, msgsent, const_cast<int *> (itone),
+ &m_currentMessageType, (FCL)22, (FCL)22);
+ if(m_mode=="JT65") gen65(message, &ichk, msgsent, const_cast<int *> (itone),
+ &m_currentMessageType);
+ if(m_mode=="WSPR") genwspr_(message, msgsent, const_cast<int *> (itone),
+ (FCL)22, (FCL)22);
+ if(m_mode=="MSK144" or m_mode=="FT8" or m_mode=="FT4"
+ or m_mode=="FST4" or m_mode=="FST4W" || "Q65" == m_mode) {
+ if(m_mode=="MSK144") {
+ genmsk_128_90_(message, &ichk, msgsent, const_cast<int *> (itone),
+ &m_currentMessageType, (FCL)37, (FCL)37);
+ if(m_restart) {
+ int nsym=144;
+ if(itone[40]==-40) nsym=40;
+ m_modulator->set_nsym(nsym);
+ }
+ }
+
+ if(m_mode=="FT8") {
+ if(SpecOp::FOX==m_specOp and ui->tabWidget->currentIndex()==1) {
+ foxTxSequencer();
+ } else {
+ int i3=0;
+ int n3=0;
+ char ft8msgbits[77];
+ genft8_(message, &i3, &n3, msgsent, const_cast<char *> (ft8msgbits),
+ const_cast<int *> (itone), (FCL)37, (FCL)37);
+ int nsym=79;
+ int nsps=4*1920;
+ float fsample=48000.0;
+ float bt=2.0;
+ float f0=ui->TxFreqSpinBox->value() - m_XIT;
+ int icmplx=0;
+ int nwave=nsym*nsps;
+ gen_ft8wave_(const_cast<int *>(itone),&nsym,&nsps,&bt,&fsample,&f0,foxcom_.wave,
+ foxcom_.wave,&icmplx,&nwave);
+ if(SpecOp::FOX == m_specOp) {
+ //Fox must generate the full Tx waveform, not just an itone[] array.
+ QString fm = QString::fromStdString(message).trimmed();
+ foxGenWaveform(0,fm);
+ foxcom_.nslots=1;
+ foxcom_.nfreq=ui->TxFreqSpinBox->value();
+ if(m_config.split_mode()) foxcom_.nfreq = foxcom_.nfreq - m_XIT; //Fox Tx freq
+ QString foxCall=m_config.my_callsign() + " ";
+ ::memcpy(foxcom_.mycall, foxCall.toLatin1(), sizeof foxcom_.mycall); //Copy Fox callsign into foxcom_
+ bool bSuperFox=m_config.superFox();
+ auto fname {QDir::toNativeSeparators(m_config.writeable_data_dir().absoluteFilePath("sfox_1.dat")).toLocal8Bit()};
+ foxcom_.bMoreCQs=ui->cbMoreCQs->isChecked();
+ foxcom_.bSendMsg=ui->cbSendMsg->isChecked();
+ memcpy(foxcom_.textMsg, m_freeTextMsg.leftJustified(26,' ').toLatin1(),26);
+ foxgen_(&bSuperFox, fname.constData(), (FCL)fname.size());
+ if(bSuperFox) {
+ writeFoxTxMsgs();
+ sfox_tx();
+ }
+ }
+ }
+ }
+ if(m_mode=="FT4") {
+ int ichk=0;
+ char ft4msgbits[77];
+ genft4_(message, &ichk, msgsent, const_cast<char *> (ft4msgbits),
+ const_cast<int *>(itone), (FCL)37, (FCL)37);
+ int nsym=103;
+ int nsps=4*576;
+ float fsample=48000.0;
+ float f0=ui->TxFreqSpinBox->value() - m_XIT;
+ int nwave=(nsym+2)*nsps;
+ int icmplx=0;
+ gen_ft4wave_(const_cast<int *>(itone),&nsym,&nsps,&fsample,&f0,foxcom_.wave,
+ foxcom_.wave,&icmplx,&nwave);
+ }
+ if(m_mode=="FST4" or m_mode=="FST4W") {
+ int ichk=0;
+ int iwspr=0;
+ char fst4msgbits[101];
+ QString wmsg;
+ if(m_mode=="FST4W") {
+ iwspr = 1;
+ wmsg=WSPR_message();
+ ba=wmsg.toLatin1();
+ ba2msg(ba,message);
+ }
+ genfst4_(message,&ichk,msgsent,const_cast<char *> (fst4msgbits),
+ const_cast<int *>(itone), &iwspr, (FCL)37, (FCL)37);
+ int hmod=1;
+ if(m_config.x2ToneSpacing()) hmod=2;
+ if(m_config.x4ToneSpacing()) hmod=4;
+ int nsps=720;
+ if(m_TRperiod==30) nsps=1680;
+ if(m_TRperiod==60) nsps=3888;
+ if(m_TRperiod==120) nsps=8200;
+ if(m_TRperiod==300) nsps=21504;
+ if(m_TRperiod==900) nsps=66560;
+ if(m_TRperiod==1800) nsps=134400;
+ nsps=4*nsps; //48000 Hz sampling
+ int nsym=160;
+ float fsample=48000.0;
+ float dfreq=hmod*fsample/nsps;
+ float f0=ui->TxFreqSpinBox->value() - m_XIT + 1.5*dfreq;
+ if(m_mode=="FST4W") f0=ui->WSPRfreqSpinBox->value() - m_XIT + 1.5*dfreq;
+ int nwave=(nsym+2)*nsps;
+ int icmplx=0;
+ gen_fst4wave_(const_cast<int *>(itone),&nsym,&nsps,&nwave,
+ &fsample,&hmod,&f0,&icmplx,foxcom_.wave,foxcom_.wave);
+
+ QString t = QString::fromStdString(message).trimmed();
+ }
+ if(m_mode=="Q65") {
+ int i3=-1;
+ int n3=-1;
+ genq65_(message, &ichk,msgsent, const_cast<int *>(itone), &i3, &n3, (FCL)37, (FCL)37);
+ int nsps=1800;
+ if(m_TRperiod==30) nsps=3600;
+ if(m_TRperiod==60) nsps=7200;
+ if(m_TRperiod==120) nsps=16000;
+ if(m_TRperiod==300) nsps=41472;
+ int nsps4=4*nsps; //48000 Hz sampling
+ int nsym=85;
+ float fsample=48000.0;
+ int nwave=(nsym+2)*nsps4;
+ int icmplx=0;
+ int hmod=1;
+ float f0=ui->TxFreqSpinBox->value()-m_XIT;
+ genwave_(const_cast<int *>(itone),&nsym,&nsps4,&nwave,
+ &fsample,&hmod,&f0,&icmplx,foxcom_.wave,foxcom_.wave);
+ }
+
+ if(SpecOp::EU_VHF==m_specOp) {
+ if(m_ntx==2) m_xSent=ui->tx2->text().right(13);
+ if(m_ntx==3) m_xSent=ui->tx3->text().right(13);
+ }
+
+ if(SpecOp::FIELD_DAY==m_specOp or SpecOp::RTTY==m_specOp) {
+ if(m_ntx==2 or m_ntx==3) {
+ QStringList t=ui->tx2->text().split(' ', SkipEmptyParts);
+ int n=t.size();
+ if (n > 3) m_xSent=t.at(n-2) + " " + t.at(n-1);
+ }
+ }
+ }
+ msgsent[37]=0;
+ }
+
+ {
+ auto temp = m_currentMessage;
+ m_currentMessage = QString::fromLatin1(msgsent);
+ if (m_currentMessage != temp) // check if tx message changed
+ {
+ statusUpdate ();
+ }
+ }
+ m_bCallingCQ = 6 == m_ntx
+ || m_currentMessage.contains (QRegularExpression {"^(CQ|QRZ) "});
+ m_maxPoints=-1;
+
+ if (m_tune) {
+ m_currentMessage = "TUNE";
+ m_currentMessageType = -1;
+ }
+ if(m_restart) {
+ write_all("Tx",m_currentMessage);
+ if (m_config.TX_messages () and m_mode!="Echo") {
+ ui->decodedTextBrowser2->displayTransmittedText(m_currentMessage.trimmed(),m_mode,
+ ui->TxFreqSpinBox->value(),m_bFastMode,m_TRperiod,m_config.superFox());
+ }
+ }
+
+ auto t2 = QDateTime::currentDateTimeUtc ().toString ("hhmm");
+ icw[0] = 0;
+ auto msg_parts = m_currentMessage.split (' ', SkipEmptyParts);
+ if (msg_parts.size () > 2) {
+ // clean up short code forms
+ msg_parts[0].remove (QChar {'<'});
+ msg_parts[0].remove (QChar {'>'});
+ msg_parts[1].remove (QChar {'<'});
+ msg_parts[1].remove (QChar {'>'});
+ }
+ auto is_73 = message_is_73 (m_currentMessageType, msg_parts);
+ m_sentFirst73 = is_73
+ && !message_is_73 (m_lastMessageType, m_lastMessageSent.split (' ', SkipEmptyParts));
+ if (m_sentFirst73 || (is_73 && CALLING == m_QSOProgress)) {
+ m_qsoStop=t2;
+ if(m_config.id_after_73 ()) {
+ icw[0] = m_ncw;
+ }
+ if((m_config.prompt_to_log() or m_config.autoLog()) && !m_tune && CALLING != m_QSOProgress)
+ {
+ logQSOTimer.start(0);
+ }
+ else
+ {
+ cease_auto_Tx_after_QSO ();
+ }
+ }
+
+ bool b=("FT8"==m_mode or "FT4"==m_mode or "Q65"==m_mode) and ui->cbAutoSeq->isVisible ()
+ && ui->cbAutoSeq->isEnabled () && ui->cbAutoSeq->isChecked ();
+ if(is_73 and (m_config.disable_TX_on_73() or b)) {
+ m_nextCall=""; //### Temporary: disable use of "TU;" messages;
+ if(m_nextCall!="") {
+ useNextCall();
+ } else {
+ auto_tx_mode (false);
+ if(b) {
+ m_ntx=6;
+ ui->txrb6->setChecked(true);
+ m_QSOProgress = CALLING;
+ }
+ }
+ }
+
+ if(m_config.id_interval () >0) {
+ int nmin=(m_sec0-m_secID)/60;
+ if(m_sec0<m_secID) nmin=m_config.id_interval();
+ if(nmin >= m_config.id_interval()) {
+ icw[0]=m_ncw;
+ m_secID=m_sec0;
+ }
+ }
+
+ if ((m_currentMessageType < 6 || 7 == m_currentMessageType)
+ && msg_parts.length() >= 3
+ && (msg_parts[1] == m_config.my_callsign () ||
+ msg_parts[1] == m_baseCall))
+ {
+ int i1;
+ bool ok;
+ i1 = msg_parts[2].toInt(&ok);
+ if(ok and i1>=-50 and i1<50)
+ {
+ m_rptSent = msg_parts[2];
+ m_qsoStart = t2;
+ } else {
+ if (msg_parts[2].mid (0, 1) == "R")
+ {
+ i1 = msg_parts[2].mid (1).toInt (&ok);
+ if (ok and i1 >= -50 and i1 < 50)
+ {
+ m_rptSent = msg_parts[2].mid (1);
+ m_qsoStart = t2;
+ }
+ }
+ }
+ }
+ m_restart=false;
+//----------------------------------------------------------------------
+ } else {
+ if (!m_auto && m_sentFirst73) {
+ m_sentFirst73 = false;
+ }
+ }
+
+ if (g_iptt == 1 && m_iptt0 == 0) {
+ auto const& current_message = QString::fromLatin1 (msgsent);
+ if(m_config.watchdog () && m_mode!="WSPR" && m_mode!="FST4W"
+ && current_message != m_msgSent0) {
+ tx_watchdog (false); // in case we are auto sequencing
+ m_msgSent0 = current_message;
+ }
+
+ if (m_mode != "FST4W" && m_mode != "WSPR" && m_mode!="Echo")
+ {
+ if(!m_tune) write_all("Tx",m_currentMessage);
+ if (m_config.TX_messages () && !m_tune && SpecOp::FOX!=m_specOp)
+ {
+ ui->decodedTextBrowser2->displayTransmittedText(current_message.trimmed(),
+ m_mode,ui->TxFreqSpinBox->value(),m_bFastMode,m_TRperiod,m_config.superFox());
+ }
+ }
+
+ switch (m_ntx)
+ {
+ case 1: m_QSOProgress = REPLYING; break;
+ case 2: m_QSOProgress = REPORT; break;
+ case 3: m_QSOProgress = ROGER_REPORT; break;
+ case 4: m_QSOProgress = ROGERS; break;
+ case 5: m_QSOProgress = SIGNOFF; break;
+ case 6: m_QSOProgress = CALLING; break;
+ default: break; // determined elsewhere
+ }
+ m_transmitting = true;
+ transmitDisplay (true);
+ statusUpdate ();
+ }
+
+ if(!m_btxok && m_btxok0 && g_iptt==1) {
+ stopTx();
+ if ("1" == m_env.value ("WSJT_TX_BOTH", "0")) {
+ m_txFirst = !m_txFirst;
+ ui->txFirstCheckBox->setChecked (m_txFirst);
+ }
+ }
+
+ if(m_startAnother) {
+ if(m_mode=="MSK144") {
+ m_wait++;
+ }
+ if(m_mode!="MSK144" or m_wait>=4) {
+ m_wait=0;
+ m_startAnother=false;
+ on_actionOpen_next_in_directory_triggered();
+ }
+ }
+
+ if(m_mode=="FT8" or m_mode=="MSK144" or m_mode=="FT4" or m_mode=="Q65") {
+ if(ui->txrb1->isEnabled() and
+ (SpecOp::NA_VHF==m_specOp or
+ SpecOp::FIELD_DAY==m_specOp or
+ SpecOp::RTTY==m_specOp or
+ SpecOp::WW_DIGI==m_specOp or
+ SpecOp::ARRL_DIGI==m_specOp or
+ SpecOp::Q65_PILEUP==m_specOp)) {
+ //We're in a contest-like mode other than EU_VHF: start QSO with Tx2.
+ ui->tx1->setEnabled(false);
+ ui->txb1->setEnabled(false);
+ }
+ if(!ui->tx1->isEnabled() and SpecOp::EU_VHF==m_specOp) {
+ //We're in EU_VHF mode: start QSO with Tx1.
+ ui->tx1->setEnabled(true);
+ ui->txb1->setEnabled(true);
+ }
+ }
+ if(m_mode=="Echo" and !m_monitoring and !m_auto and !m_diskData) m_echoRunning=false;
+
+ if(m_mode=="Q65") {
+ mem_qmap.lock();
+ int n=0;
+ if(m_decoderBusy) n=1;
+ ipc_qmap[3]=n;
+ n=0;
+ if(m_transmitting) n=m_TRperiod;
+ ipc_qmap[4]=n;
+ if(ipc_qmap[0] > 0) { //ndecodes
+ memcpy(&qmapcom, (char*)ipc_qmap, sizeof(qmapcom)); //Fetch the new decode(s)
+ readWidebandDecodes();
+ }
+ if(ipc_qmap[5]>0) {
+ setRig((m_freqNominal/1000000)*1000000 + 1000*ipc_qmap[5]);
+ ipc_qmap[5]=0;
+ }
+ mem_qmap.unlock();
+ }
+
+//Once per second (onesec)
+ if(nsec != m_sec0) {
+// qDebug() << "AAA" << nsec%60 << ui->cbWorkDupes->isChecked();
+
+// qint64 n64 = QDateTime::currentSecsSinceEpoch();
+// n64=n64/30;
+// n64=n64*30;
+// qDebug() << "bb" << m_config.FoxKey() << nsec%60 << dec_data.params.nutc << n64 << n64%60;
+
+ // prevent tuning on top of a SuperFox message
+ if (SpecOp::HOUND==m_specOp && m_config.superFox() && m_tune) {
+ QDateTime now = QDateTime::currentDateTimeUtc();
+ int s = now.time().toString("ss").toInt();
+ if ((s >= 0 && s < 15) || (s >= 30 && s < 45)) ui->tuneButton->click ();
+ }
+
+ if(m_mode=="FST4") chk_FST4_freq_range();
+ m_currentBand=m_config.bands()->find(m_freqNominal);
+ if( SpecOp::HOUND == m_specOp ) {
+ qint32 tHound=QDateTime::currentMSecsSinceEpoch()/1000 - m_tAutoOn;
+ //To keep calling Fox, Hound must reactivate Enable Tx at least once every 2 minutes
+ if(tHound >= 120 and m_ntx==1) {
+ auto_tx_mode(false);
+ statusUpdate ();
+ }
+ }
+
+ progressBar.setVisible(true);
+ progressBar.setFormat ("%v/%m");
+ if(m_mode=="Echo") {
+ progressBar.setMaximum(3);
+ int n=0;
+ if(m_transmitting or m_monitoring) n=int(m_s6)%3;
+ progressBar.setValue(n);
+ }
+ if(m_mode!="Echo") {
+ if(m_monitoring or m_transmitting) {
+ progressBar.setMaximum(m_TRperiod);
+ int isec=int(fmod(tsec,m_TRperiod));
+ if(m_TRperiod-int(m_TRperiod)>0.0) {
+ QString progBarLabel;
+ progBarLabel = progBarLabel.asprintf("%d/%3.1f",isec,m_TRperiod);
+ progressBar.setFormat (progBarLabel);
+ }
+ progressBar.setValue(isec);
+ } else {
+ progressBar.setValue(0);
+ }
+ }
+
+ astroUpdate ();
+
+ if(m_transmitting) {
+ char s[42];
+ if(SpecOp::FOX==m_specOp and ui->tabWidget->currentIndex()==1) {
+ snprintf(s,sizeof(s),"Tx: %d Slots",foxcom_.nslots);
+ } else {
+ snprintf(s,sizeof(s),"Tx: %s",msgsent);
+ }
+ m_nsendingsh=0;
+ if(s[4]==64) m_nsendingsh=1;
+ if(m_nsendingsh==1 or m_currentMessageType==7) {
+ tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #66ffff}");
+ } else if(m_nsendingsh==-1 or m_currentMessageType==6) {
+ tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #ffccff}");
+ } else {
+ tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #ffff33}");
+ }
+ if(m_tune) {
+ tx_status_label.setText("Tx: TUNE");
+ } else {
+ if(m_mode=="Echo") {
+ tx_status_label.setText("Tx: ECHO");
+ } else {
+ s[40]=0;
+ QString t{QString::fromLatin1(s)};
+ if(SpecOp::FOX==m_specOp and ui->tabWidget->currentIndex()==1 and foxcom_.nslots==1) {
+ t=m_fm1.trimmed();
+ }
+ if(m_mode=="FT4") t="Tx: "+ m_currentMessage;
+ tx_status_label.setText(t.trimmed());
+ }
+ }
+ } else if(m_monitoring) {
+ if (!m_tx_watchdog) {
+ tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #00ff00}");
+ auto t = tr ("Receiving");
+ if(m_mode=="MSK144") {
+ int npct=int(100.0*m_fCPUmskrtd/0.298667);
+ if(npct>90) tx_status_label.setStyleSheet("QLabel{color: #000000; background-color: #ff0000}");
+ t += QString {" %1%"}.arg (npct, 2);
+ }
+ tx_status_label.setText (t);
+ }
+ transmitDisplay(false);
+ } else if (!m_diskData && !m_tx_watchdog) {
+ tx_status_label.setStyleSheet("");
+ tx_status_label.setText("");
+ }
+
+ QDateTime t = QDateTime::currentDateTimeUtc();
+ QString utc = t.date().toString("yyyy MMM dd") + "\n " +
+ t.time().toString() + " ";
+ ui->labUTC->setText(utc);
+ if(m_bBestSPArmed and (m_dateTimeBestSP.secsTo(t) >= 120)) on_pbBestSP_clicked(); //BestSP timeout
+ if(!m_monitoring and !m_diskData) ui->signal_meter_widget->setValue(0,0);
+ m_sec0=nsec;
+ displayDialFrequency ();
+ }
+ m_iptt0=g_iptt;
+ m_btxok0=m_btxok;
+} //End of guiUpdate
+
+void MainWindow::useNextCall()
+{
+ ui->dxCallEntry->setText(m_nextCall);
+ m_nextCall="";
+ if(m_nextGrid.contains(grid_regexp)) {
+ ui->dxGridEntry->setText(m_nextGrid);
+ m_ntx=2;
+ ui->txrb2->setChecked(true);
+ } else {
+ m_ntx=3;
+ ui->txrb3->setChecked(true);
+ }
+ genStdMsgs(m_nextRpt);
+}
+
+void MainWindow::startTx2()
+{
+ if (!m_modulator->isActive ()) { // TODO - not thread safe
+ double fSpread=0.0;
+ double snr=99.0;
+ QString t=ui->tx5->currentText();
+ if(t.mid(0,1)=="#") fSpread=t.mid(1,5).toDouble();
+ m_modulator->setSpread(fSpread); // TODO - not thread safe
+ t=ui->tx6->text();
+ if(t.mid(0,1)=="#") snr=t.mid(1,5).toDouble();
+ if(snr>0.0 or snr < -50.0) snr=99.0;
+ if((m_ntx==6 or m_ntx==7) and m_config.force_call_1st() and
+ ui->respondComboBox->currentIndex()==0) {
+ ui->cbAutoSeq->setChecked(true);
+ ui->respondComboBox->setCurrentIndex(1);
+ }
+ transmit (snr);
+ ui->signal_meter_widget->setValue(0,0);
+ if(m_mode=="Echo" and !m_tune) m_bTransmittedEcho=true;
+
+ if((m_mode=="WSPR" or m_mode=="FST4W") and !m_tune) {
+ if (m_config.TX_messages ()) {
+ t = " Transmitting " + m_mode + " ----------------------- " +
+ m_config.bands ()->find (m_freqNominal);
+ t=beacon_start_time (m_TRperiod / 2) + ' ' + t.rightJustified (66, '-');
+ ui->decodedTextBrowser->insertText(t);
+ }
+ write_all("Tx",m_currentMessage);
+ }
+ }
+}
+
+void MainWindow::stopTx()
+{
+ Q_EMIT endTransmitMessage ();
+ m_btxok = false;
+ m_transmitting = false;
+ g_iptt=0;
+ if (!m_tx_watchdog) {
+ tx_status_label.setStyleSheet("");
+ tx_status_label.setText("");
+ }
+ ptt0Timer.start(200); //end-of-transmission sequencer delay
+ monitor (true);
+ statusUpdate ();
+}
+
+void MainWindow::stopTx2()
+{
+ m_config.transceiver_ptt (false); //Lower PTT
+ if (m_mode == "JT9" && m_bFast9
+ && ui->cbAutoSeq->isVisible () && ui->cbAutoSeq->isEnabled () && ui->cbAutoSeq->isChecked ()
+ && m_ntx == 5 && m_nTx73 >= 5) {
+ on_stopTxButton_clicked ();
+ m_nTx73 = 0;
+ }
+ if(((m_mode=="WSPR" or m_mode=="FST4W") and m_ntr==-1) and !m_tuneup) {
+ m_wideGraph->setWSPRtransmitted();
+ WSPR_scheduling ();
+ m_ntr=0;
+ }
+ last_tx_label.setText(tr ("Last Tx: %1").arg (m_currentMessage.trimmed()));
+}
+
+void MainWindow::ba2msg(QByteArray ba, char message[]) //ba2msg()
+{
+ int iz=ba.length();
+ for(int i=0; i<37; i++) {
+ if(i<iz) {
+ if(int(ba[i])>=97 and int(ba[i])<=122) ba[i]=int(ba[i])-32;
+ message[i]=ba[i];
+ } else {
+ message[i]=32;
+ }
+ }
+ message[37]=0;
+}
+
+void MainWindow::on_txFirstCheckBox_stateChanged(int nstate) //TxFirst
+{
+ m_txFirst = (nstate==2);
+}
+
+void MainWindow::set_dateTimeQSO(int m_ntx)
+{
+ // m_ntx = -1 resets to default time
+ // Our QSO start time can be fairly well determined from Tx 2 and Tx 3 -- the grid reports
+ // If we CQ'd and sending sigrpt then 2 minutes ago n=2
+ // If we're on msg 3 then 3 minutes ago n=3 -- might have sat on msg1 for a while
+ // If we've already set our time on just return.
+ // This should mean that Tx2 or Tx3 has been repeated so don't update the start time
+ // We reset it in several places
+ if (m_ntx == -1) { // we use a default date to detect change
+ m_dateTimeQSOOn = QDateTime {};
+ }
+ else if (m_dateTimeQSOOn.isValid ()) {
+ return;
+ }
+ else { // we also take of m_TRperiod/2 to allow for late clicks
+ auto now = QDateTime::currentDateTimeUtc();
+ m_dateTimeQSOOn = now.addSecs (-(m_ntx - 2) * int(m_TRperiod) -
+ int(fmod(double(now.time().second()),m_TRperiod)));
+ }
+}
+
+void MainWindow::set_ntx(int n) //set_ntx()
+{
+ m_ntx=n;
+}
+
+void MainWindow::on_txrb1_toggled (bool status)
+{
+ if (status) {
+ if (ui->tx1->isEnabled ()) {
+ m_ntx = 1;
+ set_dateTimeQSO (-1); // we reset here as tx2/tx3 is used for start times
+ }
+ else {
+ QTimer::singleShot (0, ui->txrb2, SLOT (click ()));
+ }
+ }
+}
+
+bool MainWindow::elide_tx1_not_allowed () const
+{
+ auto const& my_callsign = m_config.my_callsign ();
+ return
+ (m_mode=="FT8" && SpecOp::HOUND == m_specOp)
+ || ((m_mode.startsWith ("FT") || "MSK144" == m_mode || "Q65" == m_mode || "FST4" == m_mode)
+ && Radio::is_77bit_nonstandard_callsign (my_callsign))
+ || (my_callsign != m_baseCall && !shortList (my_callsign));
+}
+
+void MainWindow::on_txrb1_doubleClicked ()
+{
+ ui->tx1->setEnabled (elide_tx1_not_allowed () || !ui->tx1->isEnabled ());
+ if (!ui->tx1->isEnabled ()) {
+ // leave time for clicks to complete before setting txrb2
+ QTimer::singleShot (500, ui->txrb2, SLOT (click ()));
+ }
+}
+
+void MainWindow::on_txrb2_toggled (bool status)
+{
+ // Tx 2 means we already have CQ'd so good reference
+ if (status) {
+ m_ntx=2;
+ set_dateTimeQSO (m_ntx);
+ }
+}
+
+void MainWindow::on_txrb3_toggled(bool status)
+{
+ // Tx 3 means we should have already have done Tx 1 so good reference
+ if (status) {
+ m_ntx=3;
+ set_dateTimeQSO(m_ntx);
+ }
+}
+
+void MainWindow::on_txrb4_toggled (bool status)
+{
+ if (status) {
+ m_ntx=4;
+ }
+}
+
+void MainWindow::on_txrb4_doubleClicked ()
+{
+ // RR73 only allowed if not a type 2 compound callsign
+ auto const& my_callsign = m_config.my_callsign ();
+ auto is_compound = my_callsign != m_baseCall;
+ m_send_RR73 = !((is_compound && !shortList (my_callsign)) || m_send_RR73);
+ if(m_mode=="FT4") m_send_RR73=true;
+ genStdMsgs (m_rpt);
+}
+
+void MainWindow::on_txrb5_toggled (bool status)
+{
+ if (status) {
+ m_ntx = 5;
+ }
+}
+
+void MainWindow::on_txrb5_doubleClicked ()
+{
+ genStdMsgs (m_rpt, true);
+}
+
+void MainWindow::on_txrb6_toggled(bool status)
+{
+ if (status) {
+ m_ntx=6;
+ if (ui->txrb6->text().contains (QRegularExpression {"^(CQ|QRZ) "})) set_dateTimeQSO(-1);
+ }
+}
+
+void MainWindow::on_txb1_clicked()
+{
+ if (ui->tx1->isEnabled ()) {
+ m_ntx=1;
+ m_QSOProgress = REPLYING;
+ ui->txrb1->setChecked(true);
+ if(m_transmitting) m_restart=true;
+ }
+ else {
+ on_txb2_clicked ();
+ }
+}
+
+void MainWindow::on_txb1_doubleClicked()
+{
+ ui->tx1->setEnabled (elide_tx1_not_allowed () || !ui->tx1->isEnabled ());
+}
+
+void MainWindow::on_txb2_clicked()
+{
+ m_ntx=2;
+ m_QSOProgress = REPORT;
+ ui->txrb2->setChecked(true);
+ if(m_transmitting) m_restart=true;
+}
+
+void MainWindow::on_txb3_clicked()
+{
+ m_ntx=3;
+ m_QSOProgress = ROGER_REPORT;
+ ui->txrb3->setChecked(true);
+ if(m_transmitting) m_restart=true;
+}
+
+void MainWindow::on_txb4_clicked()
+{
+ m_ntx=4;
+ m_QSOProgress = ROGERS;
+ ui->txrb4->setChecked(true);
+ if(m_transmitting) m_restart=true;
+}
+
+void MainWindow::on_txb4_doubleClicked()
+{
+ // RR73 only allowed if not a type 2 compound callsign
+ auto const& my_callsign = m_config.my_callsign ();
+ auto is_compound = my_callsign != m_baseCall;
+ m_send_RR73 = !((is_compound && !shortList (my_callsign)) || m_send_RR73);
+ if(m_mode=="FT4") m_send_RR73=true;
+ genStdMsgs (m_rpt);
+}
+
+void MainWindow::on_txb5_clicked()
+{
+ m_ntx=5;
+ m_QSOProgress = SIGNOFF;
+ ui->txrb5->setChecked(true);
+ if(m_transmitting) m_restart=true;
+}
+
+void MainWindow::on_txb5_doubleClicked()
+{
+ genStdMsgs (m_rpt, true);
+}
+
+void MainWindow::on_txb6_clicked()
+{
+ m_ntx=6;
+ m_QSOProgress = CALLING;
+ set_dateTimeQSO(-1);
+ ui->txrb6->setChecked(true);
+ if(m_transmitting) m_restart=true;
+}
+
+void MainWindow::doubleClickOnCall2(Qt::KeyboardModifiers modifiers)
+{
+//Confusing: come here after double-click on left text window, not right window.
+ set_dateTimeQSO(-1); // reset our QSO start time
+ m_decodedText2=true;
+ doubleClickOnCall(modifiers);
+ m_decodedText2=false;
+}
+
+void MainWindow::doubleClickOnCall(Qt::KeyboardModifiers modifiers)
+{
+ QTextCursor cursor;
+ if(m_mode=="FST4W") {
+ MessageBox::information_message (this,
+ "Double-click not available for FST4W mode");
+ return;
+ }
+ if(m_decodedText2) {
+ cursor=ui->decodedTextBrowser->textCursor();
+ } else {
+ cursor=ui->decodedTextBrowser2->textCursor();
+ }
+ DecodedText message {cursor.block().text().trimmed().left(61).remove("TU; ")};
+ if(message.string().contains(";") && message.string().contains("<")) {
+ QVector<qint32> Freq = {1840000,3573000,7074000,10136000,14074000,18100000,21074000,24915000,28074000,50313000,70154000,3575000,7047500,10140000,14080000,18104000,21140000,24919000,28180000,50318000};
+ for(int i=0; i<Freq.length()-1; i++) {
+ int kHzdiff=m_freqNominal - Freq[i];
+ if(qAbs(kHzdiff) < 3000 ) {
+ m_bTxTime=false;
+ if (m_auto) auto_tx_mode (false);
+ if (m_tune) stop_tuning();
+// auto const& msg2 = tr("Double-clicking on combined messages\n"
+// "not allowed on the standard FT8 sub-bands.");
+// QTimer::singleShot (0, [=] { // don't block guiUpdate
+// MessageBox::warning_message (this, tr ("Potential hash collision"), msg2);
+// });
+ return;
+ }
+ }
+ }
+ if(modifiers==(Qt::ShiftModifier + Qt::ControlModifier + Qt::AltModifier)) {
+ //### What was the purpose of this ??? ###
+ cursor.setPosition(0);
+ } else {
+ cursor.setPosition(cursor.selectionStart());
+ }
+
+ if(SpecOp::FOX==m_specOp and m_decodedText2) {
+ if(m_houndQueue.count()<10 and m_nSortedHounds>0) {
+ QString t=cursor.block().text();
+ selectHound(t, modifiers==(Qt::AltModifier)); // alt double-click gets put at top of queue
+ }
+ return;
+ }
+ m_bDoubleClicked = true;
+ processMessage (message, modifiers);
+}
+
+void MainWindow::processMessage (DecodedText const& message, Qt::KeyboardModifiers modifiers)
+{
+ // decode keyboard modifiers we are interested in
+ auto shift = modifiers.testFlag (Qt::ShiftModifier);
+ auto ctrl = modifiers.testFlag (Qt::ControlModifier);
+ // auto alt = modifiers.testFlag (Qt::AltModifier);
+ auto auto_seq = ui->cbAutoSeq->isVisible () && ui->cbAutoSeq->isEnabled () && ui->cbAutoSeq->isChecked ();
+ // basic mode sanity checks
+ auto const& parts = message.clean_string ().split (' ', SkipEmptyParts);
+ if (parts.size () < 5) return;
+ auto const& mode = parts.at (4).left (1);
+ if (("JT65" == m_mode && mode != "#")
+ || ("JT9" == m_mode && mode != "@")
+ || ("MSK144" == m_mode && !("&" == mode || "^" == mode))
+ || ("Q65" == m_mode && mode.left (1) != ":")) {
+ return; //Currently we do auto-sequencing only in FT4, FT8, MSK144, FST4, and Q65
+ }
+
+ //Skip the rest if no decoded text extracted
+ int frequency = message.frequencyOffset();
+ if (message.isTX()) {
+ if (!m_config.enable_VHF_features()) {
+ if(!shift) ui->RxFreqSpinBox->setValue(frequency); //Set Rx freq
+ if((ctrl or shift) and !ui->cbHoldTxFreq->isChecked ()) {
+ ui->TxFreqSpinBox->setValue(frequency); //Set Tx freq
+ }
+ }
+ return;
+ }
+
+ // check for CQ with listening frequency
+ if (parts.size () >= 7
+ && (m_bFastMode || m_mode=="FT8")
+ && "CQ" == parts[5]
+ && m_config.is_transceiver_online ()) {
+ bool ok;
+ auto kHz = parts[6].toUInt (&ok);
+ if (ok && kHz >= 10 && 3 == parts[6].size ()) {
+ // QSY Freq for answering CQ nnn
+ setRig (m_freqNominal / 1000000 * 1000000 + 1000 * kHz);
+ ui->decodedTextBrowser2->displayQSY (QString {"QSY %1"}.arg (m_freqNominal / 1e6, 7, 'f', 3));
+ }
+ }
+
+ int nmod = fmod(double(message.timeInSeconds()),2.0*m_TRperiod);
+ m_txFirst=(nmod!=0);
+ if( SpecOp::HOUND == m_specOp ) m_txFirst=false; //Hound must not transmit first
+ if( SpecOp::FOX == m_specOp ) m_txFirst=true; //Fox must always transmit first
+ ui->txFirstCheckBox->setChecked(m_txFirst);
+
+ auto const& message_words = message.messageWords ();
+ if (message_words.size () < 3) return;
+
+ QString hiscall;
+ QString hisgrid;
+ message.deCallAndGrid(/*out*/hiscall,hisgrid);
+
+ if(message.clean_string ().contains(hiscall+"/R")) {
+ hiscall+="/R";
+ ui->dxCallEntry->setText(hiscall);
+ }
+ if(message.clean_string ().contains(hiscall+"/P")) {
+ hiscall+="/P";
+ ui->dxCallEntry->setText(hiscall);
+ }
+
+ QStringList w=message.clean_string ().mid(22).remove("<").remove(">").split(" ",SkipEmptyParts);
+ int nw=w.size();
+ if(nw>=4) {
+ if(message_words.size()<4) return;
+ int n=w.at(nw-2).toInt();
+ if(n>=520001 and n<=592047) {
+ hiscall=w.at(1);
+ hisgrid=w.at(nw-1);
+ }
+ }
+
+ bool is_73 = message_words.filter (QRegularExpression {"^(73|RR73)$"}).size ();
+ if (!is_73 and !message.isStandardMessage() and !message.clean_string ().contains("<")) {
+ qDebug () << "Not processing message - hiscall:" << hiscall << "hisgrid:" << hisgrid
+ << message.clean_string () << message.isStandardMessage();
+ return;
+ }
+
+ if ((message.isJT9 () and m_mode != "JT9" and m_mode != "JT4") or
+ (message.isJT65 () and m_mode != "JT65" and m_mode != "JT4")) {
+ // We are not allowing mode change, so don't process decode
+ return;
+ }
+
+ // ignore calls by other hounds
+ if (SpecOp::HOUND == m_specOp
+ && message.messageWords ().indexOf (QRegularExpression {R"(R\+-[0-9]+)"}) >= 1)
+ {
+ return;
+ }
+
+ QString firstcall = message.call();
+ if(firstcall.length()>=4 and firstcall.mid(0,3)=="CQ ") firstcall="CQ";
+ if(!m_bFastMode and (!m_config.enable_VHF_features() or m_mode=="FT8" or m_mode=="FT4" or m_mode=="FST4")) {
+ // Don't change Tx freq if in a fast mode, or VHF features enabled; also not if a
+ // station is calling me, unless CTRL or SHIFT is held down.
+ if ((Radio::is_callsign (firstcall)
+ && firstcall != m_config.my_callsign () && firstcall != m_baseCall
+ && firstcall != "DE")
+ || "CQ" == firstcall || "QRZ" == firstcall || ctrl || shift) {
+ if (((SpecOp::HOUND != m_specOp) || m_mode != "FT8")
+ && (!ui->cbHoldTxFreq->isChecked () || shift || ctrl)) {
+ ui->TxFreqSpinBox->setValue(frequency);
+ }
+ if(m_mode != "JT4" && m_mode != "JT65" && !m_mode.startsWith ("JT9") &&
+ m_mode != "Q65" && m_mode!="FT8" && m_mode!="FT4" && m_mode!="FST4") {
+ return;
+ }
+ }
+ }
+
+ // prior DX call (possible QSO partner)
+ auto qso_partner_base_call = Radio::base_callsign (ui->dxCallEntry->text ());
+ auto base_call = Radio::base_callsign (hiscall);
+
+// Determine appropriate response to received message
+ auto dtext = " " + message.clean_string () + " ";
+ dtext=dtext.remove("<").remove(">");
+ if(dtext.contains (" " + m_baseCall + " ")
+ || dtext.contains ("<" + m_baseCall + "> ")
+//###??? || dtext.contains ("<" + m_baseCall + " " + hiscall + "> ")
+ || dtext.contains ("/" + m_baseCall + " ")
+ || dtext.contains (" " + m_baseCall + "/")
+ || (firstcall == "DE")) {
+
+ QString w2;
+ int nw=w.size();
+ if(nw>=3) w2=w.at(2);
+ int nrpt=w2.toInt();
+ QString w34;
+ if(nw>=4) {
+// w34=w.at(nw-2);
+ nrpt=w.at(nw-2).toInt();
+ w34=w.at(nw-1);
+ }
+ bool bRTTY = (nrpt>=529 and nrpt<=599);
+ bool bEU_VHF_w2=(nrpt>=520001 and nrpt<=594000);
+ if(bEU_VHF_w2 and SpecOp::EU_VHF!=m_specOp) {
+ auto const& msg = tr("Should you switch to EU VHF Contest mode?\n\n"
+ "To do so, check 'Special operating activity' and\n"
+ "'EU VHF Contest' on the Settings | Advanced tab.");
+ MessageBox::information_message (this, msg);
+ }
+
+ QStringList t=message.clean_string ().split(' ', SkipEmptyParts);
+ int n=t.size();
+ QString t0=t.at(n-2);
+ QString t1=t0.right(1);
+ bool bFieldDay_msg = (t1>="A" and t1<="F" and t0.size()<=3 and n>=9);
+ int m=t0.remove(t1).toInt();
+ if(m < 1) bFieldDay_msg=false;
+ if(bFieldDay_msg) {
+ m_xRcvd=t.at(n-2) + " " + t.at(n-1);
+ t0=t.at(n-3);
+ }
+ if(bFieldDay_msg and SpecOp::FIELD_DAY!=m_specOp) {
+ // ### Should be in ARRL Field Day mode ??? ###
+ MessageBox::information_message (this, tr ("Should you switch to ARRL Field Day mode?"));
+ }
+
+ if(bRTTY and SpecOp::RTTY != m_specOp) {
+ // ### Should be in RTTY contest mode ??? ###
+ MessageBox::information_message (this, tr ("Should you switch to RTTY contest mode?"));
+ }
+
+ // This is necessary to prevent crashes caused by double-clicking messages with <...> in certain QSO situations.
+ if((SpecOp::EU_VHF==m_specOp or SpecOp::RTTY==m_specOp or SpecOp::FIELD_DAY==m_specOp)
+ and message.string().contains("<...>")) return;
+
+ if(SpecOp::EU_VHF==m_specOp and message_words.at(2).contains(m_baseCall) and
+ (!message_words.at(3).contains(qso_partner_base_call)) and (!m_bDoubleClicked)) {
+ return;
+ }
+
+ bool bContestOK=(m_mode=="FT4" or m_mode=="FT8" or m_mode=="Q65" or m_mode=="MSK144");
+ if(message_words.size () > 4 // enough fields for a normal message
+ && (message_words.at(2).contains(m_baseCall) || "DE" == message_words.at(2))
+ && (message_words.at(3).contains(qso_partner_base_call) or m_bDoubleClicked
+ or bEU_VHF_w2 or (m_QSOProgress==CALLING))) {
+ if(message_words.at(4).contains(grid_regexp) and SpecOp::EU_VHF!=m_specOp) {
+ if((SpecOp::NA_VHF==m_specOp or SpecOp::WW_DIGI==m_specOp or
+ SpecOp::ARRL_DIGI==m_specOp or SpecOp::Q65_PILEUP==m_specOp)
+ and bContestOK) {
+ setTxMsg(3);
+ m_QSOProgress=ROGER_REPORT;
+ } else {
+ if(m_mode=="JT65" and message_words.size()>5 and message_words.at(5)=="OOO") {
+ setTxMsg(3);
+ m_QSOProgress=ROGER_REPORT;
+ } else {
+ setTxMsg(2);
+ m_QSOProgress=REPORT;
+ }
+ }
+ } else if(w34.contains(grid_regexp) and SpecOp::EU_VHF==m_specOp) {
+
+ if(nrpt==0) {
+ setTxMsg(2);
+ m_QSOProgress=REPORT;
+ } else {
+ if(w2=="R") {
+ setTxMsg(4);
+ m_QSOProgress=ROGERS;
+ } else {
+ setTxMsg(3);
+ m_QSOProgress=ROGER_REPORT;
+ }
+ }
+ } else if(SpecOp::RTTY == m_specOp and bRTTY) {
+ if(w2=="R") {
+ setTxMsg(4);
+ m_QSOProgress=ROGERS;
+ } else {
+ setTxMsg(3);
+ m_QSOProgress=ROGER_REPORT;
+ }
+ m_xRcvd=t[n-2] + " " + t[n-1];
+ } else if(SpecOp::FIELD_DAY==m_specOp and bFieldDay_msg) {
+ if(t0=="R") {
+ setTxMsg(4);
+ m_QSOProgress=ROGERS;
+ } else {
+ setTxMsg(3);
+ m_QSOProgress=ROGER_REPORT;
+ }
+ } else { // no grid on end of msg
+ auto const& word_3 = message_words.at (4);
+ auto word_3_as_number = word_3.toInt ();
+ if (("RRR" == word_3
+ || (word_3_as_number == 73 && ROGERS == m_QSOProgress)
+ || "RR73" == word_3
+ || ("R" == word_3 && m_QSOProgress != REPORT))) {
+ if(m_mode=="FT4" and "RR73" == word_3) m_dateTimeRcvdRR73=QDateTime::currentDateTimeUtc();
+ m_bTUmsg=false;
+ m_nextCall=""; //### Temporary: disable use of "TU;" message
+ if(SpecOp::RTTY == m_specOp and m_nextCall!="") {
+ // We're in RTTY contest and have "nextCall" queued up: send a "TU; ..." message
+ if (m_config.prompt_to_log() || m_config.autoLog()) {
+ logQSOTimer.start(0);
+ }
+ else {
+ cease_auto_Tx_after_QSO ();
+ }
+ ui->tx3->setText(ui->tx3->text().remove("TU; "));
+ useNextCall();
+ QString t="TU; " + ui->tx3->text();
+ ui->tx3->setText(t);
+ m_bTUmsg=true;
+ } else {
+ if (false) // Always Send 73 after receiving RRR or RR73, even in contest mode.
+ {
+ if (m_config.prompt_to_log() || m_config.autoLog()) {
+ logQSOTimer.start(0);
+ }
+ else {
+ cease_auto_Tx_after_QSO ();
+ }
+ m_ntx=6;
+ ui->txrb6->setChecked(true);
+ }
+ else if (word_3.contains (QRegularExpression {"^R(?!R73|RR)"})
+ && m_QSOProgress != ROGER_REPORT)
+ {
+ m_ntx=4;
+ ui->txrb4->setChecked(true);
+ }
+ else if ((m_QSOProgress > CALLING && m_QSOProgress < ROGERS)
+ || word_3.contains (QRegularExpression {"^RR(?:R|73)$"}))
+ {
+ m_ntx=5;
+ ui->txrb5->setChecked(true);
+ }
+ else if (ROGERS == m_QSOProgress)
+ {
+ if (m_config.prompt_to_log() || m_config.autoLog()) {
+ logQSOTimer.start(0);
+ }
+ else {
+ cease_auto_Tx_after_QSO ();
+ }
+ m_ntx=6;
+ ui->txrb6->setChecked(true);
+ }
+ else
+ {
+ // just work them (again)
+ if (ui->tx1->isEnabled ()) {
+ m_ntx = 1;
+ m_QSOProgress = REPLYING;
+ ui->txrb1->setChecked (true);
+ } else {
+ m_ntx=2;
+ m_QSOProgress = REPORT;
+ ui->txrb2->setChecked (true);
+ }
+ }
+ }
+ if (m_QSOProgress >= ROGER_REPORT)
+ {
+ m_QSOProgress = SIGNOFF;
+ }
+ } else if((m_QSOProgress >= REPORT
+ || (m_QSOProgress >= REPLYING &&
+ (m_mode=="MSK144" or m_mode=="FT8" or m_mode=="FT4" || "Q65" == m_mode)))
+ && word_3.startsWith ('R')) {
+ m_ntx=4;
+ m_QSOProgress = ROGERS;
+ if(SpecOp::RTTY == m_specOp) {
+ int n=t.size();
+ int nRpt=t[n-2].toInt();
+ if(nRpt>=529 and nRpt<=599) m_xRcvd=t[n-2] + " " + t[n-1];
+ }
+ ui->txrb4->setChecked(true);
+ } else if (m_QSOProgress >= CALLING)
+ {
+ if ((word_3_as_number >= -50 && word_3_as_number <= 49)
+ || (word_3_as_number >= 529 && word_3_as_number <= 599))
+ {
+ if(SpecOp::EU_VHF==m_specOp or
+ SpecOp::FIELD_DAY==m_specOp or
+ SpecOp::RTTY==m_specOp)
+ {
+ setTxMsg(2);
+ m_QSOProgress=REPORT;
+ }
+ else
+ {
+ if (word_3.startsWith ("R-") || word_3.startsWith ("R+"))
+ {
+ setTxMsg(4);
+ m_QSOProgress=ROGERS;
+ }
+ else
+ {
+ setTxMsg (3);
+ m_QSOProgress = ROGER_REPORT;
+ }
+ }
+ }
+ }
+ else
+ { // nothing for us
+ return;
+ }
+ }
+ }
+ else if (5 == message_words.size ()
+ && m_baseCall == message_words.at (1)) {
+ // dual Fox style message, possibly from MSHV
+ if (m_config.prompt_to_log() || m_config.autoLog()) {
+ logQSOTimer.start(0);
+ }
+ else {
+ cease_auto_Tx_after_QSO ();
+ }
+ m_ntx=6;
+ ui->txrb6->setChecked(true);
+ }
+ else if (m_QSOProgress >= ROGERS
+ && message_words.size () > 3 && message_words.at (2).contains (m_baseCall)
+ && message_words.at (3) == "73") {
+ // 73 back to compound call holder
+ m_ntx=5;
+ ui->txrb5->setChecked(true);
+ m_QSOProgress = SIGNOFF;
+ }
+ else if (!(m_bAutoReply && (m_QSOProgress > CALLING))) {
+ if ((message_words.size () > 5 && message_words.at (2).contains (m_baseCall)
+ && message_words.at (5) == "OOO")) {
+ // EME short code report or MSK144/FT8 contest mode reply, send back Tx3
+ m_ntx=3;
+ m_QSOProgress = ROGER_REPORT;
+ ui->txrb3->setChecked (true);
+ } else if (!is_73) { // don't respond to sign off messages
+ m_ntx=2;
+ m_QSOProgress = REPORT;
+ ui->txrb2->setChecked(true);
+ if (m_bDoubleClickAfterCQnnn and m_transmitting) {
+ on_stopTxButton_clicked();
+ TxAgainTimer.start(1500);
+ }
+ m_bDoubleClickAfterCQnnn=false;
+ }
+ else {
+ return; // nothing we need to respond to
+ }
+ }
+ else { // nothing for us
+ return;
+ }
+ }
+ else if (firstcall == "DE" && message_words.size () > 4 && message_words.at (4) == "73") {
+ if (m_QSOProgress >= ROGERS && base_call == qso_partner_base_call && m_currentMessageType) {
+ // 73 back to compound call holder
+ m_ntx=5;
+ ui->txrb5->setChecked(true);
+ m_QSOProgress = SIGNOFF;
+ } else {
+ // treat like a CQ/QRZ
+ if (ui->tx1->isEnabled ()) {
+ m_ntx = 1;
+ m_QSOProgress = REPLYING;
+ ui->txrb1->setChecked (true);
+ } else {
+ m_ntx=2;
+ m_QSOProgress = REPORT;
+ ui->txrb2->setChecked (true);
+ }
+ }
+ }
+ else if (is_73 && !message.isStandardMessage ()) {
+ m_ntx=5;
+ ui->txrb5->setChecked(true);
+ m_QSOProgress = SIGNOFF;
+ } else {
+ // just work them
+ if (ui->tx1->isEnabled ()) {
+ m_ntx = 1;
+ m_QSOProgress = REPLYING;
+ ui->txrb1->setChecked (true);
+ } else {
+ m_ntx=2;
+ m_QSOProgress = REPORT;
+ ui->txrb2->setChecked (true);
+ }
+ }
+ // if we get here then we are reacting to the message
+ if (m_bAutoReply) m_bCallingCQ = CALLING == m_QSOProgress;
+ m_maxPoints=-1;
+ if (ui->RxFreqSpinBox->isEnabled () and m_mode != "MSK144" and !shift) {
+ ui->RxFreqSpinBox->setValue (frequency); //Set Rx freq
+ }
+
+ QString s1 = m_QSOText.trimmed ();
+ QString s2 = message.clean_string ().trimmed();
+ if (s1!=s2 and !message.isTX()) {
+ if (!s2.contains(m_baseCall) or m_mode=="MSK144") { // Taken care of elsewhere if for_us and slow mode
+ ui->decodedTextBrowser2->displayDecodedText (message, m_config.my_callsign (), m_mode, m_config.DXCC (),
+ m_logBook, m_currentBand, m_config.ppfx ());
+ }
+ m_QSOText = s2;
+ }
+
+ if (Radio::is_callsign (hiscall)
+ && (base_call != qso_partner_base_call || base_call != hiscall)) {
+ if (qso_partner_base_call != base_call) {
+ // clear the DX grid if the base call of his call is different
+ // from the current DX call
+ ui->dxGridEntry->clear ();
+ }
+ // his base call different or his call more qualified
+ // i.e. compound version of same base call
+ ui->dxCallEntry->setText (hiscall);
+ }
+ if (hisgrid.contains (grid_regexp)) {
+ if(ui->dxGridEntry->text().mid(0,4) != hisgrid) ui->dxGridEntry->setText(hisgrid);
+ }
+ lookup();
+ m_hisGrid = ui->dxGridEntry->text();
+
+ if (m_bDoubleClicked)
+ {
+ // extract our report if present
+ message.report (m_baseCall, Radio::base_callsign(ui->dxCallEntry->text()), m_rptRcvd);
+ }
+
+ if (!m_bSentReport || base_call != qso_partner_base_call) // Don't change report within a QSO
+ {
+ auto n = message.report ().toInt ();
+ if(m_mode=="MSK144" and m_bShMsgs) {
+ if(n<=-2) n=-3;
+ if(n>=-1 and n<=1) n=0;
+ if(n>=2 and n<=4) n=3;
+ if(n>=5 and n<=7) n=6;
+ if(n>=8 and n<=11) n=10;
+ if(n>=12 and n<=14) n=13;
+ if(n>=15) n=16;
+ }
+ ui->rptSpinBox->setValue (n);
+ }
+// Don't genStdMsgs if we're already sending 73, or a "TU; " msg is queued.
+ m_bTUmsg=false; //### Temporary: disable use of "TU;" messages
+ if (!m_nTx73 and !m_bTUmsg) {
+ genStdMsgs (QString::number (ui->rptSpinBox->value ()));
+ }
+ if(m_transmitting) m_restart=true;
+ if (auto_seq && !m_bDoubleClicked && m_mode!="FT4") {
+ return;
+ }
+ if(m_config.quick_call() && m_bDoubleClicked) auto_tx_mode(true);
+ m_bDoubleClicked=false;
+}
+
+void MainWindow::setTxMsg(int n)
+{
+ m_ntx=n;
+ if(n==1) ui->txrb1->setChecked(true);
+ if(n==2) ui->txrb2->setChecked(true);
+ if(n==3) ui->txrb3->setChecked(true);
+ if(n==4) ui->txrb4->setChecked(true);
+ if(n==5) ui->txrb5->setChecked(true);
+ if(n==6) ui->txrb6->setChecked(true);
+}
+
+void MainWindow::genCQMsg ()
+{
+ auto const& my_callsign = m_config.my_callsign ();
+ auto is_compound = my_callsign != m_baseCall;
+ auto is_type_two = !is77BitMode () && is_compound && stdCall (m_baseCall) && !shortList (my_callsign);
+ if(my_callsign.size () && m_config.my_grid().size ()) {
+ auto const& grid = m_config.my_grid ();
+ if (ui->cbCQTx->isEnabled () && ui->cbCQTx->isVisible () && ui->cbCQTx->isChecked ()) {
+ if(stdCall (my_callsign)
+ || is_type_two) {
+ msgtype (QString {"CQ %1 %2 %3"}
+ .arg (m_freqNominal / 1000 - m_freqNominal / 1000000 * 1000, 3, 10, QChar {'0'})
+ .arg (my_callsign)
+ .arg (grid.left (4)),
+ ui->tx6);
+ } else {
+ msgtype (QString {"CQ %1 %2"}
+ .arg (m_freqNominal / 1000 - m_freqNominal / 1000000 * 1000, 3, 10, QChar {'0'})
+ .arg (my_callsign),
+ ui->tx6);
+ }
+ } else {
+ if (stdCall (my_callsign)
+ || is_type_two) {
+ msgtype (QString {"%1 %2 %3"}.arg(m_CQtype).arg(my_callsign)
+ .arg(grid.left(4)),ui->tx6);
+ } else {
+ msgtype (QString {"%1 %2"}.arg(m_CQtype).arg(my_callsign),ui->tx6);
+ }
+ }
+ if ((m_mode=="JT4" or m_mode=="Q65") and ui->cbShMsgs->isChecked()) {
+ if (ui->cbTx6->isChecked ()) {
+ msgtype ("@1250 (SEND MSGS)", ui->tx6);
+ } else {
+ msgtype ("@1000 (TUNE)", ui->tx6);
+ }
+ }
+
+ QString t=ui->tx6->text();
+ QStringList tlist=t.split(" ");
+ if((m_mode=="FT4" or m_mode=="FT8" or m_mode=="MSK144" || "Q65" == m_mode) and
+ SpecOp::NONE != m_specOp and SpecOp::HOUND != m_specOp and SpecOp::Q65_PILEUP != m_specOp and
+ ( tlist.at(1)==my_callsign or
+ tlist.at(2)==my_callsign ) and
+ stdCall(my_callsign)) {
+ if(m_config.Individual_Contest_Name() && SpecOp::FOX != m_specOp) {
+ m_cqStr = m_config.Contest_Name();
+ } else {
+ if(SpecOp::NA_VHF == m_specOp) m_cqStr="TEST";
+ if(SpecOp::EU_VHF == m_specOp) m_cqStr="TEST";
+ if(SpecOp::FIELD_DAY == m_specOp) m_cqStr="FD";
+ if(SpecOp::RTTY == m_specOp) m_cqStr="RU";
+ if(SpecOp::WW_DIGI == m_specOp) m_cqStr="WW";
+ if(SpecOp::ARRL_DIGI == m_specOp) m_cqStr="TEST";
+ }
+ if( tlist.at(1)==my_callsign ) {
+ t="CQ " + m_cqStr + " " + tlist.at(1) + " " + tlist.at(2);
+ } else {
+ t="CQ " + m_cqStr + " " + tlist.at(2) + " " + tlist.at(3);
+ }
+ ui->tx6->setText(t);
+ }
+ } else {
+ ui->tx6->clear ();
+ }
+}
+
+void MainWindow::abortQSO()
+{
+ bool b=m_auto;
+ clearDX();
+ if(b) auto_tx_mode(false);
+ ui->txrb6->setChecked(true);
+}
+
+bool MainWindow::stdCall(QString const& w)
+{
+ static QRegularExpression standard_call_re {
+ R"(
+ ^\s* # optional leading spaces
+ ( [A-Z]{0,2} | [A-Z][0-9] | [0-9][A-Z] ) # part 1
+ ( [0-9][A-Z]{0,3} ) # part 2
+ (/R | /P)? # optional suffix
+ \s*$ # optional trailing spaces
+ )", QRegularExpression::CaseInsensitiveOption | QRegularExpression::ExtendedPatternSyntaxOption};
+ return standard_call_re.match (w).hasMatch ();
+}
+
+bool MainWindow::is77BitMode () const
+{
+ return "FT8" == m_mode || "FT4" == m_mode || "MSK144" == m_mode
+ || "FST4" == m_mode || "Q65" == m_mode;
+}
+
+void MainWindow::genStdMsgs(QString rpt, bool unconditional)
+{
+ genCQMsg ();
+ auto const& hisCall=ui->dxCallEntry->text();
+ if(!hisCall.size ()) {
+ ui->labAz->clear ();
+ ui->tx1->clear ();
+ ui->tx2->clear ();
+ ui->tx3->clear ();
+ ui->tx4->clear ();
+ if(unconditional) ui->tx5->lineEdit ()->clear (); //Test if it needs sending again
+ m_gen_message_is_cq = false;
+ return;
+ }
+ auto const& my_callsign = m_config.my_callsign ();
+ auto is_compound = my_callsign != m_baseCall;
+ auto is_type_one = !is77BitMode () && is_compound && shortList (my_callsign);
+ auto const& my_grid = m_config.my_grid ().left (4);
+ auto const& hisBase = Radio::base_callsign (hisCall);
+ save_dxbase_(const_cast <char *> ((hisBase + " ").left(6).toLatin1().constData()), (FCL)6);
+ auto eme_short_codes = m_config.enable_VHF_features () && ui->cbShMsgs->isChecked ()
+ && m_mode == "JT65";
+
+ bool bMyCall=stdCall(my_callsign);
+ bool bHisCall=stdCall(hisCall);
+
+ QString t0=hisBase + " " + m_baseCall + " ";
+ QString t0s=hisCall + " " + my_callsign + " ";
+ QString t0a,t0b;
+
+ if (is77BitMode () && bHisCall && bMyCall) t0=hisCall + " " + my_callsign + " ";
+ t0a="<"+hisCall + "> " + my_callsign + " ";
+ t0b=hisCall + " <" + my_callsign + "> ";
+
+ QString t00=t0;
+ QString t {t0 + my_grid};
+ if(!bMyCall) t=t0a;
+ msgtype(t, ui->tx1);
+ if (eme_short_codes) {
+ t=t+" OOO";
+ if(!bHisCall) t=hisCall + " " + m_baseCall + " OOO";
+ if(!bMyCall) t=hisBase + " " + my_callsign + " OOO";
+ msgtype(t, ui->tx2);
+ msgtype("RO", ui->tx3);
+ msgtype("RRR", ui->tx4);
+ msgtype("73", ui->tx5->lineEdit());
+ } else {
+ int n=rpt.toInt();
+ rpt = rpt.asprintf("%+2.2d",n);
+
+ if (is77BitMode ()) {
+ QString t2,t3;
+ QString sent=rpt;
+ QString rs,rst;
+ int nn=(n+36)/6;
+ if(nn<2) nn=2;
+ if(nn>9) nn=9;
+ rst = rst.asprintf("5%1d9 ",nn);
+ rs=rst.mid(0,2);
+ t=t0;
+ if(!bMyCall) {
+ t=t0b;
+ msgtype(t0a, ui->tx1);
+ }
+ if(!bHisCall) {
+ t=t0a;
+ msgtype(t0a + my_grid, ui->tx1);
+ }
+ if(SpecOp::NA_VHF==m_specOp) sent=my_grid;
+ if(SpecOp::WW_DIGI==m_specOp) sent=my_grid;
+ if(SpecOp::ARRL_DIGI==m_specOp) sent=my_grid;
+ if(SpecOp::Q65_PILEUP==m_specOp) sent=my_grid;
+ if(SpecOp::FIELD_DAY==m_specOp) sent=m_config.Field_Day_Exchange();
+ if(SpecOp::RTTY==m_specOp) {
+ sent=rst + m_config.RTTY_Exchange();
+ QString t1=m_config.RTTY_Exchange();
+ if(t1=="DX" or t1=="#") {
+ t1 = t1.asprintf("%4.4d",ui->sbSerialNumber->value());
+ sent=rst + t1;
+ }
+ if(t1.contains(QRegularExpression {"\\d\\d\\d\\d"})) {
+ t1 = m_config.RTTY_Exchange();
+ }
+ }
+ if(SpecOp::EU_VHF==m_specOp) {
+ QString a;
+ t="<" + t0s.split(" ").at(0) + "> <" + t0s.split(" ").at(1) + "> ";
+ a = a.asprintf("%4.4d ",ui->sbSerialNumber->value());
+ sent=rs + a + m_config.my_grid();
+ }
+ msgtype(t + sent, ui->tx2);
+ if(sent==rpt) msgtype(t + "R" + sent, ui->tx3);
+ if(sent!=rpt) msgtype(t + "R " + sent, ui->tx3);
+ if(m_mode=="FT4" and SpecOp::RTTY==m_specOp) {
+ QDateTime now=QDateTime::currentDateTimeUtc();
+ int sinceTx3 = m_dateTimeSentTx3.secsTo(now);
+ int sinceRR73 = m_dateTimeRcvdRR73.secsTo(now);
+ if(m_bDoubleClicked and (sinceTx3 < 15) and (sinceRR73 < 3)) {
+ t="TU; " + ui->tx3->text();
+ ui->tx3->setText(t);
+ }
+ }
+ }
+
+ if(m_mode=="MSK144" and m_bShMsgs) {
+ int i=t0s.length()-1;
+ t0="<" + t0s.mid(0,i) + "> ";
+ if(SpecOp::NA_VHF != m_specOp) {
+ if(n<=-2) n=-3;
+ if(n>=-1 and n<=1) n=0;
+ if(n>=2 and n<=4) n=3;
+ if(n>=5 and n<=7) n=6;
+ if(n>=8 and n<=11) n=10;
+ if(n>=12 and n<=14) n=13;
+ if(n>=15) n=16;
+ rpt = rpt.asprintf("%+2.2d",n);
+ }
+ }
+
+ if (!is77BitMode ()) {
+ t=(is_type_one ? t0 : t00) + rpt;
+ msgtype(t, ui->tx2);
+ t=t0 + "R" + rpt;
+ msgtype(t, ui->tx3);
+ }
+
+ if(m_mode=="MSK144" and m_bShMsgs) {
+ if(m_specOp==SpecOp::NONE) {
+ t=t0 + "R" + rpt;
+ msgtype(t, ui->tx3);
+ }
+ m_send_RR73=false;
+ }
+
+ t=t0 + (m_send_RR73 ? "RR73" : "RRR");
+ if((m_mode=="MSK144" and !m_bShMsgs) or m_mode=="FT8" or m_mode=="FT4" || m_mode == "FST4" || m_mode == "Q65") {
+ if(!bHisCall and bMyCall) t=hisCall + " <" + my_callsign + "> " + (m_send_RR73 ? "RR73" : "RRR");
+ if(bHisCall and !bMyCall) t="<" + hisCall + "> " + my_callsign + " " + (m_send_RR73 ? "RR73" : "RRR");
+ }
+ if ((m_mode=="JT4" || m_mode=="Q65") && m_bShMsgs) t="@1500 (RRR)";
+ msgtype(t, ui->tx4);
+
+ t=t0 + "73";
+ if((m_mode=="MSK144" and !m_bShMsgs) or m_mode=="FT8" or m_mode=="FT4" || m_mode == "FST4" || m_mode == "Q65") {
+ if(!bHisCall and bMyCall) t=hisCall + " <" + my_callsign + "> 73";
+ if(bHisCall and !bMyCall) t="<" + hisCall + "> " + my_callsign + " 73";
+ }
+ if (m_mode=="JT4" || m_mode=="Q65") {
+ if (m_bShMsgs) t="@1750 (73)";
+ msgtype(t, ui->tx5->lineEdit());
+ } else if ("MSK144" == m_mode && m_bShMsgs) {
+ msgtype(t, ui->tx5->lineEdit());
+ } else if(unconditional || hisBase != m_lastCallsign || !m_lastCallsign.size ()) {
+ // only update tx5 when forced or callsign changes
+ msgtype(t, ui->tx5->lineEdit());
+ m_lastCallsign = hisBase;
+ }
+ }
+
+ if (is77BitMode ()) return;
+
+ if (is_compound) {
+ if (is_type_one) {
+ t=hisBase + " " + my_callsign;
+ msgtype(t, ui->tx1);
+ } else {
+ t = "DE " + my_callsign + " ";
+ switch (m_config.type_2_msg_gen ())
+ {
+ case Configuration::type_2_msg_1_full:
+ msgtype(t + my_grid, ui->tx1);
+ if (!eme_short_codes) {
+ if(is77BitMode () && SpecOp::NA_VHF == m_specOp) {
+ msgtype(t + "R " + my_grid, ui->tx3); // #### Unreachable code
+ } else {
+ msgtype(t + "R" + rpt, ui->tx3);
+ }
+ if ((m_mode != "JT4" && m_mode != "Q65") || !m_bShMsgs) {
+ msgtype(t + "73", ui->tx5->lineEdit ());
+ }
+ }
+ break;
+
+ case Configuration::type_2_msg_3_full:
+ if (is77BitMode () && SpecOp::NA_VHF == m_specOp) {
+ msgtype(t + "R " + my_grid, ui->tx3);
+ msgtype(t + "RRR", ui->tx4);
+ } else {
+ msgtype(t00 + my_grid, ui->tx1);
+ msgtype(t + "R" + rpt, ui->tx3);
+ }
+ if (!eme_short_codes && ((m_mode != "JT4" && m_mode != "Q65") || !m_bShMsgs)) {
+ msgtype(t + "73", ui->tx5->lineEdit ());
+ }
+ break;
+
+ case Configuration::type_2_msg_5_only:
+ msgtype(t00 + my_grid, ui->tx1);
+ if (!eme_short_codes) {
+ if (is77BitMode () && SpecOp::NA_VHF == m_specOp) {
+ msgtype(t + "R " + my_grid, ui->tx3); // #### Unreachable code
+ msgtype(t + "RRR", ui->tx4);
+ } else {
+ msgtype(t0 + "R" + rpt, ui->tx3);
+ }
+ }
+ // don't use short codes here as in a sked with a type 2
+ // prefix we would never send out prefix/suffix
+ msgtype(t + "73", ui->tx5->lineEdit ());
+ break;
+ }
+ }
+ if (hisCall != hisBase
+ && m_config.type_2_msg_gen () != Configuration::type_2_msg_5_only
+ && !eme_short_codes) {
+ // cfm we have his full call copied as we could not do this earlier
+ t = hisCall + " 73";
+ msgtype(t, ui->tx5->lineEdit ());
+ }
+ } else {
+ if (hisCall != hisBase and SpecOp::HOUND != m_specOp) {
+ if (shortList(hisCall)) {
+ // cfm we know his full call with a type 1 tx1 message
+ t = hisCall + " " + my_callsign;
+ msgtype(t, ui->tx1);
+ }
+ else if (!eme_short_codes
+ && ("MSK144" != m_mode || !m_bShMsgs)) {
+ t=hisCall + " 73";
+ msgtype(t, ui->tx5->lineEdit ());
+ }
+ }
+ }
+ m_rpt=rpt;
+ if(SpecOp::HOUND == m_specOp and is_compound) ui->tx1->setText("DE " + my_callsign);
+}
+
+void MainWindow::TxAgain()
+{
+ auto_tx_mode(true);
+}
+
+void MainWindow::clearDX ()
+{
+ set_dateTimeQSO (-1);
+ if (m_QSOProgress != CALLING) {
+ auto_tx_mode (false);
+ }
+ ui->dxCallEntry->clear ();
+ ui->dxGridEntry->clear ();
+ m_lastCallsign.clear ();
+ m_rptSent.clear ();
+ m_rptRcvd.clear ();
+ m_qsoStart.clear ();
+ m_qsoStop.clear ();
+ m_inQSOwith.clear();
+ genStdMsgs (QString {});
+ if (m_mode=="FT8" and SpecOp::HOUND == m_specOp) {
+ m_ntx=1;
+ ui->txrb1->setChecked(true);
+ } else {
+ m_ntx=6;
+ ui->txrb6->setChecked(true);
+ }
+ m_QSOProgress = CALLING;
+}
+
+void MainWindow::lookup()
+{
+ QString hisCall {ui->dxCallEntry->text()};
+ QString hisgrid0 {ui->dxGridEntry->text()};
+ if (!hisCall.size ()) return;
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("CALL3.TXT")};
+ if (f.open (QIODevice::ReadOnly | QIODevice::Text))
+ {
+ char c[132];
+ qint64 n=0;
+ for(int i=0; i<999999; i++) {
+ n=f.readLine(c,sizeof(c));
+ if(n <= 0) {
+ if(!hisgrid0.contains(grid_regexp)) {
+ ui->dxGridEntry->clear();
+ }
+ break;
+ }
+ QString t=QString(c);
+ int i1=t.indexOf(",");
+ if(t.left(i1)==hisCall) {
+ QString hisgrid=t.mid(i1+1,6);
+ i1=hisgrid.indexOf(",");
+ if(i1>0) {
+ hisgrid=hisgrid.mid(0,4);
+ } else {
+ hisgrid=hisgrid.mid(0,6).toUpper();
+ }
+ if(hisgrid.left(4)==hisgrid0.left(4) or (hisgrid0.size()==0)) {
+ ui->dxGridEntry->setText(hisgrid);
+ }
+ break;
+ }
+ }
+ f.close();
+ }
+}
+
+void MainWindow::on_lookupButton_clicked() //Lookup button
+{
+ lookup();
+}
+
+void MainWindow::on_addButton_clicked() //Add button
+{
+ if(!ui->dxGridEntry->text ().size ()) {
+ MessageBox::warning_message (this, tr ("Add to CALL3.TXT")
+ , tr ("Please enter a valid grid locator"));
+ return;
+ }
+ m_call3Modified=false;
+ QString hisCall=ui->dxCallEntry->text();
+ QString hisgrid=ui->dxGridEntry->text();
+ QString newEntry=hisCall + "," + hisgrid;
+
+ // int ret = MessageBox::query_message(this, tr ("Add to CALL3.TXT"),
+ // tr ("Is %1 known to be active on EME?").arg (newEntry));
+ // if(ret==MessageBox::Yes) {
+ // newEntry += ",EME,,";
+ // } else {
+ newEntry += ",,,";
+ // }
+
+ QFile f1 {m_config.writeable_data_dir ().absoluteFilePath ("CALL3.TXT")};
+ if(!f1.open(QIODevice::ReadWrite | QIODevice::Text)) {
+ MessageBox::warning_message (this, tr ("Add to CALL3.TXT")
+ , tr ("Cannot open \"%1\" for read/write: %2")
+ .arg (f1.fileName ()).arg (f1.errorString ()));
+ return;
+ }
+ if(f1.size()==0) {
+ QTextStream out(&f1);
+ out << "ZZZZZZ"
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f1.seek (0);
+ }
+ QFile f2 {m_config.writeable_data_dir ().absoluteFilePath ("CALL3.TMP")};
+ if(!f2.open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text)) {
+ MessageBox::warning_message (this, tr ("Add to CALL3.TXT")
+ , tr ("Cannot open \"%1\" for writing: %2")
+ .arg (f2.fileName ()).arg (f2.errorString ()));
+ return;
+ }
+ {
+ QTextStream in(&f1); //Read from CALL3.TXT
+ QTextStream out(&f2); //Copy into CALL3.TMP
+ QString hc=hisCall;
+ QString hc1="";
+ QString hc2="000000";
+ QString s;
+ do {
+ s=in.readLine();
+ hc1=hc2;
+ if(s.mid(0,2)=="//") {
+ out << s + QChar::LineFeed; //Copy all comment lines
+ } else {
+ int i1=s.indexOf(",");
+ hc2=s.mid(0,i1);
+ if(hc>hc1 && hc<hc2) {
+ out << newEntry + QChar::LineFeed;
+ out << s + QChar::LineFeed;
+ m_call3Modified=true;
+ } else if(hc==hc2) {
+ QString t {tr ("%1\nis already in CALL3.TXT"
+ ", do you wish to replace it?").arg (s)};
+ int ret = MessageBox::query_message (this, tr ("Add to CALL3.TXT"), t);
+ if(ret==MessageBox::Yes) {
+ out << newEntry + QChar::LineFeed;
+ m_call3Modified=true;
+ }
+ } else {
+ if(s!="") out << s + QChar::LineFeed;
+ }
+ }
+ } while(!s.isNull());
+ if(hc>hc1 && !m_call3Modified) out << newEntry + QChar::LineFeed;
+ }
+
+ if(m_call3Modified) {
+ auto const& old_path = m_config.writeable_data_dir ().absoluteFilePath ("CALL3.OLD");
+ QFile f0 {old_path};
+ if (f0.exists ()) f0.remove ();
+ f1.copy (old_path); // copying as we want to
+ // preserve symlinks
+ f1.open (QFile::WriteOnly | QFile::Text); // truncates
+ f2.seek (0);
+ QByteArray tmp = f2.readAll();
+ if (tmp != (const char*)NULL) f1.write (tmp); // copy contents
+ else qDebug() << "tmp==NULL at f1.write";
+ f2.remove ();
+ }
+}
+
+void MainWindow::msgtype(QString t, QLineEdit* tx) //msgtype()
+{
+// Set background colors of the Tx message boxes, depending on message type
+ char message[38];
+ char msgsent[38];
+ QByteArray s=t.toUpper().toLocal8Bit();
+ ba2msg(s,message);
+ int ichk=1,itype=0;
+ gen65(message, &ichk,msgsent, const_cast<int*>(itone0), &itype);
+ msgsent[22]=0;
+ bool text=false;
+ bool shortMsg=false;
+ if(itype==6) text=true;
+
+//### Check this stuff ###
+ if(itype==7 and m_config.enable_VHF_features() and m_mode=="JT65") shortMsg=true;
+ if(m_mode=="MSK144" and t.mid(0,1)=="<") text=false;
+ if((m_mode=="MSK144" or m_mode=="FT8" or m_mode=="FT4" || "Q65" == m_mode) and
+ SpecOp::NA_VHF==m_specOp) {
+ int i0=t.trimmed().length()-7;
+ if(t.mid(i0,3)==" R ") text=false;
+ }
+ text=false;
+//### ... to here ...
+
+
+ QPalette p(tx->palette());
+ if(text) {
+ p.setColor(QPalette::Base,"#ffccff"); //pink
+ } else {
+ if(shortMsg) {
+ p.setColor(QPalette::Base,"#66ffff"); //light blue
+ } else {
+ p.setColor(QPalette::Base,Qt::transparent);
+ if ("MSK144" == m_mode && t.count ('<') == 1) {
+ p.setColor(QPalette::Base,"#00ffff"); //another light blue
+ }
+ }
+ }
+ tx->setPalette(p);
+
+ auto pos = tx->cursorPosition ();
+ tx->setText(t.toUpper());
+ tx->setCursorPosition (pos);
+}
+
+void MainWindow::on_tx1_editingFinished() //tx1 edited
+{
+ QString t=ui->tx1->text();
+ msgtype(t, ui->tx1);
+}
+
+void MainWindow::on_tx2_editingFinished() //tx2 edited
+{
+ QString t=ui->tx2->text();
+ msgtype(t, ui->tx2);
+}
+
+void MainWindow::on_tx3_editingFinished() //tx3 edited
+{
+ QString t=ui->tx3->text();
+ msgtype(t, ui->tx3);
+}
+
+void MainWindow::on_tx4_editingFinished() //tx4 edited
+{
+ QString t=ui->tx4->text();
+ msgtype(t, ui->tx4);
+}
+
+void MainWindow::on_tx5_currentTextChanged (QString const& text) //tx5 edited
+{
+ msgtype(text, ui->tx5->lineEdit ());
+}
+
+void MainWindow::on_tx6_editingFinished() //tx6 edited
+{
+ QString t=ui->tx6->text().toUpper();
+ if(t.indexOf(" ")>0) {
+ QString t1=t.split(" ").at(1);
+ QRegExp AZ4("^[A-Z]{1,4}$");
+ QRegExp NN3("^[0-9]{1,3}$");
+ m_CQtype="CQ";
+ if(t1.size()<=4 and t1.contains(AZ4)) m_CQtype="CQ " + t1;
+ if(t1.size()<=3 and t1.contains(NN3)) m_CQtype="CQ " + t1;
+ }
+ msgtype(t, ui->tx6);
+}
+
+void MainWindow::on_RoundRobin_currentTextChanged(QString text)
+{
+ ui->sbTxPercent->setEnabled (text == tr ("Random"));
+}
+
+void MainWindow::mousePressEvent(QMouseEvent *event)
+{
+ if(ui->q65Button->hasFocus() && (event->button() & Qt::RightButton)) { // switch to Q65_Pileup mode
+ m_config.setSpecial_Q65_Pileup();
+ m_specOp=m_config.special_op_id();
+ on_actionQ65_triggered();
+ ui->q65Button->clearFocus();
+ }
+ if(ui->jt65Button->hasFocus() && (event->button() & Qt::RightButton)) { // switch to JT9 mode
+ on_actionJT9_triggered();
+ ui->jt65Button->clearFocus();
+ }
+ if(ui->ft8Button->hasFocus() && (event->button() & Qt::RightButton)) { // toggle SuperFox mode
+ keep_frequency = true;
+ m_config.toggle_SF();
+ QTimer::singleShot (250, [=] {keep_frequency = false;});
+ on_actionFT8_triggered();
+ ui->ft8Button->clearFocus();
+ ui->labDXped->setStyleSheet("QLabel {background-color: red; color: white;}");
+ }
+}
+
+void MainWindow::on_dxCallEntry_textChanged (QString const& call)
+{
+ set_dateTimeQSO (-1); // reset the QSO start time when DXCall changes
+ m_hisCall = call;
+ ui->dxGridEntry->clear();
+ statusChanged();
+ statusUpdate ();
+}
+
+void MainWindow::on_dxCallEntry_editingFinished()
+{
+ auto const& dxBase = Radio::base_callsign (m_hisCall);
+ save_dxbase_(const_cast <char *> ((dxBase + " ").left (6).toLatin1().constData()), (FCL)6);
+}
+
+
+void MainWindow::on_dxCallEntry_returnPressed ()
+{
+ on_lookupButton_clicked();
+}
+
+void MainWindow::on_dxGridEntry_textChanged (QString const& grid)
+{
+ if (ui->dxGridEntry->hasAcceptableInput ()) {
+ if (grid != m_hisGrid) {
+ m_hisGrid = grid;
+ statusUpdate ();
+ }
+ qint64 nsec = (QDateTime::currentMSecsSinceEpoch()/1000) % 86400;
+ double utch=nsec/3600.0;
+ int nAz,nEl,nDmiles,nDkm,nHotAz,nHotABetter;
+ azdist_(const_cast <char *> ((m_config.my_grid () + " ").left (6).toLatin1().constData()),
+ const_cast <char *> ((m_hisGrid + " ").left (6).toLatin1().constData()),&utch,
+ &nAz,&nEl,&nDmiles,&nDkm,&nHotAz,&nHotABetter,(FCL)6,(FCL)6);
+ QString t;
+ int nd=nDkm;
+ if(m_config.miles()) nd=nDmiles;
+ if(m_mode=="MSK144") {
+ if(nHotABetter==0)t = t.asprintf("Az: %d B: %d El: %d %d",nAz,nHotAz,nEl,nd);
+ if(nHotABetter!=0)t = t.asprintf("Az: %d A: %d El: %d %d",nAz,nHotAz,nEl,nd);
+ } else {
+ t = t.asprintf("Az: %d %d",nAz,nd);
+ }
+ if(m_config.miles()) t += " mi";
+ if(!m_config.miles()) t += " km";
+ ui->labAz->setText (t);
+ } else {
+ if (m_hisGrid.size ()) {
+ m_hisGrid.clear ();
+ ui->labAz->clear ();
+ statusUpdate ();
+ }
+ }
+}
+
+void MainWindow::on_genStdMsgsPushButton_clicked() //genStdMsgs button
+{
+ genStdMsgs(m_rpt);
+}
+
+void MainWindow::cease_auto_Tx_after_QSO ()
+{
+ if (SpecOp::FOX != m_specOp
+ && ui->cbAutoSeq->isVisible () && ui->cbAutoSeq->isEnabled () && ui->cbAutoSeq->isChecked ())
+ {
+ // ensure that auto Tx is disabled even if disable Tx
+ // on 73 is not checked, unless in Fox mode where it is allowed
+ // to be a robot.
+ auto_tx_mode (false);
+ }
+}
+
+void MainWindow::on_logQSOButton_clicked() //Log QSO button
+{
+ cease_auto_Tx_after_QSO ();
+
+ if (!m_hisCall.size ()) {
+ MessageBox::warning_message (this, tr ("Warning: DX Call field is empty."));
+ }
+ // m_dateTimeQSOOn should really already be set but we'll ensure it gets set to something just in case
+ if (!m_dateTimeQSOOn.isValid ()) {
+ m_dateTimeQSOOn = QDateTime::currentDateTimeUtc();
+ }
+ auto dateTimeQSOOff = QDateTime::currentDateTimeUtc();
+ if (dateTimeQSOOff < m_dateTimeQSOOn) dateTimeQSOOff = m_dateTimeQSOOn;
+ QString grid=m_hisGrid;
+ if(grid=="....") grid="";
+
+ switch( m_specOp )
+ {
+ case SpecOp::NA_VHF:
+ m_xSent=m_config.my_grid().left(4);
+ m_xRcvd=m_hisGrid.left(4);
+ break;
+ case SpecOp::EU_VHF:
+ m_rptSent=m_xSent.split(" ").at(0).left(2);
+ m_rptRcvd=m_xRcvd.split(" ").at(0).left(2);
+ if(m_xRcvd.split(" ").size()>=2) m_hisGrid=m_xRcvd.split(" ").at(1);
+ grid=m_hisGrid;
+ ui->dxGridEntry->setText(grid);
+ break;
+ case SpecOp::FIELD_DAY:
+ m_rptSent=m_xSent.split(" ").at(0);
+ m_rptRcvd=m_xRcvd.split(" ").at(0);
+ break;
+ case SpecOp::RTTY:
+ m_rptSent=m_xSent.split(" ").at(0);
+ m_rptRcvd=m_xRcvd.split(" ").at(0);
+ break;
+ case SpecOp::WW_DIGI:
+ m_xSent=m_config.my_grid().left(4);
+ m_xRcvd=m_hisGrid.left(4);
+ break;
+ case SpecOp::ARRL_DIGI:
+ m_xSent=m_config.my_grid().left(4);
+ m_xRcvd=m_hisGrid.left(4);
+ break;
+ case SpecOp::Q65_PILEUP:
+ m_xSent=m_config.my_grid().left(4);
+ m_xRcvd=m_hisGrid;
+ break;
+ default: break;
+ }
+
+ m_logDlg->initLogQSO (m_hisCall, grid, m_mode, m_rptSent, m_rptRcvd,
+ m_dateTimeQSOOn, dateTimeQSOOff, m_freqNominal +
+ ui->TxFreqSpinBox->value(), m_noSuffix, m_xSent, m_xRcvd);
+ m_inQSOwith="";
+ stopWRTimer.stop(); // stop a running Tx3 timer
+}
+
+void MainWindow::acceptQSO (QDateTime const& QSO_date_off, QString const& call, QString const& grid
+ , Frequency dial_freq, QString const& mode
+ , QString const& rpt_sent, QString const& rpt_received
+ , QString const& tx_power, QString const& comments
+ , QString const& name, QDateTime const& QSO_date_on, QString const& operator_call
+ , QString const& my_call, QString const& my_grid
+ , QString const& exchange_sent, QString const& exchange_rcvd
+ , QString const& propmode, QByteArray const& ADIF)
+{
+ QString date = QSO_date_on.toString("yyyyMMdd");
+ if (!m_logBook.add (call, grid, m_config.bands()->find(dial_freq), mode, ADIF))
+ {
+ MessageBox::warning_message (this, tr ("Log file error"),
+ tr ("Cannot open \"%1\"").arg (m_logBook.path ()));
+ }
+
+ m_messageClient->qso_logged (QSO_date_off, call, grid, dial_freq, mode, rpt_sent, rpt_received
+ , tx_power, comments, name, QSO_date_on, operator_call, my_call, my_grid
+ , exchange_sent, exchange_rcvd, propmode);
+ m_messageClient->logged_ADIF (ADIF);
+
+ // Log to N1MM Logger
+ if (m_config.broadcast_to_n1mm () && m_config.valid_n1mm_info ())
+ {
+ QUdpSocket sock;
+ if (-1 == sock.writeDatagram (ADIF + " <eor>"
+ , QHostAddress {m_config.n1mm_server_name ()}
+ , m_config.n1mm_server_port ()))
+ {
+ MessageBox::warning_message (this, tr ("Error sending log to N1MM"),
+ tr ("Write returned \"%1\"").arg (sock.errorString ()));
+ }
+ }
+
+ if(m_config.clear_DX () and SpecOp::HOUND != m_specOp) clearDX ();
+ m_dateTimeQSOOn = QDateTime {};
+ if(m_specOp!=SpecOp::NONE and m_specOp!=SpecOp::FOX and m_specOp!=SpecOp::HOUND) {
+ ui->sbSerialNumber->setValue(ui->sbSerialNumber->value() + 1);
+ }
+
+ if(m_ActiveStationsWidget!=NULL) {
+ if(m_mode=="Q65") {
+ m_score++;
+ m_EMEworked[call]=true;
+ if(m_specOp==SpecOp::Q65_PILEUP) {
+ rm_q3list_(const_cast<char *> (m_deCall.toLatin1().constData()), m_deCall.size());
+ refreshPileupList();
+ }
+ m_ActiveStationsWidget->setRate(m_score);
+ } else if (m_specOp==SpecOp::ARRL_DIGI) {
+ QString band=m_config.bands()->find(dial_freq);
+ activeWorked(call,band);
+ int points=m_activeCall[call].points;
+ m_score += points;
+ ARRL_logged al;
+ al.time=QDateTime::currentDateTimeUtc();
+ al.band=band;
+ al.points=points;
+ m_arrl_log.append(al);
+ updateRate();
+ }
+ }
+
+ m_xSent.clear ();
+ m_xRcvd.clear ();
+
+}
+
+void MainWindow::updateRate()
+{
+ int iz=m_arrl_log.size();
+ int rate=0;
+ int nbc=0;
+ double hrDiff;
+
+ for(int i=iz-1; i>=0; i--) {
+ hrDiff = m_arrl_log[i].time.msecsTo(QDateTime::currentDateTimeUtc())/3600000.0;
+ if(hrDiff > 1.0) break;
+ rate += m_arrl_log[i].points;
+ if(i<iz-1 and m_arrl_log[i].band != m_arrl_log[i+1].band) nbc += 1;
+ }
+ m_ActiveStationsWidget->setRate(rate);
+ m_ActiveStationsWidget->setScore(m_score);
+ m_ActiveStationsWidget->setBandChanges(nbc);
+}
+
+qint64 MainWindow::nWidgets(QString t)
+{
+ Q_ASSERT(t.length()==N_WIDGETS);
+ qint64 n=0;
+ for(int i=0; i<N_WIDGETS; i++) {
+ n=n + n + t.mid(i,1).toInt();
+ }
+ return n;
+}
+
+void MainWindow::displayWidgets(qint64 n)
+{
+ /* See text file "displayWidgets.txt" for widget numbers */
+ qint64 j=qint64(1)<<(N_WIDGETS-1);
+ bool b;
+ for(int i=0; i<N_WIDGETS; i++) {
+ b=(n&j) != 0;
+ if(i==0) ui->txFirstCheckBox->setVisible(b);
+ if(i==1) ui->TxFreqSpinBox->setVisible(b);
+ if(i==2) ui->RxFreqSpinBox->setVisible(b);
+ if(i==3) ui->sbFtol->setVisible(b);
+ if(i==4) ui->rptSpinBox->setVisible(b);
+ if(i==5) ui->sbTR->setVisible(b);
+ if(i==6) {
+ ui->sbCQTxFreq->setVisible (b);
+ ui->cbCQTx->setVisible (b);
+ auto is_compound = m_config.my_callsign () != m_baseCall;
+ ui->cbCQTx->setEnabled (b && (!is_compound || shortList (m_config.my_callsign ())));
+ }
+ if(i==7) ui->cbShMsgs->setVisible(b);
+ if(i==8) ui->cbFast9->setVisible(b);
+ if(i==9) ui->cbAutoSeq->setVisible(b);
+ if(i==10) ui->cbTx6->setVisible(b);
+ // if(i==11) ui->pbTxMode->setVisible(b);
+ if(i==12) ui->pbR2T->setVisible(b);
+ if(i==13) ui->pbT2R->setVisible(b);
+ if(i==14) ui->cbHoldTxFreq->setVisible(b);
+ if(i==15) ui->sbSubmode->setVisible(b);
+ if(i==16) ui->syncSpinBox->setVisible(b);
+ if(i==17) ui->WSPR_controls_widget->setVisible(b);
+ if(i==18) ui->ClrAvgButton->setVisible(b);
+ if(i==19) ui->actionQuickDecode->setEnabled(b);
+ if(i==19) ui->actionMediumDecode->setEnabled(b);
+ if(i==19) ui->actionDeepestDecode->setEnabled(b);
+ if(i==20) ui->actionInclude_averaging->setVisible (b);
+ if(i==21) ui->actionInclude_correlation->setVisible (b);
+ if(i==22) {
+ if(!b && m_echoGraph->isVisible()) m_echoGraph->hide();
+ }
+ if(i==23) ui->cbSWL->setVisible(b);
+ if(i==24) ui->actionEnable_AP_FT8->setVisible (b);
+ if(i==25) ui->actionEnable_AP_JT65->setVisible (b);
+ if(i==26) ui->actionEnable_AP_DXcall->setVisible (b);
+ if(i==27) ui->respondComboBox->setVisible(b);
+ if(i==29) ui->measure_check_box->setVisible(b);
+ if(i==30) ui->labDXped->setVisible(b);
+ if(i==31) ui->cbRxAll->setVisible(b);
+ if(i==32) ui->cbCQonly->setVisible(b);
+ if(i==33) ui->sbTR_FST4W->setVisible(b);
+ if (34 == i) // adjust the stacked widget
+ {
+ ui->opt_controls_stack->setCurrentIndex (b ? 1 : 0);
+ ui->sbF_Low->setVisible(b);
+ }
+ if(i==35) ui->sbF_High->setVisible(b);
+ if(i==36) ui->actionAuto_Clear_Avg->setVisible (b);
+ if(i==37) ui->sbMaxDrift->setVisible(b);
+ j=j>>1;
+ }
+ ui->pbBestSP->setVisible(m_mode=="FT4");
+ b=false;
+ if(m_mode=="FT4" or m_mode=="FT8" || "Q65" == m_mode) {
+ b=SpecOp::EU_VHF==m_specOp or
+ ( SpecOp::RTTY==m_specOp and
+ (m_config.RTTY_Exchange()=="DX" or m_config.RTTY_Exchange()=="#") );
+ }
+ if(m_mode=="MSK144") b=SpecOp::EU_VHF==m_specOp;
+ ui->sbEchoAvg->setVisible(m_mode=="Echo");
+ ui->sbSerialNumber->setVisible(b);
+ m_lastCallsign.clear (); // ensures Tx5 is updated for new modes
+ b=m_mode.startsWith("FST4");
+ ui->sbNB->setVisible(b);
+ genStdMsgs (m_rpt, true);
+ configActiveStations();
+}
+
+void MainWindow::on_actionFST4_triggered()
+{
+ QTimer::singleShot (50, [=] {
+ ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq_old",1500).toInt());
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq_old",1500).toInt());
+ on_sbSubmode_valueChanged(ui->sbSubmode->value());
+ });
+ m_mode="FST4";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ ui->actionFST4->setChecked(true);
+ m_bFast9=false;
+ m_bFastMode=false;
+ m_fastGraph->hide();
+ m_wideGraph->show();
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize(m_FFTSize);
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->rh_decodes_title_label->setText(tr ("Rx Frequency"));
+ WSPR_config(false);
+ if(m_config.single_decode()) {
+// 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11111100010011100001000000010000000000"));
+ m_wideGraph->setSingleDecode(true);
+ } else {
+ displayWidgets(nWidgets("11101100010011100001000000010000001100"));
+ m_wideGraph->setSingleDecode(false);
+ ui->sbFtol->setValue(20);
+ }
+ setup_status_bar(false);
+ ui->cbAutoSeq->setChecked(true);
+ m_wideGraph->setMode(m_mode);
+ m_wideGraph->setPeriod(m_TRperiod,6912);
+ m_wideGraph->setRxFreq(ui->RxFreqSpinBox->value());
+ m_wideGraph->setTol(ui->sbFtol->value());
+ m_wideGraph->setTxFreq(ui->TxFreqSpinBox->value());
+ m_wideGraph->setFST4_FreqRange(ui->sbF_Low->value(),ui->sbF_High->value());
+ chk_FST4_freq_range();
+ switch_mode (Modes::FST4);
+ m_wideGraph->setMode(m_mode);
+ ui->sbTR->values ({15, 30, 60, 120, 300, 900, 1800});
+ ui->sbTR->setValue (m_settings->value ("TRPeriod_FST4", 60).toInt()); // remember sbTR settings by mode
+ QTimer::singleShot (50, [=] {on_sbTR_valueChanged (ui->sbTR->value());});
+ statusChanged();
+ m_bOK_to_chk=true;
+ chk_FST4_freq_range();
+}
+
+void MainWindow::on_actionFST4W_triggered()
+{
+ m_mode="FST4W";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ ui->actionFST4W->setChecked(true);
+ m_bFast9=false;
+ m_bFastMode=false;
+ m_fastGraph->hide();
+ m_wideGraph->show();
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize(m_FFTSize);
+ WSPR_config(true);
+// 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("00000000000000000101000000000000010000"));
+ setup_status_bar(false);
+ ui->band_hopping_group_box->setChecked(false);
+ ui->band_hopping_group_box->setVisible(false);
+ on_sbTR_FST4W_valueChanged (ui->sbTR_FST4W->value ());
+ ui->WSPRfreqSpinBox->setMinimum(100);
+ ui->WSPRfreqSpinBox->setMaximum(5000);
+ m_wideGraph->setMode(m_mode);
+ m_wideGraph->setPeriod(m_TRperiod,6912);
+ m_wideGraph->setTxFreq(ui->WSPRfreqSpinBox->value());
+ m_wideGraph->setRxFreq(ui->sbFST4W_RxFreq->value());
+ m_wideGraph->setTol(ui->sbFST4W_FTol->value());
+ ui->sbFtol->setValue(100);
+ switch_mode (Modes::FST4W);
+ statusChanged();
+}
+
+void MainWindow::on_actionFT4_triggered()
+{
+ QTimer::singleShot (50, [=] {
+ ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq_old",1500).toInt());
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq_old",1500).toInt());
+ on_sbSubmode_valueChanged(ui->sbSubmode->value());
+ });
+ m_mode="FT4";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ m_TRperiod=7.5;
+ bool bVHF=m_config.enable_VHF_features();
+ m_bFast9=false;
+ m_bFastMode=false;
+ WSPR_config(false);
+ switch_mode (Modes::FT4);
+ m_nsps=6912;
+ m_FFTSize = m_nsps/2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=21;
+ setup_status_bar (bVHF);
+ m_toneSpacing=12000.0/576.0;
+ ui->actionFT4->setChecked(true);
+ m_wideGraph->setMode(m_mode);
+ m_send_RR73=true;
+ VHF_features_enabled(bVHF);
+ ui->cbAutoSeq->setChecked(true);
+ m_fastGraph->hide();
+ m_wideGraph->show();
+ ui->rh_decodes_headings_label->setText(" UTC dB DT Freq " + tr ("Message"));
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ ui->rh_decodes_title_label->setText(tr ("Rx Frequency"));
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->lh_decodes_headings_label->setText( " UTC dB DT Freq " + tr ("Message"));
+// 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11101000010011100001000000011000100000"));
+ ui->txrb2->setEnabled(true);
+ ui->txrb4->setEnabled(true);
+ ui->txrb5->setEnabled(true);
+ ui->txrb6->setEnabled(true);
+ ui->txb2->setEnabled(true);
+ ui->txb4->setEnabled(true);
+ ui->txb5->setEnabled(true);
+ ui->txb6->setEnabled(true);
+ ui->txFirstCheckBox->setEnabled(true);
+ chkFT4();
+ statusChanged();
+}
+
+void MainWindow::on_actionFT8_triggered()
+{
+ QTimer::singleShot (50, [=] {
+ if(m_specOp!=SpecOp::FOX) ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq_old",1500).toInt());
+ if(m_specOp==SpecOp::FOX && !m_config.superFox()) ui->TxFreqSpinBox->setValue(m_TxFreqFox);
+ if(SpecOp::HOUND == m_specOp && m_config.superFox() &&
+ (ui->RxFreqSpinBox->value() < 700 or ui->RxFreqSpinBox->value() > 800)) {
+ ui->RxFreqSpinBox->setValue(750);
+ } else {
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq_old",1500).toInt());
+ }
+ on_sbSubmode_valueChanged(ui->sbSubmode->value());
+ });
+ m_mode="FT8";
+ bool bVHF=m_config.enable_VHF_features();
+ m_bFast9=false;
+ m_bFastMode=false;
+ WSPR_config(false);
+ m_nsps=6912;
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=50;
+ setup_status_bar (bVHF);
+ m_toneSpacing=0.0; //???
+ ui->actionFT8->setChecked(true); //???
+ m_wideGraph->setMode(m_mode);
+ VHF_features_enabled(bVHF);
+ ui->cbAutoSeq->setChecked(true);
+ m_TRperiod=15.0;
+ ui->sbFtol->setValue (m_settings->value ("Ftol_SF", 50).toInt()); // restore last used Ftol parameter
+ m_fastGraph->hide();
+ m_wideGraph->show();
+ ui->rh_decodes_headings_label->setText(" UTC dB DT Freq " + tr ("Message"));
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ ui->rh_decodes_title_label->setText(tr ("Rx Frequency"));
+ if(SpecOp::FOX==m_specOp) {
+ ui->lh_decodes_title_label->setText(tr ("Stations calling DXpedition %1").arg (m_config.my_callsign()));
+ ui->lh_decodes_headings_label->setText( "Call Grid dB Freq Dist Age Cont Score");
+ } else {
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->lh_decodes_headings_label->setText( " UTC dB DT Freq " + tr ("Message"));
+ }
+// 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11101000010011100001000010011000100000"));
+ ui->txrb2->setEnabled(true);
+ ui->txrb4->setEnabled(true);
+ ui->txrb5->setEnabled(true);
+ ui->txrb6->setEnabled(true);
+ ui->txb2->setEnabled(true);
+ ui->txb4->setEnabled(true);
+ ui->txb5->setEnabled(true);
+ ui->txb6->setEnabled(true);
+ ui->txFirstCheckBox->setEnabled(true);
+ ui->cbAutoSeq->setEnabled(true);
+ if(SpecOp::FOX==m_specOp) {
+ ui->txFirstCheckBox->setChecked(true);
+ ui->txFirstCheckBox->setEnabled(false);
+ ui->cbHoldTxFreq->setChecked(true);
+ ui->cbAutoSeq->setEnabled(false);
+ ui->tabWidget->setCurrentIndex(1);
+ m_wideGraph->setSuperFox(false);
+ if(m_config.superFox()) {
+ ui->TxFreqSpinBox->setValue(750); //SuperFox transmits at 750 Hz
+ m_wideGraph->setSuperFox(true);
+ } else {
+ ui->TxFreqSpinBox->setValue(500);
+ }
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11101000010011100001000000000011000000"));
+ ui->cbRxAll->setText(tr("Show Already Worked"));
+ if(m_config.superFox()) {
+ ui->labDXped->setText(tr ("Super Fox"));
+ } else {
+ ui->labDXped->setText(tr ("Fox"));
+ }
+ on_fox_log_action_triggered();
+ if (m_ActiveStationsWidget) m_ActiveStationsWidget->setClickOK(true); // allow clicks
+ }
+ if(SpecOp::HOUND == m_specOp) {
+ ui->houndButton->setChecked(true);
+ ui->txFirstCheckBox->setChecked(false);
+ ui->txFirstCheckBox->setEnabled(false);
+ ui->cbAutoSeq->setEnabled(false);
+ ui->tabWidget->setCurrentIndex(0);
+ ui->cbHoldTxFreq->setChecked(true);
+ m_wideGraph->setSuperHound(false);
+ if(m_config.superFox()) {
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11111000010011000001000000000011000000"));
+ ui->labDXped->setText(tr ("Super Hound"));
+ ui->cbRxAll->setEnabled(false);
+ m_wideGraph->setRxFreq(ui->RxFreqSpinBox->value());
+ m_wideGraph->setTol(ui->sbFtol->value());
+ m_wideGraph->setSuperHound(true);
+ } else {
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11101000010011000001000000000011000000"));
+ ui->labDXped->setText(tr ("Hound"));
+ ui->cbRxAll->setEnabled(true);
+ m_wideGraph->setSuperHound(false);
+ }
+ ui->txrb1->setChecked(true);
+ ui->txrb2->setEnabled(false);
+ ui->txrb4->setEnabled(false);
+ ui->txrb5->setEnabled(false);
+ ui->txrb6->setEnabled(false);
+ ui->txb2->setEnabled(false);
+ ui->txb4->setEnabled(false);
+ ui->txb5->setEnabled(false);
+ ui->txb6->setEnabled(false);
+ if (m_ActiveStationsWidget) m_ActiveStationsWidget->setClickOK(false);
+ } else {
+ switch_mode (Modes::FT8);
+ }
+ if(m_specOp != SpecOp::HOUND) {
+ ui->houndButton->setChecked(false);
+ m_wideGraph->setSuperHound(false);
+ }
+
+ m_specOp=m_config.special_op_id();
+ if(m_specOp!=SpecOp::NONE and m_specOp!=SpecOp::FOX and m_specOp!=SpecOp::HOUND) {
+ QString t0="";
+ if(SpecOp::NA_VHF==m_specOp) t0="NA VHF";
+ if(SpecOp::EU_VHF==m_specOp) t0="EU VHF";
+ if(SpecOp::FIELD_DAY==m_specOp) t0="Field Day";
+ if(SpecOp::RTTY==m_specOp) t0="FT RU";
+ if(SpecOp::WW_DIGI==m_specOp) t0="WW Digi";
+ if(SpecOp::ARRL_DIGI==m_specOp) t0="ARRL Digi";
+ if(SpecOp::Q65_PILEUP==m_specOp) t0="Q65 Pileup";
+ if(t0=="") {
+ ui->labDXped->setVisible(false);
+ } else {
+ ui->labDXped->setVisible(true);
+ ui->labDXped->setText(t0);
+ }
+ if(m_specOp!=SpecOp::Q65_PILEUP) on_contest_log_action_triggered();
+ }
+
+ if((SpecOp::FOX==m_specOp or SpecOp::HOUND==m_specOp) and !m_config.superFox() and !m_config.split_mode() and !m_bWarnedSplit) {
+ QString errorMsg;
+ MessageBox::critical_message (this,
+ "Operation in FT8 DXpedition mode normally requires\n"
+ " *Split* rig control (either *Rig* or *Fake It* on\n"
+ "the *Settings | Radio* tab.)", errorMsg);
+ m_bWarnedSplit=true;
+ }
+ if (ui->labDXped->isVisible()) ui->labDXped->setStyleSheet("QLabel {background-color: red; color: white;}");
+ statusChanged();
+ configActiveStations();
+}
+
+void MainWindow::on_actionJT4_triggered()
+{
+ QTimer::singleShot (50, [=] {
+ ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq_old",1500).toInt());
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq_old",1500).toInt());
+ });
+ m_mode="JT4";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ bool bVHF=m_config.enable_VHF_features();
+ WSPR_config(false);
+ switch_mode (Modes::JT4);
+ m_TRperiod=60.0;
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=176;
+ if(m_config.decode_at_52s()) m_hsymStop=184;
+ m_toneSpacing=0.0;
+ ui->actionJT4->setChecked(true);
+ VHF_features_enabled(true);
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ m_wideGraph->setMode(m_mode);
+ m_bFastMode=false;
+ m_bFast9=false;
+ setup_status_bar (bVHF);
+ ui->sbSubmode->setMaximum(6);
+ ui->lh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ ui->rh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ if(bVHF) {
+ // restore last used parameters
+ ui->sbFtol->setValue (m_settings->value ("Ftol_JT4", 50).toInt());
+ m_nSubMode=m_settings->value("SubMode_JT4",0).toInt();
+ ui->sbSubmode->setValue(m_settings->value("SubMode_JT4",0).toInt());
+ QTimer::singleShot (50, [=] {on_sbSubmode_valueChanged(ui->sbSubmode->value());});
+ m_bShMsgs=m_settings->value("ShMsgs_JT4",false).toBool();
+ ui->cbShMsgs->setChecked(m_bShMsgs);
+ } else {
+ ui->sbSubmode->setValue(0);
+ }
+ if(bVHF) {
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11111001001011011011110000000000000000"));
+ } else {
+ displayWidgets(nWidgets("11101000000011000011000000000000000000"));
+ }
+ fast_config(false);
+ statusChanged();
+}
+
+void MainWindow::on_actionJT9_triggered()
+{
+ m_mode="JT9";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ bool bVHF=m_config.enable_VHF_features();
+ // restore last used parameters
+ if(bVHF && m_mode!="JT65" && !blocked) {
+ ui->sbSubmode->setMaximum(7);
+ m_bFast9=m_settings->value("JT9_Fast",false).toBool();
+ ui->cbFast9->setChecked(m_bFast9 or m_bFastMode);
+ ui->sbFtol->setValue (m_settings->value ("Ftol_JT9", 50).toInt());
+ m_nSubMode=m_settings->value("SubMode",0).toInt();
+ ui->sbSubmode->setValue(m_nSubMode);
+ QTimer::singleShot (50, [=] {
+ on_sbTR_valueChanged (ui->sbTR->value());
+ on_sbSubmode_valueChanged(ui->sbSubmode->value());
+ });
+ }
+// m_bFast9=ui->cbFast9->isChecked();
+ m_bFastMode=m_bFast9;
+ WSPR_config(false);
+ switch_mode (Modes::JT9);
+ m_nsps=6912;
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=173;
+ if(m_config.decode_at_52s()) m_hsymStop=179;
+ setup_status_bar (bVHF);
+ m_toneSpacing=0.0;
+ ui->actionJT9->setChecked(true);
+ m_wideGraph->setMode(m_mode);
+ VHF_features_enabled(bVHF);
+ if(m_nSubMode>=4 and bVHF) {
+ ui->cbFast9->setEnabled(true);
+ } else {
+ ui->cbFast9->setEnabled(false);
+ ui->cbFast9->setChecked(false);
+ }
+ ui->sbSubmode->setMaximum(7);
+ if(m_bFast9) {
+ ui->sbTR->values ({5, 10, 15, 30});
+ if(bVHF && m_mode!="JT65" && !blocked) ui->sbTR->setValue (m_settings->value ("TRPeriod", 15).toInt()); // restore last used TRperiod
+ on_sbTR_valueChanged (ui->sbTR->value());
+ m_wideGraph->hide();
+ m_fastGraph->showNormal();
+ ui->TxFreqSpinBox->setValue(700);
+ ui->RxFreqSpinBox->setValue(700);
+ ui->lh_decodes_headings_label->setText(" UTC dB T Freq " + tr ("Message"));
+ ui->rh_decodes_headings_label->setText(" UTC dB T Freq " + tr ("Message"));
+ } else {
+ ui->cbAutoSeq->setChecked(false);
+ if (m_mode != "FST4")
+ {
+ m_TRperiod=60.0;
+ ui->lh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ ui->rh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ }
+ }
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->rh_decodes_title_label->setText(tr ("Rx Frequency"));
+ if(bVHF) {
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11111010100011111001000000000000000000"));
+ } else {
+ displayWidgets(nWidgets("11101000000011100001000000000000100000"));
+ }
+ fast_config(m_bFastMode);
+ ui->cbAutoSeq->setVisible(m_bFast9);
+ statusChanged();
+}
+
+void MainWindow::on_actionJT65_triggered()
+{
+ QTimer::singleShot (50, [=] {
+ ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq_old",1500).toInt());
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq_old",1500).toInt());
+ });
+ on_actionJT9_triggered();
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ m_mode="JT65";
+ bool bVHF=m_config.enable_VHF_features();
+ WSPR_config(false);
+ switch_mode (Modes::JT65);
+ m_TRperiod=60.0;
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=174;
+ if(m_config.decode_at_52s()) m_hsymStop=183;
+ m_toneSpacing=0.0;
+ ui->actionJT65->setChecked(true);
+ VHF_features_enabled(bVHF);
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ m_wideGraph->setMode(m_mode);
+ m_wideGraph->setRxFreq(ui->RxFreqSpinBox->value());
+ m_wideGraph->setTol(ui->sbFtol->value());
+ m_wideGraph->setTxFreq(ui->TxFreqSpinBox->value());
+ setup_status_bar (bVHF);
+ m_bFastMode=false;
+ m_bFast9=false;
+ ui->sbSubmode->setMaximum(2);
+ if(bVHF) {
+ // restore last used parameters
+ ui->sbFtol->setValue (m_settings->value ("Ftol_JT65", 50).toInt());
+ m_nSubMode=m_settings->value("SubMode_JT65",0).toInt();
+ ui->sbSubmode->setValue(m_settings->value("SubMode_JT65",0).toInt());
+ QTimer::singleShot (50, [=] {on_sbSubmode_valueChanged(ui->sbSubmode->value());});
+ m_bShMsgs=m_settings->value("ShMsgs_JT65",false).toBool();
+ ui->cbShMsgs->setChecked(m_bShMsgs);
+ } else {
+ ui->sbSubmode->setValue(0);
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->rh_decodes_title_label->setText(tr ("Rx Frequency"));
+ }
+ if(bVHF) {
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11111001000011011010110001000000000000"));
+ } else {
+ displayWidgets(nWidgets("11101000000011100001000000000000100000"));
+ }
+ fast_config(false);
+ if(ui->cbShMsgs->isChecked()) {
+ ui->cbAutoSeq->setChecked(false);
+ ui->cbAutoSeq->setVisible(false);
+ }
+ statusChanged();
+}
+
+void MainWindow::on_actionQ65_triggered()
+{
+ QTimer::singleShot (50, [=] {
+ ui->TxFreqSpinBox->setValue(m_settings->value("TxFreq_old",1500).toInt());
+ ui->RxFreqSpinBox->setValue(m_settings->value("RxFreq_old",1500).toInt());
+ });
+ m_mode="Q65";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ ui->actionQ65->setChecked(true);
+ switch_mode(Modes::Q65);
+ ui->cbAutoSeq->setChecked(true);
+ fast_config(false);
+ WSPR_config(false);
+ setup_status_bar(true);
+ m_bFastMode=false;
+ m_bFast9=false;
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize(m_FFTSize);
+ m_hsymStop=49;
+ ui->sbTR->values ({15, 30, 60, 120, 300});
+ // restore last used parameters
+ ui->sbTR->setValue (m_settings->value ("TRPeriod_Q65", 30).toInt());
+ ui->sbFtol->setValue (m_settings->value ("Ftol_Q65", 50).toInt());
+ m_nSubMode=m_settings->value("SubMode_Q65",0).toInt();
+ ui->sbSubmode->setValue(m_settings->value("SubMode_Q65",0).toInt());
+ QTimer::singleShot (50, [=] {
+ on_sbTR_valueChanged (ui->sbTR->value());
+ on_sbSubmode_valueChanged(ui->sbSubmode->value());
+ });
+ m_bShMsgs=m_settings->value("ShMsgs_Q65",false).toBool();
+ ui->cbShMsgs->setChecked(m_bShMsgs);
+ QString fname {QDir::toNativeSeparators(m_config.temp_dir().absoluteFilePath ("red.dat"))};
+ m_wideGraph->setRedFile(fname);
+ m_wideGraph->setMode(m_mode);
+ m_wideGraph->setPeriod(m_TRperiod,6912);
+ m_wideGraph->setTol(ui->sbFtol->value());
+ m_wideGraph->setRxFreq(ui->RxFreqSpinBox->value());
+ m_wideGraph->setTxFreq(ui->TxFreqSpinBox->value());
+ switch_mode (Modes::Q65);
+// 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("11111101011011010011100000010000000011"));
+ ui->lh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ ui->rh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+
+ m_specOp=m_config.special_op_id();
+ if(m_specOp!=SpecOp::NONE and m_specOp!=SpecOp::FOX and m_specOp!=SpecOp::HOUND) {
+ QString t0="";
+ if(SpecOp::NA_VHF==m_specOp) t0="NA VHF";
+ if(SpecOp::EU_VHF==m_specOp) t0="EU VHF";
+ if(SpecOp::FIELD_DAY==m_specOp) t0="Field Day";
+ if(SpecOp::RTTY==m_specOp) t0="FT RU";
+ if(SpecOp::WW_DIGI==m_specOp) t0="WW Digi";
+ if(SpecOp::ARRL_DIGI==m_specOp) t0="ARRL Digi";
+ if(SpecOp::Q65_PILEUP==m_specOp) t0="Q65 Pileup";
+ if(t0=="") {
+ ui->labDXped->setVisible(false);
+ } else {
+ ui->labDXped->setVisible(true);
+ ui->labDXped->setText(t0);
+ }
+ if(m_specOp!=SpecOp::Q65_PILEUP) {
+ on_contest_log_action_triggered();
+ } else {
+ if(ui->txrb1->isChecked()) on_txb2_clicked();
+ ui->tx1->setEnabled(true);
+ ui->txb1->setEnabled(true);
+ }
+ }
+ statusChanged();
+}
+
+void MainWindow::on_actionMSK144_triggered()
+{
+ if(SpecOp::EU_VHF < m_specOp) {
+// We are rejecting the requested mode change, so re-check the old mode
+ if("FT8"==m_mode) ui->actionFT8->setChecked(true);
+ if("JT4"==m_mode) ui->actionJT4->setChecked(true);
+ if("JT9"==m_mode) ui->actionJT9->setChecked(true);
+ if("JT65"==m_mode) ui->actionJT65->setChecked(true);
+ if("Q65"==m_mode) ui->actionQ65->setChecked(true);
+ if("WSPR"==m_mode) ui->actionWSPR->setChecked(true);
+ if("Echo"==m_mode) ui->actionEcho->setChecked(true);
+ if("FreqCal"==m_mode) ui->actionFreqCal->setChecked(true);
+ if("FST4"==m_mode) ui->actionFST4->setChecked(true);
+ if("FST4W"==m_mode) ui->actionFST4W->setChecked(true);
+// Make sure that MSK144 is not checked.
+ ui->actionMSK144->setChecked(false);
+ MessageBox::warning_message (this, tr ("Improper mode"),
+ "MSK144 not available if Fox, Hound, Field Day, FT Roundup, WW Digi. or ARRL Digi contest is selected.");
+ return;
+ }
+ m_mode="MSK144";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ ui->actionMSK144->setChecked(true);
+ switch_mode (Modes::MSK144);
+ m_nsps=6;
+ m_FFTSize = 7 * 512;
+ Q_EMIT FFTSize (m_FFTSize);
+ setup_status_bar (true);
+ m_toneSpacing=0.0;
+ WSPR_config(false);
+ VHF_features_enabled(true);
+ ui->cbAutoSeq->setChecked(true);
+ m_bFastMode=true;
+ m_bFast9=false;
+ ui->sbTR->values ({5, 10, 15, 30});
+ ui->sbTR->setValue (m_settings->value ("TRPeriod_MSK144", 15).toInt()); // restore last used TRperiod
+ QTimer::singleShot (50, [=] {on_sbTR_valueChanged (ui->sbTR->value());});
+ m_bShMsgs=m_settings->value("ShMsgs_MSK144",false).toBool();
+ ui->cbShMsgs->setChecked(m_bShMsgs);
+ m_wideGraph->hide();
+ m_fastGraph->showNormal();
+ ui->TxFreqSpinBox->setValue(1500);
+ ui->RxFreqSpinBox->setValue(1500);
+ ui->RxFreqSpinBox->setMinimum(1400);
+ ui->RxFreqSpinBox->setMaximum(1600);
+ ui->RxFreqSpinBox->setSingleStep(10);
+ ui->lh_decodes_headings_label->setText(" UTC dB T Freq " + tr ("Message"));
+ ui->rh_decodes_headings_label->setText(" UTC dB T Freq " + tr ("Message"));
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_fastGraph->setTRPeriod(m_TRperiod);
+ ui->lh_decodes_title_label->setText(tr ("Band Activity"));
+ ui->rh_decodes_title_label->setText(tr ("Tx Messages"));
+ ui->actionMSK144->setChecked(true);
+ ui->rptSpinBox->setMinimum(-8);
+ ui->rptSpinBox->setMaximum(24);
+ ui->rptSpinBox->setValue(0);
+ ui->rptSpinBox->setSingleStep(1);
+ ui->sbFtol->values ({20, 50, 100, 200});
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("10111111010000000001000100001000000000"));
+ fast_config(m_bFastMode);
+ statusChanged();
+
+ QString t0="";
+ if(SpecOp::NA_VHF==m_specOp) t0="NA VHF";
+ if(SpecOp::EU_VHF==m_specOp) t0="EU VHF";
+ if(t0=="") {
+ ui->labDXped->setVisible(false);
+ } else {
+ ui->labDXped->setVisible(true);
+ ui->labDXped->setText(t0);
+ on_contest_log_action_triggered();
+ }
+}
+
+void MainWindow::on_actionWSPR_triggered()
+{
+ m_mode="WSPR";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ WSPR_config(true);
+ switch_mode (Modes::WSPR);
+ m_TRperiod=120.0;
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=396;
+ m_toneSpacing=12000.0/8192.0;
+ setup_status_bar (false);
+ ui->actionWSPR->setChecked(true);
+ VHF_features_enabled(false);
+ ui->WSPRfreqSpinBox->setMinimum(1400);
+ ui->WSPRfreqSpinBox->setMaximum(1600);
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ m_wideGraph->setMode(m_mode);
+ m_bFastMode=false;
+ m_bFast9=false;
+ ui->TxFreqSpinBox->setValue(ui->WSPRfreqSpinBox->value());
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("00000000000000000101000000000000000000"));
+ fast_config(false);
+ statusChanged();
+}
+
+void MainWindow::on_actionEcho_triggered()
+{
+ int nd=int(m_ndepth&3);
+ on_actionJT4_triggered();
+// Don't allow decoding depth to be changed just because Echo mode was entered:
+ if(nd==1) ui->actionQuickDecode->setChecked (true);
+ if(nd==2) ui->actionMediumDecode->setChecked (true);
+ if(nd==3) ui->actionDeepestDecode->setChecked (true);
+
+ m_mode="Echo";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ ui->actionEcho->setChecked(true);
+ m_TRperiod=3.0;
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=9;
+ m_toneSpacing=1.0;
+ switch_mode(Modes::Echo);
+ setup_status_bar (true);
+ m_wideGraph->setMode(m_mode);
+ ui->TxFreqSpinBox->setValue(1500);
+ ui->TxFreqSpinBox->setEnabled (false);
+ if(!m_echoGraph->isVisible()) m_echoGraph->show();
+ if (!ui->actionAstronomical_data->isChecked ()) {
+ ui->actionAstronomical_data->setChecked (true);
+ }
+ m_bFastMode=false;
+ m_bFast9=false;
+ WSPR_config(true);
+ ui->lh_decodes_headings_label->setText(" UTC Hour Level Doppler Width N Q DF SNR dBerr");
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("00000000000000000010001000000000000000"));
+ fast_config(false);
+ ui->sbEchoAvg->values ({1, 2, 5, 10, 20, 50, 100});
+ statusChanged();
+ monitor(false);
+}
+
+void MainWindow::on_actionFreqCal_triggered()
+{
+ on_actionJT9_triggered();
+ m_mode="FreqCal";
+ if(m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ ui->actionFreqCal->setChecked(true);
+ switch_mode(Modes::FreqCal);
+ m_wideGraph->setMode(m_mode);
+ ui->sbTR->values ({5, 10, 15, 30});
+ on_sbTR_valueChanged (ui->sbTR->value());
+ m_modulator->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_detector->setTRPeriod(m_TRperiod); // TODO - not thread safe
+ m_nsps=6912; //For symspec only
+ m_FFTSize = m_nsps / 2;
+ Q_EMIT FFTSize (m_FFTSize);
+ m_hsymStop=((int(m_TRperiod/0.288))/8)*8;
+ m_frequency_list_fcal_iter = m_config.frequencies ()->begin ();
+ ui->RxFreqSpinBox->setValue(1500);
+ setup_status_bar (true);
+// 18:15:47 0 1 1500 1550.349 0.100 3.5 10.2
+ ui->lh_decodes_headings_label->setText(" UTC Freq CAL Offset fMeas DF Level S/N");
+ ui->measure_check_box->setChecked (false);
+ // 01234567890123456789012345678901234567
+ displayWidgets(nWidgets("00110100000000000000000000000100000000"));
+ statusChanged();
+}
+
+void MainWindow::switch_mode (Mode mode)
+{
+ if (m_mode != "Q65" && m_specOp==SpecOp::Q65_PILEUP) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ ui->tx1->setEnabled(true);
+ ui->txb1->setEnabled(true);
+ }
+ m_fastGraph->setMode(m_mode);
+ m_config.frequencies ()->filter (m_config.region (), mode, true); // filter on current time
+ auto const& row = m_config.frequencies ()->best_working_frequency (m_freqNominal);
+ if (!keep_frequency) {
+ ui->bandComboBox->setCurrentIndex (row);
+ if (row >= 0 ) {
+ on_bandComboBox_activated (row);
+ }
+ }
+ ui->rptSpinBox->setSingleStep(1);
+ ui->rptSpinBox->setMinimum(-50);
+ ui->rptSpinBox->setMaximum(49);
+ ui->sbFtol->values ({1, 2, 5, 10, 20, 50, 100, 200, 300, 400, 500, 1000});
+ ui->sbFST4W_FTol->values({1, 2, 5, 10, 20, 50, 100});
+ if(m_mode=="MSK144") {
+ ui->RxFreqSpinBox->setMinimum(1400);
+ ui->RxFreqSpinBox->setMaximum(1600);
+ ui->RxFreqSpinBox->setSingleStep(25);
+ } else {
+ ui->RxFreqSpinBox->setMinimum(200);
+ ui->RxFreqSpinBox->setMaximum(5000);
+ ui->RxFreqSpinBox->setSingleStep(1);
+ }
+ bool b=m_mode=="FreqCal";
+ ui->tabWidget->setVisible(!b);
+ if(b) {
+ ui->DX_controls_widget->setVisible(false);
+ ui->rh_decodes_widget->setVisible (false);
+ ui->lh_decodes_title_label->setVisible(false);
+ }
+}
+
+void MainWindow::WSPR_config(bool b)
+{
+ ui->rh_decodes_widget->setVisible(!b);
+ ui->controls_stack_widget->setCurrentIndex (b && m_mode != "Echo" ? 1 : 0);
+ ui->QSO_controls_widget->setVisible (!b);
+ ui->DX_controls_widget->setVisible (!b or (m_mode=="Echo"));
+ ui->WSPR_controls_widget->setVisible (b);
+ ui->lh_decodes_title_label->setVisible(!b and ui->cbMenus->isChecked());
+ ui->logQSOButton->setVisible(!b);
+ ui->DecodeButton->setEnabled(!b);
+ bool bFST4W=(m_mode=="FST4W");
+ ui->sbTxPercent->setEnabled(!bFST4W or (tr("Random") == ui->RoundRobin->currentText()));
+ ui->band_hopping_group_box->setVisible(true);
+ ui->RoundRobin->setVisible(bFST4W);
+ ui->sbFST4W_RxFreq->setVisible(bFST4W);
+ ui->sbFST4W_FTol->setVisible(bFST4W);
+ ui->RoundRobin->lineEdit()->setAlignment(Qt::AlignCenter);
+ if(b and m_mode!="Echo" and m_mode!="FST4W") {
+ QString t="UTC dB DT Freq Drift Call Grid dBm ";
+ if(m_config.miles()) t += " mi";
+ if(!m_config.miles()) t += " km";
+ ui->lh_decodes_headings_label->setText(t);
+ if (m_config.is_transceiver_online ()) {
+ m_config.transceiver_tx_frequency (0); // turn off split
+ }
+ m_bSimplex = true;
+ } else
+ {
+ m_bSimplex = false;
+ }
+ enable_DXCC_entity (m_config.DXCC ()); // sets text window proportions and (re)inits the logbook
+}
+
+void MainWindow::fast_config(bool b)
+{
+ m_bFastMode=b;
+ ui->TxFreqSpinBox->setEnabled(!b);
+ ui->sbTR->setVisible(b);
+ if(b and (m_bFast9 or m_mode=="MSK144")) {
+ m_wideGraph->hide();
+ m_fastGraph->showNormal();
+ } else {
+ m_wideGraph->showNormal();
+ m_fastGraph->hide();
+ }
+}
+
+void MainWindow::on_TxFreqSpinBox_valueChanged(int n)
+{
+ m_wideGraph->setTxFreq(n);
+// if (ui->cbHoldTxFreq->isChecked ()) ui->RxFreqSpinBox->setValue(n);
+ if(m_mode!="MSK144") {
+ Q_EMIT transmitFrequency (n - m_XIT);
+ }
+
+ if(m_mode=="Q65") {
+ if(((m_nSubMode==4 && m_TRperiod==60.0) || (m_nSubMode==3 && m_TRperiod==30.0) ||
+ (m_nSubMode==2 && m_TRperiod==15.0)) && ui->TxFreqSpinBox->value()!=700) {
+ ui->TxFreqSpinBox->setStyleSheet("QSpinBox{background-color:red}");
+ } else {
+ ui->TxFreqSpinBox->setStyleSheet("");
+ }
+ }
+ if (m_mode != "MSK144" && m_mode != "FST4W" && m_mode != "WSPR" && m_mode != "Echo" && m_mode != "FreqCal"
+ && m_specOp!=SpecOp::FOX) {
+ QTimer::singleShot (200, [=] {m_settings->setValue("TxFreq_old",ui->TxFreqSpinBox->value());});
+ }
+ if(m_specOp==SpecOp::FOX && !m_config.superFox()) QTimer::singleShot (50, [=] {m_TxFreqFox=n;});
+ statusUpdate ();
+}
+
+void MainWindow::on_RxFreqSpinBox_valueChanged(int n)
+{
+ m_wideGraph->setRxFreq(n);
+ if (m_mode == "FreqCal") {
+ setRig ();
+ }
+ if (m_mode != "MSK144" && m_mode != "FST4W" && m_mode != "WSPR" && m_mode != "Echo" && m_mode != "FreqCal"
+ && !(SpecOp::HOUND == m_specOp && m_config.superFox())) {
+ QTimer::singleShot (200, [=] {m_settings->setValue("RxFreq_old",ui->RxFreqSpinBox->value());});
+ }
+ statusUpdate ();
+}
+
+void MainWindow::on_sbF_Low_valueChanged(int n)
+{
+ m_wideGraph->setFST4_FreqRange(n,ui->sbF_High->value());
+ chk_FST4_freq_range();
+}
+
+void MainWindow::on_sbF_High_valueChanged(int n)
+{
+ m_wideGraph->setFST4_FreqRange(ui->sbF_Low->value(),n);
+ chk_FST4_freq_range();
+}
+
+void MainWindow::chk_FST4_freq_range()
+{
+ if(!m_bOK_to_chk) return;
+ if(ui->sbF_Low->value() < m_wideGraph->nStartFreq()) ui->sbF_Low->setValue(m_wideGraph->nStartFreq());
+ if(ui->sbF_High->value() > m_wideGraph->Fmax()) {
+ int n=m_wideGraph->Fmax()/100;
+ ui->sbF_High->setValue(100*n);
+ }
+ int maxDiff=2000;
+ if(m_TRperiod==120) maxDiff=1000;
+ if(m_TRperiod==300) maxDiff=400;
+ if(m_TRperiod>=900) maxDiff=200;
+ int diff=ui->sbF_High->value() - ui->sbF_Low->value();
+
+ if(diff<100 or diff>maxDiff) {
+ ui->sbF_Low->setStyleSheet("QSpinBox { color: white; background-color: red; }");
+ ui->sbF_High->setStyleSheet("QSpinBox { color: white; background-color: red; }");
+ } else {
+ ui->sbF_Low->setStyleSheet("");
+ ui->sbF_High->setStyleSheet("");
+ }
+}
+
+void MainWindow::on_actionQuickDecode_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000001;
+}
+
+void MainWindow::on_actionMediumDecode_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000002;
+}
+
+void MainWindow::on_actionDeepestDecode_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000003;
+}
+
+void MainWindow::on_actionInclude_averaging_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000010;
+ statusChanged();
+}
+
+void MainWindow::on_actionInclude_correlation_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000020;
+}
+
+void MainWindow::on_actionEnable_AP_DXcall_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000040;
+}
+
+void MainWindow::on_actionAuto_Clear_Avg_toggled (bool checked)
+{
+ m_ndepth ^= (-checked ^ m_ndepth) & 0x00000080;
+}
+
+void MainWindow::on_actionErase_ALL_TXT_triggered() //Erase ALL.TXT
+{
+ int ret = MessageBox::query_message (this, tr ("Confirm Erase"),
+ tr ("Are you sure you want to erase file ALL.TXT?"));
+ if(ret==MessageBox::Yes) {
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("ALL.TXT")};
+ f.remove();
+ m_RxLog=1;
+ }
+}
+
+void MainWindow::on_actionErase_list_of_Q65_callers_triggered()
+{
+ int ret = MessageBox::query_message (this, tr ("Confirm Erase"),
+ tr ("Are you sure you want to erase the list of Q65 callers?"));
+ if(ret==MessageBox::Yes) {
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("tsil.3q")};
+ f.remove();
+ }
+}
+
+
+void MainWindow::on_reset_cabrillo_log_action_triggered ()
+{
+ if (MessageBox::Yes == MessageBox::query_message (this, tr ("Confirm Reset"),
+ tr ("Are you sure you want to erase your contest log?"),
+ tr ("Doing this will remove all QSO records for the current contest. "
+ "They will be kept in the ADIF log file but will not be available "
+ "for export in your Cabrillo log.")))
+ {
+ if(m_config.RTTY_Exchange()!="SCC") ui->sbSerialNumber->setValue(1);
+ m_logBook.contest_log ()->reset ();
+ m_activeCall.clear(); //Erase the QMap of active calls
+ m_EMECall.clear(); //ditto for EME calls
+ m_score=0;
+ if (m_ActiveStationsWidget) {
+ m_ActiveStationsWidget->setScore(0);
+ if(m_mode=="Q65") m_ActiveStationsWidget->setRate(0);
+ }
+ }
+}
+
+void MainWindow::on_actionExport_Cabrillo_log_triggered()
+{
+ if (QDialog::Accepted == ExportCabrillo {m_settings, &m_config, m_logBook.contest_log ()}.exec())
+ {
+ MessageBox::information_message (this, tr ("Cabrillo Log saved"));
+ }
+}
+
+
+void MainWindow::on_actionErase_wsjtx_log_adi_triggered()
+{
+ int ret = MessageBox::query_message (this, tr ("Confirm Erase"),
+ tr ("Are you sure you want to erase file wsjtx_log.adi?"));
+ if(ret==MessageBox::Yes) {
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("wsjtx_log.adi")};
+ f.remove();
+ }
+}
+
+void MainWindow::on_actionErase_WSPR_hashtable_triggered()
+{
+ int ret = MessageBox::query_message(this, tr ("Confirm Erase"),
+ tr ("Are you sure you want to erase the WSPR hashtable?"));
+ if(ret==MessageBox::Yes) {
+ QFile f {m_config.writeable_data_dir().absoluteFilePath("hashtable.txt")};
+ f.remove();
+ }
+}
+
+
+void MainWindow::on_actionOpen_log_directory_triggered ()
+{
+ QDesktopServices::openUrl (QUrl::fromLocalFile (m_config.writeable_data_dir ().absolutePath ()));
+}
+
+void MainWindow::on_bandComboBox_currentIndexChanged (int index)
+{
+ auto const& frequencies = m_config.frequencies ();
+ auto const& source_index = frequencies->mapToSource (frequencies->index (index, FrequencyList_v2_101::frequency_column));
+ Frequency frequency {m_freqNominal};
+ if (source_index.isValid ())
+ {
+ frequency = frequencies->frequency_list ()[source_index.row ()].frequency_;
+ }
+
+ // Lookup band
+ auto const& band = m_config.bands ()->find (frequency);
+ ui->bandComboBox->setCurrentText (band.size () ? band : m_config.bands ()->oob ());
+ displayDialFrequency ();
+}
+
+void MainWindow::on_bandComboBox_editTextChanged (QString const& text)
+{
+ if (text.size () && m_config.bands ()->oob () != text)
+ {
+ ui->bandComboBox->lineEdit ()->setStyleSheet ({});
+ }
+ else
+ {
+ ui->bandComboBox->lineEdit ()->setStyleSheet ("QLineEdit {color: yellow; background-color : red;}");
+ }
+}
+
+void MainWindow::on_bandComboBox_activated (int index)
+{
+ auto const& frequencies = m_config.frequencies ();
+ auto const& source_index = frequencies->mapToSource (frequencies->index (index, FrequencyList_v2_101::frequency_column));
+ Frequency frequency {m_freqNominal};
+ if (source_index.isValid ())
+ {
+ frequency = frequencies->frequency_list ()[source_index.row ()].frequency_;
+ }
+ m_bandEdited = true;
+ band_changed (frequency);
+ m_wideGraph->setRxBand (m_config.bands ()->find (frequency));
+// m_specOp=m_config.special_op_id();
+// if (m_specOp==SpecOp::HOUND) auto_tx_mode(false);
+}
+
+void MainWindow::band_changed (Frequency f)
+{
+ // Don't allow a7 decodes during the first period because they can be leftovers from the previous band
+ no_a7_decodes = true;
+ QTimer::singleShot ((int(1500.0*m_TRperiod)), [=] {no_a7_decodes = false;});
+
+ // Set the attenuation value if options are checked
+ if (m_config.pwrBandTxMemory() && !m_tune) {
+ auto const&curBand = ui->bandComboBox->currentText();
+ if (m_pwrBandTxMemory.contains(curBand)) {
+ ui->outAttenuation->setValue(m_pwrBandTxMemory[curBand].toInt());
+ }
+ else {
+ m_pwrBandTxMemory[curBand] = ui->outAttenuation->value();
+ }
+ }
+
+ if (m_bandEdited) {
+ if (m_mode!="WSPR") { // band hopping preserves auto Tx
+ if (f + m_wideGraph->nStartFreq () > m_freqNominal + ui->TxFreqSpinBox->value ()
+ || f + m_wideGraph->nStartFreq () + m_wideGraph->fSpan () <=
+ m_freqNominal + ui->TxFreqSpinBox->value ()) {
+// qDebug () << "start f:" << m_wideGraph->nStartFreq () << "span:" << m_wideGraph->fSpan () << "DF:" << ui->TxFreqSpinBox->value ();
+ // disable auto Tx if "blind" QSY outside of waterfall
+ ui->stopTxButton->click (); // halt any transmission
+ auto_tx_mode (false); // disable auto Tx
+// m_send_RR73 = false; // force user to reassess on new band
+ }
+ }
+ m_lastBand.clear ();
+ m_bandEdited = false;
+ if (m_config.spot_to_psk_reporter ())
+ {
+ // Upload any queued spots before changing band
+ m_psk_Reporter.sendReport();
+ }
+ if (!m_transmitting) monitor (true);
+ if ("FreqCal" == m_mode)
+ {
+ m_frequency_list_fcal_iter = m_config.frequencies ()->find (f);
+ }
+ setRig (f);
+ setXIT (ui->TxFreqSpinBox->value ());
+ m_specOp=m_config.special_op_id();
+ if (m_specOp==SpecOp::FOX) FoxReset("BandChange"); // when changing bands, don't preserve the Fox queues
+ }
+}
+
+void MainWindow::enable_DXCC_entity (bool on)
+{
+ if (on and m_mode!="WSPR" and m_mode!="FST4W" and m_mode!="Echo") {
+ //m_logBook.init(); // re-read the log and cty.dat files
+// ui->gridLayout->setColumnStretch(0,55); // adjust proportions of text displays
+// ui->gridLayout->setColumnStretch(1,45);
+ } else {
+// ui->gridLayout->setColumnStretch(0,0);
+// ui->gridLayout->setColumnStretch(1,0);
+ }
+ updateGeometry ();
+}
+
+void MainWindow::on_rptSpinBox_valueChanged(int n)
+{
+ int step=ui->rptSpinBox->singleStep();
+ if(n%step !=0) {
+ n++;
+ ui->rptSpinBox->setValue(n);
+ }
+ m_rpt=QString::number(n);
+ int ntx0=m_ntx;
+ genStdMsgs(m_rpt);
+ m_ntx=ntx0;
+ if(m_ntx==1) ui->txrb1->setChecked(true);
+ if(m_ntx==2) ui->txrb2->setChecked(true);
+ if(m_ntx==3) ui->txrb3->setChecked(true);
+ if(m_ntx==4) ui->txrb4->setChecked(true);
+ if(m_ntx==5) ui->txrb5->setChecked(true);
+ if(m_ntx==6) ui->txrb6->setChecked(true);
+ statusChanged();
+}
+
+void MainWindow::on_tuneButton_clicked (bool checked)
+{
+ stopWRTimer.stop(); // stop a running Tx3 timer
+ static bool lastChecked = false;
+ if (lastChecked == checked) return;
+ lastChecked = checked;
+ if (checked && m_tune==false) { // we're starting tuning so remember Tx and change pwr to Tune value
+ if (m_config.pwrBandTuneMemory ()) {
+ auto const& curBand = ui->bandComboBox->currentText();
+ m_pwrBandTxMemory[curBand] = ui->outAttenuation->value(); // remember our Tx pwr
+ m_PwrBandSetOK = false;
+ if (m_pwrBandTuneMemory.contains(curBand)) {
+ ui->outAttenuation->setValue(m_pwrBandTuneMemory[curBand].toInt()); // set to Tune pwr
+ }
+ m_PwrBandSetOK = true;
+ }
+ }
+ if (m_tune) {
+ tuneButtonTimer.start(250);
+ } else {
+ m_sentFirst73=false;
+ itone[0]=0;
+ on_monitorButton_clicked (true);
+ m_tune=true;
+ }
+ Q_EMIT tune (checked);
+}
+
+void MainWindow::end_tuning ()
+{
+ on_stopTxButton_clicked ();
+ // we're turning off so remember our Tune pwr setting and reset to Tx pwr
+ if (m_config.pwrBandTuneMemory() || m_config.pwrBandTxMemory()) {
+ auto const& curBand = ui->bandComboBox->currentText();
+ m_pwrBandTuneMemory[curBand] = ui->outAttenuation->value(); // remember our Tune pwr
+ m_PwrBandSetOK = false;
+ ui->outAttenuation->setValue(m_pwrBandTxMemory[curBand].toInt()); // set to Tx pwr
+ m_PwrBandSetOK = true;
+ }
+}
+
+void MainWindow::stop_tuning ()
+{
+ on_tuneButton_clicked(false);
+ ui->tuneButton->setChecked (false);
+ m_bTxTime=false;
+ m_tune=false;
+}
+
+void MainWindow::stopTuneATU()
+{
+ on_tuneButton_clicked(false);
+ m_bTxTime=false;
+}
+
+void MainWindow::on_stopTxButton_clicked() //Stop Tx
+{
+ if (m_tune) stop_tuning ();
+ if (m_auto and !m_tuneup) auto_tx_mode (false);
+ m_btxok=false;
+ m_bCallingCQ = false;
+ m_bAutoReply = false; // ready for next
+ m_maxPoints=-1;
+ stopWRTimer.stop(); // stop a running Tx3 timer
+}
+
+void MainWindow::rigOpen ()
+{
+ update_dynamic_property (ui->readFreq, "state", "warning");
+ ui->readFreq->setText ("");
+ ui->readFreq->setEnabled (true);
+ m_config.transceiver_online ();
+ m_config.sync_transceiver (true, true);
+}
+
+void MainWindow::on_pbR2T_clicked()
+{
+ ui->TxFreqSpinBox->setValue(ui->RxFreqSpinBox->value ());
+}
+
+void MainWindow::on_pbT2R_clicked()
+{
+ if (ui->RxFreqSpinBox->isEnabled ())
+ {
+ ui->RxFreqSpinBox->setValue (ui->TxFreqSpinBox->value ());
+ }
+}
+
+
+void MainWindow::on_readFreq_clicked()
+{
+ if (m_transmitting) return;
+
+ if (m_config.transceiver_online ())
+ {
+ m_config.sync_transceiver (true, true);
+ }
+}
+
+void MainWindow::setXIT(int n, Frequency base)
+{
+ if (m_transmitting && !m_config.tx_QSY_allowed ()) return;
+ // If "CQ nnn ..." feature is active, set the proper Tx frequency
+ if(m_config.split_mode () && ui->cbCQTx->isEnabled () && ui->cbCQTx->isVisible () &&
+ ui->cbCQTx->isChecked())
+ {
+ if (6 == m_ntx || (7 == m_ntx && m_gen_message_is_cq))
+ {
+ // All conditions are met, use calling frequency
+ base = m_freqNominal / 1000000 * 1000000 + 1000 * ui->sbCQTxFreq->value () + m_XIT;
+ }
+ }
+ if (!base) base = m_freqNominal;
+ m_XIT = 0;
+ if (!(m_bSimplex || (SpecOp::FOX==m_specOp && m_config.superFox()))) {
+ // m_bSimplex is false, so we can use split mode if requested
+ if (m_config.split_mode () && (!m_config.enable_VHF_features () ||
+ m_mode=="FT4" || m_mode == "FT8" || m_mode=="FST4")) {
+ // Don't use XIT for VHF & up
+ m_XIT=(n/500)*500 - 1500;
+ }
+
+ if ((m_monitoring || m_transmitting)
+ && m_config.is_transceiver_online ()
+ && m_config.split_mode ())
+ {
+ // All conditions are met, reset the transceiver Tx dial
+ // frequency
+ m_freqTxNominal = base + m_XIT;
+ if (m_astroWidget) m_astroWidget->nominal_frequency (m_freqNominal, m_freqTxNominal);
+ m_config.transceiver_tx_frequency (m_freqTxNominal + m_astroCorrection.tx);
+ }
+ }
+ //Now set the audio Tx freq
+ Q_EMIT transmitFrequency (ui->TxFreqSpinBox->value () - m_XIT);
+}
+
+void MainWindow::setFreq4(int rxFreq, int txFreq)
+{
+ if (m_mode=="ECHO") return; // we do not adjust rx/tx for echo mode -- always 1500Hz
+ if (ui->RxFreqSpinBox->isEnabled ()) ui->RxFreqSpinBox->setValue(rxFreq);
+ if(m_mode=="WSPR" or m_mode=="FST4W") {
+ ui->WSPRfreqSpinBox->setValue(txFreq);
+ } else {
+ if (ui->TxFreqSpinBox->isEnabled ()) {
+ ui->TxFreqSpinBox->setValue(txFreq);
+ if ("FT8" == m_mode || "FT4" == m_mode || m_mode=="FST4")
+ {
+ // we need to regenerate the current transmit waveform for
+ // GFSK modulated modes
+ if (m_transmitting) m_restart = true;
+ }
+ }
+ else if (m_config.enable_VHF_features ()
+ && (Qt::ControlModifier & QApplication::keyboardModifiers ())) {
+ // for VHF & up we adjust Tx dial frequency to equalize Tx to Rx
+ // when user CTRL+clicks on waterfall
+ auto temp = ui->TxFreqSpinBox->value ();
+ ui->RxFreqSpinBox->setValue (temp);
+ setRig (m_freqNominal + txFreq - temp);
+ setXIT (ui->TxFreqSpinBox->value ());
+ }
+ }
+}
+
+void MainWindow::handle_transceiver_update (Transceiver::TransceiverState const& s)
+{
+ Transceiver::TransceiverState old_state {m_rigState};
+ //transmitDisplay (s.ptt ());
+ if (s.ptt () // && !m_rigState.ptt ()
+ ) { // safe to start audio
+ // (caveat - DX Lab Suite Commander)
+ if (m_tx_when_ready && g_iptt) { // waiting to Tx and still needed
+ int ms_delay=1000*m_config.txDelay();
+ if(m_mode=="FT4") ms_delay=20;
+ ptt1Timer.start(ms_delay); //Start-of-transmission sequencer delay
+ m_tx_when_ready = false;
+ }
+ }
+ m_rigState = s;
+ auto old_freqNominal = m_freqNominal;
+ if (!old_freqNominal)
+ {
+ // always take initial rig frequency to avoid start up problems
+ // with bogus Tx frequencies
+ m_freqNominal = s.frequency ();
+ }
+ if (old_state.online () == false && s.online () == true)
+ {
+ // initializing
+ on_monitorButton_clicked (!(m_config.monitor_off_at_startup() or m_mode=="Echo"));
+ }
+ if (s.frequency () != old_state.frequency () || s.split () != m_splitMode)
+ {
+ m_splitMode = s.split ();
+ if (!s.ptt ())
+ {
+ m_freqNominal = s.frequency () - m_astroCorrection.rx;
+ if (old_freqNominal != m_freqNominal)
+ {
+ m_freqTxNominal = m_freqNominal;
+ genCQMsg ();
+ }
+
+ if (m_monitoring)
+ {
+ m_lastMonitoredFrequency = m_freqNominal;
+ }
+ if (m_lastDialFreq != m_freqNominal &&
+ (m_mode != "MSK144"
+ || !(ui->cbCQTx->isEnabled () && ui->cbCQTx->isVisible () && ui->cbCQTx->isChecked()))) {
+
+ if(m_lastDialFreq != m_freqNominal and m_ActiveStationsWidget != NULL) {
+ m_recentCall.clear();
+ if(m_mode!="Q65") m_ActiveStationsWidget->erase();
+ }
+
+ m_lastDialFreq = m_freqNominal;
+ m_secBandChanged=QDateTime::currentMSecsSinceEpoch()/1000;
+ pskSetLocal ();
+ statusChanged();
+ m_wideGraph->setDialFreq(m_freqNominal / 1.e6);
+ }
+ } else {
+ m_freqTxNominal = s.split () ? s.tx_frequency () - m_astroCorrection.tx : s.frequency ();
+ }
+ if (m_astroWidget) m_astroWidget->nominal_frequency (m_freqNominal, m_freqTxNominal);
+ }
+ // ensure frequency display is correct
+ if (m_astroWidget && old_state.ptt () != s.ptt ()) setRig ();
+
+ displayDialFrequency ();
+ update_dynamic_property (ui->readFreq, "state", "ok");
+ ui->readFreq->setEnabled (false);
+ ui->readFreq->setText (s.split () ? "S" : "");
+}
+
+void MainWindow::handle_transceiver_failure (QString const& reason)
+{
+ update_dynamic_property (ui->readFreq, "state", "error");
+ ui->readFreq->setEnabled (true);
+ on_stopTxButton_clicked ();
+ rigFailure (reason);
+}
+
+void MainWindow::rigFailure (QString const& reason)
+{
+ if (m_first_error)
+ {
+ // one automatic retry
+ QTimer::singleShot (0, this, SLOT (rigOpen ()));
+ m_first_error = false;
+ }
+ else
+ {
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ m_rigErrorMessageBox.setDetailedText (reason + "\n\nTimestamp: "
+#if QT_VERSION >= QT_VERSION_CHECK (5, 8, 0)
+ + QDateTime::currentDateTimeUtc ().toString (Qt::ISODateWithMs)
+#else
+ + QDateTime::currentDateTimeUtc ().toString ("yyyy-MM-ddTHH:mm:ss.zzzZ")
+#endif
+ );
+
+ // don't call slot functions directly to avoid recursion
+ m_rigErrorMessageBox.exec ();
+ auto const clicked_button = m_rigErrorMessageBox.clickedButton ();
+ if (clicked_button == m_configurations_button)
+ {
+ ui->menuConfig->exec (QCursor::pos ());
+ }
+ else
+ {
+ switch (m_rigErrorMessageBox.standardButton (clicked_button))
+ {
+ case MessageBox::Ok:
+ m_config.select_tab (1);
+ QTimer::singleShot (0, this, SLOT (on_actionSettings_triggered ()));
+ break;
+
+ case MessageBox::Retry:
+ QTimer::singleShot (0, this, SLOT (rigOpen ()));
+ break;
+
+ case MessageBox::Cancel:
+ QTimer::singleShot (0, this, SLOT (close ()));
+ break;
+
+ default: break; // squashing compile warnings
+ }
+ }
+ m_first_error = true; // reset
+ }
+}
+
+void MainWindow::transmit (double snr)
+{
+ double toneSpacing=0.0;
+ if (m_mode == "JT65") {
+ if(m_nSubMode==0) toneSpacing=11025.0/4096.0;
+ if(m_nSubMode==1) toneSpacing=2*11025.0/4096.0;
+ if(m_nSubMode==2) toneSpacing=4*11025.0/4096.0;
+ Q_EMIT sendMessage (m_mode, NUM_JT65_SYMBOLS,
+ 4096.0*12000.0/11025.0, ui->TxFreqSpinBox->value () - m_XIT,
+ toneSpacing, m_soundOutput, m_config.audio_output_channel (),
+ true, false, snr, m_TRperiod);
+ }
+
+ if((m_mode=="FT4" or m_mode=="FT8") and m_maxPoints>0 and SpecOp::ARRL_DIGI==m_specOp) {
+ ui->dxCallEntry->setText(m_deCall);
+ ui->dxGridEntry->setText(m_deGrid);
+ genStdMsgs("-10");
+ }
+
+ if (m_mode == "FT8") {
+// toneSpacing=12000.0/1920.0;
+ toneSpacing=-3;
+ if(m_config.x2ToneSpacing()) toneSpacing=2*12000.0/1920.0;
+ if(m_config.x4ToneSpacing()) toneSpacing=4*12000.0/1920.0;
+ if(SpecOp::FOX==m_specOp and !m_tune) toneSpacing=-1;
+ if(SpecOp::FOX==m_specOp and m_config.superFox()) {
+ Q_EMIT sendMessage (m_mode, NUM_SUPERFOX_SYMBOLS,
+ 1024.0, ui->TxFreqSpinBox->value () - m_XIT,
+ toneSpacing, m_soundOutput, m_config.audio_output_channel (),
+ true, false, snr, m_TRperiod);
+ } else {
+ Q_EMIT sendMessage (m_mode, NUM_FT8_SYMBOLS,
+ 1920.0, ui->TxFreqSpinBox->value () - m_XIT,
+ toneSpacing, m_soundOutput, m_config.audio_output_channel (),
+ true, false, snr, m_TRperiod);
+ }
+ }
+
+ if (m_mode == "FT4") {
+ m_dateTimeSentTx3=QDateTime::currentDateTimeUtc();
+ toneSpacing=-2.0; //Transmit a pre-computed, filtered waveform.
+ Q_EMIT sendMessage (m_mode, NUM_FT4_SYMBOLS,
+ 576.0, ui->TxFreqSpinBox->value() - m_XIT,
+ toneSpacing, m_soundOutput, m_config.audio_output_channel(),
+ true, false, snr, m_TRperiod);
+ }
+
+ if (m_mode == "FST4" or m_mode == "FST4W") {
+ m_dateTimeSentTx3=QDateTime::currentDateTimeUtc();
+ toneSpacing=-2.0; //Transmit a pre-computed, filtered waveform.
+ int nsps=720;
+ if(m_TRperiod==30) nsps=1680;
+ if(m_TRperiod==60) nsps=3888;
+ if(m_TRperiod==120) nsps=8200;
+ if(m_TRperiod==300) nsps=21504;
+ if(m_TRperiod==900) nsps=66560;
+ if(m_TRperiod==1800) nsps=134400;
+ int hmod=1;
+ if(m_config.x2ToneSpacing()) hmod=2;
+ if(m_config.x4ToneSpacing()) hmod=4;
+ double dfreq=hmod*12000.0/nsps;
+ double f0=ui->WSPRfreqSpinBox->value() - m_XIT;
+ if(m_mode=="FST4") f0=ui->TxFreqSpinBox->value() - m_XIT;
+ if(!m_tune) f0 += 1.5*dfreq;
+ Q_EMIT sendMessage (m_mode, NUM_FST4_SYMBOLS,double(nsps),f0,toneSpacing,
+ m_soundOutput,m_config.audio_output_channel(),
+ true, false, snr, m_TRperiod);
+ }
+
+ if (m_mode == "Q65") {
+ int nsps=1800;
+ if(m_TRperiod==30) nsps=3600;
+ if(m_TRperiod==60) nsps=7200;
+ if(m_TRperiod==120) nsps=16000;
+ if(m_TRperiod==300) nsps=41472;
+ int mode65=pow(2.0,double(m_nSubMode));
+ toneSpacing=mode65*12000.0/nsps;
+// toneSpacing=-4.0;
+ Q_EMIT sendMessage (m_mode, NUM_Q65_SYMBOLS,
+ double(nsps), ui->TxFreqSpinBox->value () - m_XIT,
+ toneSpacing, m_soundOutput, m_config.audio_output_channel (),
+ true, false, snr, m_TRperiod);
+ }
+
+ if (m_mode == "JT9") {
+ int nsub=pow(2,m_nSubMode);
+ int nsps[]={480,240,120,60};
+ double sps=m_nsps;
+ m_toneSpacing=nsub*12000.0/6912.0;
+ if(m_config.x2ToneSpacing()) m_toneSpacing=2.0*m_toneSpacing;
+ if(m_config.x4ToneSpacing()) m_toneSpacing=4.0*m_toneSpacing;
+ bool fastmode=false;
+ if(m_bFast9 and (m_nSubMode>=4)) {
+ fastmode=true;
+ sps=nsps[m_nSubMode-4];
+ m_toneSpacing=12000.0/sps;
+ }
+ Q_EMIT sendMessage (m_mode, NUM_JT9_SYMBOLS, sps,
+ ui->TxFreqSpinBox->value() - m_XIT, m_toneSpacing,
+ m_soundOutput, m_config.audio_output_channel (),
+ true, fastmode, snr, m_TRperiod);
+ }
+
+ if (m_mode == "MSK144") {
+ m_nsps=6;
+ double f0=1000.0;
+ if(!m_bFastMode) {
+ m_nsps=192;
+ f0=ui->TxFreqSpinBox->value () - m_XIT - 0.5*m_toneSpacing;
+ }
+ m_toneSpacing=6000.0/m_nsps;
+ m_FFTSize = 7 * 512;
+ Q_EMIT FFTSize (m_FFTSize);
+ int nsym;
+ nsym=NUM_MSK144_SYMBOLS;
+ if(itone[40] < 0) nsym=40;
+ Q_EMIT sendMessage (m_mode, nsym, double(m_nsps), f0, m_toneSpacing,
+ m_soundOutput, m_config.audio_output_channel (),
+ true, true, snr, m_TRperiod);
+ }
+
+ if (m_mode == "JT4") {
+ if(m_nSubMode==0) toneSpacing=4.375;
+ if(m_nSubMode==1) toneSpacing=2*4.375;
+ if(m_nSubMode==2) toneSpacing=4*4.375;
+ if(m_nSubMode==3) toneSpacing=9*4.375;
+ if(m_nSubMode==4) toneSpacing=18*4.375;
+ if(m_nSubMode==5) toneSpacing=36*4.375;
+ if(m_nSubMode==6) toneSpacing=72*4.375;
+ Q_EMIT sendMessage (m_mode, NUM_JT4_SYMBOLS,
+ 2520.0*12000.0/11025.0, ui->TxFreqSpinBox->value () - m_XIT,
+ toneSpacing, m_soundOutput, m_config.audio_output_channel (),
+ true, false, snr, m_TRperiod);
+ }
+ if (m_mode=="WSPR") {
+ int nToneSpacing=1;
+ if(m_config.x2ToneSpacing()) nToneSpacing=2;
+ if(m_config.x4ToneSpacing()) nToneSpacing=4;
+ Q_EMIT sendMessage (m_mode, NUM_WSPR_SYMBOLS, 8192.0,
+ ui->TxFreqSpinBox->value() - 1.5 * 12000 / 8192,
+ m_toneSpacing*nToneSpacing, m_soundOutput,
+ m_config.audio_output_channel(),true, false, snr,
+ m_TRperiod);
+ }
+
+ if(m_mode=="Echo") {
+ m_fDither=0.;
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ if(m_astroWidget && m_astroWidget->bDither()) m_fDither = QRandomGenerator::global()->bounded(20.0) - 10.0; //Dither by +/- 10 Hz
+#else
+ if(m_astroWidget && m_astroWidget->bDither()) m_fDither = 20.0*(double(qrand())/RAND_MAX) - 10.0; //Dither by +/- 10 Hz
+#endif
+ Q_EMIT sendMessage (m_mode, 27, 1024.0, 1500.0+m_fDither, 0.0, m_soundOutput,
+ m_config.audio_output_channel(), false, false, snr, m_TRperiod);
+ }
+
+// In auto-sequencing mode, stop after 5 transmissions of "73" message.
+ if (m_bFastMode || m_bFast9) {
+ if (ui->cbAutoSeq->isVisible () && ui->cbAutoSeq->isEnabled () && ui->cbAutoSeq->isChecked ()) {
+ if(m_ntx==5) {
+ m_nTx73 += 1;
+ } else {
+ m_nTx73=0;
+ }
+ }
+ }
+}
+
+void MainWindow::on_outAttenuation_valueChanged (int a)
+{
+ QString tt_str;
+ qreal dBAttn {a / 10.}; // slider interpreted as dB / 100
+ if (m_tune && m_config.pwrBandTuneMemory()) {
+ tt_str = tr ("Tune digital gain ");
+ } else {
+ tt_str = tr ("Transmit digital gain ");
+ }
+ tt_str += (a ? QString::number (-dBAttn, 'f', 1) : "0") + "dB";
+ if (ui->outAttenuation->hasFocus() && !m_block_pwr_tooltip) {
+ QToolTip::showText (QCursor::pos (), tt_str, ui->outAttenuation);
+ }
+ QString curBand = ui->bandComboBox->currentText();
+ if (m_PwrBandSetOK && !m_tune && m_config.pwrBandTxMemory ()) {
+ m_pwrBandTxMemory[curBand] = a; // remember our Tx pwr
+ }
+ if (m_PwrBandSetOK && m_tune && m_config.pwrBandTuneMemory()) {
+ m_pwrBandTuneMemory[curBand] = a; // remember our Tune pwr
+ }
+ Q_EMIT outAttenuationChanged (dBAttn);
+}
+
+void MainWindow::on_actionShort_list_of_add_on_prefixes_and_suffixes_triggered()
+{
+ if (!m_prefixes) {
+ m_prefixes.reset (new HelpTextWindow {tr ("Prefixes")
+ , R"(Type 1 Prefixes:
+
+ 1A 1S 3A 3B6 3B8 3B9 3C 3C0 3D2 3D2C 3D2R 3DA 3V 3W 3X
+ 3Y 3YB 3YP 4J 4L 4S 4U1I 4U1U 4W 4X 5A 5B 5H 5N 5R
+ 5T 5U 5V 5W 5X 5Z 6W 6Y 7O 7P 7Q 7X 8P 8Q 8R
+ 9A 9G 9H 9J 9K 9L 9M2 9M6 9N 9Q 9U 9V 9X 9Y A2
+ A3 A4 A5 A6 A7 A9 AP BS7 BV BV9 BY C2 C3 C5 C6
+ C9 CE CE0X CE0Y CE0Z CE9 CM CN CP CT CT3 CU CX CY0 CY9
+ D2 D4 D6 DL DU E3 E4 EA EA6 EA8 EA9 EI EK EL EP
+ ER ES ET EU EX EY EZ F FG FH FJ FK FKC FM FO
+ FOA FOC FOM FP FR FRG FRJ FRT FT5W FT5X FT5Z FW FY M MD
+ MI MJ MM MU MW H4 H40 HA HB HB0 HC HC8 HH HI HK
+ HK0A HK0M HL HM HP HR HS HV HZ I IS IS0 J2 J3 J5
+ J6 J7 J8 JA JDM JDO JT JW JX JY K KG4 KH0 KH1 KH2
+ KH3 KH4 KH5 KH5K KH6 KH7 KH8 KH9 KL KP1 KP2 KP4 KP5 LA LU
+ LX LY LZ OA OD OE OH OH0 OJ0 OK OM ON OX OY OZ
+ P2 P4 PA PJ2 PJ7 PY PY0F PT0S PY0T PZ R1F R1M S0 S2 S5
+ S7 S9 SM SP ST SU SV SVA SV5 SV9 T2 T30 T31 T32 T33
+ T5 T7 T8 T9 TA TF TG TI TI9 TJ TK TL TN TR TT
+ TU TY TZ UA UA2 UA9 UK UN UR V2 V3 V4 V5 V6 V7
+ V8 VE VK VK0H VK0M VK9C VK9L VK9M VK9N VK9W VK9X VP2E VP2M VP2V VP5
+ VP6 VP6D VP8 VP8G VP8H VP8O VP8S VP9 VQ9 VR VU VU4 VU7 XE XF4
+ XT XU XW XX9 XZ YA YB YI YJ YK YL YN YO YS YU
+ YV YV0 Z2 Z3 ZA ZB ZC4 ZD7 ZD8 ZD9 ZF ZK1N ZK1S ZK2 ZK3
+ ZL ZL7 ZL8 ZL9 ZP ZS ZS8 KC4 E5
+
+Type 1 Suffixes: /0 /1 /2 /3 /4 /5 /6 /7 /8 /9 /A /P)", {"Courier", 10}});
+ }
+ m_prefixes->showNormal();
+ m_prefixes->raise ();
+}
+
+bool MainWindow::shortList(QString callsign) const
+{
+ int n=callsign.length();
+ int i1=callsign.indexOf("/");
+ Q_ASSERT(i1>0 and i1<n);
+ QString t1=callsign.mid(0,i1);
+ QString t2=callsign.mid(i1+1,n-i1-1);
+ bool b=(m_pfx.contains(t1) or m_sfx.contains(t2));
+ return b;
+}
+
+void MainWindow::pskSetLocal ()
+{
+ if (!m_config.spot_to_psk_reporter ()) return;
+
+ // find the station row, if any, that matches the band we are on
+ auto stations = m_config.stations ();
+ auto matches = stations->match (stations->index (0, StationList::band_column)
+ , Qt::DisplayRole
+ , ui->bandComboBox->currentText ()
+ , 1
+ , Qt::MatchExactly);
+ QString antenna_description;
+ if (!matches.isEmpty ()) {
+ antenna_description = stations->index (matches.first ().row ()
+ , StationList::description_column).data ().toString ();
+ }
+ // qDebug() << "To PSKreporter: local station details";
+ m_psk_Reporter.setLocalStation(m_config.my_callsign (), m_config.my_grid (), antenna_description);
+}
+
+void MainWindow::transmitDisplay (bool transmitting)
+{
+ if (transmitting == m_transmitting) {
+ if (transmitting) {
+ ui->signal_meter_widget->setValue(0,0);
+ if (m_monitoring) monitor (false);
+ m_btxok=true;
+ }
+
+ auto QSY_allowed = !transmitting or m_config.tx_QSY_allowed () or
+ !m_config.split_mode ();
+ if (ui->cbHoldTxFreq->isChecked ()) {
+ ui->TxFreqSpinBox->setEnabled (QSY_allowed);
+ ui->pbT2R->setEnabled (QSY_allowed);
+ }
+
+ if (m_mode!="WSPR" and m_mode!="FST4W") {
+ if(m_config.enable_VHF_features ()) {
+ ui->TxFreqSpinBox->setEnabled (true);
+ } else {
+ ui->TxFreqSpinBox->setEnabled (QSY_allowed and !m_bFastMode);
+ ui->pbR2T->setEnabled (QSY_allowed);
+ ui->cbHoldTxFreq->setEnabled (QSY_allowed);
+ }
+ }
+
+ // the following are always disallowed in transmit
+ ui->menuMode->setEnabled (!transmitting);
+ }
+}
+
+void MainWindow::on_sbFtol_valueChanged(int value)
+{
+ m_wideGraph->setTol (value);
+ statusUpdate ();
+ // save last used parameters
+ QTimer::singleShot (200, [=] {
+ if (m_mode=="FT8") m_settings->setValue ("Ftol_SF", ui->sbFtol->value());
+ if (m_mode=="Q65") m_settings->setValue ("Ftol_Q65", ui->sbFtol->value());
+ if (m_mode=="MSK144") m_settings->setValue ("Ftol_MSK144", ui->sbFtol->value());
+ if (m_mode=="JT65") m_settings->setValue ("Ftol_JT65", ui->sbFtol->value ());
+ if (m_mode=="JT4") m_settings->setValue ("Ftol_JT4", ui->sbFtol->value());
+ if (m_mode=="JT9") m_settings->setValue ("Ftol_JT9", ui->sbFtol->value ());
+ });
+}
+
+void::MainWindow::VHF_features_enabled(bool b)
+{
+ if(m_mode!="JT4" and m_mode!="JT65" and m_mode!="Q65") b=false;
+ if(b and m_mode!="Q65" and (ui->actionInclude_averaging->isChecked() or
+ ui->actionInclude_correlation->isChecked())) {
+ ui->actionDeepestDecode->setChecked (true);
+ }
+ ui->actionInclude_averaging->setVisible (b);
+ ui->actionInclude_correlation->setVisible (b && m_mode!="Q65");
+ ui->actionMessage_averaging->setEnabled(b && (m_mode=="JT4" or m_mode=="JT65"));
+ ui->actionEnable_AP_JT65->setVisible (b && m_mode=="JT65");
+
+ if(!b && m_msgAvgWidget and (SpecOp::FOX != m_specOp) and !m_config.autoLog()) {
+ if(m_msgAvgWidget->isVisible() and m_mode!="JT4" and m_mode!="JT9" and m_mode!="JT65") {
+ m_msgAvgWidget->close();
+ }
+ }
+}
+
+void MainWindow::on_sbTR_valueChanged(int value)
+{
+ // if(!m_bFastMode and n>m_nSubMode) m_MinW=m_nSubMode;
+ if(m_bFastMode or m_mode=="FreqCal" or m_mode=="FST4" or m_mode=="FST4W" or m_mode=="Q65") {
+ m_TRperiod = value;
+ if (m_mode == "FST4" || m_mode == "FST4W" || m_mode=="Q65")
+ {
+ if (m_TRperiod < 60)
+ {
+ ui->lh_decodes_headings_label->setText(" UTC dB DT Freq " + tr ("Message"));
+ if (m_mode != "FST4W")
+ {
+ ui->rh_decodes_headings_label->setText(" UTC dB DT Freq " + tr ("Message"));
+ }
+ }
+ else
+ {
+ ui->lh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ if (m_mode != "FST4W")
+ {
+ ui->rh_decodes_headings_label->setText("UTC dB DT Freq " + tr ("Message"));
+ }
+ }
+
+ if ("Q65" == m_mode)
+ {
+ switch (value)
+ {
+ case 15: ui->sbSubmode->setMaximum (2); break;
+ case 30: ui->sbSubmode->setMaximum (3); break;
+ default: ui->sbSubmode->setMaximum (4); break;
+ }
+ }
+ }
+ m_fastGraph->setTRPeriod (value);
+ m_modulator->setTRPeriod (value); // TODO - not thread safe
+ m_detector->setTRPeriod (value); // TODO - not thread safe
+ m_wideGraph->setPeriod (value, m_nsps);
+ progressBar.setMaximum (value);
+ }
+// if(m_transmitting) on_stopTxButton_clicked(); //### Is this needed or desirable? ###
+ if (m_mode=="FST4") chk_FST4_freq_range();
+ on_sbSubmode_valueChanged(ui->sbSubmode->value());
+ statusUpdate ();
+ // save last used parameters
+ QTimer::singleShot (200, [=] {
+ if (m_mode=="Q65") m_settings->setValue ("TRPeriod_Q65", ui->sbTR->value ());
+ if (m_mode=="MSK144" && (!(m_currentBand=="6m" or m_currentBand=="4m" or m_currentBand=="2m"))) {
+ m_settings->setValue ("TRPeriod_MSK144", ui->sbTR->value ());
+ }
+ if (m_mode=="MSK144" && (m_currentBand=="6m" or m_currentBand=="4m")) {
+ m_settings->setValue ("TRPeriod_MSK144_6m", ui->sbTR->value ());
+ }
+ if (m_mode=="MSK144" && m_currentBand=="2m") {
+ m_settings->setValue ("TRPeriod_MSK144_2m", ui->sbTR->value ());
+ }
+ if (m_mode=="FST4") m_settings->setValue ("TRPeriod_FST4", ui->sbTR->value ());
+ if (m_mode=="JT9") m_settings->setValue ("TRPeriod", ui->sbTR->value ());
+ });
+}
+
+void MainWindow::on_sbTR_FST4W_valueChanged(int value)
+{
+ on_sbTR_valueChanged(value);
+}
+
+QChar MainWindow::current_submode () const
+{
+ QChar submode {0};
+ if (m_mode.contains (QRegularExpression {R"(^(JT65|JT9|JT4|Q65)$)"})
+ && (m_config.enable_VHF_features () || "JT4" == m_mode))
+ {
+ submode = m_nSubMode + 65;
+ }
+ return submode;
+}
+
+void MainWindow::on_sbSubmode_valueChanged(int n)
+{
+ m_nSubMode=n;
+ m_wideGraph->setSubMode(m_nSubMode);
+ auto submode = current_submode ();
+ if (submode != QChar::Null) {
+ QString t{m_mode + " " + submode};
+ if(m_mode=="Q65") t=m_mode + "-" + QString::number(m_TRperiod) + submode;
+ mode_label.setText (t);
+ } else {
+ mode_label.setText (m_mode);
+ }
+ if(m_mode=="Q65") {
+ if(((m_nSubMode==4 && m_TRperiod==60.0) || (m_nSubMode==3 && m_TRperiod==30.0) ||
+ (m_nSubMode==2 && m_TRperiod==15.0)) && ui->TxFreqSpinBox->value()!=700) {
+ ui->TxFreqSpinBox->setStyleSheet("QSpinBox{background-color:red}");
+ } else {
+ ui->TxFreqSpinBox->setStyleSheet("");
+ }
+ }
+ if(m_mode=="JT9") {
+ if(m_nSubMode<4) {
+ ui->cbFast9->setChecked(false);
+ on_cbFast9_clicked(false);
+ ui->cbFast9->setEnabled(false);
+ ui->sbTR->setVisible(false);
+ m_TRperiod=60.0;
+ } else {
+ if(!blocked) ui->cbFast9->setEnabled(true);
+ }
+ ui->sbTR->setVisible(m_bFast9);
+ if(m_bFast9) ui->TxFreqSpinBox->setValue(700);
+ }
+ if(m_transmitting and m_bFast9 and m_nSubMode>=4) transmit (99.0);
+ if (m_mode !="Q65") ui->TxFreqSpinBox->setStyleSheet("");
+ statusUpdate ();
+ // save last used parameters
+ QTimer::singleShot (200, [=] {
+ if (m_mode=="Q65") m_settings->setValue("SubMode_Q65",ui->sbSubmode->value());
+ if (m_mode=="JT65") m_settings->setValue("SubMode_JT65",ui->sbSubmode->value());
+ if (m_mode=="JT4") m_settings->setValue("SubMode_JT4",ui->sbSubmode->value());
+ if (m_mode=="JT9") m_settings->setValue("SubMode",ui->sbSubmode->value());
+ });
+}
+
+void MainWindow::on_cbFast9_clicked(bool b)
+{
+ if(m_mode=="JT9") {
+ m_bFast9=b;
+// ui->cbAutoSeq->setVisible(b);
+ blocked=true; // needed to prevent a loop
+ on_actionJT9_triggered();
+ QTimer::singleShot (50, [=] {blocked = false;}); // needed to prevent a loop
+ QTimer::singleShot (200, [=] {
+ if(m_mode=="JT9") m_settings->setValue("JT9_Fast",m_bFast9);
+ });
+ }
+
+ if(b) {
+ m_TRperiod = ui->sbTR->value ();
+ } else {
+ m_TRperiod=60.0;
+ }
+ progressBar.setMaximum(int(m_TRperiod));
+ m_wideGraph->setPeriod(m_TRperiod,m_nsps);
+ fast_config(b);
+ statusChanged ();
+}
+
+void MainWindow::on_cbSendMsg_toggled(bool b)
+{
+ if(b) {
+ ui->sbNslots->setValue(2);
+ } else {
+ ui->sbNslots->setValue(5);
+ }
+}
+
+void MainWindow::on_cbShMsgs_toggled(bool b)
+{
+ ui->cbTx6->setEnabled(b);
+ m_bShMsgs=b;
+ if(b) ui->cbSWL->setChecked(false);
+ if(m_bShMsgs and (m_mode=="MSK144")) ui->rptSpinBox->setValue(1);
+ int it0=itone[0];
+ int ntx=m_ntx;
+ m_lastCallsign.clear (); // ensure Tx5 gets updated
+ genStdMsgs(m_rpt);
+ itone[0]=it0;
+ if(ntx==1) ui->txrb1->setChecked(true);
+ if(ntx==2) ui->txrb2->setChecked(true);
+ if(ntx==3) ui->txrb3->setChecked(true);
+ if(ntx==4) ui->txrb4->setChecked(true);
+ if(ntx==5) ui->txrb5->setChecked(true);
+ if(ntx==6) ui->txrb6->setChecked(true);
+ QTimer::singleShot (200, [=] {
+ if(m_mode=="MSK144") m_settings->setValue("ShMsgs_MSK144",m_bShMsgs);
+ if(m_mode=="Q65") m_settings->setValue("ShMsgs_Q65",m_bShMsgs);
+ if(m_mode=="JT65") m_settings->setValue("ShMsgs_JT65",m_bShMsgs);
+ if(m_mode=="JT4") m_settings->setValue("ShMsgs_JT4",m_bShMsgs);
+ });
+}
+
+void MainWindow::on_cbSWL_toggled(bool b)
+{
+ if(b) ui->cbShMsgs->setChecked(false);
+}
+
+void MainWindow::on_cbTx6_toggled(bool)
+{
+ genCQMsg ();
+}
+
+// Takes a decoded CQ line and sets it up for reply
+void MainWindow::replyToCQ (QTime time, qint32 snr, float delta_time, quint32 delta_frequency
+ , QString const& mode, QString const& message_text
+ , bool /*low_confidence*/, quint8 modifiers)
+{
+ QString format_string {"%1 %2 %3 %4 %5 %6"};
+ auto const& time_string = time.toString ("~" == mode || "&" == mode || "+" == mode
+ || (m_TRperiod < 60. && ("`" == mode || ":" == mode))
+ ? "hhmmss" : "hhmm");
+ auto text = message_text;
+ auto ap_pos = text.lastIndexOf (QRegularExpression {R"((?:\?\s)?(?:a[0-9]|q[0-9][0-9]?)$)"});
+ if (ap_pos >= 0)
+ {
+ // beware of decodes ending on shorter version of wanted call so
+ // add a space
+ text = text.left (ap_pos).trimmed () + ' ';
+ }
+ auto message_line = format_string
+ .arg (time_string)
+ .arg (snr, 3)
+ .arg (delta_time, 4, 'f', 1)
+ .arg (delta_frequency, 4)
+ .arg (mode, -2)
+ .arg (text);
+ QTextCursor start {ui->decodedTextBrowser->document ()};
+ start.movePosition (QTextCursor::End);
+ auto cursor = ui->decodedTextBrowser->document ()->find (message_line, start, QTextDocument::FindBackward);
+ if (cursor.isNull ())
+ {
+ // try again with with -0.0 delta time
+ cursor = ui->decodedTextBrowser->document ()->find (format_string
+ .arg (time_string)
+ .arg (snr, 3)
+ .arg ('-' + QString::number (delta_time, 'f', 1), 4)
+ .arg (delta_frequency, 4)
+ .arg (mode, -2)
+ .arg (text), start, QTextDocument::FindBackward);
+ }
+ if (!cursor.isNull ())
+ {
+ if (m_config.udpWindowToFront ())
+ {
+ show ();
+ raise ();
+ activateWindow ();
+ }
+ if (m_config.udpWindowRestore () && isMinimized ())
+ {
+ showNormal ();
+ raise ();
+ }
+ if ((text.contains (QRegularExpression {R"(^(CQ |CQDX |QRZ ))"})) || (ui->cbHoldTxFreq->isChecked ())) {
+ // a message we are willing to accept and auto reply to
+ m_bDoubleClicked = true;
+ }
+ DecodedText message {message_line};
+ Qt::KeyboardModifiers kbmod {modifiers << 24};
+ processMessage (message, kbmod);
+ tx_watchdog (false);
+ QApplication::alert (this);
+ }
+ else
+ {
+ qDebug () << "process reply message ignored, decode not found:" << message_line;
+ }
+}
+
+void MainWindow::locationChange (QString const& location)
+{
+ QString grid {location.trimmed ()};
+ int len;
+
+ // string 6 chars or fewer, interpret as a grid, or use with a 'GRID:' prefix
+ if (grid.size () > 6) {
+ if (grid.toUpper ().startsWith ("GRID:")) {
+ grid = grid.mid (5).trimmed ();
+ }
+ else {
+ // TODO - support any other formats, e.g. latlong? Or have that conversion done external to wsjtx
+ return;
+ }
+ }
+ if (MaidenheadLocatorValidator::Acceptable == MaidenheadLocatorValidator ().validate (grid, len)) {
+ qDebug() << "locationChange: Grid supplied is " << grid;
+ if (m_config.my_grid () != grid) {
+ m_config.set_location (grid);
+ genStdMsgs (m_rpt, false);
+ pskSetLocal ();
+ statusUpdate ();
+ }
+ } else {
+ qDebug() << "locationChange: Invalid grid " << grid;
+ }
+}
+
+void MainWindow::replayDecodes ()
+{
+ // we accept this request even if the setting to accept UDP requests
+ // is not checked
+
+ // attempt to parse the decoded text
+ for (QTextBlock block = ui->decodedTextBrowser->document ()->firstBlock (); block.isValid (); block = block.next ())
+ {
+ auto message = block.text ();
+ message = message.left (message.indexOf (QChar::Nbsp)); // discard
+ // any
+ // appended info
+ if (message.size() >= 4 && message.left (4) != "----")
+ {
+ auto const& parts = message.split (' ', SkipEmptyParts);
+ if (parts.size () >= 5 && parts[3].contains ('.')) {
+ postWSPRDecode (false, parts);
+ } else {
+ postDecode (false, message);
+ }
+ }
+ }
+ statusChanged ();
+}
+
+void MainWindow::postDecode (bool is_new, QString const& message)
+{
+ auto const& decode = message.trimmed ();
+ auto const& parts = decode.left (22).split (' ', SkipEmptyParts);
+ if (parts.size () >= 5)
+ {
+ auto has_seconds = parts[0].size () > 4;
+ m_messageClient->decode (is_new
+ , QTime::fromString (parts[0], has_seconds ? "hhmmss" : "hhmm")
+ , parts[1].toInt ()
+ , parts[2].toFloat (), parts[3].toUInt (), parts[4]
+ , decode.mid (has_seconds ? 24 : 22)
+ , QChar {'?'} == decode.mid (has_seconds ? 24 + 36 : 22 + 36, 1)
+ , m_diskData);
+ }
+}
+
+void MainWindow::postWSPRDecode (bool is_new, QStringList parts)
+{
+ if (parts.size () < 8)
+ {
+ parts.insert (6, "");
+ }
+ m_messageClient->WSPR_decode (is_new, QTime::fromString (parts[0], "hhmm"), parts[1].toInt ()
+ , parts[2].toFloat (), Radio::frequency (parts[3].toFloat (), 6)
+ , parts[4].toInt (), parts[5], parts[6], parts[7].toInt ()
+ , m_diskData);
+}
+
+void MainWindow::networkError (QString const& e)
+{
+ if (m_splash && m_splash->isVisible ()) m_splash->hide ();
+ if (MessageBox::Retry == MessageBox::warning_message (this, tr ("Network Error")
+ , tr ("Error: %1\nUDP server %2:%3")
+ .arg (e)
+ .arg (m_config.udp_server_name ())
+ .arg (m_config.udp_server_port ())
+ , QString {}
+ , MessageBox::Cancel | MessageBox::Retry
+ , MessageBox::Cancel))
+ {
+ // retry server lookup
+ m_messageClient->set_server (m_config.udp_server_name (), m_config.udp_interface_names ());
+ }
+}
+
+void MainWindow::on_syncSpinBox_valueChanged(int n)
+{
+ m_minSync=n;
+}
+
+void MainWindow::p1ReadFromStdout() //p1readFromStdout
+{
+ QString t1;
+ while(p1.canReadLine()) {
+ QString t(p1.readLine());
+ if(ui->cbNoOwnCall->isChecked()) {
+ if(t.contains(" " + m_config.my_callsign() + " ")) continue;
+ if(t.contains(" <" + m_config.my_callsign() + "> ")) continue;
+ }
+ if(t.indexOf("<DecodeFinished>") >= 0) {
+ m_bDecoded = m_nWSPRdecodes > 0;
+ if(!m_diskData) {
+ WSPR_history(m_dialFreqRxWSPR, m_nWSPRdecodes);
+ if(m_nWSPRdecodes==0 and ui->band_hopping_group_box->isChecked()) {
+ t = " " + tr ("Receiving") + " " + m_mode + " ----------------------- " +
+ m_config.bands ()->find (m_dialFreqRxWSPR);
+ t=beacon_start_time (-m_TRperiod / 2) + ' ' + t.rightJustified (66, '-');
+ ui->decodedTextBrowser->insertText(t);
+ }
+ killFileTimer.start (45*1000); //Kill in 45s (for slow modes)
+ }
+ ndecodes_label.setText(QString::number(m_nWSPRdecodes));
+ m_nWSPRdecodes=0;
+ ui->DecodeButton->setChecked (false);
+ if(m_uploadWSPRSpots && m_config.is_transceiver_online()) { // need working rig control
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ uploadTimer.start(QRandomGenerator::global ()->bounded (0, 20000)); // Upload delay
+#else
+ uploadTimer.start(20000 * qrand()/((double)RAND_MAX + 1.0)); // Upload delay
+#endif
+ } else {
+ QFile f {QDir::toNativeSeparators (m_config.writeable_data_dir ().absoluteFilePath ("wspr_spots.txt"))};
+ if (f.exists ()) f.remove ();
+ }
+ m_RxLog=0;
+ m_startAnother=m_loopall;
+ m_decoderBusy = false;
+ statusUpdate ();
+ } else {
+ int n=t.length();
+ t=t.mid(0,n-2) + " ";
+ t.remove(QRegExp("\\s+$"));
+ QStringList rxFields = t.split(QRegExp("\\s+"));
+ QString rxLine;
+ QString grid="";
+ if ( rxFields.count() == 8 ) {
+ rxLine = QString("%1 %2 %3 %4 %5 %6 %7 %8")
+ .arg(rxFields.at(0), 4)
+ .arg(rxFields.at(1), 4)
+ .arg(rxFields.at(2), 5)
+ .arg(rxFields.at(3), 11)
+ .arg(rxFields.at(4), 4)
+ .arg(rxFields.at(5).leftJustified (12))
+ .arg(rxFields.at(6), -6)
+ .arg(rxFields.at(7), 3);
+ postWSPRDecode (true, rxFields);
+ grid = rxFields.at(6);
+ } else if ( rxFields.count() == 7 ) { // Type 2 message
+ rxLine = QString("%1 %2 %3 %4 %5 %6 %7 %8")
+ .arg(rxFields.at(0), 4)
+ .arg(rxFields.at(1), 4)
+ .arg(rxFields.at(2), 5)
+ .arg(rxFields.at(3), 11)
+ .arg(rxFields.at(4), 4)
+ .arg(rxFields.at(5).leftJustified (12))
+ .arg("", -6)
+ .arg(rxFields.at(6), 3);
+ postWSPRDecode (true, rxFields);
+ } else {
+ rxLine = t;
+ }
+ if(grid!="") {
+ double utch=0.0;
+ int nAz,nEl,nDmiles,nDkm,nHotAz,nHotABetter;
+ azdist_(const_cast <char *> ((m_config.my_grid () + " ").left (6).toLatin1 ().constData ()),
+ const_cast <char *> ((grid + " ").left (6).toLatin1 ().constData ()),&utch,
+ &nAz,&nEl,&nDmiles,&nDkm,&nHotAz,&nHotABetter,(FCL)6,(FCL)6);
+ QString t1;
+ if(m_config.miles()) {
+ t1 = t1.asprintf("%7d",nDmiles);
+ } else {
+ t1 = t1.asprintf("%7d",nDkm);
+ }
+ rxLine += t1;
+ }
+
+ if (rxLine.left (4) != m_tBlankLine) {
+ ui->decodedTextBrowser->new_period ();
+ if (m_config.insert_blank ()) {
+ QString band;
+ Frequency f=1000000.0*rxFields.at(3).toDouble()+0.5;
+ band = ' ' + m_config.bands ()->find (f);
+ ui->decodedTextBrowser->insertText(band.rightJustified (71, '-'));
+ }
+ m_tBlankLine = rxLine.left(4);
+ }
+ m_nWSPRdecodes += 1;
+ ui->decodedTextBrowser->insertText(rxLine);
+ }
+ }
+}
+
+QString MainWindow::beacon_start_time (int n)
+{
+ auto bt = qt_truncate_date_time_to (QDateTime::currentDateTimeUtc ().addSecs (n), m_TRperiod * 1.e3);
+ if (m_TRperiod < 60.)
+ {
+ return bt.toString ("HHmmss");
+ }
+ else
+ {
+ return bt.toString ("HHmm");
+ }
+}
+
+void MainWindow::WSPR_history(Frequency dialFreq, int ndecodes)
+{
+ QDateTime t=QDateTime::currentDateTimeUtc().addSecs(-60);
+ QString t1=t.toString("yyMMdd");
+ QString t2=beacon_start_time (-m_TRperiod / 2);
+ QString t3;
+ t3 = t3.asprintf("%13.6f",0.000001*dialFreq);
+ if(ndecodes<0) {
+ t1=t1 + " " + t2 + t3 + " T";
+ } else {
+ QString t4;
+ t4 = t4.asprintf("%4d",ndecodes);
+ t1=t1 + " " + t2 + t3 + " R" + t4;
+ }
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("WSPR_history.txt")};
+ if (f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append)) {
+ QTextStream out(&f);
+ out << t1
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f.close();
+ } else {
+ MessageBox::warning_message (this, tr ("File Error")
+ , tr ("Cannot open \"%1\" for append: %2")
+ .arg (f.fileName ()).arg (f.errorString ()));
+ }
+}
+
+void MainWindow::uploadWSPRSpots (bool direct_post, QString const& decode_text)
+{
+ // do not spot if disabled, replays, or if rig control not working
+ if(!m_uploadWSPRSpots || m_diskData || !m_config.is_transceiver_online ()) return;
+ if(m_uploading && !decode_text.size ()) {
+ qDebug() << "Previous upload has not completed, spots were lost";
+ wsprNet->abortOutstandingRequests ();
+ m_uploading = false;
+ }
+ QString rfreq = QString("%1").arg((m_dialFreqRxWSPR + 1500) / 1e6, 0, 'f', 6);
+ QString tfreq = QString("%1").arg((m_dialFreqRxWSPR +
+ ui->TxFreqSpinBox->value()) / 1e6, 0, 'f', 6);
+ auto pct = QString::number (ui->autoButton->isChecked () ? ui->sbTxPercent->value () : 0);
+ if (direct_post)
+ {
+ // queues one FST4W spot
+ wsprNet->post (m_config.my_callsign (), m_config.my_grid (), rfreq, tfreq,
+ m_mode, m_TRperiod, pct,
+ QString::number (m_dBm), version (), decode_text);
+ }
+ else
+ {
+ // queues spots for each decode in wspr_spots.txt
+ wsprNet->upload (m_config.my_callsign (), m_config.my_grid (), rfreq, tfreq,
+ m_mode, m_TRperiod, pct,
+ QString::number (m_dBm), version (),
+ m_config.writeable_data_dir ().absoluteFilePath ("wspr_spots.txt"));
+ }
+ // trigger upload of any queued spots
+ if (!decode_text.size ())
+ {
+ m_uploading = true;
+ }
+}
+
+void MainWindow::uploadResponse(QString const& response)
+{
+ if (response == "done") {
+ m_uploading=false;
+ } else {
+ if (response.startsWith ("Upload Failed")) {
+ m_uploading=false;
+ }
+ qDebug () << "WSPRnet.org status:" << response;
+ }
+}
+
+void MainWindow::on_TxPowerComboBox_currentIndexChanged(int index)
+{
+ m_dBm = ui->TxPowerComboBox->itemData (index).toInt ();
+}
+
+void MainWindow::on_cbUploadWSPR_Spots_toggled(bool b)
+{
+ m_uploadWSPRSpots=b;
+}
+
+void MainWindow::on_WSPRfreqSpinBox_valueChanged(int n)
+{
+ ui->TxFreqSpinBox->setValue(n);
+}
+
+void MainWindow::on_sbFST4W_RxFreq_valueChanged(int n)
+{
+ m_wideGraph->setRxFreq(n);
+ statusUpdate ();
+}
+
+void MainWindow::on_sbFST4W_FTol_valueChanged(int n)
+{
+ ui->sbFST4W_RxFreq->setSingleStep(n);
+ m_wideGraph->setTol(n);
+ statusUpdate ();
+}
+
+void MainWindow::on_pbTxNext_clicked(bool b)
+{
+ if (b && !ui->autoButton->isChecked ())
+ {
+ ui->autoButton->click (); // make sure Tx is possible
+ }
+}
+
+void MainWindow::WSPR_scheduling ()
+{
+ if (ui->pbTxNext->isEnabled () && ui->pbTxNext->isChecked ())
+ {
+ // Tx Next button overrides all scheduling
+ m_WSPR_tx_next = true;
+ return;
+ }
+ QString t=ui->RoundRobin->currentText();
+ if(m_mode=="FST4W" and t != tr ("Random")) {
+ bool ok;
+ int i=t.left (1).toInt (&ok) - 1;
+ if (!ok) return;
+ int n=t.right (1).toInt (&ok);
+ if (!ok || 0 == n) return;
+
+ qint64 ms = QDateTime::currentMSecsSinceEpoch() % 86400000;
+ int nsec=ms/1000;
+ int ntr=m_TRperiod;
+ int j=((nsec+ntr-1) % (n*ntr))/ntr;
+ m_WSPR_tx_next = i == j;
+ return;
+ }
+ m_WSPR_tx_next = false;
+ if (!ui->sbTxPercent->isEnabled ())
+ {
+ return; // don't schedule if %age disabled
+ }
+ if (m_config.is_transceiver_online () // need working rig control for hopping
+ && !m_config.is_dummy_rig ()
+ && ui->band_hopping_group_box->isChecked ()) {
+ auto hop_data = m_WSPR_band_hopping.next_hop (m_auto);
+ qDebug () << "hop data: period:" << hop_data.period_name_
+ << "frequencies index:" << hop_data.frequencies_index_
+ << "tune:" << hop_data.tune_required_
+ << "tx:" << hop_data.tx_next_;
+ m_WSPR_tx_next = hop_data.tx_next_;
+ if (hop_data.frequencies_index_ >= 0) { // new band
+ ui->bandComboBox->setCurrentIndex (hop_data.frequencies_index_);
+ on_bandComboBox_activated (hop_data.frequencies_index_);
+ // Execute user's hardware controller
+ auto band = m_config.bands ()->find (m_freqNominal).remove ('m');
+#if defined(Q_OS_WIN)
+ // On windows we use CMD.EXE to find and execute the
+ // user_hardware executable. This means that the first matching
+ // file extension on the PATHEXT environment variable found on
+ // the PATH environment variable path list. This give maximum
+ // flexibility for users to write user_hardware in their
+ // language of choice, and place the file anywhere on the PATH
+ // environment variable. Equivalent to typing user_hardware
+ // without any path or extension at the CMD.EXE prompt.
+ p3.start("CMD", QStringList {"/C", "user_hardware", band});
+#else
+ // On non-Windows systems we expect the user_hardware executable
+ // to be anywhere in the paths specified in the PATH environment
+ // variable path list, and executable. Equivalent to typing
+ // user_hardware without any path at the shell prompt.
+ p3.start("/bin/sh", QStringList {"-c", "user_hardware " + band});
+#endif
+
+ // Produce a short tuneup signal
+ m_tuneup = false;
+ if (hop_data.tune_required_) {
+ m_tuneup = true;
+ on_tuneButton_clicked (true);
+ tuneATU_Timer.start (2500);
+ }
+ }
+
+ // Display grayline status
+ band_hopping_label.setText (hop_data.period_name_);
+ }
+ else {
+ m_WSPR_tx_next = m_WSPR_band_hopping.next_is_tx(m_mode=="FST4W");
+ }
+}
+
+void MainWindow::astroUpdate ()
+{
+ if (m_astroWidget) {
+ // no Doppler correction while CTRL pressed allows manual tuning
+ if (Qt::ControlModifier & QApplication::queryKeyboardModifiers ()) return;
+
+ auto correction = m_astroWidget->astroUpdate(QDateTime::currentDateTimeUtc (),
+ m_config.my_grid(), m_hisGrid,m_freqNominal,"Echo" == m_mode,
+ m_transmitting,m_auto,!m_config.tx_QSY_allowed (),m_TRperiod);
+ m_fDop=correction.dop;
+ m_fSpread=correction.width;
+
+ if (m_transmitting && !m_config.tx_QSY_allowed ()) return; // No Tx Doppler correction if rig can't do it
+ if (!m_astroWidget->doppler_tracking() or m_astroWidget->DopplerMethod()==0) {
+ // We are not using RF Doppler correction
+ m_fAudioShift=m_fDop;
+ return;
+ }
+ if ((m_monitoring || m_transmitting)
+ && m_freqNominal >= 21000000 // No Doppler correction below 15m
+ && m_config.split_mode ()) // Doppler correcion needs split mode
+ {
+ // adjust for rig resolution
+ if (m_config.transceiver_resolution () > 2)
+ {
+ correction.rx = (correction.rx + 50) / 100 * 100;
+ correction.tx = (correction.tx + 50) / 100 * 100;
+ }
+ else if (m_config.transceiver_resolution () > 1)
+ {
+ correction.rx = (correction.rx + 10) / 20 * 20;
+ correction.tx = (correction.tx + 10) / 20 * 20;
+ }
+ else if (m_config.transceiver_resolution () > 0)
+ {
+ correction.rx = (correction.rx + 5) / 10 * 10;
+ correction.tx = (correction.tx + 5) / 10 * 10;
+ }
+ else if (m_config.transceiver_resolution () < -2)
+ {
+ correction.rx = correction.rx / 100 * 100;
+ correction.tx = correction.tx / 100 * 100;
+ }
+ else if (m_config.transceiver_resolution () < -1)
+ {
+ correction.rx = correction.rx / 20 * 20;
+ correction.tx = correction.tx / 20 * 20;
+ }
+ else if (m_config.transceiver_resolution () < 0)
+ {
+ correction.rx = correction.rx / 10 * 10;
+ correction.tx = correction.tx / 10 * 10;
+ }
+ m_astroCorrection = correction;
+ if (m_reverse_Doppler) m_astroCorrection.reverse ();
+ } else {
+ m_astroCorrection = {};
+ }
+ setRig ();
+ m_fAudioShift=m_fDop - correction.rx;
+ }
+}
+
+void MainWindow::setRig (Frequency f)
+{
+ if (f)
+ {
+ m_freqNominal = f;
+ genCQMsg ();
+ m_freqTxNominal = m_freqNominal;
+ if (m_astroWidget) m_astroWidget->nominal_frequency (m_freqNominal, m_freqTxNominal);
+ }
+ if (m_mode == "FreqCal"
+ && m_frequency_list_fcal_iter != m_config.frequencies ()->end ()) {
+ m_freqNominal = m_frequency_list_fcal_iter->frequency_ - ui->RxFreqSpinBox->value ();
+ }
+ if(m_transmitting && !m_config.tx_QSY_allowed ()) return;
+ if ((m_monitoring || m_transmitting) && m_config.transceiver_online ())
+ {
+ if (m_transmitting && m_config.split_mode () && !(m_config.superFox() && m_specOp==SpecOp::FOX))
+ {
+ m_config.transceiver_tx_frequency (m_freqTxNominal + m_astroCorrection.tx);
+ }
+ else
+ {
+ m_config.transceiver_frequency (m_freqNominal + m_astroCorrection.rx);
+ }
+ }
+}
+
+void MainWindow::fastPick(int x0, int x1, int y)
+{
+ float pixPerSecond=12000.0/512.0;
+ if(m_TRperiod<30.0) pixPerSecond=12000.0/256.0;
+ if(m_mode!="MSK144") return;
+ if(!m_decoderBusy) {
+ dec_data.params.newdat=0;
+ dec_data.params.nagain=1;
+ m_nPick=1;
+ if(y > 120) m_nPick=2;
+ m_t0Pick=x0/pixPerSecond;
+ m_t1Pick=x1/pixPerSecond;
+ m_dataAvailable=true;
+ decode();
+ }
+}
+
+void MainWindow::on_actionMeasure_reference_spectrum_triggered()
+{
+ if(!m_monitoring) on_monitorButton_clicked (true);
+ m_bRefSpec=true;
+}
+
+void MainWindow::on_actionMeasure_phase_response_triggered()
+{
+ if(m_bTrain) {
+ m_bTrain=false;
+ MessageBox::information_message (this, tr ("Phase Training Disabled"));
+ } else {
+ m_bTrain=true;
+ MessageBox::information_message (this, tr ("Phase Training Enabled"));
+ }
+}
+
+void MainWindow::on_actionErase_reference_spectrum_triggered()
+{
+ m_bClearRefSpec=true;
+}
+
+void MainWindow::freqCalStep()
+{
+ if (m_frequency_list_fcal_iter == m_config.frequencies ()->end ()
+ || ++m_frequency_list_fcal_iter == m_config.frequencies ()->end ()) {
+ m_frequency_list_fcal_iter = m_config.frequencies ()->begin ();
+ }
+
+ // allow for empty list
+ if (m_frequency_list_fcal_iter != m_config.frequencies ()->end ()) {
+ setRig (m_frequency_list_fcal_iter->frequency_ - ui->RxFreqSpinBox->value ());
+ }
+}
+
+void MainWindow::on_sbCQTxFreq_valueChanged(int)
+{
+ setXIT (ui->TxFreqSpinBox->value ());
+}
+
+void MainWindow::on_cbCQTx_toggled(bool b)
+{
+ ui->sbCQTxFreq->setEnabled(b);
+ genCQMsg();
+ if(b) {
+ ui->txrb6->setChecked(true);
+ m_ntx=6;
+ m_QSOProgress = CALLING;
+ }
+ setRig ();
+ setXIT (ui->TxFreqSpinBox->value ());
+}
+
+void MainWindow::statusUpdate () const
+{
+ if (!ui || m_block_udp_status_updates) return;
+ auto submode = current_submode ();
+ auto ftol = ui->sbFtol->value ();
+ if ("FST4W" == m_mode)
+ {
+ ftol = ui->sbFST4W_FTol->value ();
+ }
+ else if (!(ui->sbFtol->isVisible () && ui->sbFtol->isEnabled ()))
+ {
+ ftol = quint32_max;
+ }
+ auto tr_period = ui->sbTR->value ();
+ auto rx_frequency = ui->RxFreqSpinBox->value ();
+ if ("FST4W" == m_mode)
+ {
+ tr_period = ui->sbTR_FST4W->value ();
+ rx_frequency = ui->sbFST4W_RxFreq->value ();
+ }
+ else if (!(ui->sbTR->isVisible () && ui->sbTR->isEnabled ()))
+ {
+ tr_period = quint32_max;
+ }
+ m_messageClient->status_update (m_freqNominal, m_mode, m_hisCall,
+ QString::number (ui->rptSpinBox->value ()),
+ m_mode, ui->autoButton->isChecked (),
+ m_transmitting, m_decoderBusy,
+ rx_frequency, ui->TxFreqSpinBox->value (),
+ m_config.my_callsign (), m_config.my_grid (),
+ m_hisGrid, m_tx_watchdog,
+ submode != QChar::Null ? QString {submode} : QString {}, m_bFastMode,
+ static_cast<quint8> (m_specOp),
+ ftol, tr_period, m_multi_settings->configuration_name (),
+ m_currentMessage);
+}
+
+void MainWindow::childEvent (QChildEvent * e)
+{
+ if (e->child ()->isWidgetType ())
+ {
+ switch (e->type ())
+ {
+ case QEvent::ChildAdded: add_child_to_event_filter (e->child ()); break;
+ case QEvent::ChildRemoved: remove_child_from_event_filter (e->child ()); break;
+ default: break;
+ }
+ }
+ QMainWindow::childEvent (e);
+}
+
+// add widget and any child widgets to our event filter so that we can
+// take action on key press ad mouse press events anywhere in the main window
+void MainWindow::add_child_to_event_filter (QObject * target)
+{
+ if (target && target->isWidgetType ())
+ {
+ target->installEventFilter (this);
+ }
+ auto const& children = target->children ();
+ for (auto iter = children.begin (); iter != children.end (); ++iter)
+ {
+ add_child_to_event_filter (*iter);
+ }
+}
+
+// recursively remove widget and any child widgets from our event filter
+void MainWindow::remove_child_from_event_filter (QObject * target)
+{
+ auto const& children = target->children ();
+ for (auto iter = children.begin (); iter != children.end (); ++iter)
+ {
+ remove_child_from_event_filter (*iter);
+ }
+ if (target && target->isWidgetType ())
+ {
+ target->removeEventFilter (this);
+ }
+}
+
+void MainWindow::tx_watchdog (bool triggered)
+{
+ auto prior = m_tx_watchdog;
+ m_tx_watchdog = triggered;
+ if (triggered)
+ {
+ m_bTxTime=false;
+ if (m_tune) stop_tuning ();
+ if (m_auto) auto_tx_mode (false);
+ tx_status_label.setStyleSheet ("QLabel{color: #000000; background-color: #ff0000}");
+ tx_status_label.setText (tr ("Runaway Tx watchdog"));
+ QApplication::alert (this);
+ }
+ else
+ {
+ m_idleMinutes = 0;
+ update_watchdog_label ();
+ }
+ if (prior != triggered) statusUpdate ();
+}
+
+void MainWindow::update_watchdog_label ()
+{
+ if (m_config.watchdog () && m_mode!="WSPR" && m_mode!="FST4W")
+ {
+ watchdog_label.setText (tr ("WD:%1m").arg (m_config.watchdog () - m_idleMinutes));
+ watchdog_label.setVisible (true);
+ }
+ else
+ {
+ watchdog_label.setText (QString {});
+ watchdog_label.setVisible (false);
+ }
+}
+
+void MainWindow::on_cbMenus_toggled(bool b)
+{
+ select_geometry (!b ? 2 : ui->actionSWL_Mode->isChecked () ? 1 : 0);
+}
+
+void MainWindow::on_cbCQonly_toggled(bool)
+{ //Fix this -- no decode here?
+ to_jt9(m_ihsym,1,-1); //Send m_ihsym to jt9[.exe] and start decoding
+ decodeBusy(true);
+}
+
+void MainWindow::on_cbAutoSeq_toggled(bool b)
+{
+ ui->respondComboBox->setVisible((m_mode=="FT8" or m_mode=="FT4" or m_mode=="FST4"
+ or m_mode=="Q65") and b);
+}
+
+void MainWindow::on_measure_check_box_stateChanged (int state)
+{
+ m_config.enable_calibration (Qt::Checked != state);
+}
+
+void MainWindow::write_transmit_entry (QString const& file_name)
+{
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath (file_name)};
+ if (f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
+ {
+ QTextStream out(&f);
+ auto time = QDateTime::currentDateTimeUtc ();
+ time = time.addSecs (-fmod(double(time.time().second()),m_TRperiod));
+ out << time.toString("yyMMdd_hhmmss")
+ << " Transmitting " << qSetRealNumberPrecision (12) << (m_freqNominal / 1.e6)
+ << " MHz " << m_mode
+ << ": " << m_currentMessage
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f.close();
+ }
+ else
+ {
+ auto const& message = tr ("Cannot open \"%1\" for append: %2")
+ .arg (f.fileName ()).arg (f.errorString ());
+ QTimer::singleShot (0, [=] { // don't block guiUpdate
+ MessageBox::warning_message (this, tr ("Log File Error"), message);
+ });
+ }
+}
+
+void MainWindow::readWidebandDecodes()
+{
+ if(m_ActiveStationsWidget==NULL) return;
+ int nhr=0;
+ int nmin=0;
+ int nsec=0;
+ int nsnr=0;
+ while(m_fetched < qmapcom.ndecodes) {
+ // Recover and parse each decoded line.
+ QString line=QString::fromLatin1(qmapcom.result[m_fetched]);
+ m_fetched++;
+ nhr=line.mid(0,2).toInt();
+ nmin=line.mid(2,2).toInt();
+ nsec=line.mid(4,2).toInt();
+ double frx=line.mid(6,9).toDouble();
+ double fsked=line.mid(16,7).toDouble();
+ QString submode=line.mid(36,3);
+ QString msg=line.mid(41,-1);
+ int i1=msg.indexOf(" ");
+ int i2=i1 +1 + msg.mid(i1+1,-1).indexOf(" ");
+ QString dxcall=msg.mid(i1+1,i2-i1-1);
+ if(stdCall(dxcall)) {
+ QString w3=msg.mid(i2+1,-1);
+ nsnr=line.mid(31,3).toInt();
+ m_EMECall[dxcall].frx=frx;
+ m_EMECall[dxcall].fsked=fsked;
+ m_EMECall[dxcall].nsnr=nsnr;
+ m_EMECall[dxcall].t=3600*nhr + 60*nmin + nsec;
+ m_EMECall[dxcall].submode=submode;
+//### Make sure WSJT-X is set to a Q65 submode consistent with the executing QMAP.
+ if(w3.contains(grid_regexp)) m_EMECall[dxcall].grid4=w3;
+ bool bCQ=line.contains(" CQ ");
+// m_EMECall[dxcall].ready2call=(bCQ or line.contains(" 73") or line.contains(" RR73"));
+ m_EMECall[dxcall].ready2call=(bCQ);
+ Frequency frequency = (m_freqNominal/1000000) * 1000000 + int(fsked*1000.0);
+ bool bFromDisk=qmapcom.nQDecoderDone==2;
+ if(!bFromDisk and (m_EMECall[dxcall].grid4.contains(grid_regexp) or bCQ)) {
+ qDebug() << "To PSKreporter:" << dxcall << m_EMECall[dxcall].grid4 << frequency << m_mode << nsnr;
+ if (!m_psk_Reporter.addRemoteStation (dxcall, m_EMECall[dxcall].grid4, frequency, m_mode, nsnr)) {
+ showStatusMessage (tr ("Spotting to PSK Reporter unavailable"));
+ }
+ }
+ }
+ }
+
+ if (m_config.spot_to_psk_reporter ()) {
+ m_psk_Reporter.sendReport(); // Upload any queued spots
+ }
+
+// Update "m_wEMECall" by reading qmap_decodes.txt
+ QMap<QString,EMECall>::iterator i;
+ QString t="";
+ QString t1;
+ QString dxcall;
+ QString dxgrid4;
+ QStringList list;
+ float f[100];
+ int indx[100];
+ int maxAge=m_ActiveStationsWidget->maxAge();
+
+ m_ActiveStationsWidget->setClickOK(false);
+ int k=0;
+
+ for(i=m_EMECall.begin(); i!=m_EMECall.end(); i++) {
+ bool bSkip=false;
+ if(m_ActiveStationsWidget->wantedOnly() and m_EMEworked[i.key()]) bSkip=true;
+ if(m_ActiveStationsWidget->readyOnly() and !i->ready2call) bSkip=true;
+ if(!bSkip) {
+ int snr=i->nsnr;
+ QString submode=i->submode;
+ int odd=0;
+ if(submode.left(2)=="30" and (i->t%60)==0) odd=1;
+ if(submode.left(2)=="60" and (i->t%120)==0) odd=1;
+ int age=(3600*nhr + 60*nmin + nsec - (i->t))/60;
+ char c2[3]={32,32,0};
+ if(age<0) age += 1440;
+ if(age<=maxAge) {
+ dxcall=(i.key()+" ").left(8);
+ dxgrid4=(i->grid4+"... ").left(4);
+ if(!m_EMEworked[dxcall.trimmed()]) c2[0]=35; //# for not in log
+ if(i->ready2call) c2[1]=42; //* for ready to call
+ t1=t1.asprintf("%7.3f %5.1f %+03d %3s %8s %4s %3d %3d %2s\n",i->frx,i->fsked,snr,
+ submode.toLatin1().constData(),dxcall.toLatin1().constData(),
+ dxgrid4.toLatin1().constData(),odd,age,c2);
+ f[k]=i->fsked;
+ list.append(t1);
+ k++;
+ }
+ m_ActiveStationsWidget->setClickOK(true);
+ }
+ }
+
+ if(k>0) {
+ t1="";
+ int kz=k;
+ indexx_(f,&kz,indx);
+ for(int k=0; k<kz; k++) {
+ int j=indx[k]-1;
+ t1=t1.asprintf("%2d. ",k+1);
+ t1+=list[j];
+ m_ready2call[k]=list[j];
+ t+=t1;
+ }
+ }
+
+ if(m_ActiveStationsWidget != NULL) {
+ m_ActiveStationsWidget->erase();
+ m_ActiveStationsWidget->displayRecentStations(m_mode,t);
+ m_ActiveStationsWidget->setClickOK(true);
+ }
+ if(ipc_qmap[2]!=0) {
+ m_fetched=0;
+ ipc_qmap[0]=0;
+ ipc_qmap[2]=0;
+ }
+}
+
+// -------------------------- Code for FT8 DXpedition Mode ---------------------------
+
+void MainWindow::hound_reply ()
+{
+ if (!m_tune) {
+ // Select Tx3, set TxFreq to FoxFreq, and Force Auto ON.
+ ui->txrb3->setChecked (true);
+ m_nSentFoxRrpt = 1;
+ ui->rptSpinBox->setValue(m_rptSent.toInt());
+ if (!m_auto) auto_tx_mode(true);
+ if (!m_config.superFox()) ui->TxFreqSpinBox->setValue (m_nFoxFreq);
+ stopWRTimer.start(int(11000.0*m_TRperiod)); // Tx3 timeout when in Hound mode
+ }
+}
+
+void MainWindow::on_sbNlist_valueChanged(int n)
+{
+ m_Nlist=n;
+}
+
+void MainWindow::on_sbNslots_valueChanged(int n)
+{
+ m_Nslots=n;
+ if(m_specOp!=SpecOp::FOX) return;
+ QString t;
+ t = t.asprintf(" NSlots %d",m_Nslots);
+ writeFoxQSO(t);
+ if(!m_config.superFox()) m_Nslots0=n;
+}
+
+void MainWindow::on_sbMax_dB_valueChanged(int n)
+{
+ m_max_dB=n;
+ if(m_specOp!=SpecOp::FOX) return;
+ QString t;
+ t = t.asprintf(" Max_dB %d",m_max_dB);
+ writeFoxQSO(t);
+}
+void MainWindow::FoxReset(QString reason="")
+{
+ QFile f(m_config.temp_dir().absoluteFilePath("houndcallers.txt"));
+ f.remove();
+ ui->decodedTextBrowser->setText("");
+ ui->houndQueueTextBrowser->setText("");
+ ui->foxTxListTextBrowser->setText("");
+
+ m_houndQueue.clear();
+ m_foxQSO.clear();
+ m_foxQSOinProgress.clear();
+ m_discard_decoded_hounds_this_cycle = true; // discard decoded messages until the next cycle
+ if (reason != "") writeFoxQSO(" " + reason);
+ writeFoxQSO(" Reset");
+}
+
+void MainWindow::on_pbFoxReset_clicked()
+{
+ if(m_specOp!=SpecOp::FOX) return;
+ auto button = MessageBox::query_message (this, tr ("Confirm Reset"),
+ tr ("Are you sure you want to clear the QSO queues?"));
+ if(button == MessageBox::Yes) {
+ FoxReset();
+ }
+}
+
+void MainWindow::on_pbFreeText_clicked()
+{
+ bool ok;
+ m_freeTextMsg = QInputDialog::getText (this, tr("Free Text Message"),
+ tr("Message:"), QLineEdit::Normal, m_freeTextMsg0, &ok).left(26);
+ if(ok) {
+ m_freeTextMsg=m_freeTextMsg.toUpper();
+ m_freeTextMsg0=m_freeTextMsg;
+ }
+}
+
+void MainWindow::on_comboBoxHoundSort_activated(int index)
+{
+ if(index!=-99) houndCallers(); //Silence compiler warning
+}
+
+#ifdef FOX_OTP
+QString MainWindow::foxOTPcode()
+{
+ QString code;
+ if (!m_config.OTPSeed().isEmpty())
+ {
+ char output[7];
+ QDateTime dateTime = dateTime.currentDateTime();
+ QByteArray ba = m_config.OTPSeed().toLocal8Bit();
+ char *c_str = ba.data();
+ int return_length;
+ if (6 == (return_length = create_totp(c_str, output, dateTime.toTime_t(), 30, 0)))
+ {
+ code = QString(output);
+ } else
+ {
+ code = "000000";
+ LOG_INFO(QString("foxOTPcode: Incorrect return length %1").arg(return_length));
+ }
+ } else
+ {
+ code = "000000";
+ showStatusMessage(tr("TOTP: No seed entered in fox configuration to generate verification code."));
+ LOG_INFO(QString("foxOTPcode: No seed entered in fox configuration to generate verification code."));
+ }
+ return code;
+}
+#endif
+//------------------------------------------------------------------------------
+QString MainWindow::sortHoundCalls(QString t, int isort, int max_dB)
+{
+/* Called from "houndCallers()" to sort the list of calling stations by
+ * specified criteria.
+ *
+ * QString "t" contains a list of Hound callers read from file "houndcallers.txt".
+ * isort=0: random (shuffled order)
+ * 1: Call
+ * 2: Grid
+ * 3: SNR (reverse order)
+ * 4: Distance (reverse order)
+ * 5: Age (reverse order)
+ * 6: Continent
+ * 7: User defined (reverse order)
+ *
+*/
+
+ QMap<QString,QString> map;
+ QStringList lines,lines2;
+ QString msg,houndCall,t1;
+ QString ABC{"ABCDEFGHIJKLMNOPQRSTUVWXYZ _"};
+ QList<int> reverse_sorted{3,4,5,6};
+ QString Continents{" AF AN AS EU NA OC SA UN "}; // matches what we get from AD1C's country list
+ QList<int> list;
+ int i,j,k,n,nlines;
+ bool bReverse = reverse_sorted.contains(isort);
+
+ isort=qAbs(isort);
+// Save only the most recent transmission from each caller.
+ lines = t.split("\n");
+ nlines=lines.length()-1;
+ for(i=0; i<nlines; i++) {
+ msg=lines.at(i); //key = callsign
+ if(msg.mid(13,1)==" ") msg=msg.mid(0,13) + "...." + msg.mid(17);
+ houndCall=msg.split(" ").at(0); //value = "call grid snr freq dist age continent user-defined
+ map[houndCall]=msg;
+ }
+
+ j=0;
+ t="";
+ for(auto a: map.keys()) {
+ t1=map[a].split(" ",SkipEmptyParts).at(2);
+ // add the user-defined value to the end of the line. Example:
+ // JJ0NCC PM97 15 2724 7580 2 AS 67
+ // PY7ZZ HI21 -13 1673 10549 1 SA -
+
+ QString annotated_value_s{" - "}; // default
+ qint32 annotated_value = 0;
+
+ if (m_annotated_callsigns.contains(a)) {
+ annotated_value = m_annotated_callsigns.value(a);
+ annotated_value_s = QString::number(annotated_value);
+ }
+
+ map[a] += QString(" %1").arg(annotated_value_s, 8);
+ int nsnr=t1.toInt(); // get snr
+ if(nsnr <= max_dB) { // keep only if snr in specified range
+ if(isort==1) t += map[a] + "\n";
+ if (isort==3 or isort==4 or isort==5) { // numeric ones: snr, distance, age
+ if (isort==3)
+ i=2; // sort Hound calls by snr
+ else
+ i=isort; // part of the line that we want
+ t1=map[a].split(" ",SkipEmptyParts).at(i);
+ int isort_value = t1.toInt();
+ if (isort==5) { // sort by age ascending
+ isort_value = (100 < isort_value ? 100 : 100-isort_value);
+ }
+ n=1000*(isort_value+100) + j; // pack (snr or dist or age) and index j into n
+ list.insert(j,n); // add n to list at [j]
+ }
+ if (isort == 6) { // sort by continent
+ i = 6;
+ QStringList parts = map[a].split(" ", SkipEmptyParts);
+ if (parts.size() <= i + 1) {
+ n = j;
+ } else {
+ QString cont = map[a].split(" ", SkipEmptyParts).at(i);
+ int cont_n = Continents.indexOf(" " + cont + " ");
+ n = 1000 + 1000 * cont_n + j; // index may return -1, so add 1000 to make it positive
+ }
+ list.insert(j, n);
+ }
+
+ if(isort==2) { // sort Hound calls by grid
+ t1=map[a].split(" ",SkipEmptyParts).at(1);
+ if(t1=="....") t1="ZZ99";
+ int i1=ABC.indexOf(t1.mid(0,1));
+ int i2=ABC.indexOf(t1.mid(1,1));
+ n=100*(26*i1+i2)+t1.mid(2,2).toInt();
+ n=1000*n + j; // pack ngrid and index j into n
+ list.insert(j,n); // add n to list at [j]
+ }
+
+ if(isort==7) { // annotated value provided by external app
+ n = 1000 + 1000 * std::max((qint32) 0, annotated_value) + j;
+ list.insert(j, n);
+ }
+
+ lines2.insert(j,map[a]); // add map[a] to lines2 at [j]
+ j++;
+ }
+ }
+
+ if(isort>1) {
+ if(bReverse) {
+ std::sort (list.begin (), list.end (), std::greater<int> ());
+ } else {
+ std::sort (list.begin (), list.end ());
+ }
+ }
+
+ if(isort>1) {
+ for(i=0; i<j; i++) {
+ k=list[i]%1000;
+ n=list[i]/1000 - 100;
+ t += lines2.at(k) + "\n";
+ }
+ }
+
+ int nn=lines2.length();
+ if(isort==0) { // shuffle Hound calls to random order
+ int a[nn];
+ for(i=0; i<nn; i++) {
+ a[i]=i;
+ }
+ for(i=nn-1; i>-1; i--) {
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ j = (i + 1) * QRandomGenerator::global ()->generateDouble ();
+#else
+ j=(i+1)*double(qrand())/RAND_MAX;
+#endif
+ std::swap (a[j], a[i]);
+ t += lines2.at(a[i]) + "\n";
+ }
+ }
+
+ int i0=t.indexOf("\n") + 1;
+ m_nSortedHounds=0;
+ if(i0 > 0) {
+ m_nSortedHounds=qMin(t.length(),m_Nlist*i0)/i0; // Number of sorted & displayed Hounds
+ }
+ m_houndCallers=t.mid(0,m_Nlist*i0);
+
+ return m_houndCallers;
+}
+
+void MainWindow::removeHoundFromCallingList(QString callsign)
+{
+ QString text = m_houndCallers;
+ QRegularExpression re = QRegularExpression("^" + callsign + "[^\\n]+\\n", QRegularExpression::MultilineOption);
+ text.remove(re);
+ if (text != m_houndCallers) {
+ m_nSortedHounds--;
+ m_houndCallers = text;
+ ui->decodedTextBrowser->setHighlightedHoundText(m_houndCallers);
+ }
+}
+//------------------------------------------------------------------------------
+void MainWindow::selectHound(QString line, bool bTopQueue)
+{
+/* Called from doubleClickOnCall() in DXpedition Fox mode.
+ * QString "line" is a user-selected line from left text window.
+ * The line may be selected by double-clicking; alternatively, hitting
+ * <Enter> is equivalent to double-clicking on the top-most line.
+*/
+ if(line.simplified().isEmpty()) return;
+ if(line.length() < 6) return;
+ QString houndCall=line.split(" ",SkipEmptyParts).at(0);
+
+// Don't add a call already enqueued or in QSO
+ if(ui->houndQueueTextBrowser->toPlainText().indexOf(houndCall) >= 0) return;
+
+ QString houndGrid=line.split(" ",SkipEmptyParts).at(1); // Hound caller's grid
+ QString rpt=line.split(" ",SkipEmptyParts).at(2); // Hound SNR
+
+ m_houndCallers=m_houndCallers.remove(line+"\n"); // Remove t from sorted Hound list
+ m_nSortedHounds--;
+ ui->decodedTextBrowser->setHighlightedHoundText(m_houndCallers); // Populate left window with Hound callers
+ QString t1=houndCall + " ";
+ QString t2=rpt;
+ QString t1_with_grid;
+ if(rpt.mid(0,1) != "-" and rpt.mid(0,1) != "+") t2="+" + rpt;
+ if(t2.length()==2) t2=t2.mid(0,1) + "0" + t2.mid(1,1);
+ t1=t1.mid(0,12) + t2;
+ // display the callers, highlighting calls if necessary
+ ui->houndQueueTextBrowser->insertText(bTopQueue ? t1 + "\n" : t1, QColor{}, QColor{}, houndCall, "", bTopQueue ? QTextCursor::Start : QTextCursor::End);
+
+ t1_with_grid=t1 + " " + houndGrid; // Append the grid
+
+ if (bTopQueue)
+ {
+ m_houndQueue.prepend(t1_with_grid); // Put this hound into the queue at the top
+ }
+ else
+ {
+ m_houndQueue.enqueue(t1_with_grid); // Put this hound into the queue
+ }
+ writeFoxQSO(" Sel: " + t1_with_grid);
+ QTextCursor cursor = ui->houndQueueTextBrowser->textCursor();
+ cursor.setPosition(0); // Scroll to top of list
+ ui->houndQueueTextBrowser->setTextCursor(cursor);
+ cursor = ui->decodedTextBrowser->textCursor();
+ cursor.setPosition(0); // Highlighting happens in the forward direction
+ ui->decodedTextBrowser->setTextCursor(cursor);
+}
+
+//------------------------------------------------------------------------------
+void MainWindow::houndCallers()
+{
+/* Called from decodeDone(), in DXpedition Fox mode. Reads decodes from file
+ * "houndcallers.txt", ignoring any that are not addressed to MyCall, are already
+ * in the stack, or with whom a QSO has been started. Others are considered to
+ * be Hounds eager for a QSO. We add caller information (Call, Grid, SNR, Freq,
+ * Distance, Age, and Continent) to a list, sort the list by specified criteria,
+ * and display the top N_Hounds entries in the left text window.
+*/
+ // if frequency was changed in the middle of an interval, there's a flag set to ignore the decodes. Reset it here
+ //
+
+ if (m_discard_decoded_hounds_this_cycle)
+ {
+ m_discard_decoded_hounds_this_cycle = false; //
+ return; // don't use these decodes
+ }
+
+// Read decodes of the current period
+ QFile d(m_config.temp_dir().absoluteFilePath("decoded.txt"));
+ QTextStream ds(&d);
+ QString decoded="";
+ if(d.open(QIODevice::ReadOnly | QIODevice::Text)) {
+ while (!ds.atEnd()) {
+ decoded = ds.readAll();
+ }
+ ds.flush();
+ d.close();
+ }
+
+ QFile f(m_config.temp_dir().absoluteFilePath("houndcallers.txt"));
+ if(f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+ QTextStream s(&f);
+ QString t="";
+ QString line,houndCall,paddedHoundCall;
+ m_nHoundsCalling=0;
+ int nTotal=0; //Total number of decoded Hounds calling Fox in 4 most recent Rx sequences
+
+// Read and process the file of Hound callers.
+ while(!s.atEnd()) {
+ line=s.readLine();
+ nTotal++;
+ int i0=line.indexOf(" ");
+ houndCall=line.mid(0,i0);
+ paddedHoundCall=houndCall + " ";
+ //Don't list a hound already in the queue
+ if(!ui->houndQueueTextBrowser->toPlainText().contains(paddedHoundCall)) {
+ if(ui->cbWorkDupes->isChecked()) {
+ if(m_loggedByFox[houndCall].contains(m_lastBand)
+ and !decoded.contains(paddedHoundCall)) continue; // don't display old messages again of stations already logged
+ } else {
+ if(m_loggedByFox[houndCall].contains(m_lastBand)) continue; // already logged on this band
+ }
+ if(m_foxQSO.contains(houndCall)) continue; // still in the QSO map
+ auto const& entity = m_logBook.countries ()->lookup (houndCall);
+ auto const& continent = AD1CCty::continent (entity.continent);
+
+// If we are using a directed CQ, ignore Hound calls that do not comply.
+ QString CQtext=ui->comboBoxCQ->currentText();
+ if(CQtext.length()==5 and (continent!=CQtext.mid(3,2))) continue;
+ int nCallArea=-1;
+ if(CQtext.length()==4) {
+ for(int i=houndCall.length()-1; i>0; i--) {
+ if(houndCall.mid(i,1).toInt() > 0) nCallArea=houndCall.mid(i,1).toInt();
+ if(houndCall.mid(i,1)=="0") nCallArea=0;
+ if(nCallArea>=0) break;
+ }
+ if(nCallArea!=CQtext.mid(3,1).toInt()) continue;
+ }
+// This houndCall passes all tests, add it to the list.
+ t = t + line + " " + continent + "\n";
+ m_nHoundsCalling++; // Number of accepted Hounds to be sorted
+ }
+ }
+ if(m_foxLogWindow) m_foxLogWindow->callers (nTotal);
+
+// Sort and display accumulated list of Hound callers
+ if(t.length()>30) {
+ m_isort=ui->comboBoxHoundSort->currentIndex();
+ QString t1=sortHoundCalls(t,m_isort,m_max_dB);
+ ui->decodedTextBrowser->setHighlightedHoundText(t1);
+ }
+ QTextCursor cursor = ui->decodedTextBrowser->textCursor();
+ cursor.setPosition(0); // Set scroll at top, in preparation for highlighting messages
+ ui->decodedTextBrowser->setTextCursor(cursor);
+ f.close();
+ }
+}
+
+void MainWindow::foxRxSequencer(QString msg, QString houndCall, QString rptRcvd)
+{
+/* Called from "readFromStdOut()" to process decoded messages of the form
+ * "myCall houndCall R+rpt".
+ *
+ * If houndCall matches a callsign in one of our active QSO slots, we
+ * prepare to send "houndCall RR73" to that caller.
+*/
+ if(m_foxQSO.contains(houndCall)) {
+ m_foxQSO[houndCall].rcvd=rptRcvd.mid(1); //Save report Rcvd, for the log
+ m_foxQSO[houndCall].tFoxRrpt=m_tFoxTx; //Save time R+rpt was received
+ writeFoxQSO(" Rx: " + msg.trimmed());
+ } else {
+ for(QString hc: m_foxQSO.keys()) { //Check for a matching compound call
+ if(hc.contains("/"+houndCall) or hc.contains(houndCall+"/")) {
+ m_foxQSO[hc].rcvd=rptRcvd.mid(1); //Save report Rcvd, for the log
+ m_foxQSO[hc].tFoxRrpt=m_tFoxTx; //Save time R+rpt was received
+ writeFoxQSO(" Rx: " + msg.trimmed());
+ }
+ }
+ }
+}
+
+void MainWindow::updateFoxQSOsInProgressDisplay()
+{
+
+ ui->foxTxListTextBrowser->clear();
+ for (int i = 0; i < m_foxQSOinProgress.count(); i++)
+ {
+ //First do those for QSOs in progress
+ QString hc = m_foxQSOinProgress.at(i);
+ QString status = m_foxQSO[hc].ncall > m_maxStrikes ? QString(" (rx) ") : QString(" ");
+ QString str = (hc + " ").left(13) + QString::number(m_foxQSO[hc].ncall) + status;
+ ui->foxTxListTextBrowser->insertText(str, QColor{}, QColor{}, hc, "", QTextCursor::End);
+ }
+}
+
+void MainWindow::foxTxSequencer()
+{
+/* Called from guiUpdate at the point where an FT8 Fox-mode transmission
+ * is to be started.
+ *
+ * Determine what the Tx message(s) will be for each active slot, call
+ * foxgen() to generate and accumulate the corresponding waveform.
+*/
+
+ qint64 now=QDateTime::currentMSecsSinceEpoch()/1000;
+ QStringList list1; //Up to NSlots Hound calls to be sent RR73
+ QStringList list2; //Up to NSlots Hound calls to be sent a report
+ QString fm; //Fox message to be transmitted
+ QString hc,hc1,hc2; //Hound calls
+ QString t,rpt;
+ qint32 islot=0;
+ qint32 ncalls_sent=0;
+ qint32 n1,n2,n3;
+ int nMaxRemainingSlots=0;
+ static u_int m_tFoxTxSinceOTP=99;
+
+ m_tFoxTxSinceOTP++;
+ m_tFoxTx++; //Increment Fox Tx cycle counter
+
+ //Is it time for a stand-alone CQ?
+ if(m_tFoxTxSinceCQ >= m_foxCQtime and ui->cbMoreCQs->isChecked()) {
+ fm=ui->comboBoxCQ->currentText() + " " + m_config.my_callsign();
+ if(!fm.contains("/")) {
+ //If Fox is not a compound callsign, add grid to the CQ message.
+ fm += " " + m_config.my_grid().mid(0,4);
+ m_fullFoxCallTime=now;
+ }
+ m_tFoxTx0=m_tFoxTx; //Remember when we sent a CQ
+ islot++;
+ foxGenWaveform(islot-1,fm);
+ goto Transmit;
+ }
+
+#ifdef FOX_OTP
+ // Send OTP message maybe for regular fox mode
+ if (!m_config.superFox() && m_config.OTPEnabled() && (islot < m_Nslots) && (m_tFoxTxSinceOTP >= m_config.OTPinterval()))
+ {
+ // truncated callsign + OTP code (to be under 13 character limit of free text)
+ QString trunc_call=m_config.my_callsign().left(5).split("/").at(0);
+ fm = trunc_call + ".V" + foxOTPcode(); // N5J-> N5J.V123456, W1AW/7 -> W1AW.V123456, 4U1IARU -> 4U1IA.V123456
+ m_tFoxTxSinceOTP = 0; //Remember when we sent a Tx5
+ islot++;
+ foxGenWaveform(islot - 1, fm);
+ }
+#endif
+
+//Compile list1: up to NSLots Hound calls to be sent RR73
+ for(QString hc: m_foxQSO.keys()) { //Check all Hound calls: First priority
+ if(m_foxQSO[hc].tFoxRrpt<0) continue;
+ if(m_foxQSO[hc].tFoxRrpt - m_foxQSO[hc].tFoxTxRR73 > 3) {
+ //Has been a long time since we sent RR73
+ if(list1.size()>=(m_Nslots - islot)) goto list1Done;
+ list1 << hc; //Add to list1
+ m_foxQSO[hc].tFoxTxRR73 = m_tFoxTx; //Time RR73 is sent
+ m_foxQSO[hc].nRR73++; //Increment RR73 counter
+ }
+ }
+
+ for(QString hc: m_foxQSO.keys()) { //Check all Hound calls: Second priority
+ if(m_foxQSO[hc].tFoxRrpt<0) continue;
+ if(m_foxQSO[hc].tFoxTxRR73 < 0) {
+ //Have not yet sent RR73
+ if(list1.size()>=(m_Nslots - islot)) goto list1Done;
+ list1 << hc; //Add to list1
+ m_foxQSO[hc].tFoxTxRR73 = m_tFoxTx; //Time RR73 is sent
+ m_foxQSO[hc].nRR73++; //Increment RR73 counter
+ }
+ }
+
+ for(QString hc: m_foxQSO.keys()) { //Check all Hound calls: Third priority
+ if(m_foxQSO[hc].tFoxRrpt<0) continue;
+ if(m_foxQSO[hc].tFoxTxRR73 <= m_foxQSO[hc].tFoxRrpt) {
+ //We received R+rpt more recently than we sent RR73
+ if(list1.size()>=(m_Nslots - islot)) goto list1Done;
+ list1 << hc; //Add to list1
+ m_foxQSO[hc].tFoxTxRR73 = m_tFoxTx; //Time RR73 is sent
+ m_foxQSO[hc].nRR73++; //Increment RR73 counter
+ }
+ }
+
+list1Done:
+//Compile list2: Up to Nslots Hound calls to be sent a report.
+// For Superfox, up to 5 RR73, but only 4 callsigns with reports. m_NSlots should be 5 for SF.
+ nMaxRemainingSlots = (m_config.superFox()) ? m_Nslots - 1 : m_Nslots;
+ for(int i=0; i<m_foxQSOinProgress.count(); i++) {
+ //First do those for QSOs in progress
+ hc=m_foxQSOinProgress.at(i);
+ if((m_foxQSO[hc].tFoxRrpt < 0) and (m_foxQSO[hc].ncall < m_maxStrikes)) {
+ //Sent him a report and have not received R+rpt: call him again
+ if(list2.size()>=(nMaxRemainingSlots - islot)) goto list2Done;
+ list2 << hc; //Add to list2
+ if(list2.size() == nMaxRemainingSlots) goto list2Done;
+ }
+ }
+
+ while(!m_houndQueue.isEmpty()) {
+ //Start QSO with a new Hound
+ if (list2.size() == (nMaxRemainingSlots - islot))
+ {
+ break;
+ }
+ t=m_houndQueue.dequeue(); //Fetch new hound from queue
+ int i0=t.indexOf(" ");
+ hc=t.mid(0,i0); //hound call
+ list2 << hc; //Add new Hound to list2
+ m_foxQSOinProgress.enqueue(hc); //Put him in the QSO queue
+ m_foxQSO[hc].grid=t.mid(16,4); //Hound grid
+ rpt=t.mid(12,3); //report to send Hound
+ m_foxQSO[hc].sent=rpt; //Report to send him
+ m_foxQSO[hc].ncall=0; //Start a new Hound
+ m_foxQSO[hc].nRR73 = 0; //Have not sent RR73
+ m_foxQSO[hc].rcvd = -99; //Have not received R+rpt
+ m_foxQSO[hc].tFoxRrpt = -1; //Have not received R+rpt
+ m_foxQSO[hc].tFoxTxRR73 = -1; //Have not sent RR73
+ refreshHoundQueueDisplay();
+ }
+
+list2Done:
+
+ n1=list1.size();
+ n2=list2.size();
+ n3=qMax(n1,n2);
+ if(n3>m_Nslots) n3=m_Nslots;
+ for(int i=0; i<n3; i++) {
+ hc1="";
+ fm="";
+ if(i<n1 and i<n2) {
+ hc1=list1.at(i);
+ hc2=list2.at(i);
+ m_foxQSO[hc2].ncall++;
+ fm = Radio::base_callsign(hc1) + " RR73; " + Radio::base_callsign(hc2) +
+ " <" + m_config.my_callsign() + "> " + m_foxQSO[hc2].sent;
+ }
+ if(i<n1 and i>=n2) {
+ hc1=list1.at(i);
+ fm = Radio::base_callsign(hc1) + " " + m_baseCall + " RR73"; //Standard FT8 message
+ }
+
+ if(hc1!="") {
+ auto already_logged = m_loggedByFox[hc1].contains(m_lastBand + " "); // already logged this call on this band?
+
+ if (!already_logged) { // Log this QSO!
+ auto QSO_time = QDateTime::currentDateTimeUtc ();
+ m_hisCall=hc1;
+ m_hisGrid=m_foxQSO[hc1].grid;
+ m_rptSent=m_foxQSO[hc1].sent;
+ m_rptRcvd=m_foxQSO[hc1].rcvd;
+ if (!m_foxLogWindow) on_fox_log_action_triggered ();
+ if (m_logBook.fox_log ()->add_QSO (QSO_time, m_hisCall, m_hisGrid, m_rptSent, m_rptRcvd, m_lastBand))
+ {
+ writeFoxQSO (QString {" Log: %1 %2 %3 %4 %5"}.arg (m_hisCall).arg (m_hisGrid)
+ .arg (m_rptSent).arg (m_rptRcvd).arg (m_lastBand));
+ on_logQSOButton_clicked ();
+ QTimer::singleShot (13000, [=] {
+ m_foxQSOinProgress.removeOne(hc1); //Remove from In Progress window
+ updateFoxQSOsInProgressDisplay(); //Update InProgress display after Tx is complete
+ });
+ }
+ m_loggedByFox[hc1] += (m_lastBand + " ");
+ }
+ else
+ {
+ // note that this is a duplicate
+ writeFoxQSO(QString{" Dup: %1 %2 %3 %4 %5"}.arg(m_hisCall).arg(m_hisGrid)
+ .arg(m_rptSent).arg(m_rptRcvd).arg(m_lastBand));
+ }
+ }
+
+ if(i<n2 and fm=="") {
+ hc2=list2.at(i);
+ m_foxQSO[hc2].ncall++;
+ fm = Radio::base_callsign(hc2) + " " + m_baseCall + " " + m_foxQSO[hc2].sent; //Standard FT8 message
+ }
+ islot++;
+ ncalls_sent++;
+ foxGenWaveform(islot-1,fm); //Generate tx waveform
+ }
+
+ if(islot < m_Nslots) {
+ //At least one slot is still open
+ if(ncalls_sent==0 or ((m_tFoxTx-m_tFoxTx0>=4) and ui->cbMoreCQs->isChecked())) {
+ //Roughly every 4th Tx sequence, put a CQ message in an otherwise empty slot
+ fm=ui->comboBoxCQ->currentText() + " " + m_config.my_callsign();
+ if(!fm.contains("/")) {
+ fm += " " + m_config.my_grid().mid(0,4);
+ m_tFoxTx0=m_tFoxTx; //Remember when we send a CQ
+ m_fullFoxCallTime=now;
+ }
+ islot++;
+ foxGenWaveform(islot-1,fm);
+ }
+ }
+
+Transmit:
+ foxcom_.nslots=islot;
+ foxcom_.nfreq=ui->TxFreqSpinBox->value();
+ if(m_config.split_mode()) foxcom_.nfreq = foxcom_.nfreq - m_XIT; //Fox Tx freq
+ QString foxCall=m_config.my_callsign() + " ";
+ ::memcpy(foxcom_.mycall, foxCall.toLatin1(),sizeof foxcom_.mycall); //Copy Fox callsign into foxcom_
+ bool bSuperFox=m_config.superFox();
+ foxcom_.bMoreCQs=ui->cbMoreCQs->isChecked();
+ foxcom_.bSendMsg=ui->cbSendMsg->isChecked();
+// qDebug() << "cc" << foxcom_.bMoreCQs << foxcom_.bSendMsg << foxcom_.nslots
+// << m_Nslots << m_freeTextMsg0;
+ ::memcpy(foxcom_.textMsg, m_freeTextMsg0.leftJustified(26,' ').toLatin1(),26);
+ auto fname {QDir::toNativeSeparators(m_config.writeable_data_dir().absoluteFilePath("sfox_1.dat")).toLocal8Bit()};
+ foxgen_(&bSuperFox, fname.constData(), (FCL)fname.size());
+ if(bSuperFox) {
+ writeFoxTxMsgs();
+ sfox_tx();
+ }
+ m_tFoxTxSinceCQ++;
+
+ for(QString hc: m_foxQSO.keys()) { //Check for strikeout or timeout
+ if(m_foxQSO[hc].ncall>=m_maxStrikes) m_foxQSO[hc].ncall++;
+ bool b1=((m_tFoxTx - m_foxQSO[hc].tFoxRrpt) > 2*m_maxFoxWait) and
+ (m_foxQSO[hc].tFoxRrpt > 0);
+ bool b2=((m_tFoxTx - m_foxQSO[hc].tFoxTxRR73) > m_maxFoxWait) and
+ (m_foxQSO[hc].tFoxTxRR73>0);
+ bool b3=(m_foxQSO[hc].ncall >= m_maxStrikes+m_maxFoxWait);
+ bool b4=(m_foxQSO[hc].nRR73 >= m_maxStrikes);
+ if(b1 or b2 or b3 or b4) {
+ m_foxQSO.remove(hc);
+ m_foxQSOinProgress.removeOne(hc);
+ }
+ }
+
+ if (m_foxLogWindow)
+ {
+ update_foxLogWindow_rate();
+ m_foxLogWindow->queued (m_foxQSOinProgress.count ());
+ }
+ updateFoxQSOsInProgressDisplay();
+}
+
+void MainWindow::update_foxLogWindow_rate()
+{
+ if (m_foxLogWindow) {
+ m_foxLogWindow->rate(m_logBook.fox_log()->rate());
+ }
+}
+
+void MainWindow::refreshHoundQueueDisplay()
+{
+ ui->houndQueueTextBrowser->clear();
+ for (QString line: m_houndQueue) {
+ auto hc = line.mid(0, 12).trimmed();
+ ui->houndQueueTextBrowser->insertText(line, QColor{}, QColor{}, hc, "", QTextCursor::End);
+ }
+}
+
+void MainWindow::doubleClickOnFoxQueue(Qt::KeyboardModifiers modifiers)
+{
+ if(modifiers==9999) return; //Silence compiler warning
+ QTextCursor cursor=ui->houndQueueTextBrowser->textCursor();
+ cursor.setPosition(cursor.selectionStart());
+ QString houndLine=cursor.block().text();
+ QString houndCall=houndLine.mid(0,12).trimmed();
+
+ if (modifiers == (Qt::AltModifier))
+ {
+ //Alt-click on a Fox queue entry - put on top of queue
+ // remove
+ for(auto i=0; i<m_houndQueue.size(); i++) {
+ QString t = m_houndQueue[i];
+ QString hc = t.mid(0, 12).trimmed();
+ if (hc == houndCall) {
+ m_houndQueue.removeAt(i);
+ break;
+ }
+ }
+ m_houndQueue.prepend(houndLine);
+ refreshHoundQueueDisplay();
+ } else
+ {
+ writeFoxQSO(" Del: " + houndCall);
+ QQueue <QString> tmpQueue;
+ while (!m_houndQueue.isEmpty())
+ {
+ QString t = m_houndQueue.dequeue();
+ QString hc = t.mid(0, 12).trimmed();
+ if (hc != houndCall) tmpQueue.enqueue(t);
+ }
+ m_houndQueue.swap(tmpQueue);
+ refreshHoundQueueDisplay();
+ }
+}
+
+void MainWindow::doubleClickOnFoxInProgress(Qt::KeyboardModifiers modifiers)
+{
+ if (modifiers == 9999) return; //Silence compiler warning
+ QTextCursor cursor = ui->foxTxListTextBrowser->textCursor();
+ cursor.setPosition(cursor.selectionStart());
+ QString houndLine = cursor.block().text();
+ QString houndCall = houndLine.mid(0, 12).trimmed();
+
+ if (modifiers == 0)
+ {
+ m_foxQSO[houndCall].ncall = m_maxStrikes + 1; // time them out
+ updateFoxQSOsInProgressDisplay();
+ }
+}
+
+void MainWindow::foxQueueTopCallCommand()
+{
+ m_decodedText2 = true;
+ if(SpecOp::FOX==m_specOp && m_decodedText2 && m_houndQueue.count() < MAX_HOUNDS_IN_QUEUE)
+ {
+
+ QTextCursor cursor = ui->decodedTextBrowser->textCursor();
+ cursor.setPosition(cursor.selectionStart());
+ QString houndCallLine = cursor.block().text();
+
+ writeFoxQSO(" QTop: " + houndCallLine);
+ selectHound(houndCallLine, true); // alt double-click gets put at top of queue
+ }
+}
+
+void MainWindow::foxGenWaveform(int i,QString fm)
+{
+//Generate and accumulate the Tx waveform
+ fm += " ";
+ fm=fm.mid(0,40);
+ if(fm.mid(0,3)=="CQ ") m_tFoxTxSinceCQ=-1;
+
+ QString txModeArg;
+ txModeArg = txModeArg.asprintf("FT8fox %d",i+1);
+ int nfreq=ui->TxFreqSpinBox->value()+60*i;
+ if(m_config.superFox()) nfreq=750;
+ ui->decodedTextBrowser2->displayTransmittedText(fm.trimmed(), txModeArg,
+ nfreq,m_bFastMode,m_TRperiod,m_config.superFox());
+ if (SpecOp::FOX==m_specOp && m_config.superFox() && ui->cbSendMsg->isChecked())
+ ui->decodedTextBrowser2->displayTransmittedText(m_freeTextMsg0, txModeArg,
+ nfreq,m_bFastMode,m_TRperiod,m_config.superFox());
+ foxcom_.i3bit[i]=0;
+ if(fm.indexOf("<")>0) foxcom_.i3bit[i]=1;
+ strncpy(&foxcom_.cmsg[i][0],fm.toLatin1(),40); //Copy this message into cmsg[i]
+ if(i==0) m_fm1=fm;
+ QString t;
+ t = t.asprintf(" Tx%d: ",i+1);
+ writeFoxQSO(t + fm.trimmed());
+}
+
+void MainWindow::writeFoxTxMsgs() {
+ // references extern struct foxcom_
+ QString t;
+ for (int i = 0; i < 5; i++) {
+ t = QString::fromLatin1(foxcom_.cmsg[i]).left(40);
+ if (t.length() > 0) {
+ write_all("Tx", t);
+ }
+ }
+ t = QString::fromLatin1(foxcom_.textMsg).left(38);
+ if (foxcom_.bSendMsg) {
+ write_all("Tx", "-Free Text- "+t);
+ }
+ if (foxcom_.bMoreCQs) {
+ write_all("Tx", "-MoreCQs- ");
+ }
+}
+ void MainWindow::writeFoxQSO(QString const& msg)
+{
+ QString t;
+ t = t.asprintf("%3d%3d%3d",m_houndQueue.count(),m_foxQSOinProgress.count(),m_foxQSO.count());
+ QFile f {m_config.writeable_data_dir ().absoluteFilePath ("FoxQSO.txt")};
+ if (f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append)) {
+ QTextStream out(&f);
+ out << QDateTime::currentDateTimeUtc().toString("yyyy-MM-dd hh:mm:ss") << " "
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::fixed
+#else
+ << fixed
+#endif
+ << qSetRealNumberPrecision (3) << (m_freqNominal/1.e6)
+ << t << msg
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f.close();
+ } else {
+ MessageBox::warning_message (this, tr("File Open Error"),
+ tr("Cannot open \"%1\" for append: %2").arg(f.fileName()).arg(f.errorString()));
+ }
+}
+
+/*################################################################################### */
+void MainWindow::foxTest()
+{
+ QString curdir = QDir::currentPath();
+ bool b_hounds_written = false;
+
+ QFile fdiag(m_config.writeable_data_dir ().absoluteFilePath("diag.txt"));
+ if(!fdiag.open(QIODevice::WriteOnly | QIODevice::Text)) return;
+
+ QFile f(m_config.writeable_data_dir ().absoluteFilePath("steps.txt"));
+ if(!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+ fdiag.write("Cannot open steps.txt");
+ return;
+ }
+
+ QTextStream s(&f);
+ QTextStream sdiag(&fdiag);
+
+ QFile fhounds(m_config.temp_dir().absoluteFilePath("houndcallers.txt"));
+ if(!fhounds.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text))
+ {
+ sdiag << "can't write to houndcallers.txt";
+ return;
+ }
+ QTextStream houndstream(&fhounds);
+
+ QString line;
+ QString t;
+ QString msg;
+ QString hc1;
+ QString rptRcvd;
+ qint32 n=0;
+
+ while(!s.atEnd()) {
+ line=s.readLine();
+ if(line.length()==0) continue;
+ if(line.mid(0,4).toInt()==0) line=" " + line;
+ if(line.contains("NSlots")) {
+ n=line.mid(44,1).toInt();
+ ui->sbNslots->setValue(n);
+ }
+ if(line.contains("Sel:")) {
+ t=line.mid(43,6) + " " + line.mid(54,4) + " " + line.mid(50,3);
+ selectHound(t, false);
+ }
+ auto line_trimmed = line.trimmed();
+ if(line_trimmed.startsWith("Hound:")) {
+ t=line_trimmed.mid(6,-1).trimmed();
+ b_hounds_written = true;
+ houndstream << t
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ }
+
+ if(line.contains("Del:")) {
+ int i0=line.indexOf("Del:");
+ hc1=line.mid(i0+6);
+ int i1=hc1.indexOf(" ");
+ hc1=hc1.mid(0,i1);
+
+ writeFoxQSO(" Del: " + hc1);
+ QQueue<QString> tmpQueue;
+ while(!m_houndQueue.isEmpty()) {
+ t=m_houndQueue.dequeue();
+ QString hc=t.mid(0,6).trimmed();
+ if(hc != hc1) tmpQueue.enqueue(t);
+ }
+ m_houndQueue.swap(tmpQueue);
+ refreshHoundQueueDisplay();
+ }
+ if(line.contains("Rx:")) {
+ msg=line.mid(37+6);
+ t=msg.mid(24);
+ int i0=t.indexOf(" ");
+ hc1=t.mid(i0+1);
+ int i1=hc1.indexOf(" ");
+ hc1=hc1.mid(0,i1);
+ int i2=qMax(msg.indexOf("R+"),msg.indexOf("R-"));
+ if(i2>10) {
+ rptRcvd=msg.mid(i2,4);
+ foxRxSequencer(msg,hc1,rptRcvd);
+ }
+ }
+ if(line.contains("Tx1:")) {
+ foxTxSequencer();
+ } else {
+ t = t.asprintf("%3d %3d %3d %3d %5d ",m_houndQueue.count(),
+ m_foxQSOinProgress.count(),m_foxQSO.count(),
+ m_loggedByFox.count(),m_tFoxTx);
+ sdiag << t << line.mid(37).trimmed() << "\n";
+ }
+ }
+ if (b_hounds_written)
+ {
+ fhounds.close();
+ houndCallers();
+ }
+}
+
+void MainWindow::write_all(QString txRx, QString message)
+{
+ if (!(ui->actionDisable_writing_of_ALL_TXT->isChecked())) {
+ QString line;
+ QString t;
+ QString msg;
+ QString mode_string;
+ QString file_name="ALL.TXT";
+ QRegularExpression verified_call_regex {"[A-Z0-9/]+\\sverified\\s*"};
+
+ if(m_mode!="Echo") {
+ if (message.size () > 5 && message[4]==' ') {
+ msg=message.mid(4,-1);
+ } else {
+ msg=message.mid(6,-1);
+ }
+
+ if (message.size () > 19 && message[19]=='#') {
+ mode_string="JT65 ";
+ } else if (message.size () > 19 && message[19]=='@') {
+ mode_string="JT9 ";
+ } else if(m_mode=="Q65") {
+ mode_string=mode_label.text();
+ } else {
+ mode_string=m_mode.leftJustified(6,' ');
+ }
+
+ if(mode_string=="FT8 " and txRx=="Tx" and m_config.superFox() and
+ m_specOp==SpecOp::FOX) mode_string="FT8_SF";
+
+ if(mode_string=="FT8 " and m_config.superFox() and
+ m_specOp==SpecOp::HOUND) mode_string="FT8_SH";
+
+ if (mode_string == "FT8_SH" && verified_call_regex.match(message).hasMatch()) {
+ msg = " "+message;
+ } else {
+ msg = msg.mid(0, 15) + msg.mid(18, -1);
+ }
+
+ t = t.asprintf("%5d",ui->TxFreqSpinBox->value());
+ if (txRx=="Tx") msg=" 0 0.0" + t + " " + message;
+ auto time = QDateTime::currentDateTimeUtc ();
+ if( (txRx=="Rx" || txRx=="Ck") && !m_bFastMode ) time=m_dateTimeSeqStart;
+
+ if (txRx=="Rx") {
+ t = t.asprintf("%10.3f ",m_freqNominalPeriod/1.e6); // prevent writing of wrong frequencies
+ } else {
+ t = t.asprintf("%10.3f ",m_freqNominal/1.e6);
+ }
+ if (m_diskData) {
+ if (m_fileDateTime.size()==11) {
+ line=m_fileDateTime + " " + t + txRx + " " + mode_string + msg;
+ } else {
+ line=m_fileDateTime + t + txRx + " " + mode_string + msg;
+ }
+ } else {
+ line=time.toString("yyMMdd_hhmmss") + t + txRx + " " + mode_string + msg;
+ }
+
+ if (ui->actionSplit_ALL_TXT_yearly->isChecked()) file_name=(time.toString("yyyy") + "-" + "ALL.TXT");
+ if (ui->actionSplit_ALL_TXT_monthly->isChecked()) file_name=(time.toString("yyyy-MM") + "-" + "ALL.TXT");
+ if (m_mode=="WSPR") file_name="ALL_WSPR.TXT";
+ } else {
+ file_name="all_echo.txt";
+ line=message;
+ }
+
+ QFile f{m_config.writeable_data_dir().absoluteFilePath(file_name)};
+ if (f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append)) {
+ QTextStream out(&f);
+ out << line.trimmed()
+#if QT_VERSION >= QT_VERSION_CHECK (5, 15, 0)
+ << Qt::endl
+#else
+ << endl
+#endif
+ ;
+ f.close();
+ } else {
+ auto const& message2 = tr ("Cannot open \"%1\" for append: %2")
+ .arg (f.fileName ()).arg (f.errorString ());
+ QTimer::singleShot (0, [=] { // don't block guiUpdate
+ MessageBox::warning_message(this, tr ("Log File Error"), message2); });
+ }
+ }
+}
+
+void MainWindow::chkFT4()
+{
+ if(m_mode!="FT4") return;
+ ui->cbAutoSeq->setEnabled(true);
+ ui->respondComboBox->setVisible(true);
+ ui->respondComboBox->setEnabled(true);
+ ui->labDXped->setVisible(m_specOp!=SpecOp::NONE);
+ ui->respondComboBox->setVisible(ui->cbAutoSeq->isChecked());
+
+ m_specOp=m_config.special_op_id();
+ if(m_specOp!=SpecOp::NONE and m_specOp!=SpecOp::FOX and m_specOp!=SpecOp::HOUND) {
+ QString t0="";
+ if(SpecOp::NA_VHF==m_specOp) t0="NA VHF";
+ if(SpecOp::EU_VHF==m_specOp) t0="EU VHF";
+ if(SpecOp::FIELD_DAY==m_specOp) t0="Field Day";
+ if(SpecOp::RTTY==m_specOp) t0="FT RU";
+ if(SpecOp::WW_DIGI==m_specOp) t0="WW Digi";
+ if(SpecOp::ARRL_DIGI==m_specOp) t0="ARRL Digi";
+ if(SpecOp::Q65_PILEUP==m_specOp) t0="Q65 Pileup";
+ if(t0=="") {
+ ui->labDXped->setVisible(false);
+ } else {
+ ui->labDXped->setVisible(true);
+ ui->labDXped->setText(t0);
+ }
+ if(m_specOp!=SpecOp::Q65_PILEUP) on_contest_log_action_triggered();
+ }
+ if (SpecOp::HOUND == m_specOp or SpecOp::FOX == m_specOp) {
+ ui->labDXped->setVisible(false);
+ }
+
+}
+
+void MainWindow::on_pbBestSP_clicked()
+{
+ m_bBestSPArmed = !m_bBestSPArmed;
+ if(m_bBestSPArmed and !m_transmitting) ui->pbBestSP->setStyleSheet ("QPushButton{color:red}");
+ if(!m_bBestSPArmed) ui->pbBestSP->setStyleSheet ("");
+ if(m_bBestSPArmed) m_dateTimeBestSP=QDateTime::currentDateTimeUtc();
+}
+
+void MainWindow::set_mode (QString const& mode)
+{
+ if ("FT4" == mode) on_actionFT4_triggered ();
+ else if ("FST4" == mode) on_actionFST4_triggered ();
+ else if ("FST4W" == mode) on_actionFST4W_triggered ();
+ else if ("FT8" == mode) on_actionFT8_triggered ();
+ else if ("JT4" == mode) on_actionJT4_triggered ();
+ else if ("JT9" == mode) on_actionJT9_triggered ();
+ else if ("JT65" == mode) on_actionJT65_triggered ();
+ else if ("Q65" == mode) on_actionQ65_triggered ();
+ else if ("FreqCal" == mode) on_actionFreqCal_triggered ();
+ else if ("MSK144" == mode) on_actionMSK144_triggered ();
+ else if ("WSPR" == mode) on_actionWSPR_triggered ();
+ else if ("Echo" == mode) on_actionEcho_triggered ();
+}
+
+void MainWindow::configActiveStations()
+{
+ if (m_ActiveStationsWidget != NULL and (m_mode == "Q65" or m_mode == "FT4" or m_mode == "FT8")) {
+ if (m_specOp == SpecOp::Q65_PILEUP) {
+ m_ActiveStationsWidget->displayRecentStations("Q65-pileup", "");
+ } else {
+ if (m_specOp == SpecOp::FOX)
+ if (m_config.superFox())
+ m_ActiveStationsWidget->displayRecentStations("SuperFox Mode", "");
+ else
+ m_ActiveStationsWidget->displayRecentStations("Fox Mode", "");
+ else
+ m_ActiveStationsWidget->displayRecentStations(m_mode, "");
+ }
+ }
+}
+
+void MainWindow::remote_configure (QString const& mode, quint32 frequency_tolerance
+ , QString const& submode, bool fast_mode, quint32 tr_period, quint32 rx_df
+ , QString const& dx_call, QString const& dx_grid, bool generate_messages)
+{
+ if (mode.size ())
+ {
+ if (mode != m_mode) set_mode (mode);
+ }
+ auto is_FST4W = "FST4W" == m_mode;
+ if (frequency_tolerance != quint32_max && (ui->sbFtol->isVisible () || is_FST4W))
+ {
+ m_block_udp_status_updates = true;
+ if (is_FST4W)
+ {
+ ui->sbFST4W_FTol->setValue (frequency_tolerance);
+ }
+ else
+ {
+ ui->sbFtol->setValue (frequency_tolerance);
+ }
+ m_block_udp_status_updates = false;
+ }
+ if (submode.size () && ui->sbSubmode->isVisible ())
+ {
+ ui->sbSubmode->setValue (submode.toUpper ().at (0).toLatin1 () - 'A');
+ }
+ if (ui->cbFast9->isVisible () && ui->cbFast9->isChecked () != fast_mode)
+ {
+ ui->cbFast9->click ();
+ }
+ if (tr_period != quint32_max && ui->sbTR->isVisible ())
+ {
+ if (is_FST4W)
+ {
+ ui->sbTR_FST4W->setValue (tr_period);
+ ui->sbTR_FST4W->interpretText ();
+ }
+ else
+ {
+ ui->sbTR->setValue (tr_period);
+ ui->sbTR->interpretText ();
+ }
+ }
+ if (rx_df != quint32_max && ui->RxFreqSpinBox->isVisible ())
+ {
+ m_block_udp_status_updates = true;
+ if (is_FST4W)
+ {
+ ui->sbFST4W_RxFreq->setValue (rx_df);
+ ui->sbFST4W_RxFreq->interpretText ();
+ }
+ else
+ {
+ ui->RxFreqSpinBox->setValue (rx_df);
+ ui->RxFreqSpinBox->interpretText ();
+ }
+ m_block_udp_status_updates = false;
+ }
+ if (dx_call.size () && ui->dxCallEntry->isVisible ())
+ {
+ ui->dxCallEntry->setText (dx_call);
+ }
+ if (dx_grid.size () && ui->dxGridEntry->isVisible ())
+ {
+ ui->dxGridEntry->setText (dx_grid);
+ }
+ if (generate_messages && ui->genStdMsgsPushButton->isVisible ())
+ {
+ ui->genStdMsgsPushButton->click ();
+ }
+ if (m_config.udpWindowToFront ())
+ {
+ show ();
+ raise ();
+ activateWindow ();
+ }
+ if (m_config.udpWindowRestore () && isMinimized ())
+ {
+ showNormal ();
+ raise ();
+ }
+ tx_watchdog (false);
+ QApplication::alert (this);
+}
+
+QString MainWindow::WSPR_message()
+{
+ QString sdBm,msg0,msg1,msg2;
+ sdBm = sdBm.asprintf(" %d",m_dBm);
+ m_tx=1-m_tx;
+ int i2=m_config.my_callsign().indexOf("/");
+ if(i2>0
+ || (6 == m_config.my_grid ().size ()
+ && !ui->WSPR_prefer_type_1_check_box->isChecked ())) {
+ if(i2<0) { // "Type 2" WSPR message
+ msg1=m_config.my_callsign() + " " + m_config.my_grid().mid(0,4) + sdBm;
+ } else {
+ msg1=m_config.my_callsign() + sdBm;
+ }
+ msg0="<" + m_config.my_callsign() + "> " + m_config.my_grid();
+ if(m_mode=="WSPR") msg0 += sdBm;
+ if(m_tx==0) msg2=msg0;
+ if(m_tx==1) msg2=msg1;
+ } else {
+ msg2=m_config.my_callsign() + " " + m_config.my_grid().mid(0,4) + sdBm; // Normal WSPR message
+ }
+ return msg2;
+}
+
+void MainWindow::on_houndButton_clicked (bool checked)
+{
+ if (checked) {
+ m_config.setSpecial_Hound();
+ ui->tx1->setVisible(true);
+ ui->tx1->setEnabled(true);
+ ui->txb1->setEnabled(true);
+ } else {
+ m_config.setSpecial_None();
+ keep_frequency = true;
+ QTimer::singleShot (250, [=] {keep_frequency = false;});
+ }
+ m_specOp=m_config.special_op_id();
+ on_actionFT8_triggered();
+}
+
+void MainWindow::on_ft8Button_clicked()
+{
+ if (m_specOp==SpecOp::HOUND) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ on_actionFT8_triggered();
+}
+
+void MainWindow::on_ft4Button_clicked()
+{
+ on_actionFT4_triggered();
+}
+
+void MainWindow::on_msk144Button_clicked()
+{
+ on_actionMSK144_triggered();
+}
+
+void MainWindow::on_q65Button_clicked()
+{
+ if (m_specOp==SpecOp::Q65_PILEUP) {
+ m_config.setSpecial_None();
+ m_specOp=m_config.special_op_id();
+ }
+ on_actionQ65_triggered();
+}
+
+void MainWindow::on_jt65Button_clicked()
+{
+ on_actionJT65_triggered();
+}
+
+void MainWindow::sfox_tx() {
+ auto fname{QDir::toNativeSeparators(m_config.writeable_data_dir().absoluteFilePath("sfox_1.dat")).toLocal8Bit()};
+ QStringList args{fname};
+ qint32 otp_key = 0;
+ args.append(m_config.my_callsign());
+#ifdef FOX_OTP
+ if (m_config.OTPEnabled())
+ {
+ LOG_INFO("TOTP: Generating OTP key");
+ if (m_config.OTPSeed().length() == 16) {
+ QString output=foxOTPcode();
+ if (6 == output.length())
+ {
+ otp_key = QString(output).toInt();
+ LOG_INFO(QString("TOTP SF: %1 [%2]").arg(output).arg(otp_key).toStdString());
+ } else
+ {
+ otp_key = 0;
+ LOG_INFO(QString("TOTP SF: Incorrect length"));
+ }
+ } else
+ {
+ showStatusMessage (tr ("TOTP SF: seed not long enough."));
+ LOG_INFO(QString("TOTP SF: seed not long enough"));
+ }
+ }
+ args.append(QString("OTP:%1").arg(otp_key));
+#else
+ args.append(m_config.FoxKey());
+#endif
+// qDebug() << "aa" << QDir::toNativeSeparators(m_appDir)+QDir::separator()+"sftx";
+// qDebug() << "bb" << args;
+LOG_INFO(QString("%1 %2").arg(QDir::toNativeSeparators(m_appDir)+QDir::separator()+"sftx").arg(args.join(" ")).toStdString());
+ p2.start(QDir::toNativeSeparators(m_appDir)+QDir::separator()+"sftx", args);
+ p2.waitForFinished();
+ auto fname2 {QDir::toNativeSeparators(m_config.writeable_data_dir().absoluteFilePath("sfox_2.dat")).toLocal8Bit()};
+ sfox_wave_gfsk_(fname2.constData(), (FCL)fname2.size());
+}
diff --git a/widgets/mainwindow.h b/widgets/mainwindow.h
index 1e078721f..7400907c8 100644
--- a/widgets/mainwindow.h
+++ b/widgets/mainwindow.h
@@ -896,7 +896,7 @@ private:
void read_log();
void refreshPileupList();
QString userAgent();
- void handleVerifyMsg(int status, QDateTime ts, QString callsign, QString code, QString const &response);
+ void handleVerifyMsg(int status, QDateTime ts, QString callsign, QString code, unsigned int hz, QString const &response);
void writeFoxTxMsgs();
QString foxOTPcode();
};