grib_pi.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by David S. Register                               *
 *                                                                         *
 *   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 2 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, see <https://www.gnu.org/licenses/>. *
 ***************************************************************************/
 
#include "wx/wxprec.h"
 
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
 
#include "pi_gl.h"
 
#ifdef ocpnUSE_GL
#include <wx/glcanvas.h>
#endif
 
#include <wx/fileconf.h>
#include <wx/stdpaths.h>
 
#include "grib_pi.h"
 
#include "jsonwriter.h"
 
#ifdef __WXQT__
#include "qdebug.h"
#endif
 
double g_ContentScaleFactor;
 
// the class factories, used to create and destroy instances of the PlugIn
 
extern "C" DECL_EXP opencpn_plugin *create_pi(void *ppimgr) {
  return new GribPi(ppimgr);
}
 
extern "C" DECL_EXP void destroy_pi(opencpn_plugin *p) { delete p; }
 
extern int m_DialogStyle;
 
GribPi *g_pi;
bool g_bpause;
 
//---------------------------------------------------------------------------------------------------------
//
//    Grib PlugIn Implementation
//
//---------------------------------------------------------------------------------------------------------
 
#include "icons.h"
 
//---------------------------------------------------------------------------------------------------------
//
//          PlugIn initialization and de-init
//
//---------------------------------------------------------------------------------------------------------
 
GribPi::GribPi(void *ppimgr) : opencpn_plugin_116(ppimgr) {
  // Create the PlugIn icons
  initialize_images();
 
  wxString shareLocn = *GetpSharedDataLocation() + "plugins" +
                       wxFileName::GetPathSeparator() + "grib_pi" +
                       wxFileName::GetPathSeparator() + "data" +
                       wxFileName::GetPathSeparator();
  wxImage panelIcon(shareLocn + "grib_panel_icon.png");
  if (panelIcon.IsOk())
    m_panelBitmap = wxBitmap(panelIcon);
  else
    wxLogMessage("    GRIB panel icon NOT loaded");
 
  m_pLastTimelineSet = nullptr;
  m_bShowGrib = false;
  m_GUIScaleFactor = -1.;
  g_pi = this;
}
 
GribPi::~GribPi() {
  delete _img_grib_pi;
  delete _img_grib;
  delete m_pLastTimelineSet;
}
 
int GribPi::Init() {
  AddLocaleCatalog("opencpn-grib_pi");
 
  // Set some default private member parameters
  m_CtrlBarxy = wxPoint(0, 0);
  m_CursorDataxy = wxPoint(0, 0);
 
  m_pGribCtrlBar = nullptr;
  m_pGRIBOverlayFactory = nullptr;
 
  ::wxDisplaySize(&m_display_width, &m_display_height);
 
  m_DialogStyleChanged = false;
 
  //    Get a pointer to the opencpn configuration object
  m_pconfig = GetOCPNConfigObject();
 
  //    And load the configuration items
  LoadConfig();
 
  // Get a pointer to the opencpn display canvas, to use as a parent for the
  // GRIB dialog
  m_parent_window = GetOCPNCanvasWindow();
 
  g_ContentScaleFactor = m_parent_window->GetContentScaleFactor();
 
  //      int m_height = GetChartbarHeight();
  //    This PlugIn needs a CtrlBar icon, so request its insertion if enabled
  //    locally
  wxString shareLocn = *GetpSharedDataLocation() + "plugins" +
                       wxFileName::GetPathSeparator() + "grib_pi" +
                       wxFileName::GetPathSeparator() + "data" +
                       wxFileName::GetPathSeparator();
  // Initialize catalog file
  wxString local_grib_catalog = "sources.json";
  wxString data_path = *GetpPrivateApplicationDataLocation() +
                       wxFileName::GetPathSeparator() + "grib_pi";
  if (!wxDirExists(data_path)) {
    wxMkdir(data_path);
  }
  m_local_sources_catalog =
      data_path + wxFileName::GetPathSeparator() + local_grib_catalog;
  if (!wxFileExists(m_local_sources_catalog)) {
    wxCopyFile(shareLocn + local_grib_catalog, m_local_sources_catalog);
  }
  if (m_bGRIBShowIcon) {
    wxString normalIcon = shareLocn + "grib.svg";
    wxString toggledIcon = shareLocn + "grib_toggled.svg";
    wxString rolloverIcon = shareLocn + "grib_rollover.svg";
 
    //  For journeyman styles, we prefer the built-in raster icons which match
    //  the rest of the toolbar.
    if (GetActiveStyleName().Lower() != "traditional") {
      normalIcon = "";
      toggledIcon = "";
      rolloverIcon = "";
    }
 
    wxLogMessage(normalIcon);
    m_leftclick_tool_id = InsertPlugInToolSVG(
        "", normalIcon, rolloverIcon, toggledIcon, wxITEM_CHECK, _("Grib"), "",
        nullptr, GRIB_TOOL_POSITION, 0, this);
  }
 
  if (!QualifyCtrlBarPosition(m_CtrlBarxy, m_CtrlBar_Sizexy)) {
    m_CtrlBarxy = wxPoint(20, 60);  // reset to the default position
    m_CursorDataxy = wxPoint(20, 170);
  }
 
  return (WANTS_OVERLAY_CALLBACK | WANTS_OPENGL_OVERLAY_CALLBACK |
          WANTS_CURSOR_LATLON | WANTS_TOOLBAR_CALLBACK | INSTALLS_TOOLBAR_TOOL |
          WANTS_CONFIG | WANTS_PREFERENCES | WANTS_PLUGIN_MESSAGING |
          WANTS_ONPAINT_VIEWPORT | WANTS_MOUSE_EVENTS | WANTS_NMEA_EVENTS);
}
 
