ConfigurationDialog.cpp

/***************************************************************************
 *
 * Project:  OpenCPN Weather Routing plugin
 * Author:   Sean D'Epagnier
 *
 ***************************************************************************
 *   Copyright (C) 2015 by Sean D'Epagnier                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,  USA.         *
 ***************************************************************************
 *
 */

#include <wx/wx.h>

#include <stdlib.h>
#include <math.h>

#include "Boat.h"
#include "RouteMapOverlay.h"
#include "ConfigurationDialog.h"
#include "BoatDialog.h"
#include "weather_routing_pi.h"
#include "WeatherRouting.h"

#include <algorithm>

ConfigurationDialog::ConfigurationDialog(WeatherRouting& weatherrouting)
#ifndef __WXOSX__
    : ConfigurationDialogBase(&weatherrouting),
#else
    : ConfigurationDialogBase(&weatherrouting, wxID_ANY,
                              _("Weather Routing Configuration"),
                              wxDefaultPosition, wxDefaultSize,
                              wxDEFAULT_DIALOG_STYLE | wxSTAY_ON_TOP),
#endif
      m_WeatherRouting(weatherrouting),
      m_bBlockUpdate(false) {
  wxFileConfig* pConf = GetOCPNConfigObject();
  pConf->SetPath(_T( "/PlugIns/WeatherRouting" ));

#ifdef __OCPN__ANDROID__
  wxSize sz = ::wxGetDisplaySize();
  SetSize(0, 0, sz.x, sz.y - 40);
#else
  wxPoint p = GetPosition();
  pConf->Read(_T ( "ConfigurationX" ), &p.x, p.x);
  pConf->Read(_T ( "ConfigurationY" ), &p.y, p.y);
  SetPosition(p);
#endif
}

ConfigurationDialog::~ConfigurationDialog() {
  wxFileConfig* pConf = GetOCPNConfigObject();
  pConf->SetPath(_T( "/PlugIns/WeatherRouting" ));

  wxPoint p = GetPosition();
  pConf->Write(_T ( "ConfigurationX" ), p.x);
  pConf->Write(_T ( "ConfigurationY" ), p.y);
}

void ConfigurationDialog::EditBoat() {
  m_WeatherRouting.m_BoatDialog.LoadPolar(m_tBoat->GetValue());
  m_WeatherRouting.m_BoatDialog.Show();
}
void ConfigurationDialog::OnGribTime(wxCommandEvent& event) {
  SetStartDateTime(m_GribTimelineTime);
  Update();
}

void ConfigurationDialog::OnCurrentTime(wxCommandEvent& event) {
  SetStartDateTime(wxDateTime::Now());  // Local time converted to UTC
  Update();
}

void ConfigurationDialog::OnUseCurrentTime(wxCommandEvent& event) {
  m_dpStartDate->Enable(!m_cbUseCurrentTime->IsChecked());
  m_tpTime->Enable(!m_cbUseCurrentTime->IsChecked());
  m_bGribTime->Enable(!m_cbUseCurrentTime->IsChecked());
  m_bCurrentTime->Enable(!m_cbUseCurrentTime->IsChecked());
  Update();
}

void ConfigurationDialog::OnStartFromBoat(wxCommandEvent& event) {
  m_cStart->Enable(!m_rbStartFromBoat->GetValue());
  Update();
}

void ConfigurationDialog::OnStartFromPosition(wxCommandEvent& event) {
  AddPositions(true);
  m_cStart->Enable(m_rbStartPositionSelection->GetValue());
  Update();
}

void ConfigurationDialog::OnStartFromWaypoint(wxCommandEvent& event) {
  AddWaypoints(true);
  m_cStart->Enable(m_rbStartWaypointSelection->GetValue());
  Update();
}

void ConfigurationDialog::OnEndAtPosition(wxCommandEvent& event) {
  AddPositions(false);
  m_cStart->Enable(m_rbStartPositionSelection->GetValue());
  Update();
}

void ConfigurationDialog::OnEndAtWaypoint(wxCommandEvent& event) {
  AddWaypoints(false);
  m_cStart->Enable(m_rbStartWaypointSelection->GetValue());
  Update();
}

