[Plplot-devel] build PLPlot with debug symbols in linux / cmake

[Pedro V. <ped...@sp...>]

#include <assert.h>
#include <jansson.h>
#include "wx/wxprec.h"
#include "wx/wx.h"
//icons
#include "icons/sample.xpm"
#include "icons/back.xpm"
#include "icons/forward.xpm"
#include "icons/doc_blue.xpm"
#ifdef HAVE_VLD
#include "vld.h"
#endif
//local
#include "wx_thread.hh"
#include "wx_client.hh"
#include "socket.hh"
#include "rdr_read.hh"
//plot
#ifdef HAVE_PLPLOT_WX
#include "wx_plplotwindow.hpp"
template< class WXWINDOW >
void plot_points(wx_PLplotwindow<WXWINDOW> *plotwindow);
template< class WXWINDOW >
void plot_bars(wx_PLplotwindow<WXWINDOW> *plotwindow);
#endif

const unsigned short port = 2000;

/////////////////////////////////////////////////////////////////////////////////////////////////////
//get_app_name
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxString get_app_name()
{
  wxString str(wxT("STAR Reader"));
  return str;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxAppClient
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxIMPLEMENT_APP(wxAppClient);

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxAppClient::OnInit()
/////////////////////////////////////////////////////////////////////////////////////////////////////

bool wxAppClient::OnInit()
{
  if (!wxApp::OnInit())
  {
    return false;
  }
  wxFrameClient *frame = new wxFrameClient();
  frame->Show(true);
  frame->Maximize();
  return true;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::wxFrameClient
//Note: set size to 1000 to avoid Gtk-CRITICAL IA__gtk_widget_set_size_request
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxBEGIN_EVENT_TABLE(wxFrameClient, wxMDIParentFrame)
EVT_CLOSE(wxFrameClient::OnClose)
EVT_MENU(wxID_EXIT, wxFrameClient::OnQuit)
EVT_MENU(wxID_ABOUT, wxFrameClient::OnAbout)
EVT_MENU(ID_WINDOW_FRAME_GRID, wxFrameClient::event_grid)
EVT_MENU(ID_WINDOW_FRAME_PLOT_POINT, wxFrameClient::event_plot_point)
EVT_SIZE(wxFrameClient::OnSize)
EVT_CALENDAR_SEL_CHANGED(ID_CALENDAR_START, wxFrameClient::event_calendar_start_change)
EVT_CALENDAR_SEL_CHANGED(ID_CALENDAR_END, wxFrameClient::event_calendar_end_change)
EVT_TEXT_ENTER(ID_WINDOW_TOOLBAR_TEXTCTRL_SERVER, wxFrameClient::event_textctrl_server)
EVT_COMMAND(wxID_ANY, EVENT_STATUS_BAR, wxFrameClient::update_status_bar)
EVT_COMMAND(wxID_ANY, EVENT_GAUGE_VALUE, wxFrameClient::update_gauge_value)
EVT_COMMAND(wxID_ANY, EVENT_GAUGE_RANGE, wxFrameClient::update_gauge_range)
EVT_COMMAND(wxID_ANY, EVENT_SET_DATA, wxFrameClient::update_set_data)
wxEND_EVENT_TABLE()

wxFrameClient::wxFrameClient() :
  wxMDIParentFrame(NULL, wxID_ANY, get_app_name(), wxPoint(0, 0), wxSize(1000, 840)),
  m_thread(NULL)
{
  int w, h;
  GetClientSize(&w, &h);
  wxSashLayoutWindow* win;

  SetIcon(wxICON(sample));

  /////////////////////////////////////////////////////////////////////////////////////////////////////
  //menu
  /////////////////////////////////////////////////////////////////////////////////////////////////////

  wxMenu *menu_file = new wxMenu;
  menu_file->Append(wxID_EXIT, "E&xit\tAlt-X", "Quit this program");
  wxMenu *menu_data = new wxMenu;
  menu_data->Append(ID_WINDOW_FRAME_GRID, "Show &Grid", "Show grid");
  menu_data->Append(ID_WINDOW_FRAME_PLOT_POINT, "Show &Point plot", "Show point plot");
  wxMenu *menu_help = new wxMenu;
  menu_help->Append(wxID_ABOUT, "&About\tF1", "Show about dialog");

  wxMenuBar *menu_bar = new wxMenuBar();
  menu_bar->Append(menu_file, "&File");
  menu_bar->Append(menu_data, "&Data");
  menu_bar->Append(menu_help, "&Help");
  SetMenuBar(menu_bar);
  CreateStatusBar(2);
  SetStatusText("Ready");

  /////////////////////////////////////////////////////////////////////////////////////////////////////
  //calendar pane
  /////////////////////////////////////////////////////////////////////////////////////////////////////

  win = new wxSashLayoutWindow(this, ID_WINDOW_SASH_CALENDAR, wxDefaultPosition, wxDefaultSize, wxNO_BORDER | wxSW_3D | wxCLIP_CHILDREN);
  win->SetDefaultSize(wxSize(300, h));
  win->SetOrientation(wxLAYOUT_VERTICAL);
  win->SetAlignment(wxLAYOUT_RIGHT);
  win->SetSashVisible(wxSASH_RIGHT, true);
  win->SetExtraBorderSize(10);
  win->SetMinimumSizeX(100);
  win->SetBackgroundColour(*wxWHITE);

  m_sash_calendar = win;

  m_date_start.Set(30, wxDateTime::May, 2016, 0, 0, 0, 0);
  m_date_end.Set(1, wxDateTime::Jun, 2016, 0, 0, 0, 0);
  m_panel = new PanelCalendar(m_sash_calendar, m_date_start, m_date_end);

  /////////////////////////////////////////////////////////////////////////////////////////////////////
  //toolbar
  /////////////////////////////////////////////////////////////////////////////////////////////////////

  wxToolBar* toolbar = CreateToolBar();

  wxArrayString strings;
  strings.Add(wxT("173.66.46.228"));
  strings.Add(wxT("127.0.0.1"));
  strings.Add(wxT("rhw9121.star1.nesdis.noaa.gov"));
  m_textctrl_server = new wxTextCtrl(toolbar, ID_WINDOW_TOOLBAR_TEXTCTRL_SERVER, strings[1], wxDefaultPosition, wxSize(500, -1), wxTE_PROCESS_ENTER);
  toolbar->AddControl(m_textctrl_server);
  toolbar->AddSeparator();

  m_gauge = new wxGauge();
  wxSize size = m_textctrl_server->GetSize();
  size.SetWidth(size.GetWidth());
  m_gauge->Create(toolbar, ID_WINDOW_TOOLBAR_GAUGE, 0, wxDefaultPosition, wxSize(size), wxGA_HORIZONTAL | wxGA_SMOOTH);
  toolbar->AddControl(m_gauge);
  toolbar->Realize();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::~wxFrameClient
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxFrameClient::~wxFrameClient()
{
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::OnClose
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::OnClose(wxCloseEvent&)
{
  {
    wxCriticalSectionLocker enter(m_critical_section);
    if (m_thread)
    {
      m_thread->Delete();
    }
  }
  // exit from the critical section to give the thread
  // the possibility to enter its destructor
  while (1)
  {
    {
      wxCriticalSectionLocker enter(m_critical_section);
      if (!m_thread) break;
    }
    // wait for thread completion
    wxThread::This()->Sleep(1);
  }
  Destroy();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::OnSize
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::OnSize(wxSizeEvent& WXUNUSED(eve))
{
  wxLayoutAlgorithm layout;
  layout.LayoutMDIFrame(this);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::OnQuit
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::OnQuit(wxCommandEvent& WXUNUSED(eve))
{
  Close(true);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::OnAbout
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::OnAbout(wxCommandEvent& WXUNUSED(eve))
{
  wxMessageBox("NOAA ICVS\n\n", get_app_name(), wxOK, this);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::event_calendar_start_change
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::event_calendar_start_change(wxCalendarEvent& event)
{
  wxString str;
  m_date_start = event.GetDate();
  str.Printf(wxT("Start date: %s"), m_date_start.FormatISODate().c_str());
  m_panel->m_text_start->SetLabel(str);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::event_calendar_end_change
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::event_calendar_end_change(wxCalendarEvent& event)
{
  wxString str;
  m_date_end = event.GetDate();
  str.Printf(wxT("End date: %s"), m_date_end.FormatISODate().c_str());
  m_panel->m_text_end->SetLabel(str);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::event_textctrl_server
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::event_textctrl_server(wxCommandEvent& WXUNUSED(eve))
{
  m_gauge->SetRange(1);
  m_gauge->Pulse();
  m_thread = new wxThreadReceive(this, m_textctrl_server->GetValue());
  wxThreadError err = m_thread->Create();
  err = m_thread->Run();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::update_status_bar
//called when the event from the thread is received
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::update_status_bar(wxCommandEvent& evt)
{
  GetStatusBar()->SetStatusText(evt.GetString());
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::update_gauge_value
//called when the event from the thread is received
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::update_gauge_value(wxCommandEvent& evt)
{
  m_gauge->SetValue(evt.GetInt());
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::update_gauge_range
//called when the event from the thread is received
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::update_gauge_range(wxCommandEvent& evt)
{
  m_gauge->SetRange(evt.GetInt());
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::update_set_data
//called when the event from the thread is received
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::update_set_data(wxCommandEvent& evt)
{
  //delete data from previous request, if any
  m_vec_current_anomaly.clear();
  json_t *response_orbit = (json_t *)evt.GetClientData();

  //parse JSON
  json_t *json_object = json_object_get(response_orbit, "current_anomaly");
  assert(json_is_object(json_object));
  const char *json_key;
  json_t *json_value;
  json_object_foreach(json_object, json_key, json_value)
  {
    size_t size_arr = json_array_size(json_value);
    assert(size_arr == 7);
    orbit_current_anomaly_t oc(
      static_cast<int>(json_integer_value(json_array_get(json_value, 0))), //orbit_number
      static_cast<int>(json_integer_value(json_array_get(json_value, 1))), //year
      static_cast<int>(json_integer_value(json_array_get(json_value, 2))), //month
      static_cast<int>(json_integer_value(json_array_get(json_value, 3))), //day
      json_real_value(json_array_get(json_value, 4)), //mean
      json_real_value(json_array_get(json_value, 5)), //max
      json_real_value(json_array_get(json_value, 6))); //min
    m_vec_current_anomaly.push_back(oc);
  }

  json_decref(response_orbit);
  wxFrameGrid *subframe = new wxFrameGrid(this, "Grid");
  subframe->Show(true);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::event_grid
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::event_grid(wxCommandEvent& WXUNUSED(eve))
{
  if (m_vec_current_anomaly.size())
  {
    wxFrameGrid *subframe = new wxFrameGrid(this, "Grid");
    subframe->Show(true);
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxGridOrbit::wxGridOrbit
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxBEGIN_EVENT_TABLE(wxGridOrbit, wxGrid)
wxEND_EVENT_TABLE()

wxGridOrbit::wxGridOrbit(wxWindow *parent, const wxSize& size) :
  wxGrid(parent, wxID_ANY, wxPoint(0, 0), size, wxNO_BORDER)
{
  wxFrameGrid *frame = (wxFrameGrid*)GetParent();
  wxFrameClient *main = (wxFrameClient*)frame->GetParent();
  std::vector<orbit_current_anomaly_t> &orbit = main->m_vec_current_anomaly;

  /////////////////////////////////////////////////////////////////////////////////////////////////////
  //define grid
  /////////////////////////////////////////////////////////////////////////////////////////////////////

  m_nbr_rows = orbit.size();
  m_nbr_cols = 5;
  this->CreateGrid(m_nbr_rows, m_nbr_cols);
  this->MakeGrid(orbit);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxGridOrbit::~wxGridOrbit
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxGridOrbit::~wxGridOrbit()
{
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxGridOrbit::MakeGrid
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxGridOrbit::MakeGrid(const std::vector<orbit_current_anomaly_t> &orbit)
{
  this->SetColSize(0, 200);
  this->SetColSize(1, 150);
  this->SetColSize(2, 150);
  this->SetColSize(3, 150);
  this->SetColSize(4, 150);
  this->SetColLabelValue(0, wxT("Orbit number"));
  this->SetColLabelValue(1, wxT("Date"));
  this->SetColLabelValue(2, wxT("Mean"));
  this->SetColLabelValue(3, wxT("Maximum"));
  this->SetColLabelValue(4, wxT("Minimum"));

  for (int idx_row = 0; idx_row < m_nbr_rows; idx_row++)
  {
    orbit_current_anomaly_t ob = orbit.at(idx_row);
    this->SetCellValue(idx_row, 0, wxString::Format(wxT("%i"), ob.orbit_number));
    wxDateTime dt;
    dt.Set(ob.day, (wxDateTime::Month)(ob.month - 1), ob.year, 0, 0, 0, 0);
    this->SetCellValue(idx_row, 1, dt.FormatISODate());
    this->SetCellValue(idx_row, 2, wxString::Format(wxT("%f"), ob.mean));
    this->SetCellValue(idx_row, 3, wxString::Format(wxT("%f"), ob.maximum));
    this->SetCellValue(idx_row, 4, wxString::Format(wxT("%f"), ob.minimum));
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameGrid::wxFrameGrid
/////////////////////////////////////////////////////////////////////////////////////////////////////

wxBEGIN_EVENT_TABLE(wxFrameGrid, wxFrame)
EVT_MENU(ID_WINDOW_GRID_QUIT, wxFrameGrid::OnQuit)
wxEND_EVENT_TABLE()

wxFrameGrid::wxFrameGrid(wxMDIParentFrame *parent, const wxString& title) :
  wxFrame(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE | wxFRAME_FLOAT_ON_PARENT)
{
  SetIcon(wxICON(sample));
  m_grid = new wxGridOrbit(this, GetClientSize());
  Raise();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameGrid::OnActivate
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameGrid::OnActivate(wxActivateEvent& event)
{
  if (event.GetActive() && m_grid)
    m_grid->SetFocus();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameGrid::OnQuit
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameGrid::OnQuit(wxCommandEvent& WXUNUSED(eve))
{
  Close(true);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//wxFrameClient::event_plot_point
/////////////////////////////////////////////////////////////////////////////////////////////////////

void wxFrameClient::event_plot_point(wxCommandEvent& WXUNUSED(eve))
{
  wx_PLplotwindow<wxFrame> *frame = new wx_PLplotwindow<wxFrame>();

  frame->Create(this,
    wxID_ANY,
    "Plot",
    wxDefaultPosition,
    wxSize(900, 700),
    wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE | wxFRAME_FLOAT_ON_PARENT);
  frame->Show(true);

  wx_PLplotstream* pls = frame->GetStream();
  pls->init();

  pls->adv(0);
  pls->scol0(0, 255, 255, 255);
  pls->clear();
  pls->scol0(1, 0, 0, 0);

  plot_points(frame);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//plot_points
/////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef HAVE_PLPLOT_WX
template< class WXWINDOW >
void plot_points(wx_PLplotwindow<WXWINDOW> *plotwindow)
{
  wxFrameClient* frame = (wxFrameClient*)plotwindow->GetParent();
  std::vector<orbit_current_anomaly_t> &ob = frame->m_vec_current_anomaly;

  wx_PLplotstream* pls = plotwindow->GetStream();
  const int NSIZE = ob.size();
  PLFLT xmin, xmax, ymin, ymax;
  PLFLT *x, *y;
  xmin = 0;
  xmax = NSIZE;
  ymin = -0.5;
  ymax = 5.0;
  x = new PLFLT[NSIZE];
  y = new PLFLT[NSIZE];

  pls->schr(0, 1.2);
  pls->col0(1);
  pls->env(xmin, xmax, ymin, ymax, 0, 0);
  pls->lab("", "Current (Amps)", "Scan Drive Main Motor Current");

  //time axis
  for (int idx_orb = 0; idx_orb < NSIZE; idx_orb++)
  {
    x[idx_orb] = idx_orb;
  }

  //mean
  pls->col0(1); //black
  for (int idx_orb = 0; idx_orb < NSIZE; idx_orb++)
  {
    y[idx_orb] = ob[idx_orb].mean;
  }
  pls->poin(NSIZE, x, y, 46);

  //max
  for (int idx_orb = 0; idx_orb < NSIZE; idx_orb++)
  {
    y[idx_orb] = ob[idx_orb].maximum;
  }
  pls->col0(9); //blue
  pls->poin(NSIZE, x, y, 46);

  //min
  for (int idx_orb = 0; idx_orb < NSIZE; idx_orb++)
  {
    y[idx_orb] = ob[idx_orb].minimum;
  }
  pls->col0(9);
  pls->poin(NSIZE, x, y, 46);

  delete[] x;
  delete[] y;
  plotwindow->RenewPlot();
}
#endif