bool GribPi::DeInit() {
  // Reset timeline to system time before shutting down
  SendTimelineMessage(wxInvalidDateTime);
 
  if (m_pGribCtrlBar) {
    m_pGribCtrlBar->Close();
    delete m_pGribCtrlBar;
    m_pGribCtrlBar = nullptr;
  }
 
  delete m_pGRIBOverlayFactory;
  m_pGRIBOverlayFactory = nullptr;
 
  return true;
}
 
int GribPi::GetAPIVersionMajor() { return MY_API_VERSION_MAJOR; }
 
int GribPi::GetAPIVersionMinor() { return MY_API_VERSION_MINOR; }
 
int GribPi::GetPlugInVersionMajor() { return PLUGIN_VERSION_MAJOR; }
 
int GribPi::GetPlugInVersionMinor() { return PLUGIN_VERSION_MINOR; }
 
wxBitmap *GribPi::GetPlugInBitmap() { return &m_panelBitmap; }
 
wxString GribPi::GetCommonName() { return "GRIB"; }
 
wxString GribPi::GetShortDescription() { return _("GRIB PlugIn for OpenCPN"); }
 
wxString GribPi::GetLongDescription() {
  return _(
      "GRIB PlugIn for OpenCPN\n\
Provides basic GRIB file overlay capabilities for several GRIB file types\n\
and a request function to get GRIB files by eMail.\n\n\
Supported GRIB data include:\n\
- wind direction and speed (at 10 m)\n\
- wind gust\n\
- surface pressure\n\
- rainfall\n\
- cloud cover\n\
- significant wave height and direction\n\
- air surface temperature (at 2 m)\n\
- sea surface temperature\n\
- surface current direction and speed\n\
- Convective Available Potential Energy (CAPE)\n\
- wind, altitude, temperature and relative humidity at 300, 500, 700, 850 hPa.");
}
 
void GribPi::SetDefaults() {}
 
int GribPi::GetToolBarToolCount() { return 1; }
 
bool GribPi::MouseEventHook(wxMouseEvent &event) {
  if ((m_pGribCtrlBar && m_pGribCtrlBar->pReq_Dialog))
    return m_pGribCtrlBar->pReq_Dialog->MouseEventHook(event);
  return false;
}
 
void GribPi::ShowPreferencesDialog(wxWindow *parent) {
  auto *Pref = new GribPreferencesDialog(parent);
 
  DimeWindow(Pref);     // aplly global colours scheme
  SetDialogFont(Pref);  // Apply global font
 
  Pref->m_cbUseHiDef->SetValue(m_bGRIBUseHiDef);
  Pref->m_cbUseGradualColors->SetValue(m_bGRIBUseGradualColors);
  Pref->m_cbDrawBarbedArrowHead->SetValue(m_bDrawBarbedArrowHead);
  Pref->m_cZoomToCenterAtInit->SetValue(m_bZoomToCenterAtInit);
  Pref->m_cbCopyFirstCumulativeRecord->SetValue(m_bCopyFirstCumRec);
  Pref->m_cbCopyMissingWaveRecord->SetValue(m_bCopyMissWaveRec);
  Pref->m_rbLoadOptions->SetSelection(m_bLoadLastOpenFile);
  Pref->m_rbStartOptions->SetSelection(m_bStartOptions);
 
  if (Pref->m_textDirectory) {  // not present on Android
    wxFileConfig *pConf = GetOCPNConfigObject();
    if (pConf) {
      wxString l_grib_dir;
      pConf->SetPath("/Directories");
      pConf->Read("GRIBDirectory", &l_grib_dir);
      Pref->m_grib_dir_sel = l_grib_dir;
      Pref->m_textDirectory->ChangeValue(l_grib_dir);
    }
  }
 
#ifdef __WXMSW__
  int val = (m_GribIconsScaleFactor * 10.) - 10;
  Pref->m_sIconSizeFactor->SetValue(val);
#endif
 
#ifdef __ANDROID__
  if (m_parent_window) {
    int xmax = m_parent_window->GetSize().GetWidth();
    int ymax = m_parent_window->GetParent()
                   ->GetSize()
                   .GetHeight();  // This would be the Options dialog itself
    Pref->SetSize(xmax, ymax);
    Pref->Layout();
    Pref->Move(0, 0);
  }
  Pref->Show();
#else
  // Constrain size on small displays
 
  int display_width, display_height;
  wxDisplaySize(&display_width, &display_height);
  int char_width = GetOCPNCanvasWindow()->GetCharWidth();
  int char_height = GetOCPNCanvasWindow()->GetCharHeight();
  if (display_height < 600) {
    wxSize canvas_size = GetOCPNCanvasWindow()->GetSize();
    Pref->SetMaxSize(GetOCPNCanvasWindow()->GetSize());
    Pref->SetSize(wxSize(60 * char_width, canvas_size.x * 8 / 10));
    Pref->CentreOnScreen();
  } else {
    Pref->SetMaxSize(GetOCPNCanvasWindow()->GetSize());
    Pref->SetSize(wxSize(60 * char_width, 32 * char_height));
  }
 
  Pref->ShowModal();
#endif
}
 