void ConfigurationDialog::OnAvoidCyclones(wxCommandEvent& event) { Update(); }

void ConfigurationDialog::OnUseMotor(wxCommandEvent& event) {
  // Enable/disable motor controls based on checkbox state
  bool useMotor = m_cbUseMotor->IsChecked();
  m_sMotorSpeedThreshold->Enable(useMotor);
  m_sMotorSpeed->Enable(useMotor);
  Update();
}

void ConfigurationDialog::OnUseOptimalAngles(wxCommandEvent& event) {
    bool use_optimal_angles = m_cbUseOptimalAngles->IsChecked();
    if (use_optimal_angles) {
        m_sFromDegree->SetValue(0.0);
        m_sToDegree->SetValue(180.0);
        m_edited_controls.push_back(m_sFromDegree);
        m_edited_controls.push_back(m_sToDegree);
    }
    m_sFromDegree->Enable(!use_optimal_angles);
    m_sToDegree->Enable(!use_optimal_angles);
    Update();
}

void ConfigurationDialog::OnBoatFilename(wxCommandEvent& event) {
  wxFileDialog openDialog(
      this, _("Select Boat File"), wxFileName(m_tBoat->GetValue()).GetPath(),
      wxT(""), wxT("xml (*.xml)|*.XML;*.xml|All files (*.*)|*.*"), wxFD_OPEN);

  if (openDialog.ShowModal() == wxID_OK) SetBoatFilename(openDialog.GetPath());
}

// --- Macros for filling controls from configurations --------------------------------
// Control helper used by many SET_* macros
#define SET_CONTROL_VALUE(VALUE, CONTROL, SETTER, TYPE, NULLVALUE)          \
  do {                                                                      \
    bool allsame = true;                                                    \
    std::list<RouteMapConfiguration>::iterator it = configurations.begin(); \
    TYPE value = VALUE;                                                     \
    for (it++; it != configurations.end(); ++it) {                          \
      if (value != VALUE) {                                                 \
        allsame = false;                                                    \
        break;                                                              \
      }                                                                     \
    }                                                                       \
    CONTROL->SETTER(allsame ? value : NULLVALUE);                           \
    wxSize s(CONTROL->GetSize());                                           \
    if (allsame)                                                            \
      CONTROL->SetForegroundColour(wxColour(0, 0, 0));                      \
    else                                                                    \
      CONTROL->SetForegroundColour(wxColour(180, 180, 180));                \
    CONTROL->Fit();                                                         \
    CONTROL->SetSize(s);                                                    \
  } while (0)

#define SET_CONTROL(FIELD, CONTROL, SETTER, TYPE, NULLVALUE) \
  SET_CONTROL_VALUE((*it).FIELD, CONTROL, SETTER, TYPE, NULLVALUE)

