#include “json.hpp” using json = nlohmann::json; void GUIApp::setup() {

gui0 = new ofxDatGui( 0, 0 );
gui0->setTheme( new AppGuiTheme() );
bool reload_prev_iteration = true;
json prevStateVars;
printf( "Do you wish to reload the previous interation values? Yes = 1, No = 0. " );
cin >> reload_prev_iteration;
if( reload_prev_iteration )
{
  // read a JSON file
  std::ifstream i( "sweeper_saved_variables.json" );
  i >> prevStateVars;
  reload_prev_iteration = !prevStateVars.empty();
}

———————————————————————————–

gui0_SaveFile = gui0->addButton( "[ Save To File ]" );
gui0_SaveAs = gui0->addButton( "[ Save as ]" );
gui0_LoadFile = gui0->addButton( "[ Load From File ]" );
gui0_equalizerEnable = gui0->addToggle( "Enable Equalizer", ( reload_prev_iteration ? prevStateVars[ "gui0_equalizerEnable" ] : false ) );
gui0_timeCoherent = gui0->addToggle( "Time-Coherent", ( reload_prev_iteration ? prevStateVars[ "gui0_timeCoherent" ] : false ) );

sweep_mode = ( reload_prev_iteration ? prevStateVars[ "sweep_mode" ] : 1 ); // 0 - manual
                                                                            // 1 - automatic
vector<string> sweep_options ={ "Sweep: Manual","Sweep: Auto" };
gui0_SweepMode = gui0->addDropdown( "Sweep Mode", sweep_options );
gui0_SweepMode->select( sweep_mode );
gui0_StopSweep = gui0->addButton( "[ Stop Sweep ]" );

sweep_rate = ( reload_prev_iteration ? prevStateVars[ "sweep_rate" ] : 0.25 );
gui0_SweepRate = gui0->addSlider( "Sweep Rate", -2.0, 2.0 );
gui0_SweepRate->setValue( sweep_rate );
gui0_SweepRate->setVisible( true );
sweep_percentage = ( reload_prev_iteration ? prevStateVars[ "sweep_percentage" ] : 0.5 );
gui0_SweepPercentage = gui0->addSlider( "Sweep Alpha", 0.0, 1.0 );
gui0_SweepPercentage->setValue( sweep_percentage );
gui0_SweepPercentage->setVisible( true );
vector<string> mode_options ={ "Output Mode: Shared", "Output Mode: Separate" };
gui0_outputModeDD = gui0->addDropdown( "Output Mode", mode_options );
output_mode = ( reload_prev_iteration ? prevStateVars[ "output_mode" ] : 1 ); // 0 - all three together
                                                                             // 1 - all three separate
gui0_outputModeDD->select( output_mode );
vector<string> channel_options ={ "Output Channel: Red", "Output Channel: Green", "Output Channel: Blue" };
gui0_outputChannelDD = gui0->addDropdown( "Output Channel", channel_options );
output_channel = ( reload_prev_iteration ? prevStateVars[ "output_channel" ] : 0 ); // 0 - all three on R
                                                                                    // 1 - all three on G
                                                                                    // 2 - all three on B
gui0_outputChannelDD->select( output_channel );
gui0_outputChannelDD->setVisible( output_mode == 0 );
vector<string> mixing_options ={ "Averaging Divisor: Constant", "Averaging Divisor: Summation" };
gui0_mixingModeDD = gui0->addDropdown( "Shared Mixing Mode", mixing_options );
shared_output_mixing_mode = ( reload_prev_iteration ? prevStateVars[ "shared_output_mixing_mode" ] : 0 ); 
                                      // 0 - average with constant divisor
                                      // 1 - average with changing divisor based upon sum of amplitudes
gui0_mixingModeDD->setVisible( output_mode == 0 );
char temp_c_str[ 16 ];

