ElectroHolography Laboratory

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
#include "GUIApp.h"
#include "outputApp.h"
#include "json.hpp" 

using json = nlohmann::json;
int window_width = 400;
int window_height = 400;
int window_position_x = 100;
int window_position_y = 200;
int prev_positionX;
int prev_positionY;
int prev_window_width;
int prev_window_height;

bool fullscreen = false;
void GUIApp::loadSettingsFromFile( string file_path )
{ // read a JSON file
  std::ifstream i( file_path );
  if( !i )
  {
    i.clear();
    i.open( file_path, std::ios::out ); // Create using out
    if( !i ) { printf( "File doesn't exist." ); }
    i.close();
    i.open( file_path ); // Open for I/O
    if( !i ) { printf( "Could not open file." ); }
  }
  else
  {
    try
    {
      json prevStateVars; // Create a place to store the variable values
      i >> prevStateVars; // Load the file values into the JSON

      gui0_equalizerEnable->setChecked( prevStateVars.at( "equalizerEnable" ) );
      gui0_timeCoherent->setChecked( prevStateVars.at( "timeCoherent" ) );
      // Change and update sweep mode
      sweep_mode = prevStateVars.at( "sweep_mode" ); // 0 - manual
                                                     // 1 - automatic
      gui0_SweepMode->select( sweep_mode );
      // Change and update sweep rate
      sweep_rate = prevStateVars.at( "sweep_rate" );
      gui0_SweepRate->setValue( sweep_rate );
      // Change and update sweep percentage
      sweep_percentage = prevStateVars.at( "sweep_percentage" );
      gui0_SweepPercentage->setValue( sweep_percentage );
      // Change and update output mode
      output_mode =  prevStateVars.at( "output_mode" ); // 0 - all three together
                                                        // 1 - all three separate
      gui0_outputModeDD->select( output_mode );
      // Change and update output channel
      output_channel = prevStateVars.at( "output_channel" ); // 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 );
      // Change and update output mixing mode
      shared_output_mixing_mode =  prevStateVars.at( "shared_output_mixing_mode" ); // 0 - average with constant divisor
                                                                                    // 1 - average with changing divisor based upon sum of amplitudes
      gui0_outputChannelDD->select( shared_output_mixing_mode );
      gui0_mixingModeDD->setVisible( output_mode == 0 );

      char temp_c_str[ 16 ];

      // Update Green enable and green carrier frequency
      gui0_RedEnable->setChecked( prevStateVars.at( "red_enable" ) );
      red_carrier_freq = prevStateVars.at( "red_carrier_freq" );
      sprintf( temp_c_str, "%.2f", red_carrier_freq );
      gui0_RedCarrierFrequency->setText( temp_c_str );

      // Change red frequency variables
      gui0_RedMinFreq->setValue( prevStateVars.at( "red_min_freq" ) );
      gui0_RedFreq->setValue( prevStateVars.at( "red_freq" ) );
      gui0_RedMaxFreq->setValue( prevStateVars.at( "red_max_freq" ) );
      gui0_RedAmp->setValue( prevStateVars.at( "red_amp" ) );
     
      // Call helper function to change red min, max, and current frequencies in response to the carrier frequency
      carrier_freq_change_helper( gui0_RedMinFreq, red_carrier_freq );
      carrier_freq_change_helper( gui0_RedMaxFreq, red_carrier_freq );
      carrier_freq_change_helper( gui0_RedFreq, red_carrier_freq );

      // Update Green enable and green carrier frequency
      gui0_GreenEnable->setChecked( prevStateVars.at( "green_enable" ) );
      green_carrier_freq = prevStateVars.at( "green_carrier_freq" );
      sprintf( temp_c_str, "%.2f", green_carrier_freq );
      gui0_GreenCarrierFrequency->setText( temp_c_str );

      // Change green frequency variables
      gui0_GreenMinFreq->setValue( prevStateVars.at( "green_min_freq" ) );
      gui0_GreenFreq->setValue( prevStateVars.at( "green_freq" ) );
      gui0_GreenMaxFreq->setValue( prevStateVars.at( "green_max_freq" ) );
      gui0_GreenAmp->setValue( prevStateVars.at( "green_amp" ) );

      // Call helper function to change green min, max, and current frequencies in response to the carrier frequency
      carrier_freq_change_helper( gui0_GreenMinFreq, green_carrier_freq );
      carrier_freq_change_helper( gui0_GreenMaxFreq, green_carrier_freq );
      carrier_freq_change_helper( gui0_GreenFreq, green_carrier_freq );

      // Update Blue enable and blue carrier frequency
      gui0_BlueEnable->setChecked( prevStateVars.at( "blue_enable" ) );
      blue_carrier_freq = prevStateVars.at( "blue_carrier_freq" );
      sprintf( temp_c_str, "%.2f", blue_carrier_freq );
      gui0_BlueCarrierFrequency->setText( temp_c_str );

      // Change blue frequency variables
      gui0_BlueMinFreq->setValue( prevStateVars.at( "blue_min_freq" ) );
      gui0_BlueFreq->setValue( prevStateVars.at( "blue_freq" ) );
      gui0_BlueMaxFreq->setValue( prevStateVars.at( "blue_max_freq" ) );
      gui0_BlueAmp->setValue( prevStateVars.at( "blue_amp" ) );
   
      // Call helper function to change blue min, max, and current frequencies in response to the carrier frequency
      carrier_freq_change_helper( gui0_BlueMinFreq, blue_carrier_freq );
      carrier_freq_change_helper( gui0_BlueMaxFreq, blue_carrier_freq );
      carrier_freq_change_helper( gui0_BlueFreq, blue_carrier_freq );
   
//      ofSetFullscreen( prevStateVars.at( "fullscreen" ) );

      fullscreen = prevStateVars.at( "fullscreen" );

      window_width = prevStateVars.at( "window_width" );
      window_height = prevStateVars.at( "window_height" );
      window_position_x = prevStateVars.at( "window_position_x" );
      window_position_y = prevStateVars.at( "window_position_y" );
  

    }
    catch( std::invalid_argument& ia )
    { // Catch invalid files
      ia.what();
    }
    catch( std::out_of_range& oor )
    { // Catch out of range values
      oor.what();
    }
    catch( std::domain_error& derr )
    { // Catch domain errors
      derr.what();
    }
    if( sweep_mode )
    { // Make some slider options visible when changing to Automatic mode
      gui0_SweepRate->setVisible( true );
      gui0_SweepPercentage->setVisible( true );
      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
    {// Make some slider options invisible when changing to Manual mode
      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 );
    }
    // Call Event Functions to update GUI display
    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;
    // Resize window if GUI options changed 
    gui_window->setWindowShape( gui0->getWidth(), gui0->getHeight() + font.getLineHeight() );
  }
}
void GUIApp::loadFile( string file_name )
{ // This double call is neccessary in order to correctly load the freq variables
  loadSettingsFromFile( file_name );
  loadSettingsFromFile( file_name );
}
void GUIApp::toggleFullScreen()
{
  fullscreen = !fullscreen;
}
bool GUIApp::getFullScreen()
{
  return fullscreen;
}