void GribPi::UpdatePrefs(GribPreferencesDialog *Pref) {
  m_bGRIBUseHiDef = Pref->m_cbUseHiDef->GetValue();
  m_bGRIBUseGradualColors = Pref->m_cbUseGradualColors->GetValue();
  m_bLoadLastOpenFile = Pref->m_rbLoadOptions->GetSelection();
  m_bDrawBarbedArrowHead = Pref->m_cbDrawBarbedArrowHead->GetValue();
  m_bZoomToCenterAtInit = Pref->m_cZoomToCenterAtInit->GetValue();
#ifdef __WXMSW__
  double val = Pref->m_sIconSizeFactor->GetValue();
  m_GribIconsScaleFactor = 1. + (val / 10);
#endif
 
  if (m_pGRIBOverlayFactory)
    m_pGRIBOverlayFactory->SetSettings(m_bGRIBUseHiDef, m_bGRIBUseGradualColors,
                                       m_bDrawBarbedArrowHead);
 
  int updatelevel = 0;
 
  if (m_bStartOptions != Pref->m_rbStartOptions->GetSelection()) {
    m_bStartOptions = Pref->m_rbStartOptions->GetSelection();
    updatelevel = 1;
  }
 
  bool copyrec = Pref->m_cbCopyFirstCumulativeRecord->GetValue();
  bool copywave = Pref->m_cbCopyMissingWaveRecord->GetValue();
  if (m_bCopyFirstCumRec != copyrec || m_bCopyMissWaveRec != copywave) {
    m_bCopyFirstCumRec = copyrec;
    m_bCopyMissWaveRec = copywave;
    updatelevel = 3;
  }
 
  if (m_pGribCtrlBar) {
    switch (updatelevel) {
      case 0:
        break;
      case 3:
        // rebuild current activefile with new parameters and rebuil data list
        // with current index
        m_pGribCtrlBar->CreateActiveFileFromNames(
            m_pGribCtrlBar->m_bGRIBActiveFile->GetFileNames());
        m_pGribCtrlBar->PopulateComboDataList();
        m_pGribCtrlBar->TimelineChanged();
        break;
      case 2:
        // only rebuild  data list with current index and new timezone
        // This no longer applicable because the timezone is set in the
        // OpenCPN core global settings (Options -> Display -> General)
        m_pGribCtrlBar->PopulateComboDataList();
        m_pGribCtrlBar->TimelineChanged();
        break;
      case 1:
        // only re-compute the best forecast
        m_pGribCtrlBar->ComputeBestForecastForNow();
        break;
    }
    if (Pref->m_grib_dir_sel.Length()) {
      m_pGribCtrlBar->m_grib_dir = Pref->m_grib_dir_sel;
      m_pGribCtrlBar->m_file_names.Clear();
    }
  }
 
  if (Pref->m_grib_dir_sel.Length()) {
    wxFileConfig *pConf = GetOCPNConfigObject();
    if (pConf) {
      pConf->SetPath("/Directories");
      pConf->Write("GRIBDirectory", Pref->m_grib_dir_sel);
      pConf->DeleteGroup("/Settings/GRIB/FileNames");
      pConf->Flush();
    }
  }
  SaveConfig();
}
 