gui_widgets[ 0 ] = gui0_RedEnable   = gui0->addToggle( "Red Enable", ( reload_prev_iteration ? prevStateVars[ "red_enable" ] : true ) );
red_carrier_freq = ( reload_prev_iteration ? prevStateVars[ "red_carrier_freq" ] : 350.0 );
sprintf( temp_c_str, "%.2f", red_carrier_freq );
gui0_RedCarrierFrequency = gui0->addTextInput( "Red Carrier Freq", temp_c_str );
gui0_RedCarrierFrequency->setInputType( ofxDatGuiInputType::NUMERIC );
gui0_RedMinFreq                   = gui0->addSlider( "Red Min Freq", red_carrier_freq, red_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "red_min_freq" ] : red_carrier_freq ) );
gui_widgets[ 1 ] = gui0_RedFreq     = gui0->addSlider( "Red Freq", red_carrier_freq, red_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "red_freq" ] : ( red_carrier_freq + GPU_BW_MHZ * 0.5 ) ) );
gui0_RedMaxFreq                   = gui0->addSlider( "Red Max Freq", red_carrier_freq, red_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "red_max_freq" ] : ( red_carrier_freq + GPU_BW_MHZ ) ) );
gui_widgets[ 2 ] = gui0_RedAmp      = gui0->addSlider( "Red Amp", 0.0, 1.0, ( reload_prev_iteration ? prevStateVars[ "red_amp" ] : 1.0 ) );

gui_widgets[ 3 ] = gui0_GreenEnable = gui0->addToggle( "Green Enable", ( reload_prev_iteration ? prevStateVars[ "green_enable" ] : false ) );
green_carrier_freq = ( reload_prev_iteration ? prevStateVars[ "green_carrier_freq" ] : 0.0 );
sprintf( temp_c_str, "%.2f", green_carrier_freq );
gui0_GreenCarrierFrequency = gui0->addTextInput( "Green Carrier Freq", temp_c_str );
gui0_GreenCarrierFrequency->setInputType( ofxDatGuiInputType::NUMERIC );
gui0_GreenMinFreq                 = gui0->addSlider( "Green Min Freq", green_carrier_freq, green_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "green_min_freq" ] : 0.0 ) );
gui_widgets[ 4 ] = gui0_GreenFreq   = gui0->addSlider( "Green Freq", green_carrier_freq, green_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "green_freq" ] : 0.0 ) );
gui0_GreenMaxFreq                 = gui0->addSlider( "Green Max Freq", green_carrier_freq, green_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "green_max_freq" ] : 0.0 ) );
gui_widgets[ 5 ] = gui0_GreenAmp    = gui0->addSlider( "Green Amp", 0.0, 1.0, ( reload_prev_iteration ? prevStateVars[ "green_amp" ] : 1.0 ) );

gui_widgets[ 6 ] = gui0_BlueEnable  = gui0->addToggle( "Blue Enable", ( reload_prev_iteration ? prevStateVars[ "blue_enable" ] : true ) );
blue_carrier_freq = ( reload_prev_iteration ? prevStateVars[ "blue_carrier_freq" ] : 0.0 );
sprintf( temp_c_str, "%.2f", blue_carrier_freq );
gui0_BlueCarrierFrequency = gui0->addTextInput( "Blue Carrier Freq", temp_c_str );
gui0_BlueCarrierFrequency->setInputType( ofxDatGuiInputType::NUMERIC );
gui0_BlueMinFreq                  = gui0->addSlider( "Blue Min Freq", blue_carrier_freq, blue_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "blue_min_freq" ] : 1.0 ) );
gui_widgets[ 7 ] = gui0_BlueFreq    = gui0->addSlider( "Blue Freq", blue_carrier_freq, blue_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "blue_freq" ] : 1.0 ) );
gui0_BlueMaxFreq                  = gui0->addSlider( "Blue Max Freq", blue_carrier_freq, blue_carrier_freq + GPU_BW_MHZ, ( reload_prev_iteration ? prevStateVars[ "blue_max_freq" ] : 1.0 ) );
gui_widgets[ 8 ] = gui0_BlueAmp     = gui0->addSlider( "Blue Amp", 0.0, 1.0, ( reload_prev_iteration ? prevStateVars[ "blue_amp" ] : 1.0 ) );

————————————————————

