wxgraphgui.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys 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.                                                                          *
 *                                                                                   *
 * MechSys 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      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_WXGUI_H
#define MECHSYS_WXGUI_H

#include <cstdlib> // for srand and rand

#ifdef HAVE_CONFIG_H
  #include "config.h"
#else
  #ifndef REAL
    #define REAL double
  #endif
#endif

#include <wx/wx.h>
#include <wx/thread.h>

#include "gui/wxgraph.h"


// ------------------------------------- RunSim -----------------------------------

class RunSim : public wxThread
{
public:
    // Constructor
    RunSim (WxGraph * pPlot, bool * pRunning) : _plot(pPlot), _running(pRunning) {}
    // Methods
    virtual void * Entry();
    // Events
    virtual void OnExit(); // called when the thread exits; whether it terminates normally or is stopped with Delete(), but not when it is Kill()ed!
private:
    // Data
    WxGraph * _plot;
    bool    * _running;
}; // class RunSim


// ------------------------------------- wxApp ------------------------------------

class App : public wxApp
{
public:
    virtual bool OnInit();
}; // class App


// ------------------------------------ wxFrame -----------------------------------

class Frame : public wxFrame
{
public:
    // Constructor & Destructor
    Frame(wxString const & Title);
    ~Frame();
    // Events
    void OnQuit  (wxCommandEvent & Event);
    void OnAbout (wxCommandEvent & Event);
    void OnRun   (wxCommandEvent & Event);
    void OnStop  (wxCommandEvent & Event);
private:
    // Event table
    DECLARE_EVENT_TABLE()
    // Controls
    wxTextCtrl * _term;
    // Data
    WxGraph * _plot;
    bool      _running;
    RunSim  * _run_thread;
}; // class Frame




// ------------------------------------- RunSim -----------------------------------

inline void * RunSim::Entry() // {{{
{
    for (int i=0; i<1000; ++i)
    {
        if (TestDestroy()) break;

        const int n_points=10000;
        REAL X1[n_points];
        REAL Y1[n_points];
        REAL X2[n_points];
        REAL Y2[n_points];
        REAL phase=i/10;
        REAL x0=500;
        REAL y0=500;
        REAL r=400/10000.0;
        for (int j=0; j<n_points; ++j)
        {
            X1[j] = x0+r*j*sin(phase+r*j*.02); 
            X2[j] = x0-r*j*sin(phase+r*j*.02); 
            Y1[j] = y0+r*j*cos(phase+r*j*.07);
            Y2[j] = y0-r*j*cos(phase+r*j*.07);
        }

        wxMutexGuiEnter();
        _plot->ResetCurve(0, X1,Y1,n_points);
        _plot->ResetCurve(1, X2,Y2,n_points);
        wxMutexGuiLeave();

        //std::cout << "hi from Entry with i = " << i << std::endl;
        wxThread::Sleep(10);
    }

    std::cout << "Finished\n";
    return NULL;
} // }}}

inline void RunSim::OnExit() // {{{
{
    //wxMutexGuiEnter();
    //(*_running) = false;
    //wxMutexGuiLeave();
} // }}}

// ------------------------------------- wxApp ------------------------------------

inline bool App::OnInit() // {{{
{
    Frame * frame = new Frame(_("Minimal wxWidgets GUI App"));
    frame->Show(true);
    return true;
} // }}}

DECLARE_APP (App) // Implements App & GetApp()


// ------------------------------------ wxFrame -----------------------------------

enum // {{{
{
    ID_RUN  = 100,
    ID_STOP = 101
}; // }}}