bool GribPi::QualifyCtrlBarPosition(
    wxPoint position,
    wxSize size) {  // Make sure drag bar (title bar) or grabber always screen
  bool b_reset_pos = false;
#ifdef __WXMSW__
  //  Support MultiMonitor setups which an allow negative window positions.
  //  If the requested window does not intersect any installed monitor,
  //  then default to simple primary monitor positioning.
  RECT frame_title_rect;
  frame_title_rect.left = position.x;
  frame_title_rect.top = position.y;
  frame_title_rect.right = position.x + size.x;
  frame_title_rect.bottom = m_DialogStyle == ATTACHED_HAS_CAPTION
                                ? position.y + 30
                                : position.y + size.y;
 
  if (nullptr == MonitorFromRect(&frame_title_rect, MONITOR_DEFAULTTONULL))
    b_reset_pos = true;
#else
  wxRect window_title_rect;  // conservative estimate
  window_title_rect.x = position.x;
  window_title_rect.y = position.y;
  window_title_rect.width = size.x;
  window_title_rect.height =
      m_DialogStyle == ATTACHED_HAS_CAPTION ? 30 : size.y;
 
  wxRect ClientRect = wxGetClientDisplayRect();
  if (!ClientRect.Intersects(window_title_rect)) b_reset_pos = true;
 
#endif
  return !b_reset_pos;
}
 
void GribPi::MoveDialog(wxDialog *dialog, wxPoint position) {
  //  Use the application frame to bound the control bar position.
  wxApp *app = wxTheApp;
 
  wxWindow *frame =
      app->GetTopWindow();  // or GetOCPNCanvasWindow()->GetParent();
  if (!frame) return;
 
  wxPoint p = frame->ScreenToClient(position);
  // Check and ensure there is always a "grabb" zone always visible wathever the
  // dialoue size is.
  if (p.x + dialog->GetSize().GetX() > frame->GetClientSize().GetX())
    p.x = frame->GetClientSize().GetX() - dialog->GetSize().GetX();
  if (p.y + dialog->GetSize().GetY() > frame->GetClientSize().GetY())
    p.y = frame->GetClientSize().GetY() - dialog->GetSize().GetY();
 
#ifdef __WXGTK__
  dialog->Move(0, 0);
#endif
  dialog->Move(frame->ClientToScreen(p));
}
 
void GribPi::OnToolbarToolCallback(int id) {
  // if( !::wxIsBusy() ) ::wxBeginBusyCursor();
 
  bool starting = false;
 
  double scale_factor =
      GetOCPNGUIToolScaleFactor_PlugIn() * OCPN_GetWinDIPScaleFactor();
#ifdef __WXMSW__
  scale_factor *= m_GribIconsScaleFactor;
#endif
  if (scale_factor != m_GUIScaleFactor) starting = true;
 
  if (!m_pGribCtrlBar) {
    starting = true;
    long style = m_DialogStyle == ATTACHED_HAS_CAPTION
                     ? wxCAPTION | wxCLOSE_BOX | wxSYSTEM_MENU
                     : wxBORDER_NONE | wxSYSTEM_MENU;
#ifdef __WXOSX__
    style |= wxSTAY_ON_TOP;
#endif
    m_pGribCtrlBar = new GRIBUICtrlBar(m_parent_window, wxID_ANY, wxEmptyString,
                                       wxDefaultPosition, wxDefaultSize, style,
                                       this, scale_factor);
    m_pGribCtrlBar->SetScaledBitmap(scale_factor);
 
    auto *dummy = new wxMenu("Plugin");
    auto *table = new wxMenuItem(dummy, wxID_ANY, wxString(_("Weather table")),
                                 wxEmptyString, wxITEM_NORMAL);
    /* Menu font do not work properly for MSW (wxWidgets 3.2.1)
    #ifdef __WXMSW__
        wxFont *qFont = OCPNGetFont(_("Menu"));
        table->SetFont(*qFont);
    #endif
    */
    m_MenuItem = AddCanvasContextMenuItem(table, this);
    SetCanvasContextMenuItemViz(m_MenuItem, false);
 
    // Create the drawing factory
    m_pGRIBOverlayFactory = new GRIBOverlayFactory(*m_pGribCtrlBar);
    m_pGRIBOverlayFactory->SetMessageFont();
    m_pGRIBOverlayFactory->SetParentSize(m_display_width, m_display_height);
    m_pGRIBOverlayFactory->SetSettings(m_bGRIBUseHiDef, m_bGRIBUseGradualColors,
                                       m_bDrawBarbedArrowHead);
 
    m_pGribCtrlBar->OpenFile(m_bLoadLastOpenFile == 0);
  }
 
  // Toggle GRIB overlay display
  if (id >= 0) m_bShowGrib = !m_bShowGrib;
 
  //    Toggle dialog?
  if (m_bShowGrib || id < 0) {
    // A new file could have been added since grib plugin opened
    if (!starting && m_bLoadLastOpenFile == 0) {
      m_pGribCtrlBar->OpenFile(true);
      starting = true;
    }
    // the dialog font could have been changed since grib plugin opened
    if (m_pGribCtrlBar->GetFont() != *OCPNGetFont(_("Dialog"))) starting = true;
    if (starting) {
      m_pGRIBOverlayFactory->SetMessageFont();
      SetDialogFont(m_pGribCtrlBar);
      m_GUIScaleFactor = scale_factor;
      m_pGribCtrlBar->SetScaledBitmap(m_GUIScaleFactor);
      m_pGribCtrlBar->SetDialogsStyleSizePosition(true);
      m_pGribCtrlBar->Refresh();
    } else {
      MoveDialog(m_pGribCtrlBar, GetCtrlBarXY());
      if (m_DialogStyle >> 1 == SEPARATED) {
        MoveDialog(m_pGribCtrlBar->GetCDataDialog(), GetCursorDataXY());
        m_pGribCtrlBar->GetCDataDialog()->Show(m_pGribCtrlBar->m_CDataIsShown);
      }
#ifdef __ANDROID__
      m_pGribCtrlBar->SetDialogsStyleSizePosition(true);
      m_pGribCtrlBar->Refresh();
#endif
    }
    if (id >= 0) m_pGribCtrlBar->Show();
    if (m_pGribCtrlBar->m_bGRIBActiveFile) {
      if (m_pGribCtrlBar->m_bGRIBActiveFile->IsOK()) {
        ArrayOfGribRecordSets *rsa =
            m_pGribCtrlBar->m_bGRIBActiveFile->GetRecordSetArrayPtr();
        if (rsa->GetCount() > 1) {
          SetCanvasContextMenuItemViz(m_MenuItem, true);
        }
        if (rsa->GetCount() >= 1) {  // XXX Should be only on Show
          SendTimelineMessage(m_pGribCtrlBar->TimelineTime());
        }
      }
    }
    // Toggle is handled by the CtrlBar but we must keep plugin manager b_toggle
    // updated to actual status to ensure correct status upon CtrlBar rebuild
    SetToolbarItemState(m_leftclick_tool_id, m_bShowGrib);
 
    // Do an automatic "zoom-to-center" on the overlay canvas if set in
    // Preferences
    if (m_pGribCtrlBar && m_bZoomToCenterAtInit) {
      m_pGribCtrlBar->DoZoomToCenter();
    }
 
    RequestRefresh(m_parent_window);  // refresh main window
  } else
    m_pGribCtrlBar->Close();
}
 
