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

Pedro Vicente Wed, 07 Dec 2016 23:20:13 -0800

Hi Alan

I have a wxWidgets application that I developed for Windows and Linux that uses 
PLplot .


I started having a segfault on the *Linux* only version.

Debugging in Windows is a breeze with Visual Studio.

For Linux I was able to make a QtCreator project to debug (yes, Qt debugging 
wxWidgets !)

However when I try to step into the PLplot code, there is no step into, because 
probably debugging symbols were not built

I used the following cmake call

cmake ..  -G "Unix Makefiles" -DBUILD_SHARED_LIBS:BOOL=OFF 
-DENABLE_f95:BOOL=OFF -DENABLE_tcl:BOOL=OFF -DENABLE_tk:BOOL=OFF 
-DCMAKE_INSTALL_PREFIX:PATH=/data/data127/pvicente/install/plplot-5.11.1 
-DPL_HAVE_PTHREAD:BOOL=OFF -DPLD_xwin:BOOL=OFF -DPLD_wxwidgets:BOOL=ON 
-DwxWidgets_ROOT_DIR:PATH=/data/data127/pvicente/install/wxwidgets-3.1.0 
-DwxWidgets_LIB_DIR:PATH=/data/data127/pvicente/install/wxwidgets-3.1.0/lib 
-DwxWidgets_CONFIGURATION=mswud -DENABLE_MIX_CXX=ON 
-DwxWidgets_EXCLUDE_COMMON_LIBRARIES:BOOL=OFF


this is more probably a cmake question, but I am not that familiar with cmake, 
so the question is, 
how can I add debug symbols to PLPlot for  the above cmake call?

The code is attached 

The segfault happens when I try to get into the init() call here

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

The weird thing is that I have nearly identical code for other application that 
works fine

when I was learning the PLplot code , and the app was just exiting for unknow 
reasons I found out that the init() call is dependent on at least 2 pallete and 
2 font

files to read from several "standard" locations.

Since I develop cross platforms and in many machines I ended up doing a svn 
repository with those 4 files at the same location as the program, like that 
they are always found.

but that is not the cause here, because those file are found (by the way, is 
there a way to eliminate the need to read those files?)

The Qt project is also attached in case anyone needs a Qt project to debug 
wxWidgets and PLPlot

thanks

-Pedro

#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

# usage : 
# make -f Makefile
# make -f Makefile clean
# wx-config --cxxflags
# wx-config --libs

# Note: 
# HAVE_PLPLOT_WX requires libplplotwxwidgets.a libplplotcxx.a


TEMPLATE = app
TARGET = wx_client
QT += core
QT -= gui
CONFIG += console
CONFIG += debug
CONFIG += static
lessThan(QT_MAJOR_VERSION, 5) {
QMAKE_CXXFLAGS += -std=c++0x
} else {
CONFIG += c++11
}

SRC7 =  ../../src/atms/RDR_DWELL/lib/rdr_data.cc

SRC10 = ../lib_netsockets/src/socket.cc
SRC11 = ../wx_lib/wx_calendar.cpp
SRC12 = ../wx_lib/wx_util.cpp
SRC13 = ../wx_lib/wx_plplotstream.cpp
SRC14 = wx_thread.cc
SRC_MAIN1 = wx_client.cc

unix {
 DEFINES += HAVE_PLPLOT 
 DEFINES += HAVE_PLPLOT_WX
 DEFINES += _FILE_OFFSET_BITS=64 
 DEFINES += __WXGTK__ 
 DEFINES += pthread

 dir_inc_atms = ../../src/atms/RDR_DWELL/lib
 dir_inc_lib_netsockets = ../lib_netsockets/src
 dir_inc_jansson = /data/data127/pvicente/install/jansson-2.9/include
 dir_lib_jansson = /data/data127/pvicente/install/jansson-2.9/lib
 dir_inc_hdf5 = /data/starfs1/libs/hdf5-1.8.7-linux-x86_64-static/include
 dir_lib_hdf5 = /data/starfs1/libs/hdf5-1.8.7-linux-x86_64-static/lib
 dir_inc_plplot = /data/data127/pvicente/install/plplot-5.11.1/include/plplot
 dir_lib_plplot = /data/data127/pvicente/install/plplot-5.11.1/lib
 dir_inc_wx = /data/data127/pvicente/install/wxwidgets-3.1.0/include/wx-3.1
 dir_inc_wx_setup = 
/data/data127/pvicente/install/wxwidgets-3.1.0/lib/wx/include/gtk2-unicode-static-3.1
 dir_lib_wx = /data/data127/pvicente/install/wxwidgets-3.1.0/lib


 INCLUDEPATH += $${dir_inc_plplot}
 INCLUDEPATH += $${dir_inc_wx}
 INCLUDEPATH += $${dir_inc_wx_setup}
 INCLUDEPATH += $${dir_inc_jansson}
 INCLUDEPATH += ../wx_lib
 INCLUDEPATH += $${dir_inc_lib_netsockets}
 INCLUDEPATH += $${dir_inc_atms}

 QMAKE_LIBDIR += $${dir_lib_jansson}
 LIBS += -ljansson 

 QMAKE_LIBDIR += $${dir_lib_plplot}
 LIBS += -lplplotwxwidgets 
 LIBS += -lplplotcxx
 LIBS += -lplplot
 LIBS += -lcsirocsa
 LIBS += -lqsastime

 QMAKE_LIBDIR += $${dir_lib_wx}
 LIBS += -lwx_gtk2u_xrc-3.1
 LIBS += -lwx_gtk2u_qa-3.1
 LIBS += -lwx_baseu_net-3.1
 LIBS += -lwx_gtk2u_html-3.1
 LIBS += -lwx_gtk2u_adv-3.1
 LIBS += -lwx_gtk2u_core-3.1
 LIBS += -lwx_baseu-3.1
 LIBS += -pthread
 LIBS += -lX11
 LIBS += -lXxf86vm
 LIBS += -lSM
 LIBS += -lgtk-x11-2.0
 LIBS += -lgdk-x11-2.0
 LIBS += -latk-1.0
 LIBS += -lgio-2.0
 LIBS += -lpangoft2-1.0
 LIBS += -lpangocairo-1.0
 LIBS += -lgdk_pixbuf-2.0
 LIBS += -lcairo
 LIBS += -lpango-1.0
 LIBS += -lfreetype
 LIBS += -lfontconfig
 LIBS += -lgobject-2.0
 LIBS += -lgmodule-2.0
 LIBS += -lgthread-2.0
 LIBS += -lrt
 LIBS += -lglib-2.0
 LIBS += -lpng
 LIBS += -ljpeg
 LIBS += -lexpat
 LIBS += -lwxregexu-3.1
 LIBS += -lwxtiff-3.1
 LIBS += -lz -ldl
 LIBS += -lm
 LIBS += -llzma 
 
 HEADERS += 
 SOURCES +=  $${SRC7} $${SRC10} $${SRC11} $${SRC12} $${SRC13} $${SRC14}  
$${SRC_MAIN1}
}

------------------------------------------------------------------------------
Developer Access Program for Intel Xeon Phi Processors
Access to Intel Xeon Phi processor-based developer platforms.
With one year of Intel Parallel Studio XE.
Training and support from Colfax.
Order your platform today.http://sdm.link/xeonphi

_______________________________________________
Plplot-devel mailing list
Plplot-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/plplot-devel

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

Reply via email to