void GUIApp::setOutputWidth( int width )
{ // Set the width of the output window
  window_width = width;
}
void GUIApp::setOutputHeight( int height )
{ // Set the height of the output window
  window_height = height;
}
void GUIApp::setPositionX( int positionX )
{ // Set the X position of the output window
  window_position_x = positionX;
}
void GUIApp::setPositionY( int positionY )
{ // Set the Y position of the output window
  window_position_y = positionY;
}

void GUIApp::setPreviousWidth( int width )
{
  prev_window_width = width;
}
void GUIApp::setPreviousHeight( int height )
{
  prev_window_height = height;
}
void GUIApp::setPreviousPositionX( int positionX )
{
  prev_positionX = positionX;
}
void GUIApp::setPreviousPositionY( int positionY )
{
  prev_positionY = positionY;
}

int GUIApp::getOutputWidth()
{ // Return the width of the output window
  return window_width;
}
int GUIApp::getOutputHeight()
{ // Return the height of the output window
  return window_height;
}
int GUIApp::getPositionX()
{ // Return the X position of the output window
  return window_position_x;
}
int GUIApp::getPositionY()
{ // Return the Y position of the output window
  return window_position_y;
}
void GUIApp::saveSettingsToFile( string file_path )
{ 
    json savedStateVars; // Create a place to store the variable values
    // Store variables based on a (key, value) system
    savedStateVars[ "equalizerEnable" ] = gui0_equalizerEnable->getChecked();
    savedStateVars[ "timeCoherent" ] = gui0_timeCoherent->getChecked();
    savedStateVars[ "sweep_mode" ] = sweep_mode;
    savedStateVars[ "sweep_rate" ] = sweep_rate;
    savedStateVars[ "sweep_percentage" ] = sweep_percentage;
    savedStateVars[ "output_mode" ] = output_mode;
    savedStateVars[ "output_channel" ] = output_channel;
    savedStateVars[ "shared_output_mixing_mode" ] = shared_output_mixing_mode;
    // Store red frequency variables
    savedStateVars[ "red_enable" ] = gui0_RedEnable->getChecked();
    savedStateVars[ "red_carrier_freq" ] = red_carrier_freq;
    savedStateVars[ "red_min_freq" ] = red_min_freq;
    savedStateVars[ "red_freq" ] = gui0_RedFreq->getValue();
    savedStateVars[ "red_max_freq" ] = red_max_freq;
    savedStateVars[ "red_amp" ] = gui0_RedAmp->getValue();
    // Store green frequency variables
    savedStateVars[ "green_enable" ] = gui0_GreenEnable->getChecked();
    savedStateVars[ "green_carrier_freq" ] = green_carrier_freq;
    savedStateVars[ "green_min_freq" ] = green_min_freq;
    savedStateVars[ "green_freq" ] = gui0_GreenFreq->getValue();
    savedStateVars[ "green_max_freq" ] = green_max_freq;
    savedStateVars[ "green_amp" ] = gui0_GreenAmp->getValue();
    // Store blue frequency variables
    savedStateVars[ "blue_enable" ] = gui0_BlueEnable->getChecked();
    savedStateVars[ "blue_carrier_freq" ] = blue_carrier_freq;
    savedStateVars[ "blue_min_freq" ] = blue_min_freq;
    savedStateVars[ "blue_freq" ] = gui0_BlueFreq->getValue();
    savedStateVars[ "blue_max_freq" ] = blue_max_freq;
    savedStateVars[ "blue_amp" ] = gui0_BlueAmp->getValue();
    // Store Output window position, width, and height

    savedStateVars[ "fullscreen" ] = fullscreen;
    if( fullscreen )
    {
      savedStateVars[ "window_position_x" ] = prev_positionX;
      savedStateVars[ "window_position_y" ] = prev_positionY;
      savedStateVars[ "window_width" ] =  prev_window_width;
      savedStateVars[ "window_height" ] = prev_window_height;
    }
    else
    {
      savedStateVars[ "window_position_x" ] = window_position_x;
      savedStateVars[ "window_position_y" ] = window_position_y;
      savedStateVars[ "window_width" ] =  window_width;
      savedStateVars[ "window_height" ] = window_height;
    }

    // write prettified JSON to file
    std::ofstream off_program_file( file_path );
    off_program_file << std::setw( 20 ) << savedStateVars << std::endl;
}
ElectroHolography Laboratory

User Tools

Site Tools

Page Tools