void GribPi::OnGribCtrlBarClose() {
  m_bShowGrib = false;
  SetToolbarItemState(m_leftclick_tool_id, m_bShowGrib);
 
  m_pGribCtrlBar->Hide();
 
  SaveConfig();
 
  SetCanvasContextMenuItemViz(m_MenuItem, false);
 
  RequestRefresh(m_parent_window);  // refresh main window
 
  if (::wxIsBusy()) ::wxEndBusyCursor();
 
#ifdef __ANDROID__
  m_DialogStyleChanged = true;  //  Force a delete of the control bar dialog
#endif
 
  if (m_DialogStyleChanged) {
    m_pGribCtrlBar->Destroy();
    m_pGribCtrlBar = nullptr;
    m_DialogStyleChanged = false;
  }
}
 
bool GribPi::RenderOverlay(wxDC &dc, PlugIn_ViewPort *vp) { return false; }
 
bool GribPi::DoRenderOverlay(wxDC &dc, PlugIn_ViewPort *vp, int canvasIndex) {
  if (!m_pGribCtrlBar || !m_pGribCtrlBar->IsShown() || !m_pGRIBOverlayFactory)
    return false;
 
  m_pGRIBOverlayFactory->RenderGribOverlay(dc, vp);
  if (PluginGetFocusCanvas() == GetCanvasByIndex(canvasIndex)) {
    m_pGribCtrlBar->SetViewPortWithFocus(vp);
  }
 
  if (GetCanvasByIndex(canvasIndex) == GetCanvasUnderMouse()) {
    m_pGribCtrlBar->SetViewPortUnderMouse(vp);
    if (m_pGribCtrlBar->pReq_Dialog &&
        GetCanvasIndexUnderMouse() ==
            m_pGribCtrlBar->pReq_Dialog->GetBoundingBoxCanvasIndex()) {
      m_pGribCtrlBar->pReq_Dialog->RenderZoneOverlay(dc);
    }
  }
  if (::wxIsBusy()) ::wxEndBusyCursor();
  return true;
}
 
bool GribPi::RenderGLOverlay(wxGLContext *pcontext, PlugIn_ViewPort *vp) {
  return false;
}
 