if( sweep_mode )
{
  gui0_RedMinFreq->setVisible( true );
  gui0_RedMaxFreq->setVisible( true );
  gui0_GreenMinFreq->setVisible( true );
  gui0_GreenMaxFreq->setVisible( true );
  gui0_BlueMinFreq->setVisible( true );
  gui0_BlueMaxFreq->setVisible( true );
}
else
{
  gui0_SweepRate->setVisible( false );
  gui0_SweepPercentage->setVisible( false );

  gui0_RedMinFreq->setVisible( false );
  gui0_RedMaxFreq->setVisible( false );
  gui0_GreenMinFreq->setVisible( false );
  gui0_GreenMaxFreq->setVisible( false );
  gui0_BlueMinFreq->setVisible( false );
  gui0_BlueMaxFreq->setVisible( false );
}
gui_widget_focused_index = 1; // focus on red frequency widget initially

gui0->onButtonEvent( this, &GUIApp::onButtonEvent );
gui0->onToggleEvent( this, &GUIApp::onToggleEvent );
gui0->onTextInputEvent( this, &GUIApp::onTextInputEvent );
gui0->onSliderEvent( this, &GUIApp::onSliderEvent );
gui0->onDropdownEvent( this, &GUIApp::onDropdownEvent );

alt_modifier = false;
shift_modifier = false;
ctrl_modifier = false;
is_adjusting_min_max_freq = false;
//ofTrueTypeFont::setGlobalDpi( 72 ); // this screws up the font size
font.load( "FAFERS_Technical_Font.ttf", 14, false );
if( !font.isLoaded() )
  font.load( "arial.ttf", 14, false );
font.setLineHeight( font.getSize() * 1.125 );
font.setLetterSpacing( 1.037 );

}

bool save_curr_iteration = true;

printf( "Do you wish to save current data? Yes = 1, No = 0 \n" );
cin >> save_curr_iteration;
if (save_curr_iteration)
{
   json savedStateVars;
   savedStateVars["sweep_rate"] = gui0_SweepRate->getValue();
   savedStateVars["sweep_percentage"] = gui0_SweepPercentage->getValue();

savedStateVars["red_enable"] = gui0_RedEnable->getChecked();
savedStateVars["red_carrier_freq"] = gui0_RedCarrierFrequency->getLabel();
savedStateVars["red_min_freq"] = gui0_RedMinFreq->getValue();
savedStateVars["red_freq"] = gui0_RedFreq->getValue();
savedStateVars["red_max_freq"] = gui0_RedMaxFreq->getValue();
savedStateVars["red_amp"] = gui0_RedAmp->getValue();

savedStateVars["green_enable"] = gui0_GreenEnable->getChecked();
savedStateVars["green_carrier_freq"] = gui0_GreenCarrierFrequency->getLabel();
savedStateVars["green_min_freq"] = gui0_GreenMinFreq->getValue();
savedStateVars["green_freq"] = gui0_GreenFreq->getValue();
savedStateVars["green_max_freq"] = gui0_GreenMaxFreq->getValue();
savedStateVars["green_amp"] = gui0_GreenAmp->getValue();

savedStateVars["blue_enable"] = gui0_BlueEnable->getChecked();
savedStateVars["blue_carrier_freq"] = gui0_BlueCarrierFrequency->getLabel();
savedStateVars["blue_min_freq"] = gui0_BlueMinFreq->getValue();
savedStateVars["blue_freq"] = gui0_BlueFreq->getValue();
savedStateVars["blue_max_freq"] = gui0_BlueMaxFreq->getValue();
savedStateVars["blue_amp"] = gui0_BlueAmp->getValue();

// write prettified JSON to another file
std::ofstream off_program_file("sweeper_saved_variables.json");
off_program_file << std::setw(10) << savedStateVars << std::endl;

printf("sweep_rate: %f \n", savedStateVars["sweep_rate"]);
printf("sweep_percentage: %f \n", savedStateVars["sweep_percentage"]);
printf("red_min_freq: %f \n", savedStateVars["red_min_freq"]);
printf("red curr freq: %f \n", savedStateVars["red_freq"]);
printf("red_max_freq: %f \n", savedStateVars["red_max_freq"]);
printf("green_min_freq: %f \n", savedStateVars["green_min_freq"]);
printf("green curr freq: %f \n", savedStateVars["green_freq"]);
printf("green_max_freq: %f \n", savedStateVars["green_max_freq"]);
printf("blue_min_freq: %f \n", savedStateVars["blue_min_freq"]);
printf("blue curr freq: %f \n", savedStateVars["blue_freq"]);
printf("blue_max_freq: %f \n", savedStateVars["blue_max_freq"]);
 }