#define SET_CHOICE_VALUE(FIELD, VALUE)                                        \
  do {                                                                        \
    bool allsame = true;                                                      \
    std::list<RouteMapConfiguration>::iterator it = configurations.begin();   \
    wxString value = VALUE;                                                   \
    for (it++; it != configurations.end(); ++it) {                            \
      if (value != VALUE) {                                                   \
        allsame = false;                                                      \
        break;                                                                \
      }                                                                       \
    }                                                                         \
    if (allsame)                                                              \
      m_c##FIELD->SetValue(value);                                            \
    else {                                                                    \
      if (m_c##FIELD->GetString(m_c##FIELD->GetCount() - 1) != wxEmptyString) \
        m_c##FIELD->Append(wxEmptyString);                                    \
      m_c##FIELD->SetValue(wxEmptyString);                                    \
    }                                                                         \
  } while (0)

#define SET_CHOICE(FIELD) SET_CHOICE_VALUE(FIELD, (*it).FIELD)

#define SET_SPIN_VALUE(FIELD, VALUE) \
  SET_CONTROL_VALUE(VALUE, m_s##FIELD, SetValue, int, value)

#define SET_SPIN(FIELD) SET_SPIN_VALUE(FIELD, (*it).FIELD)

#define SET_SPIN_DOUBLE_VALUE(FIELD, VALUE) \
  SET_CONTROL_VALUE(VALUE, m_s##FIELD, SetValue, double, value)

#define SET_SPIN_DOUBLE(FIELD) SET_SPIN_DOUBLE_VALUE(FIELD, (*it).FIELD)

// Safer checkbox macros: use internal wr_cfg loop and safe fallback for 2-state
#define SET_CHECKBOX_FIELD(FIELD, VALUE_EXPR)                             \
  do {                                                                    \
    bool wr_alltrue = true, wr_allfalse = true;                           \
    for (const auto& wr_cfg : configurations) {                           \
      if (VALUE_EXPR)                                                      \
        wr_allfalse = false;                                               \
      else                                                                 \
        wr_alltrue = false;                                                \
    }                                                                      \
    wxCheckBox* cb = m_cb##FIELD;                                          \
    if ( cb && cb->Is3State() ) {                                          \
      cb->Set3StateValue(wr_alltrue ? wxCHK_CHECKED                        \
                         : wr_allfalse ? wxCHK_UNCHECKED                   \
                                       : wxCHK_UNDETERMINED);              \
    } else if ( cb ) {                                                     \
      /* 2-state fallback: if unanimous keep value, otherwise choose false */\
      if (wr_alltrue) cb->SetValue(true);                                  \
      else cb->SetValue(false);                                            \
    }                                                                      \
  } while (0)

#define SET_CHECKBOX(FIELD) SET_CHECKBOX_FIELD(FIELD, wr_cfg.FIELD)

#define GET_CHECKBOX(FIELD)                                                 \
  do {                                                                       \
    wxCheckBox* cb = m_cb##FIELD;                                            \
    if (cb && cb->Is3State()) {                                              \
      wxCheckBoxState wr_st = cb->Get3StateValue();                          \
      if (wr_st == wxCHK_UNCHECKED)                                          \
        configuration.FIELD = false;                                         \
      else if (wr_st == wxCHK_CHECKED)                                       \
        configuration.FIELD = true;                                          \
      /* UNDETERMINED: leave configuration.FIELD unchanged */                \
    } else if (cb) {                                                         \
      /* 2-state checkbox: use boolean value */                              \
      configuration.FIELD = cb->GetValue();                                  \
    }                                                                        \
  } while (0)

#ifdef __OCPN__ANDROID__
#define NO_EDITED_CONTROLS 1
#else
#define NO_EDITED_CONTROLS 0
#endif
// ---------------------------------------------------------------------------------

void ConfigurationDialog::SetConfigurations(
    std::list<RouteMapConfiguration> configurations) {
  m_bBlockUpdate = true;

  m_edited_controls.clear();

  //-----------

  // Keep original behaviour for multi-selection fields
  SET_CHOICE(Start);

  // If there are no configurations, nothing to populate - bail out safely.
  if (configurations.empty()) {
    m_bBlockUpdate = false;
    return;
  }

  // Create iterator used by the existing macros that expect (*it)
  std::list<RouteMapConfiguration>::iterator it = configurations.begin();

  const bool ult =
      m_WeatherRouting.m_SettingsDialog.m_cbUseLocalTime->IsChecked();

  // Populate date/time from the first configuration safely
  if (it != configurations.end()) {
    // Date part: only set if valid (avoid MSW assert), otherwise set "none"
    // only when the control supports wxDP_ALLOWNONE
    wxDateTime dateVal = it->StartTime.GetDateOnly();  // No conversion here
    wxSize s(m_dpStartDate->GetSize());
    if (dateVal.IsValid()) {
      // SetValue() assumes dateVal is UTC and converts to local time for GUI
      if (!ult) dateVal = dateVal.ToUTC();  // Undo the FromUTC() in SetValue()
      m_dpStartDate->SetValue(dateVal);
      m_dpStartDate->SetForegroundColour(wxColour(0, 0, 0));
    } else if (m_dpStartDate->GetWindowStyle() & wxDP_ALLOWNONE) {
      m_dpStartDate->SetValue(wxDefaultDateTime);
      m_dpStartDate->SetForegroundColour(wxColour(180, 180, 180));
    }  // else leave control unchanged
    m_dpStartDate->Fit();
    m_dpStartDate->SetSize(s);

    // Time part: only set if valid (time control usually requires a valid
    // value)
    wxDateTime timeVal = it->StartTime;
    wxSize s2(m_tpTime->GetSize());
    if (timeVal.IsValid()) {
      // SetValue() assumes timeVal is UTC and converts to local time for GUI
      if (!ult) timeVal = timeVal.ToUTC();  // Undo the FromUTC() in SetValue()
      m_tpTime->SetValue(timeVal);
      m_tpTime->SetForegroundColour(wxColour(0, 0, 0));
    }  // else leave control unchanged
    m_tpTime->Fit();
    m_tpTime->SetSize(s2);
  }

// -------------

  SET_CHECKBOX(UseCurrentTime);

  bool timeButtonsEnabled = m_tpTime->IsEnabled() &&
                            m_dpStartDate->IsEnabled() &&
                            !m_cbUseCurrentTime->IsChecked();
  m_dpStartDate->Enable(timeButtonsEnabled);
  m_tpTime->Enable(timeButtonsEnabled);
  m_bCurrentTime->Enable(timeButtonsEnabled);
  m_bGribTime->Enable(timeButtonsEnabled);

  SET_SPIN_VALUE(TimeStepHours, (int)((*it).DeltaTime / 3600));
  SET_SPIN_VALUE(TimeStepMinutes, ((int)(*it).DeltaTime / 60) % 60);

  SET_CONTROL(boatFileName, m_tBoat, SetValue, wxString, _T(""));
  long l = m_tBoat->GetValue().Length();
  m_tBoat->SetSelection(l, l);

  SET_CHOICE(End);

  // if there's a Route GUID it's an OpenCPN route, in that case disable start
  // and end.
  bool oRoute = false;
  bool allStartFromBoat = true;
  bool allStartFromPosition = true;
  for (auto it : configurations) {
    if (!it.RouteGUID.IsEmpty()) {
      oRoute = true;
      break;
    }
    if (it.StartType != RouteMapConfiguration::START_FROM_BOAT)
      allStartFromBoat = false;
    if (it.StartType != RouteMapConfiguration::START_FROM_POSITION)
      allStartFromPosition = false;
  }
  m_rbStartFromBoat->Enable(!oRoute);
  m_rbStartPositionSelection->Enable(!oRoute);
  m_rbStartFromBoat->SetValue(allStartFromBoat);
  m_rbStartPositionSelection->SetValue(allStartFromPosition);

  if (!oRoute && !m_rbStartFromBoat->GetValue()) {
    bool isPosition = false;
    for (const auto& p : RouteMap::Positions) {
      if (p.Name == it->Start) {
        isPosition = true;
        break;
      }
    }
    isPosition ? AddPositions(true) : AddWaypoints(true);
    m_rbStartPositionSelection->SetValue(isPosition);
    m_rbStartWaypointSelection->SetValue(!isPosition);
    m_cStart->SetValue(it->Start);
    m_cStart->Enable(true);
  } else
    m_cStart->Enable(false);

  if (!oRoute) {
    bool isPosition = false;
    std::cout << "INIT Searching for " << it->End << std::endl;
    for (const auto& p : RouteMap::Positions) {
      if (p.Name == it->End) {
        isPosition = true;
        break;
      }
    }
    isPosition ? AddPositions(false) : AddWaypoints(false);
    m_rbEndPositionSelection->SetValue(isPosition);
    m_rbEndWaypointSelection->SetValue(!isPosition);
    m_cEnd->SetValue(it->End);
    m_cEnd->Enable(true);
  } else
    m_cEnd->Enable(false);

  m_bGribTime->Enable(!m_cbUseCurrentTime->IsChecked());
  m_bCurrentTime->Enable(!m_cbUseCurrentTime->IsChecked());
  m_dpStartDate->Enable(!m_cbUseCurrentTime->IsChecked());
  m_tpTime->Enable(!m_cbUseCurrentTime->IsChecked());

  SET_SPIN(FromDegree);
  SET_SPIN(ToDegree);
  SET_CHECKBOX(UseOptimalAngles);
  // Enable/disable degree controls based on checkbox state
  m_sFromDegree->Enable(!m_cbUseOptimalAngles->IsChecked());
  m_sToDegree->Enable(!m_cbUseOptimalAngles->IsChecked());
  SET_SPIN_DOUBLE(ByDegrees);

  // Motor settings
  SET_CHECKBOX(UseMotor);
  SET_SPIN_DOUBLE_VALUE(MotorSpeedThreshold, (*it).MotorSpeedThreshold);
  SET_SPIN_DOUBLE_VALUE(MotorSpeed, (*it).MotorSpeed);

  // Enable/disable motor controls based on checkbox state
  bool motorEnabled = m_cbUseMotor->IsChecked();
  m_sMotorSpeedThreshold->Enable(motorEnabled);
  m_sMotorSpeed->Enable(motorEnabled);

  SET_CHOICE_VALUE(Integrator,
                   ((*it).Integrator == RouteMapConfiguration::RUNGE_KUTTA
                        ? _T("Runge Kutta")
                        : _T("Newton")));

  SET_SPIN(MaxDivertedCourse);
  SET_SPIN(MaxCourseAngle);
  SET_SPIN(MaxSearchAngle);
  SET_SPIN(MaxTrueWindKnots);
  SET_SPIN(MaxApparentWindKnots);

  SET_SPIN_DOUBLE(MaxSwellMeters);
  SET_SPIN(MaxLatitude);
  SET_SPIN(TackingTime);
  SET_SPIN(JibingTime);
  SET_SPIN(SailPlanChangeTime);
  SET_SPIN(WindVSCurrent);

  SET_CHECKBOX(AvoidCycloneTracks);
  SET_SPIN(CycloneMonths);
  SET_SPIN(CycloneDays);
  SET_SPIN_DOUBLE(SafetyMarginLand);

  SET_CHECKBOX(DetectLand);
  SET_CHECKBOX(DetectBoundary);
  SET_CHECKBOX(Currents);
  SET_CHECKBOX(OptimizeTacking);

  SET_CHECKBOX(InvertedRegions);
  SET_CHECKBOX(Anchoring);

  SET_CHECKBOX(UseGrib);
  SET_CONTROL(ClimatologyType, m_cClimatologyType, SetSelection, int, -1);
  SET_CHECKBOX(AllowDataDeficient);
  SET_SPIN_VALUE(WindStrength, (int)((*it).WindStrength * 100));

  SET_SPIN_VALUE(UpwindEfficiency, (int)((*it).UpwindEfficiency * 100));
  SET_SPIN_VALUE(DownwindEfficiency, (int)((*it).DownwindEfficiency * 100));
  SET_SPIN_VALUE(NightCumulativeEfficiency,
                 (int)((*it).NightCumulativeEfficiency * 100));

  m_bBlockUpdate = false;
}

void ConfigurationDialog::AddSource(wxString name) {
  m_cStart->Append(name);
  m_cEnd->Append(name);
}

void ConfigurationDialog::RemoveSource(wxString name) {
  int i = m_cStart->FindString(name, true);
  if (i >= 0) {
    m_cStart->Delete(i);
    m_cEnd->Delete(i);
  }
}

void ConfigurationDialog::ClearSources() {
  m_cStart->Clear();
  m_cEnd->Clear();
}

void ConfigurationDialog::AddWaypoints(const bool atStart) {
  wxComboBox* combobox = atStart ? m_cStart : m_cEnd;
  combobox->Clear();

  wxArrayString waypoint_guids = GetWaypointGUIDArray();
  for (const auto& guid : waypoint_guids)
    combobox->Append(GetWaypoint_Plugin(guid)->m_MarkName);
}

void ConfigurationDialog::AddPositions(const bool atStart) {
  wxComboBox* combobox = atStart ? m_cStart : m_cEnd;
  combobox->Clear();

  for (const auto& p : RouteMap::Positions) combobox->Append(p.Name);
}

void ConfigurationDialog::SetBoatFilename(wxString path) {
  m_tBoat->SetValue(path);
  long l = m_tBoat->GetValue().Length();
  m_tBoat->SetSelection(l, l);

  Update();
}

void ConfigurationDialog::OnResetAdvanced(wxCommandEvent& event) {
  m_bBlockUpdate = true;

  // constraints
  m_sMaxLatitude->SetValue(90);
  m_sWindVSCurrent->SetValue(0);
  m_sMaxCourseAngle->SetValue(180);
  m_sMaxSearchAngle->SetValue(120);
  m_cbAvoidCycloneTracks->SetValue(false);
  // XXX missing 2

  // Options
  m_cbInvertedRegions->SetValue(false);
  m_cbAnchoring->SetValue(false);
  m_cIntegrator->SetSelection(0);
  m_sWindStrength->SetValue(100);
  m_sUpwindEfficiency->SetValue(100);
  m_sDownwindEfficiency->SetValue(100);
  m_sNightCumulativeEfficiency->SetValue(100);
  m_sTackingTime->SetValue(0);
  m_sJibingTime->SetValue(0);
  m_sSailPlanChangeTime->SetValue(0);
  m_sSafetyMarginLand->SetValue(0.);

  m_sFromDegree->SetValue(0);
  m_sToDegree->SetValue(180);
  m_cbUseOptimalAngles->SetValue(false);
  m_sFromDegree->Enable(true);
  m_sToDegree->Enable(true);
  m_sByDegrees->SetValue(5.0);

  // Motor settings
  m_cbUseMotor->SetValue(false);
  m_sMotorSpeedThreshold->SetValue(2.0);
  m_sMotorSpeed->SetValue(5.0);
  m_sMotorSpeedThreshold->Enable(false);
  m_sMotorSpeed->Enable(false);

  m_bBlockUpdate = false;
  Update();
}

void ConfigurationDialog::SetStartDateTime(wxDateTime datetime) {
  // datetime is passed as UTC
  if (datetime.IsValid()) {
    // SetValue() for both pickers assumes that datetime is UTC and converts
    // to local time for display in the GUI
    if (!m_WeatherRouting.m_SettingsDialog.m_cbUseLocalTime->IsChecked())
      datetime = datetime.ToUTC();  // Undo the FromUTC() in SetValue()

    m_dpStartDate->SetValue(datetime);
    m_tpTime->SetValue(datetime);
    m_edited_controls.push_back(m_tpTime);
    m_edited_controls.push_back(m_dpStartDate);
  } else {
    wxMessageDialog mdlg(this, _("Invalid Date Time."),
                         wxString(_("Weather Routing"), wxOK | wxICON_WARNING));
    mdlg.ShowModal();
  }
}

#define GET_SPIN(FIELD)                                              \
  if (NO_EDITED_CONTROLS ||                                          \
      std::find(m_edited_controls.begin(), m_edited_controls.end(),  \
                (wxObject*)m_s##FIELD) != m_edited_controls.end()) { \
    configuration.FIELD = m_s##FIELD->GetValue();                    \
    m_s##FIELD->SetForegroundColour(wxColour(0, 0, 0));              \
  }

#define GET_CHOICE(FIELD)                                                     \
  if (NO_EDITED_CONTROLS ||                                                   \
      std::find(m_edited_controls.begin(), m_edited_controls.end(),           \
                (wxObject*)m_c##FIELD) != m_edited_controls.end())            \
    if (m_c##FIELD->GetValue() != wxEmptyString) {                            \
      configuration.FIELD = m_c##FIELD->GetValue();                           \
      if (m_c##FIELD->GetString(m_c##FIELD->GetCount() - 1) == wxEmptyString) \
        m_c##FIELD->Delete(m_c##FIELD->GetCount() - 1);                       \
    }
	

void ConfigurationDialog::Update() {
  if (m_bBlockUpdate) return;

  // Ensure the combobox is properly enabled/disabled based on radio button
  // selection
  m_cStart->Enable(!m_rbStartFromBoat->GetValue());

  bool refresh = false;
  RouteMapConfiguration configuration;
  std::list<RouteMapOverlay*> currentroutemaps =
      m_WeatherRouting.CurrentRouteMaps();
  for (std::list<RouteMapOverlay*>::iterator it = currentroutemaps.begin();
       it != currentroutemaps.end(); it++) {
    configuration = (*it)->GetConfiguration();

    // Set the start type based on the radio button selection
    if (m_rbStartFromBoat->GetValue()) {
      configuration.StartType = RouteMapConfiguration::START_FROM_BOAT;
    } else {
      configuration.StartType = RouteMapConfiguration::START_FROM_POSITION;
    }

    // Only get start position choice if not using boat position
    if (configuration.StartType == RouteMapConfiguration::START_FROM_POSITION)
      GET_CHOICE(Start);
    GET_CHOICE(End);

    GET_CHECKBOX(UseCurrentTime);

    if (NO_EDITED_CONTROLS ||
        std::find(m_edited_controls.begin(), m_edited_controls.end(),
                  (wxObject*)m_dpStartDate) != m_edited_controls.end() ||
        std::find(m_edited_controls.begin(), m_edited_controls.end(),
                  (wxObject*)m_tpTime) != m_edited_controls.end()) {
      if (!m_dpStartDate->GetDateCtrlValue().IsValid()) continue;

      /*
       * GetDateCtrlValue() and GetTimeCtrlValue() assume that the entered time
       * is local time and convert to UTC for internal storage
       * GetHour() etc. convert internal UTC value to local time
       * wxDateTime() constructor assumes input in local time and converts to
       * UTC for internal storage
       * Therefore we must undo one ToUTC() conversion if the GUI option has
       * been set to use UTC
       * Note: There will be one hour error if the switch to/from DST happens
       * in between these calls
       * Note: GetTimeCtrlValue() sets the date part to Jan 1st of the current
       *       year, therefore calling ToUTC() on it is not DST-safe
       */
      wxDateTime ctrl_date = m_dpStartDate->GetDateCtrlValue();
      wxDateTime ctrl_time = m_tpTime->GetTimeCtrlValue();
      wxDateTime time(ctrl_date.GetDay(), ctrl_date.GetMonth(),
                      ctrl_date.GetYear(), ctrl_time.GetHour(),
                      ctrl_time.GetMinute(), ctrl_time.GetSecond());
      if (!time.IsValid())
        time = wxDateTime::Now();  // Local time converted to UTC
      else if (!m_WeatherRouting.m_SettingsDialog.m_cbUseLocalTime->IsChecked())
        time = time.FromUTC();  // Undo extra conversion

      configuration.StartTime = time;

      if (std::find(m_edited_controls.begin(), m_edited_controls.end(),
                    (wxObject*)m_dpStartDate) != m_edited_controls.end())
        m_dpStartDate->SetForegroundColour(wxColour(0, 0, 0));
      else if (std::find(m_edited_controls.begin(), m_edited_controls.end(),
                         (wxObject*)m_tpTime) != m_edited_controls.end())
        m_tpTime->SetForegroundColour(wxColour(0, 0, 0));
    }

    if (!m_tBoat->GetValue().empty()) {
      configuration.boatFileName = m_tBoat->GetValue();
      m_tBoat->SetForegroundColour(wxColour(0, 0, 0));
    }

    if (NO_EDITED_CONTROLS ||
        std::find(m_edited_controls.begin(), m_edited_controls.end(),
                  (wxObject*)m_sTimeStepHours) != m_edited_controls.end() ||
        std::find(m_edited_controls.begin(), m_edited_controls.end(),
                  (wxObject*)m_sTimeStepMinutes) != m_edited_controls.end()) {
      configuration.DeltaTime = 60 * (60 * m_sTimeStepHours->GetValue() +
                                      m_sTimeStepMinutes->GetValue());
      m_sTimeStepHours->SetForegroundColour(wxColour(0, 0, 0));
      m_sTimeStepMinutes->SetForegroundColour(wxColour(0, 0, 0));
    }

    if (m_cIntegrator->GetValue() == _T("Newton"))
      configuration.Integrator = RouteMapConfiguration::NEWTON;
    else if (m_cIntegrator->GetValue() == _T("Runge Kutta"))
      configuration.Integrator = RouteMapConfiguration::RUNGE_KUTTA;

    GET_SPIN(MaxDivertedCourse);
    GET_SPIN(MaxCourseAngle);
    GET_SPIN(MaxSearchAngle);
    GET_SPIN(MaxTrueWindKnots);
    GET_SPIN(MaxApparentWindKnots);

    GET_SPIN(MaxSwellMeters);
    GET_SPIN(MaxLatitude);
    GET_SPIN(TackingTime);
    GET_SPIN(JibingTime);
    GET_SPIN(SailPlanChangeTime);
    GET_SPIN(WindVSCurrent);

    if (m_sWindStrength->IsEnabled())
      configuration.WindStrength = m_sWindStrength->GetValue() / 100.0;

    if (m_sUpwindEfficiency->IsEnabled())
      configuration.UpwindEfficiency = m_sUpwindEfficiency->GetValue() / 100.0;
    if (m_sDownwindEfficiency->IsEnabled())
      configuration.DownwindEfficiency =
          m_sDownwindEfficiency->GetValue() / 100.0;
    if (m_sNightCumulativeEfficiency->IsEnabled())
      configuration.NightCumulativeEfficiency =
          m_sNightCumulativeEfficiency->GetValue() / 100.0;

    GET_CHECKBOX(AvoidCycloneTracks);
    GET_SPIN(CycloneMonths);
    GET_SPIN(CycloneDays);
    GET_SPIN(SafetyMarginLand);

    GET_CHECKBOX(DetectLand);
    GET_CHECKBOX(DetectBoundary);
    GET_CHECKBOX(Currents);
    GET_CHECKBOX(OptimizeTacking);

    GET_CHECKBOX(InvertedRegions);
    GET_CHECKBOX(Anchoring);

    GET_CHECKBOX(UseGrib);
    if (m_cClimatologyType->GetSelection() != -1)
      configuration.ClimatologyType =
          (RouteMapConfiguration::ClimatologyDataType)
              m_cClimatologyType->GetSelection();
    GET_CHECKBOX(AllowDataDeficient);
    if (m_sWindStrength->IsEnabled())
      configuration.WindStrength = m_sWindStrength->GetValue() / 100.0;

    GET_SPIN(FromDegree);
    GET_SPIN(ToDegree);
    GET_CHECKBOX(UseOptimalAngles);
    GET_SPIN(ByDegrees);

    // Motor settings
    GET_CHECKBOX(UseMotor);
    if (NO_EDITED_CONTROLS ||
        std::find(m_edited_controls.begin(), m_edited_controls.end(),
                  (wxObject*)m_sMotorSpeedThreshold) !=
            m_edited_controls.end()) {
      configuration.MotorSpeedThreshold = m_sMotorSpeedThreshold->GetValue();
      m_sMotorSpeedThreshold->SetForegroundColour(wxColour(0, 0, 0));
    }
    if (NO_EDITED_CONTROLS ||
        std::find(m_edited_controls.begin(), m_edited_controls.end(),
                  (wxObject*)m_sMotorSpeed) != m_edited_controls.end()) {
      configuration.MotorSpeed = m_sMotorSpeed->GetValue();
      m_sMotorSpeed->SetForegroundColour(wxColour(0, 0, 0));
    }

    (*it)->SetConfiguration(configuration);

    /* if the start position changed, we must reset the route */
    RouteMapConfiguration newc = (*it)->GetConfiguration();
    if (newc.StartLat != configuration.StartLat ||
        newc.StartLon != configuration.StartLon) {
      (*it)->Reset();
      refresh = true;
    } else if (newc.EndLat != configuration.EndLat ||
               newc.EndLon != configuration.EndLon)
      refresh = true;  // update drawing
  }

  double by = m_sByDegrees->GetValue();
  if (m_sToDegree->GetValue() - m_sFromDegree->GetValue() < 2 * by) {
    wxMessageDialog mdlg(
        this, _("Warning: less than 4 different degree steps specified\n"),
        wxString(_("Weather Routing"), wxOK | wxICON_WARNING));
    mdlg.ShowModal();
  }

  m_WeatherRouting.UpdateCurrentConfigurations();

  if (refresh) m_WeatherRouting.GetParent()->Refresh();

  // Schedule auto-save to persist any configuration changes
  m_WeatherRouting.ScheduleAutoSave();
}