bool GribPi::DoRenderGLOverlay(wxGLContext *pcontext, PlugIn_ViewPort *vp,
                               int canvasIndex) {
  if (!m_pGribCtrlBar || !m_pGribCtrlBar->IsShown() || !m_pGRIBOverlayFactory)
    return false;
 
  m_pGRIBOverlayFactory->RenderGLGribOverlay(pcontext, vp);
  if (PluginGetFocusCanvas() == GetCanvasByIndex(canvasIndex)) {
    m_pGribCtrlBar->SetViewPortWithFocus(vp);
  }
 
  if (GetCanvasByIndex(canvasIndex) == GetCanvasUnderMouse()) {
    m_pGribCtrlBar->SetViewPortUnderMouse(vp);
    if (m_pGribCtrlBar->pReq_Dialog &&
        GetCanvasIndexUnderMouse() ==
            m_pGribCtrlBar->pReq_Dialog->GetBoundingBoxCanvasIndex()) {
      m_pGribCtrlBar->pReq_Dialog->RenderGlZoneOverlay();
    }
  }
 
  if (::wxIsBusy()) ::wxEndBusyCursor();
 
#ifdef __ANDROID__
  m_pGribCtrlBar->Raise();  // Control bar should always be visible
#endif
 
  return true;
}
 
bool GribPi::RenderGLOverlayMultiCanvas(wxGLContext *pcontext,
                                        PlugIn_ViewPort *vp, int canvasIndex) {
  return DoRenderGLOverlay(pcontext, vp, canvasIndex);
}
 
bool GribPi::RenderOverlayMultiCanvas(wxDC &dc, PlugIn_ViewPort *vp,
                                      int canvasIndex) {
  return DoRenderOverlay(dc, vp, canvasIndex);
}
 
void GribPi::SetCursorLatLon(double lat, double lon) {
  if (m_pGribCtrlBar && m_pGribCtrlBar->IsShown())
    m_pGribCtrlBar->SetCursorLatLon(lat, lon);
}
 
void GribPi::OnContextMenuItemCallback(int id) {
  if (!m_pGribCtrlBar->m_bGRIBActiveFile) return;
  m_pGribCtrlBar->ContextMenuItemCallback(id);
}
 
void GribPi::SetDialogFont(wxWindow *dialog, wxFont *font) {
  dialog->SetFont(*font);
  wxWindowList list = dialog->GetChildren();
  wxWindowListNode *node = list.GetFirst();
  for (size_t i = 0; i < list.GetCount(); i++) {
    wxWindow *win = node->GetData();
    win->SetFont(*font);
    node = node->GetNext();
  }
  dialog->Fit();
  dialog->Refresh();
}
 