inline Frame::Frame(wxString const & Title) // {{{
    : wxFrame(/* parent */ NULL, wxID_ANY, Title),
      _running(false)
{
    // Menubar
    wxMenuBar * mnu_bar  = new wxMenuBar;
    wxMenu    * mnu_file = new wxMenu;
    wxMenu    * mnu_run  = new wxMenu;
    wxMenu    * mnu_help = new wxMenu;
    mnu_file->Append(wxID_EXIT , _("&Quit\tCtrl-Q") , _("Quit this program"));
    mnu_run ->Append(ID_RUN    , _("&Run\tCtrl-R")  , _("Run simulation"));
    mnu_run ->Append(ID_STOP   , _("&Stop\tCtrl-S") , _("Stop running simulation, if any"));
    mnu_help->Append(wxID_ABOUT, _("&About\tF1")    , _("Show about dialog"));
    mnu_bar ->Append(mnu_file  , _("&File"));
    mnu_bar ->Append(mnu_run   , _("&Run"));
    mnu_bar ->Append(mnu_help  , _("&Help"));
    SetMenuBar(mnu_bar);

    // Statusbar
    CreateStatusBar(2);
    SetStatusText(_("Welcome !"));

    // Text control (Terminal)
    _term = new wxTextCtrl(this, wxID_ANY, _("\n"), wxDefaultPosition, wxSize(200,100), wxTE_MULTILINE);
    _term->SetBackgroundColour(wxT("wheat"));

    // Graph
    _plot = new WxGraph(this, "yellow", "wheat");
    //_plot->EqualScales(true);
    //_plot->Grid().Active(false);
    _plot->XRuler().Active(false);

    // Ruler
    _plot->XRuler ().nMajorTicks(30).Thickness(43).MajorTickLen(40);
    _plot->YRuler ().nMajorTicks(10);
    _plot->X2Ruler().nMajorTicks(15);
    _plot->Y2Ruler().nMajorTicks(40);

    // Curves
    REAL Xa[] = {0, 1, 2, 3, 4, 25};
    REAL Ya[] = {0, 5, 1, 5, 1, 25};
    //REAL Ya[] = {0, 1, 4, 9, 16, 25};
    REAL Xb[] = {-1, 5, 8, 10, 3, 1, 0};
    REAL Yb[] = { 1, 2, 3,  4, 5, 6, 7};
    REAL Xc[] = {0, 1, 2, 3, 4, 5};
    REAL Yc[] = {1, 2, 3, 4, -2, 0};
    REAL Xd[] = { 0, 1, 2, 3, 4, 6};    
    REAL Yd[] = { 0, 5, 1, 5, 1, 10};   
    _plot->AddCurve(Xa, Ya, 6).LineColour(_T("red"   )).LineStyle(wxSOLID     ).PointFGColour(_T("black")).PointBGColour(_T("yellow")).PointType(WxCurve::WxCurve_PS_NONE);
    _plot->AddCurve(Xb, Yb, 7).LineColour(_T("blue"  )).LineStyle(wxDOT       ).PointFGColour(_T("black")).PointBGColour(_T("green" )).PointType(WxCurve::WxCurve_PS_SQUARE_MED);
    _plot->AddCurve(Xc, Yc, 6).LineColour(_T("yellow")).LineStyle(wxLONG_DASH ).PointFGColour(_T("black")).PointBGColour(_T("blue"  )).PointType(WxCurve::WxCurve_PS_DOT);
    _plot->AddCurve(Xd, Yd, 6).LineColour(_T("blue"  )).LineStyle(wxSHORT_DASH).PointFGColour(_T("black")).PointBGColour(_T("black" )).PointType(WxCurve::WxCurve_PS_CROSS_BIG);

    // Sizer
    wxBoxSizer * top_sizer = new wxBoxSizer(wxVERTICAL);
    //top_sizer->Add(_term, /*stretch factor*/2, wxEXPAND, /*border*/wxALL, /*border width*/0);
    top_sizer->Add(_plot,                   1, wxEXPAND,           wxALL,                 0);

    // SetSizer
    SetSizer(top_sizer);
    top_sizer->Fit(this);
    top_sizer->SetSizeHints(this);

} // }}}

inline Frame::~Frame() // {{{
{
    //if (_running) _run_thread->Delete();
    //_run_thread->Wait();
} // }}}

inline void Frame::OnQuit(wxCommandEvent & Event) // {{{
{
    Close();
} // }}}

inline void Frame::OnAbout(wxCommandEvent & Event) // {{{
{
    wxString msg;
    msg.Printf(_("Hello and welcome to %s"), wxVERSION_STRING);
    wxMessageBox(msg, _("About Minimal"), wxOK | wxICON_INFORMATION, this);
} // }}}

inline void Frame::OnRun(wxCommandEvent & Event) // {{{
{
    if (!_running)
    {
        _plot->EnableCurve(1, false);
        _plot->EnableCurve(2, false);
        _plot->EnableCurve(3, false);
        _run_thread = new RunSim(_plot, &_running);
        if (_run_thread->Create()!=wxTHREAD_NO_ERROR) wxLogError(_("Can not create thread!"));
        else
        {
            _running = true;
            _run_thread->Run();
        }
    }
    else wxLogError(_("Simulation is already running"));
} // }}}

inline void Frame::OnStop(wxCommandEvent & Event) // {{{
{
    if (_running)
    {
        _run_thread->Delete();
        _running = false;
    }
    else wxLogError(_("Simulation is not running"));
} // }}}

BEGIN_EVENT_TABLE(Frame, wxFrame) // {{{
    EVT_MENU (wxID_EXIT , Frame::OnQuit )
    EVT_MENU (wxID_ABOUT, Frame::OnAbout)
    EVT_MENU (ID_RUN    , Frame::OnRun  )
    EVT_MENU (ID_STOP   , Frame::OnStop )
END_EVENT_TABLE() // }}}

#endif // MECHSYS_WXGUI_H

// vim:fdm=marker

---