2017-01-02 21:07:43 -05:00
// Copyright (c) Charles J. Cliffe
// SPDX-License-Identifier: GPL-2.0+
2014-10-27 21:22:29 -04:00
# include "AppFrame.h"
# include "wx/wxprec.h"
# ifndef WX_PRECOMP
# include "wx/wx.h"
# endif
2015-01-06 00:57:57 -05:00
# include "wx/numdlg.h"
2015-01-08 23:57:58 -05:00
# include "wx/filedlg.h"
2015-01-06 00:57:57 -05:00
2014-10-27 21:22:29 -04:00
# if !wxUSE_GLCANVAS
# error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library"
# endif
2014-10-28 21:39:59 -04:00
# include <vector>
2016-08-16 19:45:42 -04:00
# include <algorithm>
2018-01-13 05:50:08 -05:00
# include "AudioSinkFileThread.h"
2014-11-16 19:02:40 -05:00
# include "CubicSDR.h"
2015-01-09 17:17:56 -05:00
# include "DataTree.h"
2015-01-14 22:14:57 -05:00
# include "ColorTheme.h"
2015-10-20 23:00:10 -04:00
# include "DemodulatorMgr.h"
2016-11-01 22:29:58 -04:00
# include "ImagePanel.h"
2018-01-14 18:56:30 -05:00
# include "ActionDialog.h"
2014-10-27 21:22:29 -04:00
2014-11-21 21:50:14 -05:00
# include <thread>
2017-08-24 15:11:50 -04:00
# include <iostream>
# include <iomanip>
2014-11-21 21:50:14 -05:00
2014-12-27 23:47:56 -05:00
# include <wx/panel.h>
2017-03-01 16:13:41 -05:00
# include <wx/numformatter.h>
2021-04-04 22:22:16 -04:00
# include <cstddef>
2014-12-27 23:47:56 -05:00
2019-02-25 19:51:06 -05:00
# if defined(__linux__) || defined(__FreeBSD__)
2015-03-08 17:31:43 -04:00
# include "CubicSDR.xpm"
# endif
2014-10-28 21:39:59 -04:00
wxBEGIN_EVENT_TABLE ( AppFrame , wxFrame )
//EVT_MENU(wxID_NEW, AppFrame::OnNewWindow)
2015-07-15 00:32:36 -04:00
EVT_CLOSE ( AppFrame : : OnClose )
2014-12-31 21:31:37 -05:00
EVT_MENU ( wxID_ANY , AppFrame : : OnMenu )
2014-10-28 21:39:59 -04:00
EVT_IDLE ( AppFrame : : OnIdle )
2015-10-25 14:09:59 -04:00
EVT_SPLITTER_DCLICK ( wxID_ANY , AppFrame : : OnDoubleClickSash )
EVT_SPLITTER_UNSPLIT ( wxID_ANY , AppFrame : : OnUnSplit )
2014-10-27 21:22:29 -04:00
wxEND_EVENT_TABLE ( )
2016-01-03 19:00:26 -05:00
# ifdef USE_HAMLIB
# include "RigThread.h"
2017-04-20 19:40:09 -04:00
# include "PortSelectorDialog.h"
# include "rs232.h"
2016-01-03 19:00:26 -05:00
# endif
2015-10-25 14:09:59 -04:00
2016-10-20 21:44:33 -04:00
2018-01-14 18:56:30 -05:00
class ActionDialogBookmarkReset : public ActionDialog {
public :
ActionDialogBookmarkReset ( ) : ActionDialog ( wxGetApp ( ) . getAppFrame ( ) , wxID_ANY , wxT ( " Reset Bookmarks? " ) ) {
m_questionText - > SetLabelText ( wxT ( " Resetting bookmarks will erase all current bookmarks; are you sure? " ) ) ;
}
2021-04-04 22:22:16 -04:00
void doClickOK ( ) override {
2018-01-14 18:56:30 -05:00
wxGetApp ( ) . getBookmarkMgr ( ) . resetBookmarks ( ) ;
wxGetApp ( ) . getBookmarkMgr ( ) . updateBookmarks ( ) ;
wxGetApp ( ) . getBookmarkMgr ( ) . updateActiveList ( ) ;
}
} ;
2016-07-28 23:35:48 -04:00
# define APPFRAME_MODEMPROPS_MINSIZE 20
# define APPFRAME_MODEMPROPS_MAXSIZE 240
2016-07-28 22:50:02 -04:00
2014-10-27 21:22:29 -04:00
AppFrame : : AppFrame ( ) :
2021-04-04 22:22:16 -04:00
wxFrame ( nullptr , wxID_ANY , CUBICSDR_TITLE ) , activeDemodulator ( nullptr ) {
2014-10-27 21:22:29 -04:00
2019-03-16 17:44:41 -04:00
initIcon ( ) ;
deviceChanged . store ( false ) ;
modemPropertiesUpdated . store ( false ) ;
2015-10-27 01:56:49 -04:00
demodTray = new wxBoxSizer ( wxHORIZONTAL ) ;
2021-04-04 22:22:16 -04:00
auto * demodScopeTray = new wxBoxSizer ( wxVERTICAL ) ;
auto * demodTunerTray = new wxBoxSizer ( wxHORIZONTAL ) ;
2014-12-27 23:47:56 -05:00
2018-03-10 02:34:39 -05:00
// OpenGL settings:
//deprecated format: std::vector<int> attribList = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, 0 };
wxGLAttributes attribList ;
attribList . PlatformDefaults ( ) . RGBA ( ) . MinRGBA ( 8 , 8 , 8 , 8 ) . DoubleBuffer ( ) . EndList ( ) ;
2015-02-09 20:49:21 -05:00
2015-10-25 14:09:59 -04:00
mainSplitter = new wxSplitterWindow ( this , wxID_MAIN_SPLITTER , wxDefaultPosition , wxDefaultSize , wxSP_3DSASH | wxSP_LIVE_UPDATE ) ;
2016-12-18 12:00:53 -05:00
mainSplitter - > SetSashGravity ( 10.0f / 37.0f ) ;
2015-10-25 14:09:59 -04:00
mainSplitter - > SetMinimumPaneSize ( 1 ) ;
2021-04-04 22:22:16 -04:00
auto * demodPanel = new wxPanel ( mainSplitter , wxID_ANY ) ;
2016-10-20 21:44:33 -04:00
# ifdef CUBICSDR_HEADER_IMAGE
wxFileName exePath = wxFileName ( wxStandardPaths : : Get ( ) . GetExecutablePath ( ) ) ;
std : : string headerPath = exePath . GetPath ( ) . ToStdString ( ) ;
headerPath + = filePathSeparator + std : : string ( " " CUBICSDR_HEADER_IMAGE ) ;
wxInitAllImageHandlers ( ) ;
2016-11-01 22:29:58 -04:00
2016-11-02 22:01:51 -04:00
ImagePanel * imgPanel = new ImagePanel ( demodPanel , headerPath , wxBITMAP_TYPE_ANY ) ;
2016-11-01 22:29:58 -04:00
2016-10-20 21:44:33 -04:00
std : : string headerBgColor = " " CUBICSDR_HEADER_BG ;
if ( headerBgColor ! = " " ) {
2016-11-02 22:01:51 -04:00
imgPanel - > SetBackgroundColour ( wxColour ( headerBgColor ) ) ;
2016-10-20 21:44:33 -04:00
}
2016-11-01 22:29:58 -04:00
2016-11-02 22:01:51 -04:00
imgPanel - > SetBestFittingSize ( wxSize ( 200 , 0 ) ) ;
2016-11-01 22:29:58 -04:00
demodTray - > Add ( imgPanel , 0 , wxEXPAND | wxALL , 0 ) ;
2016-10-20 21:44:33 -04:00
demodTray - > AddSpacer ( 1 ) ;
# endif
2015-10-25 14:09:59 -04:00
2015-10-27 01:56:49 -04:00
gainCanvas = new GainCanvas ( demodPanel , attribList ) ;
2017-08-24 15:11:50 -04:00
gainCanvas - > setHelpTip ( " Tuner gains, usually in dB. Click / use Mousewheel to change. " ) ;
2015-10-27 01:56:49 -04:00
gainSizerItem = demodTray - > Add ( gainCanvas , 0 , wxEXPAND | wxALL , 0 ) ;
gainSizerItem - > Show ( false ) ;
gainSpacerItem = demodTray - > AddSpacer ( 1 ) ;
gainSpacerItem - > Show ( false ) ;
2019-01-22 00:01:31 -05:00
// Demod mode selector
demodModeSelector = makeModemSelectorPanel ( demodPanel , attribList ) ;
2015-01-05 19:12:16 -05:00
demodTray - > Add ( demodModeSelector , 2 , wxEXPAND | wxALL , 0 ) ;
2015-05-29 07:45:15 -04:00
2015-11-15 13:52:54 -05:00
# ifdef ENABLE_DIGITAL_LAB
2019-01-22 00:01:31 -05:00
// Digital Lab Mode Selector
demodModeSelectorAdv = makeModemAdvSelectorPanel ( demodPanel , attribList ) ;
2015-06-09 11:00:05 -04:00
demodTray - > Add ( demodModeSelectorAdv , 3 , wxEXPAND | wxALL , 0 ) ;
2015-11-24 23:32:40 -05:00
# endif
2015-11-23 21:32:50 -05:00
2019-01-22 00:01:31 -05:00
// Modem properties panel
modemProps = makeModemProperties ( demodPanel ) ;
2016-10-20 21:44:33 -04:00
2015-11-23 22:03:14 -05:00
demodTray - > Add ( modemProps , 15 , wxEXPAND | wxALL , 0 ) ;
2016-07-28 23:43:51 -04:00
# ifndef __APPLE__
demodTray - > AddSpacer ( 1 ) ;
# endif
2016-10-20 21:44:33 -04:00
# if CUBICSDR_ENABLE_VIEW_DEMOD
2019-01-22 00:01:31 -05:00
// Demodulator View
2021-04-04 22:22:16 -04:00
auto * demodVisuals = new wxBoxSizer ( wxVERTICAL ) ;
2016-10-20 21:44:33 -04:00
2019-01-22 00:01:31 -05:00
// Demod Spectrum
demodSpectrumCanvas = makeDemodSpectrumCanvas ( demodPanel , attribList ) ;
2015-01-06 19:15:27 -05:00
demodVisuals - > Add ( demodSpectrumCanvas , 3 , wxEXPAND | wxALL , 0 ) ;
2019-01-22 00:01:31 -05:00
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > setup ( DEFAULT_DMOD_FFT_SIZE ) ;
2015-08-16 18:12:12 -04:00
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > attachOutput ( demodSpectrumCanvas - > getVisualDataQueue ( ) ) ;
2014-12-29 00:24:10 -05:00
demodVisuals - > AddSpacer ( 1 ) ;
2014-12-28 20:55:05 -05:00
2019-01-22 00:01:31 -05:00
// Demod Waterfall
demodWaterfallCanvas = makeWaterfallCanvas ( demodPanel , attribList ) ;
2014-12-29 00:24:10 -05:00
demodWaterfallCanvas - > attachSpectrumCanvas ( demodSpectrumCanvas ) ;
2015-01-06 19:15:27 -05:00
demodVisuals - > Add ( demodWaterfallCanvas , 6 , wxEXPAND | wxALL , 0 ) ;
2019-01-22 00:01:31 -05:00
demodSpectrumCanvas - > attachWaterfallCanvas ( demodWaterfallCanvas ) ;
2015-08-16 18:12:12 -04:00
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > attachOutput ( demodWaterfallCanvas - > getVisualDataQueue ( ) ) ;
2015-11-28 23:03:07 -05:00
demodVisuals - > SetMinSize ( wxSize ( 128 , - 1 ) ) ;
2014-12-31 19:45:01 -05:00
demodTray - > Add ( demodVisuals , 30 , wxEXPAND | wxALL , 0 ) ;
2015-01-14 22:14:57 -05:00
demodTray - > AddSpacer ( 1 ) ;
2016-10-20 21:44:33 -04:00
# else
demodSpectrumCanvas = nullptr ;
demodWaterfallCanvas = nullptr ;
# endif
2014-12-28 20:55:05 -05:00
2019-01-22 00:01:31 -05:00
// Demod Signal/Squelch Meter
demodSignalMeter = makeSignalMeter ( demodPanel , attribList ) ;
demodTray - > Add ( demodSignalMeter , 1 , wxEXPAND | wxALL , 0 ) ;
2015-01-14 22:14:57 -05:00
demodTray - > AddSpacer ( 1 ) ;
2014-12-28 05:13:46 -05:00
2016-10-20 21:44:33 -04:00
# if CUBICSDR_ENABLE_VIEW_SCOPE
2019-01-22 00:01:31 -05:00
// Scope
scopeCanvas = makeScopeCanvas ( demodPanel , attribList ) ;
2015-01-04 17:11:20 -05:00
demodScopeTray - > Add ( scopeCanvas , 8 , wxEXPAND | wxALL , 0 ) ;
2019-01-22 00:01:31 -05:00
2017-02-04 04:32:35 -05:00
wxGetApp ( ) . getScopeProcessor ( ) - > setup ( DEFAULT_SCOPE_FFT_SIZE ) ;
2015-08-01 11:03:00 -04:00
wxGetApp ( ) . getScopeProcessor ( ) - > attachOutput ( scopeCanvas - > getInputQueue ( ) ) ;
2015-01-04 17:11:20 -05:00
2015-01-14 22:14:57 -05:00
demodScopeTray - > AddSpacer ( 1 ) ;
2016-10-20 21:44:33 -04:00
# else
scopeCanvas = nullptr ;
# endif
2019-01-22 00:01:31 -05:00
// Delta Lock Button
deltaLockButton = makeDeltaLockButton ( demodPanel , attribList ) ;
2016-02-15 17:43:10 -05:00
demodTunerTray - > Add ( deltaLockButton , 0 , wxEXPAND | wxALL , 0 ) ;
demodTunerTray - > AddSpacer ( 1 ) ;
2019-01-22 00:01:31 -05:00
// Modem Tuner
demodTuner = makeModemTuner ( demodPanel , attribList ) ;
2016-02-15 17:43:10 -05:00
demodTunerTray - > Add ( demodTuner , 1 , wxEXPAND | wxALL , 0 ) ;
2019-01-22 00:01:31 -05:00
2016-02-15 17:43:10 -05:00
demodScopeTray - > Add ( demodTunerTray , 1 , wxEXPAND | wxALL , 0 ) ;
2015-01-04 17:11:20 -05:00
demodTray - > Add ( demodScopeTray , 30 , wxEXPAND | wxALL , 0 ) ;
2015-01-14 22:14:57 -05:00
demodTray - > AddSpacer ( 1 ) ;
2015-01-10 20:33:30 -05:00
2021-04-04 22:22:16 -04:00
auto * demodGainTray = new wxBoxSizer ( wxVERTICAL ) ;
2019-01-22 00:01:31 -05:00
// Demod Gain Meter
demodGainMeter = makeModemGainMeter ( demodPanel , attribList ) ;
2015-08-17 00:59:38 -04:00
demodGainTray - > Add ( demodGainMeter , 8 , wxEXPAND | wxALL , 0 ) ;
2016-02-11 01:09:15 -05:00
demodGainTray - > AddSpacer ( 1 ) ;
2019-01-22 00:01:31 -05:00
// Solo Button
soloModeButton = makeSoloModeButton ( demodPanel , attribList ) ;
2016-02-11 01:09:15 -05:00
demodGainTray - > Add ( soloModeButton , 1 , wxEXPAND | wxALL , 0 ) ;
2015-08-17 00:59:38 -04:00
demodGainTray - > AddSpacer ( 1 ) ;
2019-01-22 00:01:31 -05:00
// Mute Button
demodMuteButton = makeModemMuteButton ( demodPanel , attribList ) ;
2015-08-17 00:59:38 -04:00
demodGainTray - > Add ( demodMuteButton , 1 , wxEXPAND | wxALL , 0 ) ;
2015-01-10 20:33:30 -05:00
2015-08-17 00:59:38 -04:00
demodTray - > Add ( demodGainTray , 1 , wxEXPAND | wxALL , 0 ) ;
2015-10-25 14:09:59 -04:00
demodPanel - > SetSizer ( demodTray ) ;
2017-01-08 06:46:31 -05:00
bookmarkSplitter = new wxSplitterWindow ( mainSplitter , wxID_BM_SPLITTER , wxDefaultPosition , wxDefaultSize , wxSP_3DSASH | wxSP_LIVE_UPDATE ) ;
2016-09-14 22:10:27 -04:00
bookmarkSplitter - > SetMinimumPaneSize ( 1 ) ;
2016-12-18 12:00:53 -05:00
bookmarkSplitter - > SetSashGravity ( 1.0f / 20.0f ) ;
2016-09-14 22:10:27 -04:00
mainVisSplitter = new wxSplitterWindow ( bookmarkSplitter , wxID_VIS_SPLITTER , wxDefaultPosition , wxDefaultSize , wxSP_3DSASH | wxSP_LIVE_UPDATE ) ;
2015-10-25 14:09:59 -04:00
mainVisSplitter - > SetMinimumPaneSize ( 1 ) ;
2016-12-18 12:00:53 -05:00
mainVisSplitter - > SetSashGravity ( 6.0f / 25.0f ) ;
2015-10-25 14:09:59 -04:00
2021-04-04 22:22:16 -04:00
auto * spectrumPanel = new wxPanel ( mainVisSplitter , wxID_ANY ) ;
auto * spectrumSizer = new wxBoxSizer ( wxHORIZONTAL ) ;
2015-10-25 14:09:59 -04:00
2019-01-22 00:01:31 -05:00
// Spectrum Canvas
spectrumCanvas = makeSpectrumCanvas ( spectrumPanel , attribList ) ;
2017-02-04 04:32:35 -05:00
wxGetApp ( ) . getSpectrumProcessor ( ) - > setup ( DEFAULT_FFT_SIZE ) ;
2015-08-16 18:12:12 -04:00
wxGetApp ( ) . getSpectrumProcessor ( ) - > attachOutput ( spectrumCanvas - > getVisualDataQueue ( ) ) ;
2019-01-22 00:01:31 -05:00
spectrumSizer - > Add ( spectrumCanvas , 63 , wxEXPAND | wxALL , 0 ) ;
spectrumSizer - > AddSpacer ( 1 ) ;
2021-04-04 22:22:16 -04:00
auto * spectrumCtlTray = new wxBoxSizer ( wxVERTICAL ) ;
2019-01-22 00:01:31 -05:00
// Peak Hold
peakHoldButton = makePeakHoldButton ( spectrumPanel , attribList ) ;
2015-12-31 20:44:39 -05:00
spectrumCtlTray - > Add ( peakHoldButton , 1 , wxEXPAND | wxALL , 0 ) ;
spectrumCtlTray - > AddSpacer ( 1 ) ;
2019-01-22 00:01:31 -05:00
// Spectrum Average Meter
spectrumAvgMeter = makeSpectrumAvgMeter ( spectrumPanel , attribList ) ;
spectrumCtlTray - > Add ( spectrumAvgMeter , 8 , wxEXPAND | wxALL , 0 ) ;
2015-12-31 20:44:39 -05:00
spectrumSizer - > Add ( spectrumCtlTray , 1 , wxEXPAND | wxALL , 0 ) ;
2015-10-25 14:09:59 -04:00
spectrumPanel - > SetSizer ( spectrumSizer ) ;
2015-08-03 01:38:38 -04:00
2021-04-04 22:22:16 -04:00
auto * waterfallPanel = new wxPanel ( mainVisSplitter , wxID_ANY ) ;
auto * waterfallSizer = new wxBoxSizer ( wxHORIZONTAL ) ;
2019-01-22 00:01:31 -05:00
// Waterfall
waterfallCanvas = makeWaterfall ( waterfallPanel , attribList ) ;
2019-03-16 17:44:41 -04:00
// Create and connect the FFT visual data thread
2015-08-14 19:17:43 -04:00
waterfallDataThread = new FFTVisualDataThread ( ) ;
waterfallDataThread - > setInputQueue ( " IQDataInput " , wxGetApp ( ) . getWaterfallVisualQueue ( ) ) ;
waterfallDataThread - > setOutputQueue ( " FFTDataOutput " , waterfallCanvas - > getVisualDataQueue ( ) ) ;
2015-11-03 00:53:39 -05:00
waterfallDataThread - > getProcessor ( ) - > setHideDC ( true ) ;
2015-08-19 23:22:46 -04:00
t_FFTData = new std : : thread ( & FFTVisualDataThread : : threadMain , waterfallDataThread ) ;
2019-03-16 17:44:41 -04:00
2019-01-22 00:01:31 -05:00
// Waterfall speed meter
waterfallSpeedMeter = makeWaterfallSpeedMeter ( waterfallPanel , attribList ) ;
2015-08-11 23:52:03 -04:00
2019-03-16 17:44:41 -04:00
waterfallSizer - > Add ( waterfallCanvas , 63 , wxEXPAND | wxALL , 0 ) ;
waterfallSizer - > AddSpacer ( 1 ) ;
waterfallSizer - > Add ( waterfallSpeedMeter , 1 , wxEXPAND | wxALL , 0 ) ;
waterfallPanel - > SetSizer ( waterfallSizer ) ;
2015-08-11 23:52:03 -04:00
2015-10-25 14:09:59 -04:00
mainVisSplitter - > SplitHorizontally ( spectrumPanel , waterfallPanel , 0 ) ;
2019-01-22 00:01:31 -05:00
// Bookmark View
2016-09-14 22:49:32 -04:00
bookmarkView = new BookmarkView ( bookmarkSplitter , wxID_ANY , wxDefaultPosition , wxSize ( 120 , - 1 ) ) ;
bookmarkSplitter - > SplitVertically ( bookmarkView , mainVisSplitter ) ;
2016-09-14 22:10:27 -04:00
mainSplitter - > SplitHorizontally ( demodPanel , bookmarkSplitter ) ;
2019-03-16 17:44:41 -04:00
2016-12-18 12:00:53 -05:00
2015-08-11 23:52:03 -04:00
// TODO: refactor these..
2014-12-29 00:24:10 -05:00
waterfallCanvas - > attachSpectrumCanvas ( spectrumCanvas ) ;
2015-01-01 21:10:54 -05:00
spectrumCanvas - > attachWaterfallCanvas ( waterfallCanvas ) ;
2015-08-11 23:52:03 -04:00
2019-03-16 17:44:41 -04:00
// Primary sizer for the window
2021-04-04 22:22:16 -04:00
auto * vbox = new wxBoxSizer ( wxVERTICAL ) ;
2019-03-16 17:44:41 -04:00
vbox - > Add ( mainSplitter , 1 , wxEXPAND | wxALL , 0 ) ;
2016-07-07 22:37:57 -04:00
/* * /
2015-06-20 20:19:52 -04:00
vbox - > AddSpacer ( 1 ) ;
testCanvas = new UITestCanvas ( this , attribList ) ;
vbox - > Add ( testCanvas , 20 , wxEXPAND | wxALL , 0 ) ;
2015-07-29 18:34:58 -04:00
// */
2015-06-20 20:19:52 -04:00
2014-11-15 23:41:41 -05:00
this - > SetSizer ( vbox ) ;
2014-10-27 21:22:29 -04:00
2019-03-16 17:44:41 -04:00
// Load and apply configuration
initConfigurationSettings ( ) ;
// Initialize menu
initMenuBar ( ) ;
// Create status bar
CreateStatusBar ( ) ;
// Show the window
Show ( ) ;
// Force refresh of all
Refresh ( ) ;
// Pop up the device selector
wxGetApp ( ) . deviceSelector ( ) ;
}
void AppFrame : : initIcon ( ) {
# if defined(__linux__) || defined(__FreeBSD__)
SetIcon ( wxICON ( cubicsdr ) ) ;
# endif
# ifdef _WIN32
SetIcon ( wxICON ( frame_icon ) ) ;
# endif
}
void AppFrame : : initMenuBar ( ) { // File Menu
2015-11-02 21:04:02 -05:00
menuBar = new wxMenuBar ;
2019-01-22 00:01:31 -05:00
fileMenu = makeFileMenu ( ) ;
menuBar - > Append ( fileMenu , wxT ( " &File " ) ) ;
// Settings Menu
2015-11-03 19:58:42 -05:00
settingsMenu = new wxMenu ;
menuBar - > Append ( settingsMenu , wxT ( " &Settings " ) ) ;
2014-12-31 19:45:01 -05:00
2019-01-22 00:01:31 -05:00
// Sample Rate Menu
2016-07-28 19:33:59 -04:00
sampleRateMenu = new wxMenu ;
menuBar - > Append ( sampleRateMenu , wxT ( " Sample &Rate " ) ) ;
2015-01-11 03:09:59 -05:00
2019-01-22 00:01:31 -05:00
// Audio Sample Rate Menu
menuBar - > Append ( makeAudioSampleRateMenu ( ) , wxT ( " Audio &Sample Rate " ) ) ;
2015-03-12 19:41:50 -04:00
2019-03-16 17:44:41 -04:00
//Add a Recording menu
2019-01-22 00:01:31 -05:00
recordingMenu = makeRecordingMenu ( ) ;
2019-03-16 17:44:41 -04:00
menuBar - > Append ( recordingMenu , wxT ( " Recordin&g " ) ) ;
updateRecordingMenu ( ) ;
2015-03-22 20:47:07 -04:00
2019-01-22 00:01:31 -05:00
# ifdef USE_HAMLIB
rigPortDialog = nullptr ;
2015-03-22 20:47:07 -04:00
2019-01-22 00:01:31 -05:00
// Rig Menu
rigMenu = makeRigMenu ( ) ;
menuBar - > Append ( rigMenu , wxT ( " &Rig Control " ) ) ;
# endif
2015-03-12 19:41:50 -04:00
2019-01-22 00:01:31 -05:00
// Display Menu
displayMenu = makeDisplayMenu ( ) ;
menuBar - > Append ( displayMenu , wxT ( " &Display " ) ) ;
2015-03-12 19:41:50 -04:00
2019-01-22 00:01:31 -05:00
SetMenuBar ( menuBar ) ;
2015-03-12 19:41:50 -04:00
2019-03-16 17:44:41 -04:00
wxAcceleratorEntry entries [ 3 ] ;
entries [ 0 ] . Set ( wxACCEL_CTRL , ( int ) ' O ' , wxID_OPEN ) ;
entries [ 1 ] . Set ( wxACCEL_CTRL , ( int ) ' S ' , wxID_SAVE ) ;
entries [ 2 ] . Set ( wxACCEL_CTRL , ( int ) ' A ' , wxID_SAVEAS ) ;
wxAcceleratorTable accel ( 3 , entries ) ;
SetAcceleratorTable ( accel ) ;
}
void AppFrame : : initConfigurationSettings ( ) {
// Init Theme
ThemeMgr : : mgr . setTheme ( wxGetApp ( ) . getConfig ( ) - > getTheme ( ) ) ;
bookmarkView - > updateTheme ( ) ;
2015-03-12 19:41:50 -04:00
2019-01-22 00:01:31 -05:00
// Init Font Scale
int fontScale = wxGetApp ( ) . getConfig ( ) - > getFontScale ( ) ;
GLFont : : setScale ( ( GLFont : : GLFontScale ) fontScale ) ;
// Init window position from configuration
wxRect * win = wxGetApp ( ) . getConfig ( ) - > getWindow ( ) ;
if ( win ) {
2019-03-16 17:44:41 -04:00
SetPosition ( win - > GetPosition ( ) ) ;
SetClientSize ( win - > GetSize ( ) ) ;
2019-01-22 00:01:31 -05:00
} else {
SetClientSize ( 1280 , 600 ) ;
Centre ( ) ;
2015-03-12 19:41:50 -04:00
}
2019-03-16 17:44:41 -04:00
// Init maximize state
2019-01-22 00:01:31 -05:00
if ( wxGetApp ( ) . getConfig ( ) - > getWindowMaximized ( ) ) {
2019-03-16 17:44:41 -04:00
Maximize ( ) ;
2019-01-22 00:01:31 -05:00
}
2015-03-12 19:41:50 -04:00
2019-03-16 17:44:41 -04:00
// Init frequency snap
2019-01-22 00:01:31 -05:00
wxGetApp ( ) . setFrequencySnap ( wxGetApp ( ) . getConfig ( ) - > getSnap ( ) ) ;
2018-01-13 05:50:08 -05:00
2019-03-16 17:44:41 -04:00
// Init spectrum average speed
2019-01-22 00:01:31 -05:00
float spectrumAvg = wxGetApp ( ) . getConfig ( ) - > getSpectrumAvgSpeed ( ) ;
spectrumAvgMeter - > setLevel ( spectrumAvg ) ;
wxGetApp ( ) . getSpectrumProcessor ( ) - > setFFTAverageRate ( spectrumAvg ) ;
2019-03-16 17:44:41 -04:00
// Init waterfall speed
2019-01-22 00:01:31 -05:00
int wflps = wxGetApp ( ) . getConfig ( ) - > getWaterfallLinesPerSec ( ) ;
2019-03-16 17:44:41 -04:00
waterfallSpeedMeter - > setLevel ( sqrtf ( wflps ) ) ;
2019-01-22 00:01:31 -05:00
waterfallDataThread - > setLinesPerSecond ( wflps ) ;
waterfallCanvas - > setLinesPerSecond ( wflps ) ;
2016-06-15 16:21:41 -04:00
2019-03-16 17:44:41 -04:00
// Init modem property collapsed state
2019-01-22 00:01:31 -05:00
int mpc = wxGetApp ( ) . getConfig ( ) - > getModemPropsCollapsed ( ) ;
if ( mpc ) {
modemProps - > setCollapsed ( true ) ;
}
2016-06-15 16:21:41 -04:00
2019-03-16 17:44:41 -04:00
// Init main splitter position (separates top/bottom area horizontally)
2019-01-22 00:01:31 -05:00
int msPos = wxGetApp ( ) . getConfig ( ) - > getMainSplit ( ) ;
if ( msPos ! = - 1 ) {
mainSplitter - > SetSashPosition ( msPos ) ;
}
2019-03-16 17:44:41 -04:00
// Init bookmark splitter position (separates bookmark/main vis vertically)
2019-01-22 00:01:31 -05:00
int bsPos = wxGetApp ( ) . getConfig ( ) - > getBookmarkSplit ( ) ;
if ( bsPos ! = - 1 ) {
bookmarkSplitter - > SetSashPosition ( bsPos ) ;
}
2019-03-16 17:44:41 -04:00
// Init vis splitter position (separates spectrum/waterfall horizontally)
2019-01-22 00:01:31 -05:00
int vsPos = wxGetApp ( ) . getConfig ( ) - > getVisSplit ( ) ;
if ( vsPos ! = - 1 ) {
mainVisSplitter - > SetSashPosition ( vsPos ) ;
}
2016-07-28 19:33:59 -04:00
2019-03-16 17:44:41 -04:00
if ( ! wxGetApp ( ) . getConfig ( ) - > getBookmarksVisible ( ) ) {
bookmarkSplitter - > Unsplit ( bookmarkView ) ;
bookmarkSplitter - > Layout ( ) ;
}
2019-01-22 00:01:31 -05:00
2019-03-16 17:44:41 -04:00
# ifdef USE_HAMLIB
rigModel = wxGetApp ( ) . getConfig ( ) - > getRigModel ( ) ;
rigSerialRate = wxGetApp ( ) . getConfig ( ) - > getRigRate ( ) ;
rigPort = wxGetApp ( ) . getConfig ( ) - > getRigPort ( ) ;
# endif
2019-01-22 00:01:31 -05:00
}
ModemProperties * AppFrame : : makeModemProperties ( wxPanel * parent ) {
2021-04-04 22:22:16 -04:00
auto * pProperties = new ModemProperties ( parent , wxID_ANY ) ;
2019-01-22 00:01:31 -05:00
pProperties - > SetMinSize ( wxSize ( APPFRAME_MODEMPROPS_MAXSIZE , - 1 ) ) ;
pProperties - > SetMaxSize ( wxSize ( APPFRAME_MODEMPROPS_MAXSIZE , - 1 ) ) ;
ModemArgInfoList dummyInfo ;
pProperties - > initProperties ( dummyInfo , nullptr ) ;
pProperties - > updateTheme ( ) ;
return pProperties ;
}
ModeSelectorCanvas * AppFrame : : makeModemAdvSelectorPanel ( wxPanel * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ModeSelectorCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > addChoice ( " ASK " ) ;
pCanvas - > addChoice ( " APSK " ) ;
pCanvas - > addChoice ( " BPSK " ) ;
pCanvas - > addChoice ( " DPSK " ) ;
pCanvas - > addChoice ( " PSK " ) ;
pCanvas - > addChoice ( " FSK " ) ;
pCanvas - > addChoice ( " GMSK " ) ;
pCanvas - > addChoice ( " OOK " ) ;
pCanvas - > addChoice ( " ST " ) ;
pCanvas - > addChoice ( " SQAM " ) ;
pCanvas - > addChoice ( " QAM " ) ;
pCanvas - > addChoice ( " QPSK " ) ;
pCanvas - > setHelpTip ( " Choose advanced modulation types. " ) ;
pCanvas - > SetMinSize ( wxSize ( 50 , - 1 ) ) ;
pCanvas - > SetMaxSize ( wxSize ( 50 , - 1 ) ) ;
return pCanvas ;
}
2016-06-15 16:21:41 -04:00
2016-01-03 19:00:26 -05:00
# ifdef USE_HAMLIB
2019-01-22 00:01:31 -05:00
wxMenu * AppFrame : : makeRigMenu ( ) {
2019-05-07 23:35:06 -04:00
auto * pMenu = new wxMenu ;
2016-01-03 19:00:26 -05:00
2019-01-22 00:01:31 -05:00
rigEnableMenuItem = pMenu - > AppendCheckItem ( wxID_RIG_TOGGLE , wxT ( " Enable Rig " ) ) ;
2016-01-03 19:00:26 -05:00
2019-01-22 00:01:31 -05:00
pMenu - > Append ( wxID_RIG_SDR_IF , wxT ( " SDR-IF " ) ) ;
2016-02-16 01:13:26 -05:00
2019-01-22 00:01:31 -05:00
rigControlMenuItem = pMenu - > AppendCheckItem ( wxID_RIG_CONTROL , wxT ( " Control Rig " ) ) ;
2016-02-16 01:13:26 -05:00
rigControlMenuItem - > Check ( wxGetApp ( ) . getConfig ( ) - > getRigControlMode ( ) ) ;
2019-01-22 00:01:31 -05:00
rigFollowMenuItem = pMenu - > AppendCheckItem ( wxID_RIG_FOLLOW , wxT ( " Follow Rig " ) ) ;
2016-02-16 01:13:26 -05:00
rigFollowMenuItem - > Check ( wxGetApp ( ) . getConfig ( ) - > getRigFollowMode ( ) ) ;
2019-01-22 00:01:31 -05:00
rigCenterLockMenuItem = pMenu - > AppendCheckItem ( wxID_RIG_CENTERLOCK , wxT ( " Floating Center " ) ) ;
2016-02-29 23:14:23 -05:00
rigCenterLockMenuItem - > Check ( wxGetApp ( ) . getConfig ( ) - > getRigCenterLock ( ) ) ;
2019-01-22 00:01:31 -05:00
rigFollowModemMenuItem = pMenu - > AppendCheckItem ( wxID_RIG_FOLLOW_MODEM , wxT ( " Track Modem " ) ) ;
2016-02-29 23:14:23 -05:00
rigFollowModemMenuItem - > Check ( wxGetApp ( ) . getConfig ( ) - > getRigFollowModem ( ) ) ;
2019-05-13 20:52:36 -04:00
rigModelMenu = new wxMenu ;
2016-01-03 19:00:26 -05:00
RigList & rl = RigThread : : enumerate ( ) ;
2019-05-13 20:52:36 -04:00
numRigs = rl . size ( ) ;
2019-05-07 23:35:06 -04:00
std : : map < string , int > mfgCount ;
std : : map < string , wxMenu * > mfgMenu ;
for ( auto ri : rl ) {
mfgCount [ ri - > mfg_name ] + + ;
}
2019-01-22 00:01:31 -05:00
2016-01-03 19:00:26 -05:00
int modelMenuId = wxID_RIG_MODEL_BASE ;
2019-05-07 23:35:06 -04:00
for ( auto ri : rl ) {
string modelString ( ri - > mfg_name ) ;
2016-01-03 19:00:26 -05:00
modelString . append ( " " ) ;
2019-05-07 23:35:06 -04:00
modelString . append ( ri - > model_name ) ;
wxMenu * parentMenu = nullptr ;
if ( mfgCount [ ri - > mfg_name ] > 1 ) {
if ( mfgMenu . find ( ri - > mfg_name ) = = mfgMenu . end ( ) ) {
rigModelMenu - > AppendSubMenu ( mfgMenu [ ri - > mfg_name ] = new wxMenu ( ) , ri - > mfg_name ) ;
}
parentMenu = mfgMenu [ ri - > mfg_name ] ;
} else {
parentMenu = rigModelMenu ;
}
2019-01-22 00:01:31 -05:00
2019-05-07 23:35:06 -04:00
rigModelMenuItems [ ri - > rig_model ] = parentMenu - > AppendCheckItem ( modelMenuId , modelString , ri - > copyright ) ;
2019-01-22 00:01:31 -05:00
2019-05-07 23:35:06 -04:00
if ( rigModel = = ri - > rig_model ) {
rigModelMenuItems [ ri - > rig_model ] - > Check ( true ) ;
2016-01-03 19:00:26 -05:00
}
2019-01-22 00:01:31 -05:00
2016-01-03 19:00:26 -05:00
modelMenuId + + ;
}
2019-01-22 00:01:31 -05:00
pMenu - > AppendSubMenu ( rigModelMenu , wxT ( " Model " ) ) ;
2016-01-03 19:00:26 -05:00
2019-05-07 23:35:06 -04:00
auto * rigSerialMenu = new wxMenu ;
2019-01-22 00:01:31 -05:00
2016-01-03 19:00:26 -05:00
rigSerialRates . push_back ( 1200 ) ;
rigSerialRates . push_back ( 2400 ) ;
rigSerialRates . push_back ( 4800 ) ;
rigSerialRates . push_back ( 9600 ) ;
rigSerialRates . push_back ( 19200 ) ;
rigSerialRates . push_back ( 38400 ) ;
rigSerialRates . push_back ( 57600 ) ;
rigSerialRates . push_back ( 115200 ) ;
rigSerialRates . push_back ( 128000 ) ;
rigSerialRates . push_back ( 256000 ) ;
int rateMenuId = wxID_RIG_SERIAL_BASE ;
2019-05-07 23:35:06 -04:00
for ( auto rate_i : rigSerialRates ) {
2019-01-22 00:01:31 -05:00
string rateString ;
2019-05-07 23:35:06 -04:00
rateString . append ( std : : to_string ( rate_i ) ) ;
2016-01-03 19:00:26 -05:00
rateString . append ( " baud " ) ;
2019-01-22 00:01:31 -05:00
2019-05-07 23:35:06 -04:00
rigSerialMenuItems [ rate_i ] = rigSerialMenu - > AppendRadioItem ( rateMenuId , rateString , wxT ( " Description? " ) ) ;
2019-01-22 00:01:31 -05:00
2019-05-07 23:35:06 -04:00
if ( rigSerialRate = = rate_i ) {
rigSerialMenuItems [ rate_i ] - > Check ( true ) ;
2016-01-03 19:00:26 -05:00
}
2019-01-22 00:01:31 -05:00
2016-01-03 19:00:26 -05:00
rateMenuId + + ;
}
2019-01-22 00:01:31 -05:00
pMenu - > AppendSubMenu ( rigSerialMenu , wxT ( " Serial Rate " ) ) ;
2016-01-03 19:00:26 -05:00
2019-01-22 00:01:31 -05:00
rigPortMenuItem = pMenu - > Append ( wxID_RIG_PORT , wxT ( " Control Port " ) ) ;
return pMenu ;
}
2016-01-03 19:00:26 -05:00
# endif
2016-07-28 22:50:02 -04:00
2019-01-22 00:01:31 -05:00
ScopeCanvas * AppFrame : : makeScopeCanvas ( wxPanel * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ScopeCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setHelpTip ( " Audio Visuals, drag left/right to toggle Scope or Spectrum, 'B' to toggle decibels display. " ) ;
pCanvas - > SetMinSize ( wxSize ( 128 , - 1 ) ) ;
return pCanvas ;
}
2014-10-27 21:22:29 -04:00
2019-01-22 00:01:31 -05:00
wxMenu * AppFrame : : makeDisplayMenu ( ) {
2015-07-15 00:32:36 -04:00
2019-01-22 00:01:31 -05:00
//Add Display menu
2021-04-04 22:22:16 -04:00
auto * dispMenu = new wxMenu ;
auto * fontMenu = new wxMenu ;
2015-07-16 18:57:03 -04:00
2019-01-22 00:01:31 -05:00
int fontScale = wxGetApp ( ) . getConfig ( ) - > getFontScale ( ) ;
2015-07-18 21:49:53 -04:00
2019-01-22 00:01:31 -05:00
fontMenu - > AppendRadioItem ( wxID_DISPLAY_BASE , " Default " ) - > Check ( GLFont : : GLFONT_SCALE_NORMAL = = fontScale ) ;
fontMenu - > AppendRadioItem ( wxID_DISPLAY_BASE + 1 , " 1.5x " ) - > Check ( GLFont : : GLFONT_SCALE_MEDIUM = = fontScale ) ;
fontMenu - > AppendRadioItem ( wxID_DISPLAY_BASE + 2 , " 2.0x " ) - > Check ( GLFont : : GLFONT_SCALE_LARGE = = fontScale ) ;
2015-08-13 22:00:05 -04:00
2019-01-22 00:01:31 -05:00
dispMenu - > AppendSubMenu ( fontMenu , " &Text Size " ) ;
2016-04-07 20:00:59 -04:00
2021-04-04 22:22:16 -04:00
auto * themeMenu = new wxMenu ;
2016-07-28 22:50:02 -04:00
2019-01-22 00:01:31 -05:00
int themeId = wxGetApp ( ) . getConfig ( ) - > getTheme ( ) ;
themeMenu - > AppendRadioItem ( wxID_THEME_DEFAULT , " Default " ) - > Check ( themeId = = COLOR_THEME_DEFAULT ) ;
2019-09-23 01:24:04 -04:00
themeMenu - > AppendRadioItem ( wxID_THEME_DEFAULT_JET , " Default (Jet Waterfall) " ) - > Check ( themeId = = COLOR_THEME_DEFAULT_JET ) ;
2019-01-22 00:01:31 -05:00
themeMenu - > AppendRadioItem ( wxID_THEME_RADAR , " RADAR " ) - > Check ( themeId = = COLOR_THEME_RADAR ) ;
themeMenu - > AppendRadioItem ( wxID_THEME_BW , " Black & White " ) - > Check ( themeId = = COLOR_THEME_BW ) ;
themeMenu - > AppendRadioItem ( wxID_THEME_SHARP , " Sharp " ) - > Check ( themeId = = COLOR_THEME_SHARP ) ;
themeMenu - > AppendRadioItem ( wxID_THEME_RAD , " Rad " ) - > Check ( themeId = = COLOR_THEME_RAD ) ;
themeMenu - > AppendRadioItem ( wxID_THEME_TOUCH , " Touch " ) - > Check ( themeId = = COLOR_THEME_TOUCH ) ;
themeMenu - > AppendRadioItem ( wxID_THEME_HD , " HD " ) - > Check ( themeId = = COLOR_THEME_HD ) ;
dispMenu - > AppendSubMenu ( themeMenu , wxT ( " &Color Scheme " ) ) ;
hideBookmarksItem = dispMenu - > AppendCheckItem ( wxID_DISPLAY_BOOKMARKS , wxT ( " Hide Bookmarks " ) ) ;
hideBookmarksItem - > Check ( ! wxGetApp ( ) . getConfig ( ) - > getBookmarksVisible ( ) ) ;
return dispMenu ;
}
wxMenu * AppFrame : : makeAudioSampleRateMenu ( ) {
// Audio Sample Rates
2021-04-04 22:22:16 -04:00
auto * pMenu = new wxMenu ;
2019-01-22 00:01:31 -05:00
auto outputDevices = wxGetApp ( ) . getDemodMgr ( ) . getOutputDevices ( ) ;
# define NUM_RATES_DEFAULT 4
unsigned int desired_rates [ NUM_RATES_DEFAULT ] = { 48000 , 44100 , 96000 , 192000 } ;
2021-04-04 22:22:16 -04:00
for ( auto & outputDevice : outputDevices ) {
2019-01-22 00:01:31 -05:00
unsigned int desired_rate = 0 ;
unsigned int desired_rank = NUM_RATES_DEFAULT + 1 ;
2021-04-04 22:22:16 -04:00
for ( unsigned int & sampleRate : outputDevice . second . sampleRates ) {
2019-01-22 00:01:31 -05:00
for ( unsigned int i = 0 ; i < NUM_RATES_DEFAULT ; i + + ) {
2021-04-04 22:22:16 -04:00
if ( desired_rates [ i ] = = sampleRate ) {
2019-01-22 00:01:31 -05:00
if ( desired_rank > i ) {
desired_rank = i ;
2021-04-04 22:22:16 -04:00
desired_rate = sampleRate ;
2019-01-22 00:01:31 -05:00
}
}
}
}
if ( desired_rank > NUM_RATES_DEFAULT ) {
2021-04-04 22:22:16 -04:00
desired_rate = outputDevice . second . sampleRates . back ( ) ;
2019-01-22 00:01:31 -05:00
}
2021-04-04 22:22:16 -04:00
AudioThread : : deviceSampleRate [ outputDevice . first ] = desired_rate ;
2016-07-28 22:50:02 -04:00
}
2016-12-18 12:00:53 -05:00
2021-04-04 22:22:16 -04:00
for ( auto & outputDevice : outputDevices ) {
int menu_id = wxID_AUDIO_BANDWIDTH_BASE + wxID_AUDIO_DEVICE_MULTIPLIER * outputDevice . first ;
auto * subMenu = new wxMenu ;
pMenu - > AppendSubMenu ( subMenu , outputDevice . second . name , wxT ( " Description? " ) ) ;
2019-01-22 00:01:31 -05:00
int j = 0 ;
2021-04-04 22:22:16 -04:00
for ( auto srate = outputDevice . second . sampleRates . begin ( ) ; srate ! = outputDevice . second . sampleRates . end ( ) ;
2019-01-22 00:01:31 -05:00
srate + + ) {
stringstream srateName ;
srateName < < ( ( float ) ( * srate ) / 1000.0f ) < < " kHz " ;
wxMenuItem * itm = subMenu - > AppendRadioItem ( menu_id + j , srateName . str ( ) , wxT ( " Description? " ) ) ;
2021-04-04 22:22:16 -04:00
if ( ( int ) ( * srate ) = = AudioThread : : deviceSampleRate [ outputDevice . first ] ) {
2019-01-22 00:01:31 -05:00
itm - > Check ( true ) ;
}
audioSampleRateMenuItems [ menu_id + j ] = itm ;
j + + ;
}
2016-12-18 12:00:53 -05:00
}
2019-01-22 00:01:31 -05:00
return pMenu ;
}
MeterCanvas * AppFrame : : makeWaterfallSpeedMeter ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new MeterCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setHelpTip ( " Waterfall speed, click or drag to adjust (max 1024 lines per second) " ) ;
pCanvas - > setMax ( sqrt ( 1024 ) ) ;
pCanvas - > setLevel ( sqrt ( DEFAULT_WATERFALL_LPS ) ) ;
pCanvas - > setShowUserInput ( false ) ;
pCanvas - > SetMinSize ( wxSize ( 12 , 24 ) ) ;
return pCanvas ;
}
WaterfallCanvas * AppFrame : : makeWaterfall ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new WaterfallCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setup ( DEFAULT_FFT_SIZE , DEFAULT_MAIN_WATERFALL_LINES_NB ) ;
return pCanvas ;
}
MeterCanvas * AppFrame : : makeSpectrumAvgMeter ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new MeterCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setHelpTip ( " Spectrum averaging speed, click or drag to adjust. " ) ;
pCanvas - > setMax ( 1.0 ) ;
pCanvas - > setLevel ( 0.65f ) ;
pCanvas - > setShowUserInput ( false ) ;
pCanvas - > SetMinSize ( wxSize ( 12 , 24 ) ) ;
return pCanvas ;
}
SpectrumCanvas * AppFrame : : makeSpectrumCanvas ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new SpectrumCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setShowDb ( true ) ;
pCanvas - > setUseDBOfs ( true ) ;
pCanvas - > setScaleFactorEnabled ( true ) ;
return pCanvas ;
}
ModeSelectorCanvas * AppFrame : : makePeakHoldButton ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ModeSelectorCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > addChoice ( 1 , " P " ) ;
pCanvas - > setPadding ( - 1 , - 1 ) ;
pCanvas - > setHighlightColor ( RGBA4f ( 0.2f , 0.8f , 0.2f ) ) ;
pCanvas - > setHelpTip ( " Peak Hold Toggle " ) ;
pCanvas - > setToggleMode ( true ) ;
pCanvas - > setSelection ( - 1 ) ;
pCanvas - > SetMinSize ( wxSize ( 12 , 24 ) ) ;
return pCanvas ;
}
ModeSelectorCanvas * AppFrame : : makeModemMuteButton ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ModeSelectorCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > addChoice ( 1 , " M " ) ;
pCanvas - > setPadding ( - 1 , - 1 ) ;
pCanvas - > setHighlightColor ( RGBA4f ( 0.8f , 0.2f , 0.2f ) ) ;
pCanvas - > setHelpTip ( " Demodulator Mute Toggle " ) ;
pCanvas - > setToggleMode ( true ) ;
pCanvas - > setSelection ( - 1 ) ;
pCanvas - > SetMinSize ( wxSize ( 12 , 28 ) ) ;
return pCanvas ;
}
ModeSelectorCanvas * AppFrame : : makeSoloModeButton ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ModeSelectorCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > addChoice ( 1 , " S " ) ;
pCanvas - > setPadding ( - 1 , - 1 ) ;
pCanvas - > setHighlightColor ( RGBA4f ( 0.8f , 0.8f , 0.2f ) ) ;
pCanvas - > setHelpTip ( " Solo Mode Toggle " ) ;
pCanvas - > setToggleMode ( true ) ;
pCanvas - > setSelection ( - 1 ) ;
pCanvas - > SetMinSize ( wxSize ( 12 , 28 ) ) ;
return pCanvas ;
}
MeterCanvas * AppFrame : : makeModemGainMeter ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new MeterCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setMax ( 2.0 ) ;
pCanvas - > setHelpTip ( " Current Demodulator Gain Level. Click / Drag to set Gain level. " ) ;
pCanvas - > setShowUserInput ( false ) ;
pCanvas - > SetMinSize ( wxSize ( 13 , 24 ) ) ;
return pCanvas ;
}
TuningCanvas * AppFrame : : makeModemTuner ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new TuningCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > SetMinClientSize ( wxSize ( 200 , 28 ) ) ;
return pCanvas ;
}
ModeSelectorCanvas * AppFrame : : makeDeltaLockButton ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ModeSelectorCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > addChoice ( 1 , " V " ) ;
pCanvas - > setPadding ( - 1 , - 1 ) ;
pCanvas - > setHighlightColor ( RGBA4f ( 0.8f , 0.8f , 0.2f ) ) ;
pCanvas - > setHelpTip ( " Delta Lock Toggle (V) - Enable to lock modem relative to center frequency. " ) ;
pCanvas - > setToggleMode ( true ) ;
pCanvas - > setSelection ( - 1 ) ;
pCanvas - > SetMinSize ( wxSize ( 20 , 28 ) ) ;
return pCanvas ;
}
MeterCanvas * AppFrame : : makeSignalMeter ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new MeterCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setMax ( DEMOD_SIGNAL_MAX ) ;
pCanvas - > setMin ( DEMOD_SIGNAL_MIN ) ;
pCanvas - > setLevel ( DEMOD_SIGNAL_MIN ) ;
pCanvas - > setInputValue ( DEMOD_SIGNAL_MIN ) ;
pCanvas - > setHelpTip ( " Current Signal Level. Click / Drag to set Squelch level. Right-Click to Auto-Zero Squelch " ) ;
pCanvas - > SetMinSize ( wxSize ( 12 , 24 ) ) ;
return pCanvas ;
}
SpectrumCanvas * AppFrame : : makeDemodSpectrumCanvas ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new SpectrumCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setView ( wxGetApp ( ) . getConfig ( ) - > getCenterFreq ( ) , 300000 ) ;
return pCanvas ;
}
WaterfallCanvas * AppFrame : : makeWaterfallCanvas ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-04-04 22:22:16 -04:00
auto * pCanvas = new WaterfallCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
pCanvas - > setup ( DEFAULT_DMOD_FFT_SIZE , DEFAULT_DEMOD_WATERFALL_LINES_NB ) ;
pCanvas - > setView ( wxGetApp ( ) . getConfig ( ) - > getCenterFreq ( ) , 300000 ) ;
pCanvas - > setMinBandwidth ( 8000 ) ;
pCanvas - > getVisualDataQueue ( ) - > set_max_num_items ( 3 ) ;
pCanvas - > setLinesPerSecond ( ( int ) ( DEFAULT_DEMOD_WATERFALL_LINES_NB / DEMOD_WATERFALL_DURATION_IN_SECONDS ) ) ;
return pCanvas ;
}
ModeSelectorCanvas * AppFrame : : makeModemSelectorPanel ( wxWindow * parent , const wxGLAttributes & attribList ) {
2021-01-15 10:11:49 -05:00
vector < string > modemList = { " FM " , " FMS " , " NBFM " , " AM " , " CW " , " LSB " , " USB " , " DSB " , " I/Q " } ;
2019-01-22 00:01:31 -05:00
# ifdef CUBICSDR_MODEM_EXCLUDE
std : : string excludeListStr = " " CUBICSDR_MODEM_EXCLUDE ;
std : : vector < std : : string > excludeList = str_explode ( " , " , excludeListStr ) ;
for ( auto ex_i : excludeList ) {
std : : vector < std : : string > : : iterator found_i = std : : find ( modemList . begin ( ) , modemList . end ( ) , ex_i ) ;
if ( found_i ! = modemList . end ( ) ) {
modemList . erase ( found_i ) ;
}
2016-12-18 12:00:53 -05:00
}
2019-01-22 00:01:31 -05:00
# endif
2021-04-04 22:22:16 -04:00
auto * pCanvas = new ModeSelectorCanvas ( parent , attribList ) ;
2019-01-22 00:01:31 -05:00
2021-04-04 22:22:16 -04:00
for ( const auto & mt_i : modemList ) {
2019-01-22 00:01:31 -05:00
pCanvas - > addChoice ( mt_i ) ;
2016-12-18 12:00:53 -05:00
}
2014-10-27 21:22:29 -04:00
2019-01-22 00:01:31 -05:00
# ifdef CUBICSDR_MODEM_EXCLUDE
demodModeSelector - > setHelpTip ( " Use buttons to choose modulation type. " ) ;
# else
pCanvas - > setHelpTip ( " Choose modulation type: Frequency Modulation (Hotkey F), Amplitude Modulation (A) and Lower (L), Upper (U), Double Side-Band and more. " ) ;
2015-03-08 17:31:43 -04:00
# endif
2014-11-25 00:35:06 -05:00
2019-01-22 00:01:31 -05:00
pCanvas - > SetMinSize ( wxSize ( 50 , - 1 ) ) ;
pCanvas - > SetMaxSize ( wxSize ( 50 , - 1 ) ) ;
2015-01-10 12:27:03 -05:00
2019-01-22 00:01:31 -05:00
return pCanvas ;
2014-10-27 21:22:29 -04:00
}
2014-11-04 18:39:08 -05:00
AppFrame : : ~ AppFrame ( ) {
2017-03-02 16:10:17 -05:00
2015-08-14 19:17:43 -04:00
waterfallDataThread - > terminate ( ) ;
t_FFTData - > join ( ) ;
2014-11-11 20:25:16 -05:00
}
2018-01-02 23:51:32 -05:00
wxMenu * AppFrame : : makeFileMenu ( ) {
2021-04-04 22:22:16 -04:00
auto * menu = new wxMenu ;
2018-01-02 23:51:32 -05:00
# ifndef __APPLE__
# ifdef CUBICSDR_ENABLE_ABOUT_DIALOG
menu - > Append ( wxID_ABOUT_CUBICSDR , " About " CUBICSDR_INSTALL_NAME ) ;
# endif
# endif
menu - > Append ( wxID_SDR_DEVICES , " SDR Devices " ) ;
menu - > AppendSeparator ( ) ;
menu - > Append ( wxID_SDR_START_STOP , " Stop / Start Device " ) ;
menu - > AppendSeparator ( ) ;
2021-04-04 22:22:16 -04:00
auto * sessionMenu = new wxMenu ;
2018-01-14 18:56:30 -05:00
sessionMenu - > Append ( wxID_OPEN , " &Open Session " ) ;
sessionMenu - > Append ( wxID_SAVE , " &Save Session " ) ;
sessionMenu - > Append ( wxID_SAVEAS , " Save Session &As.. " ) ;
sessionMenu - > AppendSeparator ( ) ;
sessionMenu - > Append ( wxID_RESET , " &Reset Session " ) ;
menu - > AppendSubMenu ( sessionMenu , " Session " ) ;
2018-01-09 01:07:11 -05:00
menu - > AppendSeparator ( ) ;
2018-01-02 23:51:32 -05:00
2021-04-04 22:22:16 -04:00
auto * bookmarkMenu = new wxMenu ;
2018-01-14 18:56:30 -05:00
bookmarkMenu - > Append ( wxID_OPEN_BOOKMARKS , " Open Bookmarks " ) ;
bookmarkMenu - > Append ( wxID_SAVE_BOOKMARKS , " Save Bookmarks " ) ;
bookmarkMenu - > Append ( wxID_SAVEAS_BOOKMARKS , " Save Bookmarks As.. " ) ;
bookmarkMenu - > AppendSeparator ( ) ;
bookmarkMenu - > Append ( wxID_RESET_BOOKMARKS , " Reset Bookmarks " ) ;
menu - > AppendSubMenu ( bookmarkMenu , " Bookmarks " ) ;
2018-01-02 23:51:32 -05:00
# ifndef __APPLE__
menu - > AppendSeparator ( ) ;
menu - > Append ( wxID_CLOSE ) ;
# else
# ifdef CUBICSDR_ENABLE_ABOUT_DIALOG
if ( wxApp : : s_macAboutMenuItemId ! = wxID_NONE ) {
wxString aboutLabel ;
aboutLabel . Printf ( _ ( " About %s " ) , CUBICSDR_INSTALL_NAME ) ;
menu - > Append ( wxApp : : s_macAboutMenuItemId , aboutLabel ) ;
}
# endif
# endif
return menu ;
}
2018-01-13 05:50:08 -05:00
wxMenu * AppFrame : : makeRecordingMenu ( ) {
recordingMenuItems . clear ( ) ;
2021-04-04 22:22:16 -04:00
auto * menu = new wxMenu ;
2018-01-13 05:50:08 -05:00
recordingMenuItems [ wxID_RECORDING_PATH ] = menu - > Append ( wxID_RECORDING_PATH , getSettingsLabel ( " Set Recording Path " , " <Not Set> " ) ) ;
menu - > AppendSeparator ( ) ;
//Squelch options as sub-menu:
2021-04-04 22:22:16 -04:00
auto * subMenu = new wxMenu ;
2018-01-13 05:50:08 -05:00
recordingMenuItems [ wxID_RECORDING_SQUELCH_BASE ] = menu - > AppendSubMenu ( subMenu , " Squelch " ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_SILENCE ] = subMenu - > AppendRadioItem ( wxID_RECORDING_SQUELCH_SILENCE , " Record Silence " ,
" Record below squelch-break audio as silence, i.e records as the user may hear. " ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_SKIP ] = subMenu - > AppendRadioItem ( wxID_RECORDING_SQUELCH_SKIP , " Skip Silence " ,
" Do not record below squelch-break audio, i.e squelch-break audio parts are packed together. " ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_ALWAYS ] = subMenu - > AppendRadioItem ( wxID_RECORDING_SQUELCH_ALWAYS , " Record Always " ,
" Record everything irrespective of the squelch level. " ) ;
recordingMenuItems [ wxID_RECORDING_FILE_TIME_LIMIT ] = menu - > Append ( wxID_RECORDING_FILE_TIME_LIMIT , getSettingsLabel ( " File time limit " , " <Not Set> " ) ,
" Creates a new file automatically, each time the recording lasts longer than the limit, named according to the current time. " ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_SILENCE ] - > Check ( true ) ;
return menu ;
2018-01-02 23:51:32 -05:00
}
2018-01-13 05:50:08 -05:00
void AppFrame : : updateRecordingMenu ( ) {
// Recording path:
std : : string recPath = wxGetApp ( ) . getConfig ( ) - > getRecordingPath ( ) ;
if ( recPath . length ( ) > 32 ) {
recPath = " ... " + recPath . substr ( recPath . length ( ) - 32 , 32 ) ;
}
recordingMenuItems [ wxID_RECORDING_PATH ] - > SetItemLabel ( getSettingsLabel ( " Set Recording Path " , recPath . empty ( ) ? " <Not Set> " : recPath ) ) ;
//Squelch options:
int squelchEnumValue = wxGetApp ( ) . getConfig ( ) - > getRecordingSquelchOption ( ) ;
if ( squelchEnumValue = = AudioSinkFileThread : : SQUELCH_RECORD_SILENCE ) {
recordingMenuItems [ wxID_RECORDING_SQUELCH_SILENCE ] - > Check ( true ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_BASE ] - > SetItemLabel ( getSettingsLabel ( " Squelch " , " Record Silence " ) ) ;
} else if ( squelchEnumValue = = AudioSinkFileThread : : SQUELCH_SKIP_SILENCE ) {
recordingMenuItems [ wxID_RECORDING_SQUELCH_SKIP ] - > Check ( true ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_BASE ] - > SetItemLabel ( getSettingsLabel ( " Squelch " , " Skip Silence " ) ) ;
} else if ( squelchEnumValue = = AudioSinkFileThread : : SQUELCH_RECORD_ALWAYS ) {
recordingMenuItems [ wxID_RECORDING_SQUELCH_ALWAYS ] - > Check ( true ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_BASE ] - > SetItemLabel ( getSettingsLabel ( " Squelch " , " Record Always " ) ) ;
}
else {
recordingMenuItems [ wxID_RECORDING_SQUELCH_SILENCE ] - > Check ( true ) ;
recordingMenuItems [ wxID_RECORDING_SQUELCH_BASE ] - > SetItemLabel ( getSettingsLabel ( " Squelch " , " Record Silence " ) ) ;
}
//File time limit:
int fileTimeLimitSeconds = wxGetApp ( ) . getConfig ( ) - > getRecordingFileTimeLimit ( ) ;
if ( fileTimeLimitSeconds < = 0 ) {
recordingMenuItems [ wxID_RECORDING_FILE_TIME_LIMIT ] - > SetItemLabel ( getSettingsLabel ( " File time limit " , " <Not Set> " ) ) ;
}
else {
recordingMenuItems [ wxID_RECORDING_FILE_TIME_LIMIT ] - > SetItemLabel ( getSettingsLabel ( " File time limit " ,
std : : to_string ( fileTimeLimitSeconds ) , " s " ) ) ;
}
}
2018-01-02 23:51:32 -05:00
2021-04-04 22:22:16 -04:00
void AppFrame : : initDeviceParams ( SDRDeviceInfo * devInfo_in ) {
devInfo = devInfo_in ;
2015-11-02 19:27:34 -05:00
deviceChanged . store ( true ) ;
}
2015-07-08 18:54:52 -04:00
2017-01-21 05:26:51 -05:00
void AppFrame : : notifyDeviceChanged ( ) {
deviceChanged . store ( true ) ;
}
2019-03-16 18:37:52 -04:00
void AppFrame : : handleUpdateDeviceParams ( ) {
2015-11-02 19:27:34 -05:00
2017-01-21 05:26:51 -05:00
if ( ! deviceChanged . load ( ) | | devInfo = = nullptr ) {
2015-11-02 19:27:34 -05:00
return ;
}
2015-07-08 01:07:39 -04:00
2016-02-15 15:07:57 -05:00
int i = 0 ;
SoapySDR : : Device * soapyDev = devInfo - > getSoapyDevice ( ) ;
2015-07-08 01:07:39 -04:00
2015-11-03 19:58:42 -05:00
// Build settings menu
2021-04-04 22:22:16 -04:00
auto * newSettingsMenu = new wxMenu ;
2016-02-08 22:43:11 -05:00
showTipMenuItem = newSettingsMenu - > AppendCheckItem ( wxID_SET_TIPS , " Show Hover Tips " ) ;
2016-02-15 15:07:57 -05:00
showTipMenuItem - > Check ( wxGetApp ( ) . getConfig ( ) - > getShowTips ( ) ) ;
2018-05-17 11:12:29 -04:00
// CPU usage menu:
performanceMenuItems . clear ( ) ;
2021-04-04 22:22:16 -04:00
auto * subMenu = new wxMenu ;
2018-05-17 11:12:29 -04:00
2018-05-19 10:16:36 -04:00
performanceMenuItems [ wxID_PERF_BASE + ( int ) AppConfig : : PERF_HIGH ] = subMenu - > AppendRadioItem ( wxID_PERF_BASE + ( int ) AppConfig : : PERF_HIGH , " High (+enhanced DSP) " ) ;
2018-05-17 11:12:29 -04:00
performanceMenuItems [ wxID_PERF_BASE + ( int ) AppConfig : : PERF_NORMAL ] = subMenu - > AppendRadioItem ( wxID_PERF_BASE + ( int ) AppConfig : : PERF_NORMAL , " Normal " ) ;
2018-05-19 10:16:36 -04:00
performanceMenuItems [ wxID_PERF_BASE + ( int ) AppConfig : : PERF_LOW ] = subMenu - > AppendRadioItem ( wxID_PERF_BASE + ( int ) AppConfig : : PERF_LOW , " Low (-slow UI) " ) ;
2018-05-17 11:12:29 -04:00
AppConfig : : PerfModeEnum perfMode = wxGetApp ( ) . getConfig ( ) - > getPerfMode ( ) ;
if ( perfMode = = AppConfig : : PERF_HIGH ) {
wxGetApp ( ) . setChannelizerType ( SDRPostThreadChannelizerType : : SDRPostPFBCH2 ) ;
} else {
wxGetApp ( ) . setChannelizerType ( SDRPostThreadChannelizerType : : SDRPostPFBCH ) ;
2016-03-31 21:32:50 -04:00
}
2018-05-17 11:12:29 -04:00
performanceMenuItems [ wxID_PERF_BASE + ( int ) perfMode ] - > Check ( true ) ;
wxMenuItem * selectedPerfModeItem = performanceMenuItems [ wxID_PERF_BASE + ( int ) perfMode ] ;
performanceMenuItems [ wxID_PERF_CURRENT ] = newSettingsMenu - > AppendSubMenu ( subMenu , " CPU usage " ) ;
performanceMenuItems [ wxID_PERF_CURRENT ] - > SetItemLabel ( getSettingsLabel ( " CPU usage " , selectedPerfModeItem - > GetItemLabel ( ) . ToStdString ( ) ) ) ;
2016-03-31 21:32:50 -04:00
newSettingsMenu - > AppendSeparator ( ) ;
2017-08-23 17:27:49 -04:00
settingsMenuItems . clear ( ) ;
2017-08-24 15:11:50 -04:00
settingsMenuItems [ wxID_SET_DB_OFFSET ] = newSettingsMenu - > Append ( wxID_SET_DB_OFFSET , getSettingsLabel ( " Power Level Offset " , std : : to_string ( wxGetApp ( ) . getConfig ( ) - > getDBOffset ( ) ) , " dB " ) ) ;
2017-09-01 12:23:53 -04:00
settingsMenuItems [ wxID_SET_FREQ_OFFSET ] = newSettingsMenu - > Append ( wxID_SET_FREQ_OFFSET , getSettingsLabel ( " Frequency Offset " , std : : to_string ( wxGetApp ( ) . getOffset ( ) / 1000 ) , " KHz " ) ) ;
2016-02-15 15:07:57 -05:00
2016-01-31 15:11:54 -05:00
if ( devInfo - > hasCORR ( SOAPY_SDR_RX , 0 ) ) {
2017-08-24 15:11:50 -04:00
settingsMenuItems [ wxID_SET_PPM ] = newSettingsMenu - > Append ( wxID_SET_PPM , getSettingsLabel ( " Device PPM " , std : : to_string ( wxGetApp ( ) . getPPM ( ) ) , " ppm " ) ) ;
2015-07-08 01:07:39 -04:00
}
2016-02-15 15:07:57 -05:00
if ( devInfo - > getDriver ( ) ! = " rtlsdr " ) {
iqSwapMenuItem = newSettingsMenu - > AppendCheckItem ( wxID_SET_IQSWAP , " I/Q Swap " ) ;
iqSwapMenuItem - > Check ( wxGetApp ( ) . getSDRThread ( ) - > getIQSwap ( ) ) ;
}
2016-02-28 21:11:29 -05:00
agcMenuItem = nullptr ;
2021-04-04 22:22:16 -04:00
if ( ! soapyDev - > listGains ( SOAPY_SDR_RX , 0 ) . empty ( ) ) {
2016-02-28 21:11:29 -05:00
agcMenuItem = newSettingsMenu - > AppendCheckItem ( wxID_AGC_CONTROL , " Automatic Gain " ) ;
agcMenuItem - > Check ( wxGetApp ( ) . getAGCMode ( ) ) ;
2016-02-28 22:44:17 -05:00
} else if ( ! wxGetApp ( ) . getAGCMode ( ) ) {
wxGetApp ( ) . setAGCMode ( true ) ;
2016-02-28 21:11:29 -05:00
}
2017-08-23 17:27:49 -04:00
//Add an Antenna menu if more than one (RX) antenna, to keep the UI free of useless entries
antennaNames . clear ( ) ;
antennaMenuItems . clear ( ) ;
std : : vector < std : : string > availableAntennas = devInfo - > getAntennaNames ( SOAPY_SDR_RX , 0 ) ;
if ( availableAntennas . size ( ) > 1 ) {
newSettingsMenu - > AppendSeparator ( ) ;
antennaNames = availableAntennas ;
2021-04-04 22:22:16 -04:00
auto * subMenu = new wxMenu ;
2017-08-23 17:27:49 -04:00
int i = 0 ;
std : : string antennaChecked ;
2021-04-04 22:22:16 -04:00
for ( const std : : string & currentAntenna : availableAntennas ) {
2017-08-23 17:27:49 -04:00
antennaMenuItems [ wxID_ANTENNAS_BASE + i ] = subMenu - > AppendRadioItem ( wxID_ANTENNAS_BASE + i , currentAntenna ) ;
if ( wxGetApp ( ) . getAntennaName ( ) = = currentAntenna ) {
antennaMenuItems [ wxID_ANTENNAS_BASE + i ] - > Check ( true ) ;
antennaChecked = currentAntenna ;
}
i + + ;
}
antennaMenuItems [ wxID_ANTENNA_CURRENT ] = newSettingsMenu - > AppendSubMenu ( subMenu , " Antenna " ) ;
//Change the Antenna label to indicate the current antenna.
if ( ! antennaChecked . empty ( ) ) {
2017-08-24 15:11:50 -04:00
antennaMenuItems [ wxID_ANTENNA_CURRENT ] - > SetItemLabel ( getSettingsLabel ( " Antenna " , antennaChecked ) ) ;
2017-08-23 17:27:49 -04:00
}
}
2017-08-25 01:27:30 -04:00
//Add an informative, read-only menu entry to display the current TX selected antenna, if any.
if ( devInfo - > getAntennaNames ( SOAPY_SDR_TX , 0 ) . size ( ) > 1 ) {
currentTXantennaName = devInfo - > getAntennaName ( SOAPY_SDR_TX , 0 ) ;
newSettingsMenu - > AppendSeparator ( ) ;
antennaMenuItems [ wxID_ANTENNA_CURRENT_TX ] = newSettingsMenu - > Append ( wxID_ANTENNA_CURRENT_TX , getSettingsLabel ( " TX Antenna " , currentTXantennaName ) ) ;
antennaMenuItems [ wxID_ANTENNA_CURRENT_TX ] - > Enable ( false ) ;
}
2017-08-23 17:27:49 -04:00
//Runtime settings part
2015-11-03 19:58:42 -05:00
SoapySDR : : ArgInfoList : : const_iterator args_i ;
2016-02-02 19:27:08 -05:00
settingArgs = soapyDev - > getSettingInfo ( ) ;
2016-03-31 21:32:50 -04:00
2021-04-04 22:22:16 -04:00
if ( ! settingArgs . empty ( ) ) {
2016-03-31 21:32:50 -04:00
newSettingsMenu - > AppendSeparator ( ) ;
}
2017-08-11 19:04:21 -04:00
//for each Runtime option of index i:
2015-11-03 23:44:35 -05:00
for ( args_i = settingArgs . begin ( ) ; args_i ! = settingArgs . end ( ) ; args_i + + ) {
2017-08-11 19:04:21 -04:00
2015-11-03 19:58:42 -05:00
SoapySDR : : ArgInfo arg = ( * args_i ) ;
2017-08-11 19:04:21 -04:00
2016-02-02 19:27:08 -05:00
std : : string currentVal = soapyDev - > readSetting ( arg . key ) ;
2017-08-11 19:04:21 -04:00
if ( arg . type = = SoapySDR : : ArgInfo : : BOOL ) {
2015-11-03 19:58:42 -05:00
wxMenuItem * item = newSettingsMenu - > AppendCheckItem ( wxID_SETTINGS_BASE + i , arg . name , arg . description ) ;
2015-11-03 23:44:35 -05:00
item - > Check ( currentVal = = " true " ) ;
2015-11-03 19:58:42 -05:00
i + + ;
} else if ( arg . type = = SoapySDR : : ArgInfo : : INT ) {
2017-08-23 17:27:49 -04:00
2017-08-24 15:11:50 -04:00
settingsMenuItems [ wxID_SETTINGS_BASE + i ] = newSettingsMenu - > Append ( wxID_SETTINGS_BASE + i , getSettingsLabel ( arg . name , currentVal , arg . units ) , arg . description ) ;
2015-11-03 19:58:42 -05:00
i + + ;
} else if ( arg . type = = SoapySDR : : ArgInfo : : FLOAT ) {
2017-08-24 15:11:50 -04:00
settingsMenuItems [ wxID_SETTINGS_BASE + i ] = newSettingsMenu - > Append ( wxID_SETTINGS_BASE + i , getSettingsLabel ( arg . name , currentVal , arg . units ) , arg . description ) ;
2015-11-03 19:58:42 -05:00
i + + ;
} else if ( arg . type = = SoapySDR : : ArgInfo : : STRING ) {
2021-04-04 22:22:16 -04:00
if ( ! arg . options . empty ( ) ) {
auto * subMenu = new wxMenu ;
2015-11-03 19:58:42 -05:00
int j = 0 ;
2017-08-23 17:27:49 -04:00
std : : vector < int > subItemsIds ;
2017-08-11 19:04:21 -04:00
//for each of this options
2021-04-04 22:22:16 -04:00
for ( const std : : string & optName : arg . options ) {
2017-08-11 19:04:21 -04:00
//by default the option name is the same as the displayed name.
2015-11-03 19:58:42 -05:00
std : : string displayName = optName ;
2017-08-11 19:04:21 -04:00
2021-04-04 22:22:16 -04:00
if ( ! arg . optionNames . empty ( ) ) {
2015-11-03 19:58:42 -05:00
displayName = arg . optionNames [ j ] ;
}
wxMenuItem * item = subMenu - > AppendRadioItem ( wxID_SETTINGS_BASE + i , displayName ) ;
2017-08-23 17:27:49 -04:00
subItemsIds . push_back ( wxID_SETTINGS_BASE + i ) ;
2017-08-11 19:04:21 -04:00
if ( currentVal = = optName ) {
2016-01-09 00:09:46 -05:00
item - > Check ( true ) ;
2015-11-03 19:58:42 -05:00
}
j + + ;
2015-11-03 23:44:35 -05:00
i + + ;
2015-11-03 19:58:42 -05:00
}
2017-08-24 15:11:50 -04:00
settingsMenuItems [ wxID_SETTINGS_BASE + i ] = newSettingsMenu - > AppendSubMenu ( subMenu , getSettingsLabel ( arg . name , currentVal , arg . units ) , arg . description ) ;
2017-08-23 17:27:49 -04:00
//map subitems ids to their parent item !
for ( int currentSubId : subItemsIds ) {
settingsMenuItems [ currentSubId ] = settingsMenuItems [ wxID_SETTINGS_BASE + i ] ;
}
2015-11-03 19:58:42 -05:00
} else {
2017-08-24 15:11:50 -04:00
settingsMenuItems [ wxID_SETTINGS_BASE + i ] = newSettingsMenu - > Append ( wxID_SETTINGS_BASE + i , getSettingsLabel ( arg . name , currentVal , arg . units ) , arg . description ) ;
2015-11-03 19:58:42 -05:00
i + + ;
}
}
}
2015-11-03 23:44:35 -05:00
settingsIdMax = wxID_SETTINGS_BASE + i ;
2015-11-03 19:58:42 -05:00
menuBar - > Replace ( 1 , newSettingsMenu , wxT ( " &Settings " ) ) ;
settingsMenu = newSettingsMenu ;
2017-01-21 05:26:51 -05:00
// Build/Rebuild the sample rate menu :
2016-01-31 15:11:54 -05:00
sampleRates = devInfo - > getSampleRates ( SOAPY_SDR_RX , 0 ) ;
2017-01-21 05:26:51 -05:00
sampleRateMenuItems . clear ( ) ;
2015-10-20 23:00:10 -04:00
2021-04-04 22:22:16 -04:00
auto * newSampleRateMenu = new wxMenu ;
2015-10-20 23:00:10 -04:00
int ofs = 0 ;
2017-01-21 05:26:51 -05:00
//Current sample rate, try to keep it as is.
2015-10-20 23:00:10 -04:00
long sampleRate = wxGetApp ( ) . getSampleRate ( ) ;
2017-01-21 05:26:51 -05:00
long minRate = sampleRates . front ( ) ;
long maxRate = sampleRates . back ( ) ;
//If it is beyond limits, make device choose a reasonable value
if ( sampleRate < minRate | | sampleRate > maxRate ) {
sampleRate = devInfo - > getSampleRateNear ( SOAPY_SDR_RX , 0 , sampleRate ) ;
}
//Check if a manual entry was previously set: if so, check its value is still within the limits of the device. If not so, reset it.
if ( manualSampleRate > 0 & &
2017-01-24 23:14:39 -05:00
( manualSampleRate < minRate | | manualSampleRate > maxRate ) ) {
2017-01-21 05:26:51 -05:00
manualSampleRate = - 1 ;
}
2015-10-20 23:00:10 -04:00
bool checked = false ;
2021-04-04 22:22:16 -04:00
for ( long & i : sampleRates ) {
2017-01-21 05:26:51 -05:00
2021-04-04 22:22:16 -04:00
sampleRateMenuItems [ wxID_BANDWIDTH_BASE + ofs ] = newSampleRateMenu - > AppendRadioItem ( wxID_BANDWIDTH_BASE + ofs , frequencyToStr ( i ) ) ;
2017-01-21 05:26:51 -05:00
2021-04-04 22:22:16 -04:00
if ( sampleRate = = i ) {
2015-10-20 23:00:10 -04:00
sampleRateMenuItems [ wxID_BANDWIDTH_BASE + ofs ] - > Check ( true ) ;
checked = true ;
}
ofs + + ;
}
2017-01-21 05:26:51 -05:00
//Add a manual sample value radio button, but disabled by default in case the user
//never ever uses manual entry.
if ( manualSampleRate < = 0 ) {
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] = newSampleRateMenu - > AppendRadioItem ( wxID_BANDWIDTH_MANUAL , wxT ( " Manual : N/A " ) ) ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Enable ( false ) ;
}
else {
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] = newSampleRateMenu - > AppendRadioItem ( wxID_BANDWIDTH_MANUAL , wxT ( " Manual : " ) + frequencyToStr ( manualSampleRate ) ) ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Enable ( true ) ;
}
//We apply the current sample rate after all
2015-10-20 23:00:10 -04:00
if ( ! checked ) {
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Check ( true ) ;
}
2017-01-21 05:26:51 -05:00
//Append a normal button (NOT a radio-button) for manual entry dialog at the end
newSampleRateMenu - > AppendSeparator ( ) ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL_DIALOG ] = newSampleRateMenu - > Append ( wxID_BANDWIDTH_MANUAL_DIALOG , wxT ( " Manual Entry... " ) ) ;
2016-07-28 22:50:02 -04:00
menuBar - > Replace ( 2 , newSampleRateMenu , wxT ( " Sample &Rate " ) ) ;
2015-11-02 21:04:02 -05:00
sampleRateMenu = newSampleRateMenu ;
2015-10-27 01:56:49 -04:00
if ( ! wxGetApp ( ) . getAGCMode ( ) ) {
gainSpacerItem - > Show ( true ) ;
gainSizerItem - > Show ( true ) ;
2016-01-31 15:11:54 -05:00
gainSizerItem - > SetMinSize ( devInfo - > getSoapyDevice ( ) - > listGains ( SOAPY_SDR_RX , 0 ) . size ( ) * 50 , 0 ) ;
2015-10-27 01:56:49 -04:00
demodTray - > Layout ( ) ;
} else {
gainSpacerItem - > Show ( false ) ;
gainSizerItem - > Show ( false ) ;
demodTray - > Layout ( ) ;
2015-07-08 01:07:39 -04:00
}
2016-02-28 21:11:29 -05:00
2016-01-09 00:09:46 -05:00
# if USE_HAMLIB
2016-02-16 01:13:26 -05:00
if ( wxGetApp ( ) . getConfig ( ) - > getRigEnabled ( ) & & ! wxGetApp ( ) . rigIsActive ( ) ) {
enableRig ( ) ;
rigEnableMenuItem - > Check ( true ) ;
}
2016-01-09 00:09:46 -05:00
std : : string deviceId = devInfo - > getDeviceId ( ) ;
DeviceConfig * devConfig = wxGetApp ( ) . getConfig ( ) - > getDevice ( deviceId ) ;
if ( wxGetApp ( ) . rigIsActive ( ) ) {
rigSDRIF = devConfig - > getRigIF ( rigModel ) ;
if ( rigSDRIF ) {
wxGetApp ( ) . lockFrequency ( rigSDRIF ) ;
} else {
wxGetApp ( ) . unlockFrequency ( ) ;
}
}
# endif
2015-11-02 19:27:34 -05:00
deviceChanged . store ( false ) ;
2014-10-27 21:22:29 -04:00
}
2016-02-16 01:13:26 -05:00
# ifdef USE_HAMLIB
void AppFrame : : enableRig ( ) {
wxGetApp ( ) . stopRig ( ) ;
wxGetApp ( ) . initRig ( rigModel , rigPort , rigSerialRate ) ;
if ( devInfo ! = nullptr ) {
std : : string deviceId = devInfo - > getDeviceId ( ) ;
DeviceConfig * devConfig = wxGetApp ( ) . getConfig ( ) - > getDevice ( deviceId ) ;
rigSDRIF = devConfig - > getRigIF ( rigModel ) ;
if ( rigSDRIF ) {
wxGetApp ( ) . lockFrequency ( rigSDRIF ) ;
} else {
wxGetApp ( ) . unlockFrequency ( ) ;
}
} else {
wxGetApp ( ) . unlockFrequency ( ) ;
}
wxGetApp ( ) . getConfig ( ) - > setRigEnabled ( true ) ;
}
void AppFrame : : disableRig ( ) {
wxGetApp ( ) . stopRig ( ) ;
wxGetApp ( ) . unlockFrequency ( ) ;
wxGetApp ( ) . getConfig ( ) - > setRigEnabled ( false ) ;
}
2017-04-20 19:40:09 -04:00
2021-04-04 22:22:16 -04:00
void AppFrame : : setRigControlPort ( const std : : string & portName ) {
2017-04-20 19:40:09 -04:00
if ( rigPortDialog = = nullptr ) {
return ;
}
2021-04-04 22:22:16 -04:00
if ( ! portName . empty ( ) ) {
2017-04-20 19:40:09 -04:00
rigPort = portName ;
wxGetApp ( ) . stopRig ( ) ;
wxGetApp ( ) . initRig ( rigModel , rigPort , rigSerialRate ) ;
Refresh ( ) ;
}
rigPortDialog - > EndModal ( 0 ) ;
delete rigPortDialog ;
rigPortDialog = nullptr ;
}
void AppFrame : : dismissRigControlPortDialog ( ) {
rigPortDialog - > EndModal ( 0 ) ;
delete rigPortDialog ;
rigPortDialog = nullptr ;
}
2016-02-16 01:13:26 -05:00
# endif
2014-11-11 20:25:16 -05:00
2019-03-19 00:06:01 -04:00
void AppFrame : : OnMenu ( wxCommandEvent & event ) {
actionOnMenuAbout ( event )
| | actionOnMenuSDRStartStop ( event )
| | actionOnMenuPerformance ( event )
| | actionOnMenuTips ( event )
| | actionOnMenuIQSwap ( event )
| | actionOnMenuFreqOffset ( event )
| | actionOnMenuDBOffset ( event )
| | actionOnMenuAGC ( event )
| | actionOnMenuSDRDevices ( event )
| | actionOnMenuSetPPM ( event )
| | actionOnMenuLoadSave ( event )
| | actionOnMenuReset ( event )
| | actionOnMenuClose ( event )
| | actionOnMenuSettings ( event )
| | actionOnMenuSampleRate ( event )
| | actionOnMenuAudioSampleRate ( event )
| | actionOnMenuRecording ( event )
| | actionOnMenuDisplay ( event )
//Optional : Rig
| | actionOnMenuRig ( event ) ;
}
2017-01-25 15:28:44 -05:00
bool AppFrame : : actionOnMenuDisplay ( wxCommandEvent & event ) {
//by default, is managed.
bool bManaged = true ;
2019-09-23 01:24:04 -04:00
2017-01-25 15:28:44 -05:00
if ( event . GetId ( ) = = wxID_THEME_DEFAULT ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_DEFAULT ) ;
}
2021-04-04 22:22:16 -04:00
else if ( event . GetId ( ) = = wxID_THEME_DEFAULT_JET ) {
2019-09-23 01:24:04 -04:00
ThemeMgr : : mgr . setTheme ( COLOR_THEME_DEFAULT_JET ) ;
}
2017-01-25 15:28:44 -05:00
else if ( event . GetId ( ) = = wxID_THEME_SHARP ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_SHARP ) ;
}
else if ( event . GetId ( ) = = wxID_THEME_BW ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_BW ) ;
}
else if ( event . GetId ( ) = = wxID_THEME_RAD ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_RAD ) ;
}
else if ( event . GetId ( ) = = wxID_THEME_TOUCH ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_TOUCH ) ;
}
else if ( event . GetId ( ) = = wxID_THEME_HD ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_HD ) ;
}
else if ( event . GetId ( ) = = wxID_THEME_RADAR ) {
ThemeMgr : : mgr . setTheme ( COLOR_THEME_RADAR ) ;
}
//Display : font sizes
else if ( event . GetId ( ) = = wxID_DISPLAY_BASE ) {
GLFont : : setScale ( GLFont : : GLFONT_SCALE_NORMAL ) ;
}
else if ( event . GetId ( ) = = wxID_DISPLAY_BASE + 1 ) {
GLFont : : setScale ( GLFont : : GLFONT_SCALE_MEDIUM ) ;
}
else if ( event . GetId ( ) = = wxID_DISPLAY_BASE + 2 ) {
GLFont : : setScale ( GLFont : : GLFONT_SCALE_LARGE ) ;
}
else if ( event . GetId ( ) = = wxID_DISPLAY_BOOKMARKS ) {
if ( hideBookmarksItem - > IsChecked ( ) ) {
bookmarkSplitter - > Unsplit ( bookmarkView ) ;
bookmarkSplitter - > Layout ( ) ;
}
else {
bookmarkSplitter - > SplitVertically ( bookmarkView , mainVisSplitter , wxGetApp ( ) . getConfig ( ) - > getBookmarkSplit ( ) ) ;
bookmarkSplitter - > Layout ( ) ;
}
}
else {
bManaged = false ;
}
//update theme choice in children elements:
if ( event . GetId ( ) > = wxID_THEME_DEFAULT & & event . GetId ( ) < = wxID_THEME_RADAR ) {
gainCanvas - > setThemeColors ( ) ;
modemProps - > updateTheme ( ) ;
bookmarkView - > updateTheme ( ) ;
}
//force all windows refresh
if ( bManaged ) {
Refresh ( ) ;
}
return bManaged ;
}
2017-02-26 05:18:09 -05:00
bool AppFrame : : actionOnMenuReset ( wxCommandEvent & event ) {
2016-07-28 22:50:02 -04:00
2017-02-26 05:18:09 -05:00
if ( event . GetId ( ) = = wxID_RESET ) {
2016-03-31 21:32:50 -04:00
2015-01-10 12:27:03 -05:00
wxGetApp ( ) . getDemodMgr ( ) . terminateAll ( ) ;
2015-07-21 00:04:04 -04:00
wxGetApp ( ) . setFrequency ( 100000000 ) ;
2015-11-17 18:57:42 -05:00
wxGetApp ( ) . getDemodMgr ( ) . setLastDemodulatorType ( " FM " ) ;
2015-08-13 22:00:05 -04:00
demodModeSelector - > setSelection ( 1 ) ;
2015-08-19 17:06:06 -04:00
wxGetApp ( ) . getDemodMgr ( ) . setLastMuted ( false ) ;
2015-08-13 22:00:05 -04:00
wxGetApp ( ) . getDemodMgr ( ) . setLastBandwidth ( DEFAULT_DEMOD_BW ) ;
wxGetApp ( ) . getDemodMgr ( ) . setLastGain ( 1.0 ) ;
2015-11-21 15:12:20 -05:00
wxGetApp ( ) . getDemodMgr ( ) . setLastSquelchLevel ( - 100 ) ;
2015-08-13 22:00:05 -04:00
waterfallCanvas - > setBandwidth ( wxGetApp ( ) . getSampleRate ( ) ) ;
waterfallCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
spectrumCanvas - > setBandwidth ( wxGetApp ( ) . getSampleRate ( ) ) ;
spectrumCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
2015-08-14 19:17:43 -04:00
waterfallDataThread - > setLinesPerSecond ( DEFAULT_WATERFALL_LPS ) ;
2015-09-09 23:29:38 -04:00
waterfallCanvas - > setLinesPerSecond ( DEFAULT_WATERFALL_LPS ) ;
2015-08-13 22:00:05 -04:00
waterfallSpeedMeter - > setLevel ( sqrt ( DEFAULT_WATERFALL_LPS ) ) ;
2016-06-01 19:42:34 -04:00
wxGetApp ( ) . getSpectrumProcessor ( ) - > setFFTAverageRate ( 0.65f ) ;
spectrumAvgMeter - > setLevel ( 0.65f ) ;
2017-02-26 05:18:09 -05:00
2020-02-26 01:11:19 -05:00
wxString titleBar = CUBICSDR_TITLE ;
//append the name of the current Device, if any.
if ( wxGetApp ( ) . getDevice ( ) ) {
titleBar + = " - " + wxGetApp ( ) . getDevice ( ) - > getName ( ) ;
}
SetTitle ( titleBar ) ;
2015-01-10 20:33:30 -05:00
currentSessionFile = " " ;
2018-01-06 04:22:14 -05:00
currentBookmarkFile = " " ;
2016-12-27 15:36:33 -05:00
bookmarkSplitter - > Unsplit ( bookmarkView ) ;
2017-02-26 05:18:09 -05:00
bookmarkSplitter - > SplitVertically ( bookmarkView , mainVisSplitter , wxGetApp ( ) . getConfig ( ) - > getBookmarkSplit ( ) ) ;
2016-12-27 15:36:33 -05:00
hideBookmarksItem - > Check ( false ) ;
2016-06-20 12:29:56 -04:00
//force all windows refresh
Refresh ( ) ;
2017-01-25 15:28:44 -05:00
2017-02-26 05:18:09 -05:00
return true ;
2016-06-15 16:21:41 -04:00
}
2017-02-26 05:18:09 -05:00
return false ;
}
bool AppFrame : : actionOnMenuAbout ( wxCommandEvent & event ) {
# ifdef __APPLE__
if ( event . GetId ( ) = = wxApp : : s_macAboutMenuItemId ) {
# else
if ( event . GetId ( ) = = wxID_ABOUT_CUBICSDR ) {
# endif
if ( aboutDlg ! = nullptr ) {
aboutDlg - > Raise ( ) ;
aboutDlg - > SetFocus ( ) ;
}
else {
2021-04-04 22:22:16 -04:00
aboutDlg = new AboutDialog ( nullptr ) ;
aboutDlg - > Connect ( wxEVT_CLOSE_WINDOW , wxCommandEventHandler ( AppFrame : : OnAboutDialogClose ) , nullptr , this ) ;
2017-02-26 05:18:09 -05:00
aboutDlg - > Show ( ) ;
}
return true ;
2016-06-15 16:21:41 -04:00
}
2017-02-26 05:18:09 -05:00
return false ;
}
bool AppFrame : : actionOnMenuSettings ( wxCommandEvent & event ) {
2019-01-10 21:23:26 -05:00
int antennaIdMax = wxID_ANTENNAS_BASE + antennaNames . size ( ) ;
if ( event . GetId ( ) > = wxID_ANTENNAS_BASE & & event . GetId ( ) < antennaIdMax ) {
2017-08-23 17:27:49 -04:00
wxGetApp ( ) . setAntennaName ( antennaNames [ event . GetId ( ) - wxID_ANTENNAS_BASE ] ) ;
2017-08-24 15:11:50 -04:00
antennaMenuItems [ wxID_ANTENNA_CURRENT ] - > SetItemLabel ( getSettingsLabel ( " Antenna " , wxGetApp ( ) . getAntennaName ( ) ) ) ;
2017-08-23 17:27:49 -04:00
return true ;
}
else if ( event . GetId ( ) > = wxID_SETTINGS_BASE & & event . GetId ( ) < settingsIdMax ) {
2017-02-26 05:18:09 -05:00
int setIdx = event . GetId ( ) - wxID_SETTINGS_BASE ;
2015-11-03 23:44:35 -05:00
int menuIdx = 0 ;
2017-02-26 05:18:09 -05:00
2021-04-04 22:22:16 -04:00
for ( auto & arg : settingArgs ) {
if ( arg . type = = SoapySDR : : ArgInfo : : STRING & & ! arg . options . empty ( ) & & setIdx > = menuIdx & & setIdx < menuIdx + ( int ) arg . options . size ( ) ) {
2017-02-26 05:18:09 -05:00
int optIdx = setIdx - menuIdx ;
2015-11-03 23:44:35 -05:00
wxGetApp ( ) . getSDRThread ( ) - > writeSetting ( arg . key , arg . options [ optIdx ] ) ;
2017-08-24 15:11:50 -04:00
2017-08-23 17:27:49 -04:00
//update parent menu item label to display the current value
2017-08-24 15:11:50 -04:00
settingsMenuItems [ menuIdx + wxID_SETTINGS_BASE ] - > SetItemLabel ( getSettingsLabel ( arg . name , arg . options [ optIdx ] , arg . units ) ) ;
2015-11-03 23:44:35 -05:00
break ;
2017-02-26 05:18:09 -05:00
}
2021-04-04 22:22:16 -04:00
else if ( arg . type = = SoapySDR : : ArgInfo : : STRING & & ! arg . options . empty ( ) ) {
2015-11-03 23:44:35 -05:00
menuIdx + = arg . options . size ( ) ;
2017-02-26 05:18:09 -05:00
}
else if ( menuIdx = = setIdx ) {
2015-11-03 23:44:35 -05:00
if ( arg . type = = SoapySDR : : ArgInfo : : BOOL ) {
2017-02-26 05:18:09 -05:00
wxGetApp ( ) . getSDRThread ( ) - > writeSetting ( arg . key , ( wxGetApp ( ) . getSDRThread ( ) - > readSetting ( arg . key ) = = " true " ) ? " false " : " true " ) ;
2015-11-03 23:44:35 -05:00
break ;
2017-02-26 05:18:09 -05:00
}
else if ( arg . type = = SoapySDR : : ArgInfo : : STRING ) {
2016-01-02 21:42:35 -05:00
wxString stringVal = wxGetTextFromUser ( arg . description , arg . name , wxGetApp ( ) . getSDRThread ( ) - > readSetting ( arg . key ) ) ;
2017-08-23 17:27:49 -04:00
2017-08-24 15:11:50 -04:00
settingsMenuItems [ menuIdx + wxID_SETTINGS_BASE ] - > SetItemLabel ( getSettingsLabel ( arg . name , stringVal . ToStdString ( ) , arg . units ) ) ;
2017-08-23 17:27:49 -04:00
2021-04-04 22:22:16 -04:00
if ( ! stringVal . ToStdString ( ) . empty ( ) ) {
2016-01-02 21:42:35 -05:00
wxGetApp ( ) . getSDRThread ( ) - > writeSetting ( arg . key , stringVal . ToStdString ( ) ) ;
}
break ;
2017-02-26 05:18:09 -05:00
}
else if ( arg . type = = SoapySDR : : ArgInfo : : INT ) {
2015-11-03 23:44:35 -05:00
int currentVal ;
try {
currentVal = std : : stoi ( wxGetApp ( ) . getSDRThread ( ) - > readSetting ( arg . key ) ) ;
2017-02-26 05:18:09 -05:00
}
2021-04-22 00:34:45 -04:00
catch ( const std : : invalid_argument & ) {
2015-11-03 23:44:35 -05:00
currentVal = 0 ;
}
int intVal = wxGetNumberFromUser ( arg . description , arg . units , arg . name , currentVal , arg . range . minimum ( ) , arg . range . maximum ( ) , this ) ;
2017-08-23 17:27:49 -04:00
2017-08-24 15:11:50 -04:00
settingsMenuItems [ menuIdx + wxID_SETTINGS_BASE ] - > SetItemLabel ( getSettingsLabel ( arg . name , std : : to_string ( intVal ) , arg . units ) ) ;
2017-08-23 17:27:49 -04:00
2015-11-03 23:44:35 -05:00
if ( intVal ! = - 1 ) {
wxGetApp ( ) . getSDRThread ( ) - > writeSetting ( arg . key , std : : to_string ( intVal ) ) ;
}
break ;
2017-02-26 05:18:09 -05:00
}
else if ( arg . type = = SoapySDR : : ArgInfo : : FLOAT ) {
2015-11-03 23:44:35 -05:00
wxString floatVal = wxGetTextFromUser ( arg . description , arg . name , wxGetApp ( ) . getSDRThread ( ) - > readSetting ( arg . key ) ) ;
try {
wxGetApp ( ) . getSDRThread ( ) - > writeSetting ( arg . key , floatVal . ToStdString ( ) ) ;
2017-02-26 05:18:09 -05:00
}
2021-04-22 00:34:45 -04:00
catch ( const std : : invalid_argument & ) {
2015-11-03 23:44:35 -05:00
// ...
}
2017-08-24 15:11:50 -04:00
settingsMenuItems [ menuIdx + wxID_SETTINGS_BASE ] - > SetItemLabel ( getSettingsLabel ( arg . name , floatVal . ToStdString ( ) , arg . units ) ) ;
2015-11-03 23:44:35 -05:00
break ;
2017-02-26 05:18:09 -05:00
}
else {
2015-11-03 23:44:35 -05:00
menuIdx + + ;
}
2017-02-26 05:18:09 -05:00
}
else {
2015-11-03 23:44:35 -05:00
menuIdx + + ;
}
2017-02-26 05:18:09 -05:00
} //end for
2017-11-19 19:33:18 -05:00
2017-02-26 05:18:09 -05:00
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuAGC ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_AGC_CONTROL ) {
2021-04-04 22:22:16 -04:00
if ( wxGetApp ( ) . getDevice ( ) = = nullptr ) {
2017-02-26 05:18:09 -05:00
agcMenuItem - > Check ( true ) ;
return true ;
}
if ( ! wxGetApp ( ) . getAGCMode ( ) ) {
wxGetApp ( ) . setAGCMode ( true ) ;
gainSpacerItem - > Show ( false ) ;
gainSizerItem - > Show ( false ) ;
demodTray - > Layout ( ) ;
}
else {
wxGetApp ( ) . setAGCMode ( false ) ;
gainSpacerItem - > Show ( true ) ;
gainSizerItem - > Show ( true ) ;
gainSizerItem - > SetMinSize ( wxGetApp ( ) . getDevice ( ) - > getSoapyDevice ( ) - > listGains ( SOAPY_SDR_RX , 0 ) . size ( ) * 40 , 0 ) ;
demodTray - > Layout ( ) ;
gainCanvas - > updateGainUI ( ) ;
2015-11-03 23:44:35 -05:00
}
2017-02-26 05:18:09 -05:00
//full Refresh, some graphical elements has changed
Refresh ( ) ;
return true ;
2015-11-03 23:44:35 -05:00
}
2017-02-26 05:18:09 -05:00
return false ;
}
bool AppFrame : : actionOnMenuSampleRate ( wxCommandEvent & event ) {
2015-08-10 18:45:46 -04:00
2017-01-21 05:26:51 -05:00
if ( event . GetId ( ) = = wxID_BANDWIDTH_MANUAL ) {
wxGetApp ( ) . setSampleRate ( manualSampleRate ) ;
2017-02-26 05:18:09 -05:00
return true ;
2017-01-21 05:26:51 -05:00
}
else if ( event . GetId ( ) = = wxID_BANDWIDTH_MANUAL_DIALOG ) {
2017-01-28 08:57:27 -05:00
int rateHigh = 0 , rateLow = 0 ;
2017-01-21 05:26:51 -05:00
SDRDeviceInfo * dev = wxGetApp ( ) . getDevice ( ) ;
if ( dev ! = nullptr ) {
2021-04-04 22:22:16 -04:00
std : : vector < long > sampleRateList = dev - > getSampleRates ( SOAPY_SDR_RX , 0 ) ;
2017-01-21 05:26:51 -05:00
//default
rateLow = MANUAL_SAMPLE_RATE_MIN ;
rateHigh = MANUAL_SAMPLE_RATE_MAX ;
2021-04-04 22:22:16 -04:00
if ( ! sampleRateList . empty ( ) ) {
rateLow = sampleRateList . front ( ) ;
rateHigh = sampleRateList . back ( ) ;
2015-10-21 17:39:44 -04:00
}
long bw = wxGetNumberFromUser ( " \n " + dev - > getName ( ) + " \n \n "
2017-01-21 05:26:51 -05:00
+ " min: " + std : : to_string ( rateLow ) + " Hz "
+ " , max: " + std : : to_string ( rateHigh ) + " Hz \n " ,
" Sample Rate in Hz " ,
" Manual Sample Rate Entry " ,
//If a manual sample rate has already been input, recall this one.
2017-02-26 05:18:09 -05:00
manualSampleRate > 0 ? manualSampleRate : wxGetApp ( ) . getSampleRate ( ) ,
2017-01-21 05:26:51 -05:00
rateLow ,
rateHigh ,
this ) ;
2015-09-13 22:18:29 -04:00
if ( bw ! = - 1 ) {
2017-01-21 05:26:51 -05:00
manualSampleRate = bw ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Enable ( true ) ;
2017-02-26 05:18:09 -05:00
2017-01-21 05:26:51 -05:00
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > SetItemLabel ( wxT ( " Manual : " ) + frequencyToStr ( manualSampleRate ) ) ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Check ( true ) ;
wxGetApp ( ) . setSampleRate ( manualSampleRate ) ;
2015-09-13 22:18:29 -04:00
}
2017-01-21 05:26:51 -05:00
}
2017-02-26 05:18:09 -05:00
return true ;
2015-01-11 17:08:16 -05:00
}
2017-01-21 05:26:51 -05:00
else if ( event . GetId ( ) > = wxID_BANDWIDTH_BASE & & event . GetId ( ) < wxID_BANDWIDTH_BASE + ( int ) sampleRates . size ( ) ) {
2017-02-26 05:18:09 -05:00
wxGetApp ( ) . setSampleRate ( sampleRates [ event . GetId ( ) - wxID_BANDWIDTH_BASE ] ) ;
return true ;
2015-01-12 00:40:43 -05:00
}
2017-02-26 05:18:09 -05:00
return false ;
}
bool AppFrame : : actionOnMenuAudioSampleRate ( wxCommandEvent & event ) {
2015-03-12 19:41:50 -04:00
if ( event . GetId ( ) > = wxID_AUDIO_BANDWIDTH_BASE ) {
2017-02-26 05:18:09 -05:00
2015-03-12 19:41:50 -04:00
int evId = event . GetId ( ) ;
2019-01-22 00:01:31 -05:00
auto outputDevices = wxGetApp ( ) . getDemodMgr ( ) . getOutputDevices ( ) ;
2015-03-12 19:41:50 -04:00
int i = 0 ;
2021-04-04 22:22:16 -04:00
for ( auto & outputDevice : outputDevices ) {
int menu_id = wxID_AUDIO_BANDWIDTH_BASE + wxID_AUDIO_DEVICE_MULTIPLIER * outputDevice . first ;
2015-03-12 19:41:50 -04:00
2015-03-29 20:24:00 -04:00
int j = 0 ;
2021-04-04 22:22:16 -04:00
for ( auto srate = outputDevice . second . sampleRates . begin ( ) ; srate ! = outputDevice . second . sampleRates . end ( ) ;
2017-02-26 05:18:09 -05:00
srate + + ) {
2015-03-12 19:41:50 -04:00
2015-03-29 20:24:00 -04:00
if ( evId = = menu_id + j ) {
//audioSampleRateMenuItems[menu_id+j];
//std::cout << "Would set audio sample rate on device " << mdevices_i->second.name << " (" << mdevices_i->first << ") to " << (*srate) << "Hz" << std::endl;
2021-04-04 22:22:16 -04:00
AudioThread : : setDeviceSampleRate ( outputDevice . first , * srate ) ;
2017-04-20 19:40:09 -04:00
return true ;
2015-03-29 20:24:00 -04:00
}
2015-03-12 19:41:50 -04:00
2015-03-29 20:24:00 -04:00
j + + ;
}
i + + ;
}
2017-02-26 05:18:09 -05:00
}
return false ;
}
bool AppFrame : : actionOnMenuLoadSave ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SAVE ) {
if ( ! currentSessionFile . empty ( ) ) {
saveSession ( currentSessionFile ) ;
}
else {
wxFileDialog saveFileDialog ( this , _ ( " Save XML Session file " ) , " " , " " , " XML files (*.xml)|*.xml " , wxFD_SAVE | wxFD_OVERWRITE_PROMPT ) ;
if ( saveFileDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
saveSession ( saveFileDialog . GetPath ( ) . ToStdString ( ) ) ;
}
return true ;
2015-03-12 19:41:50 -04:00
}
2017-02-26 05:18:09 -05:00
else if ( event . GetId ( ) = = wxID_OPEN ) {
wxFileDialog openFileDialog ( this , _ ( " Open XML Session file " ) , " " , " " , " XML files (*.xml)|*.xml " , wxFD_OPEN | wxFD_FILE_MUST_EXIST ) ;
if ( openFileDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
loadSession ( openFileDialog . GetPath ( ) . ToStdString ( ) ) ;
return true ;
}
else if ( event . GetId ( ) = = wxID_SAVEAS ) {
wxFileDialog saveFileDialog ( this , _ ( " Save XML Session file " ) , " " , " " , " XML files (*.xml)|*.xml " , wxFD_SAVE | wxFD_OVERWRITE_PROMPT ) ;
if ( saveFileDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
saveSession ( saveFileDialog . GetPath ( ) . ToStdString ( ) ) ;
return true ;
}
2018-01-06 04:22:14 -05:00
//save mecanic for bookmark files
2021-04-04 22:22:16 -04:00
else if ( event . GetId ( ) = = wxID_SAVE_BOOKMARKS ) {
2018-01-06 04:22:14 -05:00
if ( ! currentBookmarkFile . empty ( ) ) {
wxGetApp ( ) . getBookmarkMgr ( ) . saveToFile ( currentBookmarkFile , false , true ) ;
}
else {
wxFileDialog saveFileDialog ( this , _ ( " Save XML Bookmark file " ) , " " , " " , " XML files (*.xml)|*.xml " , wxFD_SAVE | wxFD_OVERWRITE_PROMPT ) ;
if ( saveFileDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
// Make sure the file name actually ends in .xml
std : : string fileName = saveFileDialog . GetPath ( ) . ToStdString ( ) ;
std : : string lcFileName = fileName ;
std : : transform ( lcFileName . begin ( ) , lcFileName . end ( ) , lcFileName . begin ( ) , : : tolower ) ;
if ( lcFileName . find_last_of ( " .xml " ) ! = lcFileName . length ( ) - 1 ) {
fileName . append ( " .xml " ) ;
}
wxGetApp ( ) . getBookmarkMgr ( ) . saveToFile ( fileName , false , true ) ;
currentBookmarkFile = fileName ;
}
return true ;
}
2021-04-04 22:22:16 -04:00
else if ( event . GetId ( ) = = wxID_OPEN_BOOKMARKS ) {
2018-01-06 04:22:14 -05:00
wxFileDialog openFileDialog ( this , _ ( " Open XML Bookmark file " ) , " " , " " , " XML files (*.xml)|*.xml " , wxFD_OPEN | wxFD_FILE_MUST_EXIST ) ;
if ( openFileDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
if ( wxGetApp ( ) . getBookmarkMgr ( ) . loadFromFile ( openFileDialog . GetPath ( ) . ToStdString ( ) , false , true ) ) {
wxGetApp ( ) . getBookmarkMgr ( ) . updateBookmarks ( ) ;
wxGetApp ( ) . getBookmarkMgr ( ) . updateActiveList ( ) ;
currentBookmarkFile = openFileDialog . GetPath ( ) . ToStdString ( ) ;
}
else {
//failure at loading.
currentBookmarkFile = " " ;
}
return true ;
}
2021-04-04 22:22:16 -04:00
else if ( event . GetId ( ) = = wxID_SAVEAS_BOOKMARKS ) {
2018-01-06 04:22:14 -05:00
wxFileDialog saveFileDialog ( this , _ ( " Save XML Bookmark file " ) , " " , " " , " XML files (*.xml)|*.xml " , wxFD_SAVE | wxFD_OVERWRITE_PROMPT ) ;
if ( saveFileDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
// Make sure the file name actually ends in .xml
std : : string fileName = saveFileDialog . GetPath ( ) . ToStdString ( ) ;
std : : string lcFileName = fileName ;
std : : transform ( lcFileName . begin ( ) , lcFileName . end ( ) , lcFileName . begin ( ) , : : tolower ) ;
if ( lcFileName . find_last_of ( " .xml " ) ! = lcFileName . length ( ) - 1 ) {
fileName . append ( " .xml " ) ;
}
wxGetApp ( ) . getBookmarkMgr ( ) . saveToFile ( fileName , false , true ) ;
currentBookmarkFile = fileName ;
return true ;
}
2021-04-04 22:22:16 -04:00
else if ( event . GetId ( ) = = wxID_RESET_BOOKMARKS ) {
2018-01-12 13:17:04 -05:00
2018-01-14 18:56:30 -05:00
ActionDialog : : showDialog ( new ActionDialogBookmarkReset ( ) ) ;
2018-01-12 13:17:04 -05:00
return true ;
}
2018-01-06 04:22:14 -05:00
2017-02-26 05:18:09 -05:00
return false ;
}
2018-01-13 05:50:08 -05:00
bool AppFrame : : actionOnMenuRecording ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_RECORDING_PATH ) {
std : : string recPath = wxGetApp ( ) . getConfig ( ) - > getRecordingPath ( ) ;
wxDirDialog recPathDialog ( this , _ ( " File Path for Recordings " ) , recPath , wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST ) ;
if ( recPathDialog . ShowModal ( ) = = wxID_CANCEL ) {
return true ;
}
wxGetApp ( ) . getConfig ( ) - > setRecordingPath ( recPathDialog . GetPath ( ) . ToStdString ( ) ) ;
updateRecordingMenu ( ) ;
return true ;
}
else if ( event . GetId ( ) = = wxID_RECORDING_SQUELCH_SILENCE ) {
wxGetApp ( ) . getConfig ( ) - > setRecordingSquelchOption ( AudioSinkFileThread : : SQUELCH_RECORD_SILENCE ) ;
updateRecordingMenu ( ) ;
return true ;
}
else if ( event . GetId ( ) = = wxID_RECORDING_SQUELCH_SKIP ) {
wxGetApp ( ) . getConfig ( ) - > setRecordingSquelchOption ( AudioSinkFileThread : : SQUELCH_SKIP_SILENCE ) ;
updateRecordingMenu ( ) ;
return true ;
}
else if ( event . GetId ( ) = = wxID_RECORDING_SQUELCH_ALWAYS ) {
wxGetApp ( ) . getConfig ( ) - > setRecordingSquelchOption ( AudioSinkFileThread : : SQUELCH_RECORD_ALWAYS ) ;
updateRecordingMenu ( ) ;
return true ;
}
else if ( event . GetId ( ) = = wxID_RECORDING_FILE_TIME_LIMIT ) {
int currentFileLimitSeconds = wxGetApp ( ) . getConfig ( ) - > getRecordingFileTimeLimit ( ) ;
long newFileLimit = wxGetNumberFromUser ( wxString ( " \n File time limit: \n " ) +
" \n Creates a new file automatically, each time the recording lasts longer than the limit, named according to the current time. \n \n " +
+ " min: 0 s (no limit) "
+ " , max: 36000 s (10 hours) \n " ,
" Time in seconds " ,
" File Time Limit " ,
//If a manual sample rate has already been input, recall this one.
currentFileLimitSeconds > 0 ? currentFileLimitSeconds : 0 ,
0 ,
36000 ,
this ) ;
if ( newFileLimit ! = - 1 ) {
wxGetApp ( ) . getConfig ( ) - > setRecordingFileTimeLimit ( ( int ) newFileLimit ) ;
updateRecordingMenu ( ) ;
}
return true ;
}
return false ;
}
2019-03-19 00:06:01 -04:00
bool AppFrame : : actionOnMenuRig ( wxCommandEvent & event ) {
2017-02-26 05:18:09 -05:00
bool bManaged = false ;
2016-01-03 19:00:26 -05:00
# ifdef USE_HAMLIB
2016-01-09 00:09:46 -05:00
2016-01-03 19:00:26 -05:00
bool resetRig = false ;
2017-02-26 05:18:09 -05:00
if ( event . GetId ( ) > = wxID_RIG_MODEL_BASE & & event . GetId ( ) < wxID_RIG_MODEL_BASE + numRigs ) {
2019-05-07 23:35:06 -04:00
2017-02-26 05:18:09 -05:00
int rigIdx = event . GetId ( ) - wxID_RIG_MODEL_BASE ;
2019-05-07 23:35:06 -04:00
2016-01-03 19:00:26 -05:00
RigList & rl = RigThread : : enumerate ( ) ;
rigModel = rl [ rigIdx ] - > rig_model ;
2019-05-07 23:35:06 -04:00
2016-01-09 00:09:46 -05:00
if ( devInfo ! = nullptr ) {
std : : string deviceId = devInfo - > getDeviceId ( ) ;
DeviceConfig * devConfig = wxGetApp ( ) . getConfig ( ) - > getDevice ( deviceId ) ;
2019-05-07 23:35:06 -04:00
2016-01-09 00:09:46 -05:00
rigSDRIF = devConfig - > getRigIF ( rigModel ) ;
if ( rigSDRIF ) {
wxGetApp ( ) . lockFrequency ( rigSDRIF ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-01-09 00:09:46 -05:00
wxGetApp ( ) . unlockFrequency ( ) ;
}
2019-03-19 00:06:01 -04:00
} else {
2016-01-09 00:09:46 -05:00
wxGetApp ( ) . unlockFrequency ( ) ;
}
2017-02-26 05:18:09 -05:00
2019-05-07 23:35:06 -04:00
resetRig = true ;
2017-02-26 05:18:09 -05:00
bManaged = true ;
2019-05-07 23:35:06 -04:00
for ( auto ri : rigModelMenuItems ) {
2019-05-13 20:52:36 -04:00
if ( ri . second - > IsChecked ( ) ) {
ri . second - > Check ( false ) ;
}
2019-05-07 23:35:06 -04:00
}
rigModelMenuItems [ rigModel ] - > Check ( true ) ;
2016-01-03 19:00:26 -05:00
}
2019-01-10 21:23:26 -05:00
int rigSerialIdMax = wxID_RIG_SERIAL_BASE + rigSerialRates . size ( ) ;
2019-03-19 00:06:01 -04:00
2019-01-10 21:23:26 -05:00
if ( event . GetId ( ) > = wxID_RIG_SERIAL_BASE & & event . GetId ( ) < rigSerialIdMax ) {
2017-02-26 05:18:09 -05:00
int serialIdx = event . GetId ( ) - wxID_RIG_SERIAL_BASE ;
2016-01-03 19:00:26 -05:00
rigSerialRate = rigSerialRates [ serialIdx ] ;
resetRig = true ;
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-01-03 19:00:26 -05:00
}
if ( event . GetId ( ) = = wxID_RIG_PORT ) {
2017-04-20 19:40:09 -04:00
if ( rigPortDialog = = nullptr ) {
rigPortDialog = new PortSelectorDialog ( this , wxID_ANY , rigPort ) ;
rigPortDialog - > ShowModal ( ) ;
2016-01-03 19:00:26 -05:00
}
}
if ( event . GetId ( ) = = wxID_RIG_TOGGLE ) {
resetRig = false ;
if ( ! wxGetApp ( ) . rigIsActive ( ) ) {
2016-02-16 01:13:26 -05:00
enableRig ( ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-02-16 01:13:26 -05:00
disableRig ( ) ;
2016-01-09 00:09:46 -05:00
}
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-01-09 00:09:46 -05:00
}
2017-02-26 05:18:09 -05:00
2016-01-09 00:09:46 -05:00
if ( event . GetId ( ) = = wxID_RIG_SDR_IF ) {
if ( devInfo ! = nullptr ) {
std : : string deviceId = devInfo - > getDeviceId ( ) ;
DeviceConfig * devConfig = wxGetApp ( ) . getConfig ( ) - > getDevice ( deviceId ) ;
2019-03-19 00:06:01 -04:00
long long freqRigIF = wxGetNumberFromUser ( " Rig SDR-IF Frequency " , " Frequency (Hz) " , " Frequency " ,
devConfig - > getRigIF ( rigModel ) , 0 , 2000000000 ) ;
2016-01-09 00:09:46 -05:00
if ( freqRigIF ! = - 1 ) {
rigSDRIF = freqRigIF ;
devConfig - > setRigIF ( rigModel , rigSDRIF ) ;
}
if ( rigSDRIF & & wxGetApp ( ) . rigIsActive ( ) ) {
wxGetApp ( ) . lockFrequency ( rigSDRIF ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-01-09 00:09:46 -05:00
wxGetApp ( ) . unlockFrequency ( ) ;
}
2016-01-03 19:00:26 -05:00
}
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-01-03 19:00:26 -05:00
}
2017-02-26 05:18:09 -05:00
2016-02-16 01:13:26 -05:00
if ( event . GetId ( ) = = wxID_RIG_CONTROL ) {
if ( wxGetApp ( ) . rigIsActive ( ) ) {
RigThread * rt = wxGetApp ( ) . getRigThread ( ) ;
rt - > setControlMode ( ! rt - > getControlMode ( ) ) ;
rigControlMenuItem - > Check ( rt - > getControlMode ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setRigControlMode ( rt - > getControlMode ( ) ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-02-16 01:13:26 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigControlMode ( rigControlMenuItem - > IsChecked ( ) ) ;
}
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-02-16 01:13:26 -05:00
}
if ( event . GetId ( ) = = wxID_RIG_FOLLOW ) {
if ( wxGetApp ( ) . rigIsActive ( ) ) {
RigThread * rt = wxGetApp ( ) . getRigThread ( ) ;
rt - > setFollowMode ( ! rt - > getFollowMode ( ) ) ;
rigFollowMenuItem - > Check ( rt - > getFollowMode ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setRigFollowMode ( rt - > getFollowMode ( ) ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-02-16 01:13:26 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigFollowMode ( rigFollowMenuItem - > IsChecked ( ) ) ;
}
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-02-16 01:13:26 -05:00
}
2017-02-26 05:18:09 -05:00
2016-02-29 23:14:23 -05:00
if ( event . GetId ( ) = = wxID_RIG_CENTERLOCK ) {
if ( wxGetApp ( ) . rigIsActive ( ) ) {
RigThread * rt = wxGetApp ( ) . getRigThread ( ) ;
rt - > setCenterLock ( ! rt - > getCenterLock ( ) ) ;
rigCenterLockMenuItem - > Check ( rt - > getCenterLock ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setRigCenterLock ( rt - > getCenterLock ( ) ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-02-29 23:14:23 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigCenterLock ( rigCenterLockMenuItem - > IsChecked ( ) ) ;
}
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-02-29 23:14:23 -05:00
}
if ( event . GetId ( ) = = wxID_RIG_FOLLOW_MODEM ) {
if ( wxGetApp ( ) . rigIsActive ( ) ) {
RigThread * rt = wxGetApp ( ) . getRigThread ( ) ;
rt - > setFollowModem ( ! rt - > getFollowModem ( ) ) ;
rigFollowModemMenuItem - > Check ( rt - > getFollowModem ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setRigFollowModem ( rt - > getFollowModem ( ) ) ;
2019-03-19 00:06:01 -04:00
} else {
2016-02-29 23:14:23 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigFollowModem ( rigFollowModemMenuItem - > IsChecked ( ) ) ;
}
2017-02-26 05:18:09 -05:00
bManaged = true ;
2016-02-29 23:14:23 -05:00
}
2016-01-03 19:00:26 -05:00
if ( wxGetApp ( ) . rigIsActive ( ) & & resetRig ) {
wxGetApp ( ) . stopRig ( ) ;
wxGetApp ( ) . initRig ( rigModel , rigPort , rigSerialRate ) ;
}
# endif
2015-03-12 19:41:50 -04:00
2017-02-26 05:18:09 -05:00
return bManaged ;
}
2019-03-19 00:06:01 -04:00
bool AppFrame : : actionOnMenuClose ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_CLOSE | | event . GetId ( ) = = wxID_EXIT ) {
Close ( false ) ;
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuSetPPM ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SET_PPM ) {
long ofs = wxGetNumberFromUser (
" Frequency correction for device in PPM. \n i.e. -51 for -51 PPM \n \n Note: you can adjust PPM interactively \n by holding ALT over the frequency tuning bar. \n " ,
" Parts per million (PPM) " ,
" Frequency Correction " , wxGetApp ( ) . getPPM ( ) , - 1000 , 1000 , this ) ;
wxGetApp ( ) . setPPM ( ofs ) ;
2017-02-26 05:18:09 -05:00
2019-03-19 00:06:01 -04:00
settingsMenuItems [ wxID_SET_PPM ] - > SetItemLabel (
getSettingsLabel ( " Device PPM " , to_string ( wxGetApp ( ) . getPPM ( ) ) , " ppm " ) ) ;
2017-02-26 05:18:09 -05:00
2019-03-19 00:06:01 -04:00
return true ;
2017-02-26 05:18:09 -05:00
}
2019-03-19 00:06:01 -04:00
return false ;
}
bool AppFrame : : actionOnMenuSDRDevices ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SDR_DEVICES ) {
wxGetApp ( ) . deviceSelector ( ) ;
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuDBOffset ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SET_DB_OFFSET ) {
long ofs = wxGetNumberFromUser ( " Shift the displayed RF power level by this amount. \n i.e. -30 for -30 dB " ,
" Decibels (dB) " ,
" Power Level Offset " , wxGetApp ( ) . getConfig ( ) - > getDBOffset ( ) , - 1000 , 1000 , this ) ;
if ( ofs ! = - 1 ) {
wxGetApp ( ) . getConfig ( ) - > setDBOffset ( ofs ) ;
settingsMenuItems [ wxID_SET_DB_OFFSET ] - > SetItemLabel (
getSettingsLabel ( " Power Level Offset " , to_string ( wxGetApp ( ) . getConfig ( ) - > getDBOffset ( ) ) , " dB " ) ) ;
2017-02-26 05:18:09 -05:00
}
2019-03-19 00:06:01 -04:00
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuFreqOffset ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SET_FREQ_OFFSET ) {
2021-12-29 13:54:03 -05:00
//enter in KHz to accommodate > 2GHz shifts for down/upconverters on 32 bit platforms.
2019-03-19 00:06:01 -04:00
long ofs = wxGetNumberFromUser (
" Shift the displayed frequency by this amount of KHz. \n i.e. -125000 for -125 MHz " , " Frequency (KHz) " ,
" Frequency Offset " , ( long long ) ( wxGetApp ( ) . getOffset ( ) / 1000.0 ) , - 2000000000 , 2000000000 , this ) ;
if ( ofs ! = - 1 ) {
wxGetApp ( ) . setOffset ( ( long long ) ofs * 1000 ) ;
settingsMenuItems [ wxID_SET_FREQ_OFFSET ] - > SetItemLabel (
getSettingsLabel ( " Frequency Offset " , to_string ( wxGetApp ( ) . getOffset ( ) / 1000 ) , " KHz " ) ) ;
}
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuIQSwap ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SET_IQSWAP ) {
wxGetApp ( ) . getSDRThread ( ) - > setIQSwap ( ! wxGetApp ( ) . getSDRThread ( ) - > getIQSwap ( ) ) ;
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuTips ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SET_TIPS ) {
wxGetApp ( ) . getConfig ( ) - > setShowTips ( ! wxGetApp ( ) . getConfig ( ) - > getShowTips ( ) ) ;
return true ;
}
return false ;
}
bool AppFrame : : actionOnMenuPerformance ( wxCommandEvent & event ) {
if ( event . GetId ( ) > = wxID_PERF_BASE & & event . GetId ( ) < = wxID_PERF_BASE + ( int ) AppConfig : : PERF_HIGH ) {
2018-05-17 11:12:29 -04:00
int perfEnumAsInt = event . GetId ( ) - wxID_PERF_BASE ;
AppConfig : : PerfModeEnum perfEnumSet = AppConfig : : PERF_NORMAL ;
2019-03-19 00:06:01 -04:00
if ( perfEnumAsInt = = ( int ) AppConfig : : PERF_HIGH ) {
2018-05-17 11:12:29 -04:00
perfEnumSet = AppConfig : : PERF_HIGH ;
2019-03-19 00:06:01 -04:00
} else if ( perfEnumAsInt = = ( int ) AppConfig : : PERF_LOW ) {
2018-05-17 11:12:29 -04:00
perfEnumSet = AppConfig : : PERF_LOW ;
}
wxGetApp ( ) . getConfig ( ) - > setPerfMode ( perfEnumSet ) ;
//update Channelizer mode:
if ( perfEnumSet = = AppConfig : : PERF_HIGH ) {
2019-03-19 00:06:01 -04:00
wxGetApp ( ) . setChannelizerType ( SDRPostPFBCH2 ) ;
2018-05-17 11:12:29 -04:00
} else {
2019-03-19 00:06:01 -04:00
wxGetApp ( ) . setChannelizerType ( SDRPostPFBCH ) ;
2018-05-17 11:12:29 -04:00
}
2017-02-26 05:18:09 -05:00
2018-05-17 11:12:29 -04:00
//update UI
2019-03-19 00:06:01 -04:00
wxMenuItem * selectedPerfModeItem = performanceMenuItems [ event . GetId ( ) ] ;
performanceMenuItems [ wxID_PERF_CURRENT ] - > SetItemLabel (
getSettingsLabel ( " CPU usage " , selectedPerfModeItem - > GetItemLabel ( ) . ToStdString ( ) ) ) ;
2017-08-23 17:27:49 -04:00
2019-03-19 00:06:01 -04:00
return true ;
2017-02-26 05:18:09 -05:00
}
2019-03-19 00:06:01 -04:00
return false ;
}
bool AppFrame : : actionOnMenuSDRStartStop ( wxCommandEvent & event ) {
if ( event . GetId ( ) = = wxID_SDR_START_STOP ) {
if ( ! wxGetApp ( ) . getSDRThread ( ) - > isTerminated ( ) ) {
wxGetApp ( ) . stopDevice ( true , 2000 ) ;
} else {
SDRDeviceInfo * dev = wxGetApp ( ) . getDevice ( ) ;
if ( dev ! = nullptr ) {
wxGetApp ( ) . setDevice ( dev , 0 ) ;
}
}
return true ;
2017-02-26 05:18:09 -05:00
}
2019-03-19 00:06:01 -04:00
return false ;
2014-10-27 21:22:29 -04:00
}
2015-07-15 00:32:36 -04:00
void AppFrame : : OnClose ( wxCloseEvent & event ) {
2015-11-12 18:38:38 -05:00
wxGetApp ( ) . closeDeviceSelector ( ) ;
2017-02-07 21:48:22 -05:00
if ( aboutDlg ) {
aboutDlg - > Destroy ( ) ;
}
2015-11-12 18:38:38 -05:00
2016-10-20 21:44:33 -04:00
if ( wxGetApp ( ) . getDemodSpectrumProcessor ( ) ) {
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > removeOutput ( demodSpectrumCanvas - > getVisualDataQueue ( ) ) ;
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > removeOutput ( demodWaterfallCanvas - > getVisualDataQueue ( ) ) ;
}
2015-08-16 18:12:12 -04:00
wxGetApp ( ) . getSpectrumProcessor ( ) - > removeOutput ( spectrumCanvas - > getVisualDataQueue ( ) ) ;
2016-12-27 13:01:19 -05:00
if ( saveDisabled ) {
event . Skip ( ) ;
return ;
}
2017-01-18 20:13:25 -05:00
# ifdef __APPLE__
2017-01-18 21:24:50 -05:00
if ( this - > GetPosition ( ) . y > 0 ) {
2017-01-18 20:13:25 -05:00
wxGetApp ( ) . getConfig ( ) - > setWindow ( this - > GetPosition ( ) , this - > GetClientSize ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setWindowMaximized ( this - > IsMaximized ( ) ) ;
}
# else
2015-07-15 00:32:36 -04:00
wxGetApp ( ) . getConfig ( ) - > setWindow ( this - > GetPosition ( ) , this - > GetClientSize ( ) ) ;
2015-07-16 18:57:03 -04:00
wxGetApp ( ) . getConfig ( ) - > setWindowMaximized ( this - > IsMaximized ( ) ) ;
2017-01-18 20:13:25 -05:00
# endif
2015-07-15 00:32:36 -04:00
wxGetApp ( ) . getConfig ( ) - > setTheme ( ThemeMgr : : mgr . getTheme ( ) ) ;
2016-06-20 13:28:26 -04:00
wxGetApp ( ) . getConfig ( ) - > setFontScale ( GLFont : : getScale ( ) ) ;
2015-07-18 21:49:53 -04:00
wxGetApp ( ) . getConfig ( ) - > setSnap ( wxGetApp ( ) . getFrequencySnap ( ) ) ;
2015-07-21 00:04:04 -04:00
wxGetApp ( ) . getConfig ( ) - > setCenterFreq ( wxGetApp ( ) . getFrequency ( ) ) ;
2015-08-16 18:12:12 -04:00
wxGetApp ( ) . getConfig ( ) - > setSpectrumAvgSpeed ( wxGetApp ( ) . getSpectrumProcessor ( ) - > getFFTAverageRate ( ) ) ;
2015-08-14 19:17:43 -04:00
wxGetApp ( ) . getConfig ( ) - > setWaterfallLinesPerSec ( waterfallDataThread - > getLinesPerSecond ( ) ) ;
2016-01-22 00:40:00 -05:00
wxGetApp ( ) . getConfig ( ) - > setManualDevices ( SDREnumerator : : getManuals ( ) ) ;
2016-07-28 22:50:02 -04:00
wxGetApp ( ) . getConfig ( ) - > setModemPropsCollapsed ( modemProps - > isCollapsed ( ) ) ;
2016-12-18 12:00:53 -05:00
wxGetApp ( ) . getConfig ( ) - > setMainSplit ( mainSplitter - > GetSashPosition ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setVisSplit ( mainVisSplitter - > GetSashPosition ( ) ) ;
2016-12-27 15:36:33 -05:00
if ( ! hideBookmarksItem - > IsChecked ( ) ) wxGetApp ( ) . getConfig ( ) - > setBookmarkSplit ( bookmarkSplitter - > GetSashPosition ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setBookmarksVisible ( ! hideBookmarksItem - > IsChecked ( ) ) ;
2016-01-03 19:00:26 -05:00
# ifdef USE_HAMLIB
2016-02-16 01:13:26 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigEnabled ( rigEnableMenuItem - > IsChecked ( ) ) ;
2016-01-03 19:00:26 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigModel ( rigModel ) ;
wxGetApp ( ) . getConfig ( ) - > setRigRate ( rigSerialRate ) ;
wxGetApp ( ) . getConfig ( ) - > setRigPort ( rigPort ) ;
2016-02-16 01:13:26 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigFollowMode ( rigFollowMenuItem - > IsChecked ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setRigControlMode ( rigControlMenuItem - > IsChecked ( ) ) ;
2016-02-29 23:14:23 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigCenterLock ( rigCenterLockMenuItem - > IsChecked ( ) ) ;
wxGetApp ( ) . getConfig ( ) - > setRigFollowModem ( rigFollowModemMenuItem - > IsChecked ( ) ) ;
2016-01-03 19:00:26 -05:00
# endif
2015-07-15 00:32:36 -04:00
wxGetApp ( ) . getConfig ( ) - > save ( ) ;
2016-12-12 23:47:05 -05:00
wxGetApp ( ) . getBookmarkMgr ( ) . saveToFile ( " bookmarks.xml " ) ;
2015-07-15 00:32:36 -04:00
event . Skip ( ) ;
2014-12-31 22:38:59 -05:00
}
2014-10-27 21:22:29 -04:00
void AppFrame : : OnNewWindow ( wxCommandEvent & WXUNUSED ( event ) ) {
new AppFrame ( ) ;
}
2014-10-28 21:39:59 -04:00
2019-03-19 00:06:01 -04:00
void AppFrame : : OnIdle ( wxIdleEvent & event ) {
2014-12-28 05:13:46 -05:00
2019-03-16 18:37:52 -04:00
handleUpdateDeviceParams ( ) ;
2017-08-25 01:27:30 -04:00
2019-02-11 22:59:43 -05:00
handleTXAntennaChange ( ) ;
DemodulatorInstancePtr demod = wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ;
if ( demod & & demod - > isModemInitialized ( ) ) {
handleCurrentModem ( ) ;
} else if ( demod ) {
// Wait state for current demodulator modem to activate..
} else {
handleModeSelector ( ) ;
handleGainMeter ( ) ;
handleDemodWaterfallSpectrum ( ) ;
handleSpectrumWaterfall ( ) ;
handleMuteButton ( ) ;
}
handleScopeProcessor ( ) ;
handleScopeSpectrumProcessors ( ) ;
handleModemProperties ( ) ;
handlePeakHold ( ) ;
# if USE_HAMLIB
handleRigMenu ( ) ;
# endif
2019-03-19 00:06:01 -04:00
2019-02-11 22:59:43 -05:00
# ifdef _WIN32
if ( scopeCanvas & & scopeCanvas - > HasFocus ( ) ) {
waterfallCanvas - > SetFocus ( ) ;
}
# endif
2019-03-19 00:06:01 -04:00
2019-02-11 22:59:43 -05:00
if ( ! this - > IsActive ( ) ) {
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 30 ) ) ;
} else {
if ( wxGetApp ( ) . getConfig ( ) - > getPerfMode ( ) = = AppConfig : : PERF_LOW ) {
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 30 ) ) ;
} else {
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 1 ) ) ;
}
}
2019-03-19 00:06:01 -04:00
2019-02-11 22:59:43 -05:00
event . RequestMore ( ) ;
}
void AppFrame : : handleTXAntennaChange ( ) { //Refresh the current TX antenna on, if any:
2017-08-25 12:52:33 -04:00
if ( ( antennaMenuItems . find ( wxID_ANTENNA_CURRENT_TX ) ! = antennaMenuItems . end ( ) ) & & devInfo ) {
2019-02-11 22:59:43 -05:00
string actualTxAntenna = devInfo - > getAntennaName ( SOAPY_SDR_TX , 0 ) ;
2017-08-25 01:27:30 -04:00
if ( currentTXantennaName ! = actualTxAntenna ) {
currentTXantennaName = actualTxAntenna ;
2019-03-19 00:06:01 -04:00
antennaMenuItems [ wxID_ANTENNA_CURRENT_TX ] - > SetItemLabel (
getSettingsLabel ( " TX Antenna " , currentTXantennaName ) ) ;
2017-08-25 01:27:30 -04:00
}
}
2019-02-11 22:59:43 -05:00
}
2014-12-28 05:13:46 -05:00
2019-02-11 22:59:43 -05:00
# if USE_HAMLIB
void AppFrame : : handleRigMenu ( ) {
if ( rigEnableMenuItem - > IsChecked ( ) ) {
if ( ! wxGetApp ( ) . rigIsActive ( ) ) {
rigEnableMenuItem - > Check ( false ) ;
2020-07-12 23:58:24 -04:00
wxGetApp ( ) . stopRig ( ) ;
2019-02-11 22:59:43 -05:00
wxGetApp ( ) . getConfig ( ) - > setRigEnabled ( false ) ;
}
}
}
# endif
void AppFrame : : handlePeakHold ( ) {
int peakHoldMode = peakHoldButton - > getSelection ( ) ;
if ( peakHoldButton - > modeChanged ( ) ) {
wxGetApp ( ) . getSpectrumProcessor ( ) - > setPeakHold ( peakHoldMode = = 1 ) ;
//make the peak hold act on the current dmod also, like a zoomed-in version.
if ( wxGetApp ( ) . getDemodSpectrumProcessor ( ) ) {
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > setPeakHold ( peakHoldMode = = 1 ) ;
}
peakHoldButton - > clearModeChanged ( ) ;
}
}
void AppFrame : : handleModemProperties ( ) {
DemodulatorInstancePtr demod = wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ;
if ( modemPropertiesUpdated . load ( ) & & demod & & demod - > isModemInitialized ( ) ) {
//reset notification flag
modemPropertiesUpdated . store ( false ) ;
modemProps - > initProperties ( demod - > getModemArgs ( ) , demod ) ;
modemProps - > updateTheme ( ) ;
demodTray - > Layout ( ) ;
modemProps - > fitColumns ( ) ;
# if ENABLE_DIGITAL_LAB
if ( demod - > getModemType ( ) = = " digital " ) {
2021-04-04 22:22:16 -04:00
auto * outp = ( ModemDigitalOutputConsole * ) demod - > getOutput ( ) ;
2019-02-11 22:59:43 -05:00
if ( ! outp - > getDialog ( ) ) {
outp - > setTitle ( demod - > getDemodulatorType ( ) + " : " + frequencyToStr ( demod - > getFrequency ( ) ) ) ;
2019-03-19 00:06:01 -04:00
outp - > setDialog ( new DigitalConsole ( this , outp ) ) ;
2019-02-11 22:59:43 -05:00
}
demod - > showOutput ( ) ;
}
# endif
} else if ( ! demod & & modemPropertiesUpdated . load ( ) ) {
ModemArgInfoList dummyInfo ;
modemProps - > initProperties ( dummyInfo , nullptr ) ;
modemProps - > updateTheme ( ) ;
demodTray - > Layout ( ) ;
}
if ( modemProps - > IsShown ( ) & & modemProps - > isCollapsed ( ) & & modemProps - > GetMinWidth ( ) > 22 ) {
modemProps - > SetMinSize ( wxSize ( APPFRAME_MODEMPROPS_MINSIZE , - 1 ) ) ;
modemProps - > SetMaxSize ( wxSize ( APPFRAME_MODEMPROPS_MINSIZE , - 1 ) ) ;
demodTray - > Layout ( ) ;
modemProps - > fitColumns ( ) ;
} else if ( modemProps - > IsShown ( ) & & ! modemProps - > isCollapsed ( ) & & modemProps - > GetMinWidth ( ) < 200 ) {
modemProps - > SetMinSize ( wxSize ( APPFRAME_MODEMPROPS_MAXSIZE , - 1 ) ) ;
modemProps - > SetMaxSize ( wxSize ( APPFRAME_MODEMPROPS_MAXSIZE , - 1 ) ) ;
demodTray - > Layout ( ) ;
modemProps - > fitColumns ( ) ;
}
}
void AppFrame : : handleScopeSpectrumProcessors ( ) {
SpectrumVisualProcessor * proc = wxGetApp ( ) . getSpectrumProcessor ( ) ;
if ( spectrumAvgMeter - > inputChanged ( ) ) {
float val = spectrumAvgMeter - > getInputValue ( ) ;
if ( val < 0.01 ) {
val = 0.01f ;
}
if ( val > 0.99 ) {
val = 0.99f ;
}
spectrumAvgMeter - > setLevel ( val ) ;
proc - > setFFTAverageRate ( val ) ;
2019-03-19 00:06:01 -04:00
GetStatusBar ( ) - > SetStatusText (
wxString : : Format ( wxT ( " Spectrum averaging speed changed to %0.2f%%. " ) , val * 100.0 ) ) ;
2019-02-11 22:59:43 -05:00
}
SpectrumVisualProcessor * dproc = wxGetApp ( ) . getDemodSpectrumProcessor ( ) ;
if ( dproc ) {
dproc - > setView ( demodWaterfallCanvas - > getViewState ( ) , demodWaterfallCanvas - > getCenterFrequency ( ) ,
demodWaterfallCanvas - > getBandwidth ( ) ) ;
}
SpectrumVisualProcessor * wproc = waterfallDataThread - > getProcessor ( ) ;
if ( waterfallSpeedMeter - > inputChanged ( ) ) {
float val = waterfallSpeedMeter - > getInputValue ( ) ;
waterfallSpeedMeter - > setLevel ( val ) ;
2019-03-19 00:06:01 -04:00
waterfallDataThread - > setLinesPerSecond ( ( int ) ceil ( val * val ) ) ;
waterfallCanvas - > setLinesPerSecond ( ( int ) ceil ( val * val ) ) ;
2019-02-11 22:59:43 -05:00
GetStatusBar ( ) - > SetStatusText (
2019-03-19 00:06:01 -04:00
wxString : : Format ( wxT ( " Waterfall max speed changed to %d lines per second. " ) , ( int ) ceil ( val * val ) ) ) ;
2019-02-11 22:59:43 -05:00
}
2019-03-19 00:06:01 -04:00
wproc - > setView ( waterfallCanvas - > getViewState ( ) , waterfallCanvas - > getCenterFrequency ( ) ,
waterfallCanvas - > getBandwidth ( ) ) ;
2019-02-11 22:59:43 -05:00
proc - > setView ( wproc - > isView ( ) , wproc - > getCenterFrequency ( ) , wproc - > getBandwidth ( ) ) ;
}
void AppFrame : : handleScopeProcessor ( ) {
if ( scopeCanvas ) {
scopeCanvas - > setPPMMode ( demodTuner - > isAltDown ( ) ) ;
wxGetApp ( ) . getScopeProcessor ( ) - > setScopeEnabled ( scopeCanvas - > scopeVisible ( ) ) ;
wxGetApp ( ) . getScopeProcessor ( ) - > setSpectrumEnabled ( scopeCanvas - > spectrumVisible ( ) ) ;
2019-03-19 00:06:01 -04:00
wxGetApp ( ) . getAudioVisualQueue ( ) - > set_max_num_items (
( scopeCanvas - > scopeVisible ( ) ? 1 : 0 ) + ( scopeCanvas - > spectrumVisible ( ) ? 1 : 0 ) ) ;
2019-02-11 22:59:43 -05:00
wxGetApp ( ) . getScopeProcessor ( ) - > run ( ) ;
}
}
void AppFrame : : handleMuteButton ( ) {
if ( demodMuteButton - > modeChanged ( ) ) {
2019-03-19 00:06:01 -04:00
int muteMode = demodMuteButton - > getSelection ( ) ;
if ( muteMode = = - 1 ) {
wxGetApp ( ) . getDemodMgr ( ) . setLastMuted ( false ) ;
} else if ( muteMode = = 1 ) {
wxGetApp ( ) . getDemodMgr ( ) . setLastMuted ( true ) ;
2019-02-11 22:59:43 -05:00
}
2019-03-19 00:06:01 -04:00
demodMuteButton - > clearModeChanged ( ) ;
}
2019-02-11 22:59:43 -05:00
}
void AppFrame : : handleSpectrumWaterfall ( ) {
2019-03-19 00:06:01 -04:00
if ( spectrumCanvas - > getViewState ( ) & &
abs ( wxGetApp ( ) . getFrequency ( ) - spectrumCanvas - > getCenterFrequency ( ) ) > ( wxGetApp ( ) . getSampleRate ( ) / 2 ) ) {
spectrumCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
waterfallCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
}
2019-02-11 22:59:43 -05:00
}
void AppFrame : : handleDemodWaterfallSpectrum ( ) {
if ( demodWaterfallCanvas & & wxGetApp ( ) . getFrequency ( ) ! = demodWaterfallCanvas - > getCenterFrequency ( ) ) {
2019-03-19 00:06:01 -04:00
demodWaterfallCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
if ( demodSpectrumCanvas ) {
demodSpectrumCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
2019-02-11 22:59:43 -05:00
}
2019-03-19 00:06:01 -04:00
}
2019-02-11 22:59:43 -05:00
}
void AppFrame : : handleGainMeter ( ) {
DemodulatorMgr * mgr = & wxGetApp ( ) . getDemodMgr ( ) ;
demodGainMeter - > setLevel ( mgr - > getLastGain ( ) ) ;
if ( demodSignalMeter - > inputChanged ( ) ) {
2019-03-19 00:06:01 -04:00
mgr - > setLastSquelchLevel ( demodSignalMeter - > getInputValue ( ) ) ;
}
2019-02-11 22:59:43 -05:00
if ( demodGainMeter - > inputChanged ( ) ) {
2019-03-19 00:06:01 -04:00
mgr - > setLastGain ( demodGainMeter - > getInputValue ( ) ) ;
demodGainMeter - > setLevel ( demodGainMeter - > getInputValue ( ) ) ;
}
2019-02-11 22:59:43 -05:00
}
void AppFrame : : handleModeSelector ( ) {
DemodulatorMgr * mgr = & wxGetApp ( ) . getDemodMgr ( ) ;
string dSelection = demodModeSelector - > getSelectionLabel ( ) ;
# ifdef ENABLE_DIGITAL_LAB
string dSelectionadv = demodModeSelectorAdv - > getSelectionLabel ( ) ;
// basic demodulators
2021-04-04 22:22:16 -04:00
if ( ! dSelection . empty ( ) & & dSelection ! = mgr - > getLastDemodulatorType ( ) ) {
2019-03-19 00:06:01 -04:00
mgr - > setLastDemodulatorType ( dSelection ) ;
mgr - > setLastBandwidth ( Modem : : getModemDefaultSampleRate ( dSelection ) ) ;
demodTuner - > setHalfBand ( dSelection = = " USB " | | dSelection = = " LSB " ) ;
demodModeSelectorAdv - > setSelection ( - 1 ) ;
}
2019-02-11 22:59:43 -05:00
// advanced demodulators
2021-04-04 22:22:16 -04:00
else if ( ! dSelectionadv . empty ( ) & & dSelectionadv ! = mgr - > getLastDemodulatorType ( ) ) {
2019-03-19 00:06:01 -04:00
mgr - > setLastDemodulatorType ( dSelectionadv ) ;
mgr - > setLastBandwidth ( Modem : : getModemDefaultSampleRate ( dSelectionadv ) ) ;
demodTuner - > setHalfBand ( false ) ;
demodModeSelector - > setSelection ( - 1 ) ;
}
2019-02-11 22:59:43 -05:00
# else
// basic demodulators
if ( dSelection ! = " " & & dSelection ! = mgr - > getLastDemodulatorType ( ) ) {
mgr - > setLastDemodulatorType ( dSelection ) ;
mgr - > setLastBandwidth ( Modem : : getModemDefaultSampleRate ( dSelection ) ) ;
demodTuner - > setHalfBand ( dSelection = = " USB " | | dSelection = = " LSB " ) ;
}
# endif
}
void AppFrame : : handleCurrentModem ( ) {
DemodulatorInstancePtr demod = wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ;
if ( demod - > isTracking ( ) ) {
2019-03-19 00:06:01 -04:00
if ( spectrumCanvas - > getViewState ( ) ) {
long long diff =
abs ( demod - > getFrequency ( ) - spectrumCanvas - > getCenterFrequency ( ) ) + ( demod - > getBandwidth ( ) / 2 ) +
( demod - > getBandwidth ( ) / 4 ) ;
if ( diff > spectrumCanvas - > getBandwidth ( ) / 2 ) {
if ( demod - > getBandwidth ( ) > ( int ) spectrumCanvas - > getBandwidth ( ) ) {
diff = abs ( demod - > getFrequency ( ) - spectrumCanvas - > getCenterFrequency ( ) ) ;
} else {
diff = diff - spectrumCanvas - > getBandwidth ( ) / 2 ;
2015-04-23 19:38:44 -04:00
}
2019-03-19 00:06:01 -04:00
spectrumCanvas - > moveCenterFrequency (
( demod - > getFrequency ( ) < spectrumCanvas - > getCenterFrequency ( ) ) ? diff : - diff ) ;
2015-04-23 19:38:44 -04:00
demod - > setTracking ( false ) ;
}
2019-03-19 00:06:01 -04:00
} else {
demod - > setTracking ( false ) ;
2015-04-23 19:38:44 -04:00
}
2019-03-19 00:06:01 -04:00
}
2019-02-11 22:59:43 -05:00
if ( demod - > getBandwidth ( ) ! = wxGetApp ( ) . getDemodMgr ( ) . getLastBandwidth ( ) ) {
2019-03-19 00:06:01 -04:00
wxGetApp ( ) . getDemodMgr ( ) . setLastBandwidth ( demod - > getBandwidth ( ) ) ;
}
2015-04-23 19:38:44 -04:00
2019-02-11 22:59:43 -05:00
if ( demod . get ( ) ! = activeDemodulator ) {
2019-03-19 00:06:01 -04:00
demodSignalMeter - > setInputValue ( demod - > getSquelchLevel ( ) ) ;
demodGainMeter - > setInputValue ( demod - > getGain ( ) ) ;
wxGetApp ( ) . getDemodMgr ( ) . setLastGain ( demod - > getGain ( ) ) ;
int outputDevice = demod - > getOutputDevice ( ) ;
if ( scopeCanvas ) {
auto outputDevices = wxGetApp ( ) . getDemodMgr ( ) . getOutputDevices ( ) ;
scopeCanvas - > setDeviceName ( outputDevices [ outputDevice ] . name ) ;
}
2016-07-28 22:50:02 -04:00
// outputDeviceMenuItems[outputDevice]->Check(true);
2019-03-19 00:06:01 -04:00
string dType = demod - > getDemodulatorType ( ) ;
demodModeSelector - > setSelection ( dType ) ;
2015-11-15 13:52:54 -05:00
# ifdef ENABLE_DIGITAL_LAB
2019-03-19 00:06:01 -04:00
demodModeSelectorAdv - > setSelection ( dType ) ;
2015-11-15 13:52:54 -05:00
# endif
2019-03-19 00:06:01 -04:00
deltaLockButton - > setSelection ( demod - > isDeltaLock ( ) ? 1 : - 1 ) ;
demodMuteButton - > setSelection ( demod - > isMuted ( ) ? 1 : - 1 ) ;
modemPropertiesUpdated . store ( true ) ;
demodTuner - > setHalfBand ( dType = = " USB " | | dType = = " LSB " ) ;
}
2019-02-11 22:59:43 -05:00
if ( ! demodWaterfallCanvas | | demodWaterfallCanvas - > getDragState ( ) = = WaterfallCanvas : : WF_DRAG_NONE ) {
2019-03-19 00:06:01 -04:00
long long centerFreq = demod - > getFrequency ( ) ;
unsigned int demodBw = ( unsigned int ) ceil ( ( float ) demod - > getBandwidth ( ) * 2.25 ) ;
2015-02-16 02:15:04 -05:00
2019-03-19 00:06:01 -04:00
if ( demod - > getDemodulatorType ( ) = = " USB " ) {
demodBw / = 2 ;
centerFreq + = demod - > getBandwidth ( ) / 4 ;
}
2015-02-16 02:15:04 -05:00
2019-03-19 00:06:01 -04:00
if ( demod - > getDemodulatorType ( ) = = " LSB " ) {
demodBw / = 2 ;
centerFreq - = demod - > getBandwidth ( ) / 4 ;
}
2015-01-06 00:29:33 -05:00
2019-03-19 00:06:01 -04:00
if ( demodBw > wxGetApp ( ) . getSampleRate ( ) / 2 ) {
demodBw = wxGetApp ( ) . getSampleRate ( ) / 2 ;
}
if ( demodBw < 20000 ) {
demodBw = 20000 ;
}
2015-02-16 02:15:04 -05:00
2019-03-19 00:06:01 -04:00
if ( demodWaterfallCanvas & & centerFreq ! = demodWaterfallCanvas - > getCenterFrequency ( ) ) {
demodWaterfallCanvas - > setCenterFrequency ( centerFreq ) ;
demodSpectrumCanvas - > setCenterFrequency ( centerFreq ) ;
}
2019-02-11 22:59:43 -05:00
2019-03-19 00:06:01 -04:00
string dSelection = demodModeSelector - > getSelectionLabel ( ) ;
2015-11-15 13:52:54 -05:00
# ifdef ENABLE_DIGITAL_LAB
2019-03-19 00:06:01 -04:00
string dSelectionadv = demodModeSelectorAdv - > getSelectionLabel ( ) ;
2015-06-10 13:39:08 -04:00
2019-03-19 00:06:01 -04:00
// basic demodulators
2021-04-04 22:22:16 -04:00
if ( ! dSelection . empty ( ) & & dSelection ! = demod - > getDemodulatorType ( ) ) {
2019-03-19 00:06:01 -04:00
demod - > setDemodulatorType ( dSelection ) ;
demodTuner - > setHalfBand ( dSelection = = " USB " | | dSelection = = " LSB " ) ;
demodModeSelectorAdv - > setSelection ( - 1 ) ;
}
2015-06-10 04:50:14 -04:00
// advanced demodulators
2021-04-04 22:22:16 -04:00
else if ( ! dSelectionadv . empty ( ) & & dSelectionadv ! = demod - > getDemodulatorType ( ) ) {
2019-03-19 00:06:01 -04:00
demod - > setDemodulatorType ( dSelectionadv ) ;
demodTuner - > setHalfBand ( false ) ;
demodModeSelector - > setSelection ( - 1 ) ;
}
2015-11-15 13:52:54 -05:00
# else
2019-03-19 00:06:01 -04:00
// basic demodulators
if ( dSelection ! = " " & & dSelection ! = demod - > getDemodulatorType ( ) ) {
demod - > setDemodulatorType ( dSelection ) ;
demodTuner - > setHalfBand ( dSelection = = " USB " | | dSelection = = " LSB " ) ;
}
2015-11-15 13:52:54 -05:00
# endif
2015-06-10 13:39:08 -04:00
2019-03-19 00:06:01 -04:00
int muteMode = demodMuteButton - > getSelection ( ) ;
if ( demodMuteButton - > modeChanged ( ) ) {
if ( demod - > isMuted ( ) & & muteMode = = - 1 ) {
demod - > setMuted ( false ) ;
} else if ( ! demod - > isMuted ( ) & & muteMode = = 1 ) {
demod - > setMuted ( true ) ;
}
wxGetApp ( ) . getDemodMgr ( ) . setLastMuted ( demod - > isMuted ( ) ) ;
demodMuteButton - > clearModeChanged ( ) ;
} else {
if ( demod - > isMuted ( ) & & muteMode = = - 1 ) {
demodMuteButton - > setSelection ( 1 ) ;
2015-08-19 17:06:06 -04:00
wxGetApp ( ) . getDemodMgr ( ) . setLastMuted ( demod - > isMuted ( ) ) ;
2019-03-19 00:06:01 -04:00
demodMuteButton - > Refresh ( ) ;
} else if ( ! demod - > isMuted ( ) & & muteMode = = 1 ) {
demodMuteButton - > setSelection ( - 1 ) ;
wxGetApp ( ) . getDemodMgr ( ) . setLastMuted ( demod - > isMuted ( ) ) ;
demodMuteButton - > Refresh ( ) ;
2016-02-15 17:43:10 -05:00
}
2019-03-19 00:06:01 -04:00
}
2016-02-15 17:43:10 -05:00
2019-03-19 00:06:01 -04:00
int deltaMode = deltaLockButton - > getSelection ( ) ;
if ( deltaLockButton - > modeChanged ( ) ) {
if ( demod - > isDeltaLock ( ) & & deltaMode = = - 1 ) {
demod - > setDeltaLock ( false ) ;
} else if ( ! demod - > isDeltaLock ( ) & & deltaMode = = 1 ) {
demod - > setDeltaLockOfs ( demod - > getFrequency ( ) - wxGetApp ( ) . getFrequency ( ) ) ;
demod - > setDeltaLock ( true ) ;
}
wxGetApp ( ) . getDemodMgr ( ) . setLastDeltaLock ( demod - > isDeltaLock ( ) ) ;
deltaLockButton - > clearModeChanged ( ) ;
} else {
if ( demod - > isDeltaLock ( ) & & deltaMode = = - 1 ) {
deltaLockButton - > setSelection ( 1 ) ;
wxGetApp ( ) . getDemodMgr ( ) . setLastDeltaLock ( true ) ;
deltaLockButton - > Refresh ( ) ;
} else if ( ! demod - > isDeltaLock ( ) & & deltaMode = = 1 ) {
deltaLockButton - > setSelection ( - 1 ) ;
wxGetApp ( ) . getDemodMgr ( ) . setLastDeltaLock ( false ) ;
deltaLockButton - > Refresh ( ) ;
2015-08-17 00:59:38 -04:00
}
2019-03-19 00:06:01 -04:00
}
2015-08-17 00:59:38 -04:00
2019-03-19 00:06:01 -04:00
int soloMode = soloModeButton - > getSelection ( ) ;
if ( soloModeButton - > modeChanged ( ) ) {
if ( soloMode = = 1 ) {
wxGetApp ( ) . setSoloMode ( true ) ;
2016-02-11 01:09:15 -05:00
} else {
2019-03-19 00:06:01 -04:00
wxGetApp ( ) . setSoloMode ( false ) ;
2016-02-11 01:09:15 -05:00
}
2019-03-19 00:06:01 -04:00
soloModeButton - > clearModeChanged ( ) ;
} else {
if ( wxGetApp ( ) . getSoloMode ( ) ! = ( soloMode = = 1 ) ) {
soloModeButton - > setSelection ( wxGetApp ( ) . getSoloMode ( ) ? 1 : - 1 ) ;
soloModeButton - > Refresh ( ) ;
2016-10-20 21:44:33 -04:00
}
2014-12-28 05:13:46 -05:00
}
2016-08-10 14:02:25 -04:00
2019-03-19 00:06:01 -04:00
if ( demodWaterfallCanvas ) {
demodWaterfallCanvas - > setBandwidth ( demodBw ) ;
demodSpectrumCanvas - > setBandwidth ( demodBw ) ;
}
}
2019-02-11 22:59:43 -05:00
demodSignalMeter - > setLevel ( demod - > getSignalLevel ( ) ) ;
demodSignalMeter - > setMin ( demod - > getSignalFloor ( ) ) ;
demodSignalMeter - > setMax ( demod - > getSignalCeil ( ) ) ;
demodGainMeter - > setLevel ( demod - > getGain ( ) ) ;
if ( demodSignalMeter - > inputChanged ( ) ) {
2019-03-19 00:06:01 -04:00
demod - > setSquelchLevel ( demodSignalMeter - > getInputValue ( ) ) ;
}
2019-02-11 22:59:43 -05:00
if ( demodGainMeter - > inputChanged ( ) ) {
2019-03-19 00:06:01 -04:00
demod - > setGain ( demodGainMeter - > getInputValue ( ) ) ;
demodGainMeter - > setLevel ( demodGainMeter - > getInputValue ( ) ) ;
}
2019-02-11 22:59:43 -05:00
activeDemodulator = demod . get ( ) ;
2014-10-28 21:39:59 -04:00
}
2015-01-09 17:17:56 -05:00
2015-10-25 14:09:59 -04:00
void AppFrame : : OnDoubleClickSash ( wxSplitterEvent & event )
{
wxWindow * a , * b ;
2021-04-04 22:22:16 -04:00
wxSplitterWindow * w = nullptr ;
2015-10-25 14:09:59 -04:00
float g = 0.5 ;
if ( event . GetId ( ) = = wxID_MAIN_SPLITTER ) {
w = mainSplitter ;
2016-06-01 19:42:34 -04:00
g = 10.0f / 37.0f ;
2015-10-25 14:09:59 -04:00
} else if ( event . GetId ( ) = = wxID_VIS_SPLITTER ) {
w = mainVisSplitter ;
2016-06-01 19:42:34 -04:00
g = 6.0f / 25.0f ;
2015-10-25 14:09:59 -04:00
}
2021-04-04 22:22:16 -04:00
if ( w ! = nullptr ) {
2015-10-25 14:09:59 -04:00
a = w - > GetWindow1 ( ) ;
b = w - > GetWindow2 ( ) ;
w - > Unsplit ( ) ;
w - > SetSashGravity ( g ) ;
wxSize s = w - > GetSize ( ) ;
w - > SplitHorizontally ( a , b , int ( float ( s . GetHeight ( ) ) * g ) ) ;
}
event . Veto ( ) ;
}
void AppFrame : : OnUnSplit ( wxSplitterEvent & event )
{
event . Veto ( ) ;
}
2019-01-10 20:49:05 -05:00
void AppFrame : : OnAboutDialogClose ( wxCommandEvent & /* event */ ) {
2017-02-07 21:48:22 -05:00
aboutDlg - > Destroy ( ) ;
aboutDlg = nullptr ;
}
2016-06-20 13:28:26 -04:00
2021-04-04 22:22:16 -04:00
void AppFrame : : saveSession ( const std : : string & fileName ) {
2019-01-30 23:24:33 -05:00
wxGetApp ( ) . getSessionMgr ( ) . saveSession ( fileName ) ;
2015-01-10 20:33:30 -05:00
currentSessionFile = fileName ;
2015-01-11 17:08:16 -05:00
std : : string filePart = fileName . substr ( fileName . find_last_of ( filePathSeparator ) + 1 ) ;
2015-01-10 20:33:30 -05:00
GetStatusBar ( ) - > SetStatusText ( wxString : : Format ( wxT ( " Saved session: %s " ) , currentSessionFile . c_str ( ) ) ) ;
2020-02-26 01:11:19 -05:00
wxString titleBar = CUBICSDR_TITLE ;
//append the name of the current Device, if any.
if ( wxGetApp ( ) . getDevice ( ) ) {
titleBar + = " - " + wxGetApp ( ) . getDevice ( ) - > getName ( ) ;
}
titleBar + = " : " + filePart ;
SetTitle ( titleBar ) ;
2015-01-09 17:17:56 -05:00
}
2021-04-04 22:22:16 -04:00
bool AppFrame : : loadSession ( const std : : string & fileName ) {
2019-01-30 23:24:33 -05:00
bool result = wxGetApp ( ) . getSessionMgr ( ) . loadSession ( fileName ) ;
int sample_rate = wxGetApp ( ) . getSampleRate ( ) ;
2021-12-29 13:54:03 -05:00
//scan the available sample rates and see if it matches a predefined one
2019-01-30 23:24:33 -05:00
int menuIndex = - 1 ;
for ( auto discreteRate : sampleRates ) {
if ( discreteRate = = sample_rate ) {
menuIndex + + ;
//activate Bandwidth Menu entry matching this predefined sample_rate.
sampleRateMenuItems [ wxID_BANDWIDTH_BASE + menuIndex ] - > Check ( true ) ;
break ;
}
} //end for
//this is a manual entry
if ( menuIndex = = - 1 ) {
manualSampleRate = sample_rate ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Enable ( true ) ;
// Apply the manual value, activate the menu entry
2017-08-23 17:27:49 -04:00
2019-01-30 23:24:33 -05:00
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > SetItemLabel ( wxString ( " Manual Entry : " ) + frequencyToStr ( sample_rate ) ) ;
sampleRateMenuItems [ wxID_BANDWIDTH_MANUAL ] - > Check ( true ) ;
2015-01-09 20:56:43 -05:00
}
2019-01-30 23:24:33 -05:00
deviceChanged . store ( true ) ;
2016-06-02 17:56:31 -04:00
2015-01-10 12:27:03 -05:00
currentSessionFile = fileName ;
2015-01-10 20:33:30 -05:00
2015-01-11 17:08:16 -05:00
std : : string filePart = fileName . substr ( fileName . find_last_of ( filePathSeparator ) + 1 ) ;
2015-01-10 20:33:30 -05:00
GetStatusBar ( ) - > SetStatusText ( wxString : : Format ( wxT ( " Loaded session file: %s " ) , currentSessionFile . c_str ( ) ) ) ;
2020-02-26 01:11:19 -05:00
wxString titleBar = CUBICSDR_TITLE ;
//append the name of the current Device, if any.
if ( wxGetApp ( ) . getDevice ( ) ) {
titleBar + = " - " + wxGetApp ( ) . getDevice ( ) - > getName ( ) ;
}
titleBar + = " : " + filePart ;
SetTitle ( titleBar ) ;
2015-01-20 19:13:49 -05:00
2016-11-14 23:52:50 -05:00
wxGetApp ( ) . getBookmarkMgr ( ) . updateActiveList ( ) ;
2019-01-30 23:24:33 -05:00
return result ;
2015-01-09 17:17:56 -05:00
}
2015-10-25 00:07:01 -04:00
FFTVisualDataThread * AppFrame : : getWaterfallDataThread ( ) {
return waterfallDataThread ;
}
2019-01-30 23:24:33 -05:00
WaterfallCanvas * AppFrame : : getWaterfallCanvas ( ) {
return waterfallCanvas ;
}
SpectrumCanvas * AppFrame : : getSpectrumCanvas ( ) {
return spectrumCanvas ;
}
2016-07-28 10:46:18 -04:00
void AppFrame : : notifyUpdateModemProperties ( ) {
2015-11-23 22:03:14 -05:00
modemPropertiesUpdated . store ( true ) ;
}
2015-12-29 20:52:49 -05:00
void AppFrame : : setMainWaterfallFFTSize ( int fftSize ) {
wxGetApp ( ) . getSpectrumProcessor ( ) - > setFFTSize ( fftSize ) ;
spectrumCanvas - > setFFTSize ( fftSize ) ;
waterfallDataThread - > getProcessor ( ) - > setFFTSize ( fftSize ) ;
waterfallCanvas - > setFFTSize ( fftSize ) ;
}
2016-02-07 18:01:11 -05:00
2016-07-28 22:50:02 -04:00
void AppFrame : : setScopeDeviceName ( std : : string deviceName ) {
2017-01-08 06:46:31 -05:00
if ( scopeCanvas ) {
scopeCanvas - > setDeviceName ( deviceName ) ;
}
2016-07-28 22:50:02 -04:00
}
2016-02-07 22:19:05 -05:00
void AppFrame : : refreshGainUI ( ) {
gainCanvas - > updateGainUI ( ) ;
gainCanvas - > Refresh ( ) ;
}
2016-08-16 17:55:40 -04:00
bool AppFrame : : isUserDemodBusy ( ) {
return ( modemProps & & modemProps - > isMouseInView ( ) )
| | ( waterfallCanvas - > isMouseInView ( ) & & waterfallCanvas - > isMouseDown ( ) )
2016-10-20 21:44:33 -04:00
| | ( demodWaterfallCanvas & & demodWaterfallCanvas - > isMouseInView ( ) & & demodWaterfallCanvas - > isMouseDown ( ) )
2019-02-11 22:59:43 -05:00
| | ( wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) & &
wxGetApp ( ) . getDemodMgr ( ) . getActiveContextModem ( ) & &
wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ! = wxGetApp ( ) . getDemodMgr ( ) . getActiveContextModem ( ) ) ;
2016-08-16 17:55:40 -04:00
}
2016-09-14 22:49:32 -04:00
BookmarkView * AppFrame : : getBookmarkView ( ) {
return bookmarkView ;
}
2016-12-27 13:01:19 -05:00
void AppFrame : : disableSave ( bool state ) {
saveDisabled = state ;
}
2016-08-16 17:55:40 -04:00
2016-05-30 00:17:08 -04:00
# ifdef _WIN32
2016-05-29 21:03:21 -04:00
bool AppFrame : : canFocus ( ) {
return ( ! wxGetApp ( ) . isDeviceSelectorOpen ( ) & & ( ! modemProps | | ! modemProps - > isMouseInView ( ) ) ) ;
}
2016-05-30 00:17:08 -04:00
# endif
2016-05-29 21:03:21 -04:00
2016-02-07 21:05:49 -05:00
FrequencyDialog : : FrequencyDialogTarget AppFrame : : getFrequencyDialogTarget ( ) {
FrequencyDialog : : FrequencyDialogTarget target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_DEFAULT ;
if ( waterfallSpeedMeter - > getMouseTracker ( ) - > mouseInView ( ) ) {
target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_WATERFALL_LPS ;
}
else if ( spectrumAvgMeter - > getMouseTracker ( ) - > mouseInView ( ) ) {
target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_SPECTRUM_AVG ;
2016-02-07 22:19:05 -05:00
}
else if ( demodTuner - > getMouseTracker ( ) - > mouseInView ( ) ) {
2016-02-07 21:05:49 -05:00
switch ( demodTuner - > getHoverState ( ) ) {
case TuningCanvas : : ActiveState : : TUNING_HOVER_BW :
target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_BANDWIDTH ;
break ;
case TuningCanvas : : ActiveState : : TUNING_HOVER_FREQ :
target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_FREQ ;
break ;
case TuningCanvas : : ActiveState : : TUNING_HOVER_CENTER :
default :
target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_DEFAULT ;
break ;
}
}
2016-02-07 22:19:05 -05:00
else if ( gainCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
target = FrequencyDialog : : FrequencyDialogTarget : : FDIALOG_TARGET_GAIN ;
}
2016-02-07 21:05:49 -05:00
return target ;
}
2021-04-04 22:22:16 -04:00
void AppFrame : : gkNudge ( const DemodulatorInstancePtr & demod , int snap ) {
2016-05-18 23:12:48 -04:00
if ( demod ) {
2019-05-24 00:30:22 -04:00
auto demodFreq = demod - > getFrequency ( ) + snap ;
auto demodBw = demod - > getBandwidth ( ) ;
auto ctr = wxGetApp ( ) . getFrequency ( ) ;
auto bw = wxGetApp ( ) . getSampleRate ( ) ;
// Don't let it get nudged out of view.
if ( ctr - ( bw / 2 ) > ( demodFreq - demodBw / 2 ) | | ctr + ( bw / 2 ) < ( demodFreq + demodBw / 2 ) ) {
wxGetApp ( ) . setFrequency ( ctr + ( snap * 2 ) ) ;
}
2016-05-18 23:12:48 -04:00
demod - > setFrequency ( demod - > getFrequency ( ) + snap ) ;
demod - > updateLabel ( demod - > getFrequency ( ) ) ;
}
}
2016-02-07 18:01:11 -05:00
int AppFrame : : OnGlobalKeyDown ( wxKeyEvent & event ) {
if ( ! this - > IsActive ( ) ) {
return - 1 ;
}
2017-04-20 19:40:09 -04:00
# ifdef USE_HAMLIB
if ( rigPortDialog ! = nullptr ) {
return - 1 ;
}
# endif
2016-05-19 19:23:56 -04:00
if ( modemProps & & ( modemProps - > HasFocus ( ) | | modemProps - > isMouseInView ( ) ) ) {
return - 1 ;
}
2016-02-07 18:01:11 -05:00
2016-10-13 00:41:35 -04:00
if ( bookmarkView & & bookmarkView - > isMouseInView ( ) ) {
return - 1 ;
}
2017-08-27 05:11:30 -04:00
DemodulatorInstancePtr demod = nullptr ;
2019-02-11 22:59:43 -05:00
DemodulatorInstancePtr lastDemod = wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ;
2017-08-27 05:11:30 -04:00
2016-02-12 20:38:05 -05:00
int snap = wxGetApp ( ) . getFrequencySnap ( ) ;
2016-02-11 00:08:56 -05:00
2016-08-16 19:45:42 -04:00
if ( event . ControlDown ( ) ) {
return 1 ;
}
2016-02-14 06:10:42 -05:00
if ( event . ShiftDown ( ) ) {
if ( snap ! = 1 ) {
snap / = 2 ;
}
}
2016-05-18 23:12:48 -04:00
# ifdef wxHAS_RAW_KEY_CODES
switch ( event . GetRawKeyCode ( ) ) {
case 30 :
2019-05-24 00:30:22 -04:00
gkNudge ( lastDemod , snap ) ;
2016-05-18 23:12:48 -04:00
return 1 ;
case 33 :
2019-05-24 00:30:22 -04:00
gkNudge ( lastDemod , - snap ) ;
2016-05-18 23:12:48 -04:00
return 1 ;
}
# endif
2016-02-07 18:01:11 -05:00
switch ( event . GetKeyCode ( ) ) {
case WXK_UP :
case WXK_NUMPAD_UP :
case WXK_DOWN :
case WXK_NUMPAD_DOWN :
case WXK_LEFT :
case WXK_NUMPAD_LEFT :
case WXK_RIGHT :
case WXK_NUMPAD_RIGHT :
2016-02-12 20:38:05 -05:00
waterfallCanvas - > OnKeyDown ( event ) ; // TODO: Move the stuff from there to here
2016-02-08 23:40:09 -05:00
return 1 ;
2016-02-15 17:43:10 -05:00
case ' V ' :
return 1 ;
2016-02-12 20:38:05 -05:00
case ' ] ' :
2019-05-24 00:30:22 -04:00
gkNudge ( lastDemod , snap ) ;
2016-02-12 20:38:05 -05:00
return 1 ;
case ' [ ' :
2019-05-24 00:30:22 -04:00
gkNudge ( lastDemod , - snap ) ;
2016-02-12 20:38:05 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
case ' A ' :
case ' F ' :
case ' L ' :
case ' U ' :
2016-02-11 01:09:15 -05:00
case ' S ' :
2016-06-09 18:16:03 -04:00
case ' P ' :
2016-06-11 22:13:42 -04:00
case ' M ' :
2017-10-12 00:07:05 -04:00
case ' R ' :
2016-02-08 23:40:09 -05:00
return 1 ;
2019-05-24 00:30:22 -04:00
case WXK_NUMPAD0 :
case WXK_NUMPAD1 :
case WXK_NUMPAD2 :
case WXK_NUMPAD3 :
case WXK_NUMPAD4 :
case WXK_NUMPAD5 :
case WXK_NUMPAD6 :
case WXK_NUMPAD7 :
case WXK_NUMPAD8 :
case WXK_NUMPAD9 :
wxGetApp ( ) . showFrequencyInput ( getFrequencyDialogTarget ( ) , std : : to_string ( event . GetKeyCode ( ) - WXK_NUMPAD0 ) ) ;
return 1 ;
2016-02-07 19:32:05 -05:00
case ' 0 ' :
case ' 1 ' :
case ' 2 ' :
case ' 3 ' :
case ' 4 ' :
case ' 5 ' :
case ' 6 ' :
case ' 7 ' :
case ' 8 ' :
case ' 9 ' :
2016-02-07 21:05:49 -05:00
wxGetApp ( ) . showFrequencyInput ( getFrequencyDialogTarget ( ) , std : : to_string ( event . GetKeyCode ( ) - ' 0 ' ) ) ;
2016-02-08 23:40:09 -05:00
return 1 ;
2016-02-07 19:32:05 -05:00
break ;
2016-02-11 00:08:56 -05:00
case WXK_TAB :
2019-02-11 22:59:43 -05:00
lastDemod = wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ;
2016-02-11 00:08:56 -05:00
if ( ! lastDemod ) {
break ;
}
if ( event . ShiftDown ( ) ) {
demod = wxGetApp ( ) . getDemodMgr ( ) . getPreviousDemodulator ( lastDemod ) ;
} else {
demod = wxGetApp ( ) . getDemodMgr ( ) . getNextDemodulator ( lastDemod ) ;
}
if ( demod ) {
wxGetApp ( ) . getDemodMgr ( ) . setActiveDemodulator ( nullptr ) ;
wxGetApp ( ) . getDemodMgr ( ) . setActiveDemodulator ( demod , false ) ;
}
2016-03-07 20:15:27 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
default :
break ;
}
2017-01-27 15:38:48 -05:00
//Re-dispatch the key events if the mouse cursor is within a given
//widget region, effectively activating its specific key shortcuts,
2021-12-29 13:54:03 -05:00
//which else are overridden by this global key handler.
2016-02-07 18:01:11 -05:00
if ( demodTuner - > getMouseTracker ( ) - > mouseInView ( ) ) {
demodTuner - > OnKeyDown ( event ) ;
} else if ( waterfallCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
waterfallCanvas - > OnKeyDown ( event ) ;
}
2017-01-27 15:38:48 -05:00
else if ( spectrumCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
spectrumCanvas - > OnKeyDown ( event ) ;
}
else if ( scopeCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
scopeCanvas - > OnKeyDown ( event ) ;
}
2016-02-08 23:40:09 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
}
int AppFrame : : OnGlobalKeyUp ( wxKeyEvent & event ) {
if ( ! this - > IsActive ( ) ) {
return - 1 ;
}
2017-04-20 19:40:09 -04:00
# ifdef USE_HAMLIB
if ( rigPortDialog ! = nullptr ) {
return - 1 ;
}
# endif
2016-05-19 19:23:56 -04:00
if ( modemProps & & ( modemProps - > HasFocus ( ) | | modemProps - > isMouseInView ( ) ) ) {
return - 1 ;
}
2016-02-07 18:01:11 -05:00
2016-10-13 00:41:35 -04:00
if ( bookmarkView & & bookmarkView - > isMouseInView ( ) ) {
return - 1 ;
}
2016-08-16 19:45:42 -04:00
if ( event . ControlDown ( ) ) {
return 1 ;
}
2019-02-11 22:59:43 -05:00
DemodulatorInstancePtr activeDemod = wxGetApp ( ) . getDemodMgr ( ) . getActiveContextModem ( ) ;
DemodulatorInstancePtr lastDemod = wxGetApp ( ) . getDemodMgr ( ) . getCurrentModem ( ) ;
2016-02-15 17:43:10 -05:00
2016-05-18 23:12:48 -04:00
# ifdef wxHAS_RAW_KEY_CODES
switch ( event . GetRawKeyCode ( ) ) {
case 30 :
return 1 ;
case 33 :
return 1 ;
}
# endif
2016-02-07 18:01:11 -05:00
switch ( event . GetKeyCode ( ) ) {
case WXK_SPACE :
if ( ! demodTuner - > getMouseTracker ( ) - > mouseInView ( ) ) {
2016-02-07 21:05:49 -05:00
wxGetApp ( ) . showFrequencyInput ( getFrequencyDialogTarget ( ) ) ;
2016-02-08 23:40:09 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
}
break ;
case WXK_UP :
case WXK_NUMPAD_UP :
case WXK_DOWN :
case WXK_NUMPAD_DOWN :
case WXK_LEFT :
case WXK_NUMPAD_LEFT :
case WXK_RIGHT :
case WXK_NUMPAD_RIGHT :
waterfallCanvas - > OnKeyUp ( event ) ;
2016-02-08 23:40:09 -05:00
return 1 ;
2016-02-15 17:43:10 -05:00
case ' V ' :
2016-06-11 22:13:42 -04:00
if ( activeDemod ) {
lastDemod = activeDemod ;
2016-02-17 20:49:36 -05:00
}
2016-02-15 17:43:10 -05:00
if ( lastDemod & & lastDemod - > isDeltaLock ( ) ) {
lastDemod - > setDeltaLock ( false ) ;
} else if ( lastDemod ) {
lastDemod - > setDeltaLockOfs ( lastDemod - > getFrequency ( ) - wxGetApp ( ) . getFrequency ( ) ) ;
lastDemod - > setDeltaLock ( true ) ;
}
break ;
2016-02-07 18:01:11 -05:00
case ' A ' :
demodModeSelector - > setSelection ( " AM " ) ;
2016-02-11 01:09:15 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
break ;
case ' F ' :
if ( demodModeSelector - > getSelectionLabel ( ) = = " FM " ) {
demodModeSelector - > setSelection ( " FMS " ) ;
2016-05-11 23:05:56 -04:00
} else if ( demodModeSelector - > getSelectionLabel ( ) = = " FMS " ) {
demodModeSelector - > setSelection ( " NBFM " ) ;
} else if ( demodModeSelector - > getSelectionLabel ( ) = = " NBFM " ) {
2016-02-07 18:01:11 -05:00
demodModeSelector - > setSelection ( " FM " ) ;
}
2016-02-11 01:09:15 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
break ;
case ' L ' :
demodModeSelector - > setSelection ( " LSB " ) ;
2016-02-11 01:09:15 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
break ;
case ' U ' :
demodModeSelector - > setSelection ( " USB " ) ;
2016-02-11 01:09:15 -05:00
return 1 ;
break ;
case ' S ' :
wxGetApp ( ) . setSoloMode ( ! wxGetApp ( ) . getSoloMode ( ) ) ;
return 1 ;
2016-02-07 18:01:11 -05:00
break ;
2017-10-12 00:07:05 -04:00
case ' R ' :
2017-12-29 22:46:39 -05:00
if ( event . ShiftDown ( ) ) {
toggleAllActiveDemodRecording ( ) ;
} else {
toggleActiveDemodRecording ( ) ;
}
2017-10-12 00:07:05 -04:00
break ;
2016-06-09 18:16:03 -04:00
case ' P ' :
wxGetApp ( ) . getSpectrumProcessor ( ) - > setPeakHold ( ! wxGetApp ( ) . getSpectrumProcessor ( ) - > getPeakHold ( ) ) ;
2017-01-08 06:46:31 -05:00
if ( wxGetApp ( ) . getDemodSpectrumProcessor ( ) ) {
wxGetApp ( ) . getDemodSpectrumProcessor ( ) - > setPeakHold ( wxGetApp ( ) . getSpectrumProcessor ( ) - > getPeakHold ( ) ) ;
}
2016-06-09 18:16:03 -04:00
peakHoldButton - > setSelection ( wxGetApp ( ) . getSpectrumProcessor ( ) - > getPeakHold ( ) ? 1 : 0 ) ;
peakHoldButton - > clearModeChanged ( ) ;
break ;
2016-02-12 20:38:05 -05:00
case ' ] ' :
case ' [ ' :
return 1 ;
2016-06-11 22:13:42 -04:00
case ' M ' :
if ( activeDemod ) {
lastDemod = activeDemod ;
}
if ( lastDemod ) {
lastDemod - > setMuted ( ! lastDemod - > isMuted ( ) ) ;
}
break ;
2016-02-07 18:01:11 -05:00
default :
break ;
}
2017-01-27 15:38:48 -05:00
//Re-dispatch the key events if the mouse cursor is within a given
//widget region, effectively activating its specific key shortcuts,
2021-12-29 13:54:03 -05:00
//which else are overridden by this global key handler.
2016-02-07 18:01:11 -05:00
if ( demodTuner - > getMouseTracker ( ) - > mouseInView ( ) ) {
demodTuner - > OnKeyUp ( event ) ;
2017-01-27 15:38:48 -05:00
}
else if ( waterfallCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
2016-02-07 18:01:11 -05:00
waterfallCanvas - > OnKeyUp ( event ) ;
}
2017-01-27 15:38:48 -05:00
else if ( spectrumCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
spectrumCanvas - > OnKeyUp ( event ) ;
}
else if ( scopeCanvas - > getMouseTracker ( ) - > mouseInView ( ) ) {
scopeCanvas - > OnKeyUp ( event ) ;
}
2016-02-07 18:01:11 -05:00
// TODO: Catch key-ups outside of original target
2016-02-08 23:40:09 -05:00
return 1 ;
2016-02-07 18:01:11 -05:00
}
2017-12-04 22:44:47 -05:00
void AppFrame : : toggleActiveDemodRecording ( ) {
if ( ! wxGetApp ( ) . getConfig ( ) - > verifyRecordingPath ( ) ) {
return ;
}
2019-02-11 22:59:43 -05:00
DemodulatorInstancePtr activeDemod = wxGetApp ( ) . getDemodMgr ( ) . getActiveContextModem ( ) ;
2017-12-04 22:44:47 -05:00
if ( activeDemod ) {
activeDemod - > setRecording ( ! activeDemod - > isRecording ( ) ) ;
wxGetApp ( ) . getBookmarkMgr ( ) . updateActiveList ( ) ;
}
}
2017-12-29 22:46:39 -05:00
void AppFrame : : toggleAllActiveDemodRecording ( ) {
if ( ! wxGetApp ( ) . getConfig ( ) - > verifyRecordingPath ( ) ) {
return ;
}
2018-03-24 04:48:18 -04:00
// All demods, irrespective of their active state:
// recording will start eventually when a demod come in range.
auto allDemods = wxGetApp ( ) . getDemodMgr ( ) . getDemodulators ( ) ;
2017-12-29 22:46:39 -05:00
2018-03-24 03:45:50 -04:00
//by default, do a false => true for all:
2017-12-29 22:46:39 -05:00
bool stateToSet = true ;
2021-04-04 22:22:16 -04:00
for ( const auto & i : allDemods ) {
2018-03-24 03:45:50 -04:00
if ( i - > isRecording ( ) ) {
2017-12-29 22:46:39 -05:00
stateToSet = false ;
break ;
}
}
2021-04-04 22:22:16 -04:00
for ( const auto & i : allDemods ) {
2018-03-24 03:45:50 -04:00
i - > setRecording ( stateToSet ) ;
2017-12-29 22:46:39 -05:00
}
2018-03-24 03:45:50 -04:00
//this effectively refresh the BookmarkView buttons, including Recording buttons.
wxGetApp ( ) . getBookmarkMgr ( ) . updateActiveList ( ) ;
2017-12-29 22:46:39 -05:00
}
2016-02-07 21:05:49 -05:00
void AppFrame : : setWaterfallLinesPerSecond ( int lps ) {
waterfallSpeedMeter - > setUserInputValue ( sqrt ( lps ) ) ;
}
void AppFrame : : setSpectrumAvgSpeed ( double avg ) {
spectrumAvgMeter - > setUserInputValue ( avg ) ;
}
2016-08-15 23:53:27 -04:00
void AppFrame : : setViewState ( long long center_freq , int bandwidth ) {
spectrumCanvas - > setView ( center_freq , bandwidth ) ;
waterfallCanvas - > setView ( center_freq , bandwidth ) ;
}
2017-05-29 14:08:45 -04:00
void AppFrame : : setViewState ( ) {
2016-08-15 23:53:27 -04:00
spectrumCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
waterfallCanvas - > setCenterFrequency ( wxGetApp ( ) . getFrequency ( ) ) ;
spectrumCanvas - > disableView ( ) ;
waterfallCanvas - > disableView ( ) ;
}
2016-10-20 21:44:33 -04:00
2016-12-27 00:06:25 -05:00
long long AppFrame : : getViewCenterFreq ( ) {
return waterfallCanvas - > getCenterFrequency ( ) ;
}
int AppFrame : : getViewBandwidth ( ) {
return waterfallCanvas - > getBandwidth ( ) ;
}
2021-04-04 22:22:16 -04:00
void AppFrame : : setStatusText ( wxWindow * window , const std : : string & statusText ) {
2017-03-01 16:13:41 -05:00
GetStatusBar ( ) - > SetStatusText ( statusText ) ;
if ( wxGetApp ( ) . getConfig ( ) - > getShowTips ( ) ) {
if ( statusText ! = lastToolTip ) {
wxToolTip : : Enable ( false ) ;
window - > SetToolTip ( statusText ) ;
lastToolTip = statusText ;
wxToolTip : : SetDelay ( 1000 ) ;
wxToolTip : : Enable ( true ) ;
}
}
else {
window - > SetToolTip ( " " ) ;
lastToolTip = " " ;
}
}
2021-04-04 22:22:16 -04:00
void AppFrame : : setStatusText ( const std : : string & statusText , int value ) {
2017-03-01 16:13:41 -05:00
GetStatusBar ( ) - > SetStatusText (
wxString : : Format ( statusText . c_str ( ) , wxNumberFormatter : : ToString ( ( long ) value , wxNumberFormatter : : Style_WithThousandsSep ) ) ) ;
}
2017-08-24 15:11:50 -04:00
wxString AppFrame : : getSettingsLabel ( const std : : string & settingsName ,
const std : : string & settingsValue ,
const std : : string & settingsSuffix ) {
2018-05-19 10:16:36 -04:00
size_t itemStringSize = 40 ;
2017-08-24 15:11:50 -04:00
int justifValueSize = itemStringSize - settingsName . length ( ) - 1 ;
std : : stringstream full_label ;
full_label < < settingsName + " : " ;
full_label < < std : : right < < std : : setw ( justifValueSize ) ;
2018-05-19 10:16:36 -04:00
if ( settingsSuffix . empty ( ) ) {
full_label < < settingsValue ;
} else {
full_label < < settingsValue + " " + settingsSuffix ;
}
2017-08-24 15:11:50 -04:00
return wxString ( full_label . str ( ) ) ;
}