void GribPi::SetPluginMessage(wxString &message_id, wxString &message_body) {
  if (message_id == "GRIB_VALUES_REQUEST") {
    if (!m_pGribCtrlBar) OnToolbarToolCallback(-1);
 
    // lat, lon, time, what
    wxJSONReader r;
    wxJSONValue v;
    r.Parse(message_body, &v);
    if (!v.HasMember("Day")) {
      // bogus or loading grib
      SendPluginMessage(wxString("GRIB_VALUES"), "");
      return;
    }
    wxDateTime time(v["Day"].AsInt(), (wxDateTime::Month)v["Month"].AsInt(),
                    v["Year"].AsInt(), v["Hour"].AsInt(), v["Minute"].AsInt(),
                    v["Second"].AsInt());
    double lat = v["lat"].AsDouble();
    double lon = v["lon"].AsDouble();
 
    if (m_pGribCtrlBar) {
      if (v.HasMember("WIND SPEED")) {
        double vkn, ang;
        if (m_pGribCtrlBar->getTimeInterpolatedValues(
                vkn, ang, Idx_WIND_VX, Idx_WIND_VY, lon, lat, time) &&
            vkn != GRIB_NOTDEF) {
          v["Type"] = wxString("Reply");
          v["WIND SPEED"] = vkn;
          v["WIND DIR"] = ang;
        } else {
          v.Remove("WIND SPEED");
          v.Remove("WIND DIR");
        }
      }
      if (v.HasMember("CURRENT SPEED")) {
        double vkn, ang;
        if (m_pGribCtrlBar->getTimeInterpolatedValues(
                vkn, ang, Idx_SEACURRENT_VX, Idx_SEACURRENT_VY, lon, lat,
                time) &&
            vkn != GRIB_NOTDEF) {
          v["Type"] = wxString("Reply");
          v["CURRENT SPEED"] = vkn;
          v["CURRENT DIR"] = ang;
        } else {
          v.Remove("CURRENT SPEED");
          v.Remove("CURRENT DIR");
        }
      }
      if (v.HasMember("GUST")) {
        double vkn = m_pGribCtrlBar->getTimeInterpolatedValue(Idx_WIND_GUST,
                                                              lon, lat, time);
        if (vkn != GRIB_NOTDEF) {
          v["Type"] = wxString("Reply");
          v["GUST"] = vkn;
        } else
          v.Remove("GUST");
      }
      if (v.HasMember("SWELL")) {
        double vkn = m_pGribCtrlBar->getTimeInterpolatedValue(Idx_HTSIGW, lon,
                                                              lat, time);
        if (vkn != GRIB_NOTDEF) {
          v["Type"] = wxString("Reply");
          v["SWELL"] = vkn;
        } else
          v.Remove("SWELL");
      }
 
      wxJSONWriter w;
      wxString out;
      w.Write(v, out);
      SendPluginMessage(wxString("GRIB_VALUES"), out);
    }
  } else if (message_id == "GRIB_VERSION_REQUEST") {
    wxJSONValue v;
    v["GribVersionMinor"] = GetAPIVersionMinor();
    v["GribVersionMajor"] = GetAPIVersionMajor();
 
    wxJSONWriter w;
    wxString out;
    w.Write(v, out);
    SendPluginMessage(wxString("GRIB_VERSION"), out);
  } else if (message_id == "GRIB_TIMELINE_REQUEST") {
    // local time
    SendTimelineMessage(m_pGribCtrlBar ? m_pGribCtrlBar->TimelineTime()
                                       : wxDateTime::Now());
  } else if (message_id == "GRIB_TIMELINE_RECORD_REQUEST") {
    wxJSONReader r;
    wxJSONValue v;
    r.Parse(message_body, &v);
    wxDateTime time(v["Day"].AsInt(), (wxDateTime::Month)v["Month"].AsInt(),
                    v["Year"].AsInt(), v["Hour"].AsInt(), v["Minute"].AsInt(),
                    v["Second"].AsInt());
 
    if (!m_pGribCtrlBar) OnToolbarToolCallback(-1);
 
    GribTimelineRecordSet *set =
        m_pGribCtrlBar ? m_pGribCtrlBar->GetTimeLineRecordSet(time) : nullptr;
 
    char ptr[64];
    snprintf(ptr, sizeof ptr, "%p", set);
 
    v["GribVersionMajor"] = PLUGIN_VERSION_MAJOR;
    v["GribVersionMinor"] = PLUGIN_VERSION_MINOR;
    v["TimelineSetPtr"] = wxString::From8BitData(ptr);
 
    wxJSONWriter w;
    wxString out;
    w.Write(v, out);
    SendPluginMessage(wxString("GRIB_TIMELINE_RECORD"), out);
    delete m_pLastTimelineSet;
    m_pLastTimelineSet = set;
  }
 
  else if (message_id == "GRIB_APPLY_JSON_CONFIG") {
    wxLogMessage("Got GRIB_APPLY_JSON_CONFIG");
 
    if (m_pGribCtrlBar) {
      m_pGribCtrlBar->OpenFileFromJSON(message_body);
 
      m_pGribCtrlBar->m_OverlaySettings.JSONToSettings(message_body);
      m_pGribCtrlBar->m_OverlaySettings.Write();
      m_pGribCtrlBar->SetDialogsStyleSizePosition(true);
    }
  }
}
 
bool GribPi::LoadConfig() {
  auto *pConf = (wxFileConfig *)m_pconfig;
 
  if (!pConf) return false;
 
  pConf->SetPath("/PlugIns/GRIB");
  pConf->Read("LoadLastOpenFile", &m_bLoadLastOpenFile, 0);
  pConf->Read("OpenFileOption", &m_bStartOptions, 1);
  pConf->Read("GRIBUseHiDef", &m_bGRIBUseHiDef, false);
  pConf->Read("GRIBUseGradualColors", &m_bGRIBUseGradualColors, false);
  pConf->Read("DrawBarbedArrowHead", &m_bDrawBarbedArrowHead, true);
  pConf->Read("ZoomToCenterAtInit", &m_bZoomToCenterAtInit, true);
  pConf->Read("ShowGRIBIcon", &m_bGRIBShowIcon, true);
  pConf->Read("CopyFirstCumulativeRecord", &m_bCopyFirstCumRec, true);
  pConf->Read("CopyMissingWaveRecord", &m_bCopyMissWaveRec, true);
#ifdef __WXMSW__
  pConf->Read("GribIconsScaleFactor", &m_GribIconsScaleFactor, 1);
#endif
 
  m_CtrlBar_Sizexy.x = pConf->Read("GRIBCtrlBarSizeX", 1400L);
  m_CtrlBar_Sizexy.y = pConf->Read("GRIBCtrlBarSizeY", 800L);
  m_CtrlBarxy.x = pConf->Read("GRIBCtrlBarPosX", 20L);
  m_CtrlBarxy.y = pConf->Read("GRIBCtrlBarPosY", 60L);
  m_CursorDataxy.x = pConf->Read("GRIBCursorDataPosX", 20L);
  m_CursorDataxy.y = pConf->Read("GRIBCursorDataPosY", 170L);
 
  pConf->Read("GribCursorDataDisplayStyle", &m_DialogStyle, 0);
  if (m_DialogStyle > 3)
    m_DialogStyle = 0;  // ensure validity of the .conf value
 
  return true;
}
 
bool GribPi::SaveConfig(void) {
  wxFileConfig *pConf = (wxFileConfig *)m_pconfig;
 
  if (!pConf) return false;
 
  pConf->SetPath("/PlugIns/GRIB");
 
  pConf->Write("LoadLastOpenFile", m_bLoadLastOpenFile);
  pConf->Write("OpenFileOption", m_bStartOptions);
  pConf->Write("ShowGRIBIcon", m_bGRIBShowIcon);
  pConf->Write("GRIBUseHiDef", m_bGRIBUseHiDef);
  pConf->Write("GRIBUseGradualColors", m_bGRIBUseGradualColors);
  pConf->Write("CopyFirstCumulativeRecord", m_bCopyFirstCumRec);
  pConf->Write("CopyMissingWaveRecord", m_bCopyMissWaveRec);
  pConf->Write("DrawBarbedArrowHead", m_bDrawBarbedArrowHead);
  pConf->Write("ZoomToCenterAtInit", m_bZoomToCenterAtInit);
#ifdef __WXMSW__
  pConf->Write("GribIconsScaleFactor", m_GribIconsScaleFactor);
#endif
 
  pConf->Write("GRIBCtrlBarSizeX", m_CtrlBar_Sizexy.x);
  pConf->Write("GRIBCtrlBarSizeY", m_CtrlBar_Sizexy.y);
  pConf->Write("GRIBCtrlBarPosX", m_CtrlBarxy.x);
  pConf->Write("GRIBCtrlBarPosY", m_CtrlBarxy.y);
  pConf->Write("GRIBCursorDataPosX", m_CursorDataxy.x);
  pConf->Write("GRIBCursorDataPosY", m_CursorDataxy.y);
 
  return true;
}
 
void GribPi::SetColorScheme(PI_ColorScheme cs) {
  DimeWindow(m_pGribCtrlBar);
  if (m_pGribCtrlBar) {
    if (m_pGRIBOverlayFactory) m_pGRIBOverlayFactory->ClearCachedLabel();
    if (m_pGribCtrlBar->pReq_Dialog) m_pGribCtrlBar->pReq_Dialog->Refresh();
    m_pGribCtrlBar->Refresh();
    // m_pGribDialog->SetDataBackGroundColor();
  }
}
 
void GribPi::SendTimelineMessage(wxDateTime time) {
  if (!m_pGribCtrlBar) return;
 
  wxJSONValue v;
  if (time.IsValid()) {
    v["Day"] = time.GetDay();
    v["Month"] = time.GetMonth();
    v["Year"] = time.GetYear();
    v["Hour"] = time.GetHour();
    v["Minute"] = time.GetMinute();
    v["Second"] = time.GetSecond();
  } else {
    v["Day"] = -1;
    v["Month"] = -1;
    v["Year"] = -1;
    v["Hour"] = -1;
    v["Minute"] = -1;
    v["Second"] = -1;
  }
  wxJSONWriter w;
  wxString out;
  w.Write(v, out);
  SendPluginMessage(wxString("GRIB_TIMELINE"), out);
}
 
void GribPi::SetPositionFixEx(PlugIn_Position_Fix_Ex &pfix) {
  m_boat_cog = pfix.Cog;
  m_boat_sog = pfix.Sog;
  m_boat_lat = pfix.Lat;
  m_boat_lon = pfix.Lon;
  if (pfix.FixTime != 0) {
    m_boat_time = pfix.FixTime;
  } else {
    m_boat_time = wxDateTime::Now().GetTicks();
  }
}
 
//----------------------------------------------------------------------------------------------------------
//          Prefrence dialog Implementation
//----------------------------------------------------------------------------------------------------------
void GribPreferencesDialog::OnStartOptionChange(wxCommandEvent &event) {
  if (m_rbStartOptions->GetSelection() == 2) {
    OCPNMessageBox_PlugIn(
        this,
        _("You have chosen to authorize interpolation.\nDon't forget that data "
          "displayed at current time will not be real but Recomputed\nThis can "
          "decrease accuracy!"),
        _("Warning!"));
  }
}
 
void GribPreferencesDialog::OnOKClick(wxCommandEvent &event) {
  if (g_pi) g_pi->UpdatePrefs(this);
  Close();
}