diff options
Diffstat (limited to 'Project/wxMathPlot/mathplot.cpp')
| -rw-r--r-- | Project/wxMathPlot/mathplot.cpp | 3074 |
1 files changed, 3074 insertions, 0 deletions
diff --git a/Project/wxMathPlot/mathplot.cpp b/Project/wxMathPlot/mathplot.cpp new file mode 100644 index 0000000..8543ca7 --- /dev/null +++ b/Project/wxMathPlot/mathplot.cpp @@ -0,0 +1,3074 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: mathplot.cpp +// Purpose: Framework for plotting in wxWindows +// Original Author: David Schalig +// Maintainer: Davide Rondini +// Contributors: Jose Luis Blanco, Val Greene +// Created: 21/07/2003 +// Last edit: 09/09/2007 +// Copyright: (c) David Schalig, Davide Rondini +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +// #pragma implementation "plot.h" +#pragma implementation "mathplot.h" +#endif + +// For compilers that support precompilation, includes "wx.h". +#include <wx/window.h> +//#include <wx/wxprec.h> + +// Comment out for release operation: +// (Added by J.L.Blanco, Aug 2007) +// #define MATHPLOT_DO_LOGGING + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#ifndef WX_PRECOMP +#include "wx/object.h" +#include "wx/font.h" +#include "wx/colour.h" +#include "wx/settings.h" +#include "wx/sizer.h" +//#include "wx/log.h" +#include "wx/intl.h" +#include "wx/dcclient.h" +#include "wx/cursor.h" +#endif + +#include "mathplot.h" +#include <wx/bmpbuttn.h> +#include <wx/module.h> +#include <wx/msgdlg.h> +#include <wx/image.h> +#include <wx/tipwin.h> + +#include <cmath> +#include <cstdio> // used only for debug +#include <ctime> // used for representation of x axes involving date + +// #include "pixel.xpm" + +// Memory leak debugging +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// Legend margins +#define mpLEGEND_MARGIN 5 +#define mpLEGEND_LINEWIDTH 40 + +// Minimum axis label separation +#define mpMIN_X_AXIS_LABEL_SEPARATION 64 +#define mpMIN_Y_AXIS_LABEL_SEPARATION 32 + +// Number of pixels to scroll when scrolling by a line +#define mpSCROLL_NUM_PIXELS_PER_LINE 10 + +// See doxygen comments. +double mpWindow::zoomIncrementalFactor = 1.5; + +//----------------------------------------------------------------------------- +// mpLayer +//----------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(mpLayer, wxObject) + +mpLayer::mpLayer() : m_type(mpLAYER_UNDEF) +{ + SetPen((wxPen&) *wxBLACK_PEN); + SetFont((wxFont&) *wxNORMAL_FONT); + m_continuous = FALSE; // Default + m_showName = TRUE; // Default + m_drawOutsideMargins = TRUE; + m_visible = true; +} + +wxBitmap mpLayer::GetColourSquare(int side) +{ + wxBitmap square(side, side, -1); + wxColour filler = m_pen.GetColour(); + wxBrush brush(filler, wxSOLID); + wxMemoryDC dc; + dc.SelectObject(square); + dc.SetBackground(brush); + dc.Clear(); + dc.SelectObject(wxNullBitmap); + return square; +} + +//----------------------------------------------------------------------------- +// mpInfoLayer +//----------------------------------------------------------------------------- +IMPLEMENT_DYNAMIC_CLASS(mpInfoLayer, mpLayer) + +mpInfoLayer::mpInfoLayer() +{ + m_dim = wxRect(0,0,1,1); + m_brush = *wxTRANSPARENT_BRUSH; + m_reference.x = 0; m_reference.y = 0; + m_winX = 1; //parent->GetScrX(); + m_winY = 1; //parent->GetScrY(); + m_type = mpLAYER_INFO; +} + +mpInfoLayer::mpInfoLayer(wxRect rect, const wxBrush* brush) : m_dim(rect) +{ + m_brush = *brush; + m_reference.x = rect.x; + m_reference.y = rect.y; + m_winX = 1; //parent->GetScrX(); + m_winY = 1; //parent->GetScrY(); + m_type = mpLAYER_INFO; +} + +mpInfoLayer::~mpInfoLayer() +{ + +} + +void mpInfoLayer::UpdateInfo(mpWindow& w, wxEvent& event) +{ + +} + +bool mpInfoLayer::Inside(wxPoint& point) +{ + return m_dim.Contains(point); +} + +void mpInfoLayer::Move(wxPoint delta) +{ + m_dim.SetX(m_reference.x + delta.x); + m_dim.SetY(m_reference.y + delta.y); +} + +void mpInfoLayer::UpdateReference() +{ + m_reference.x = m_dim.x; + m_reference.y = m_dim.y; +} + + +void mpInfoLayer::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + // Adjust relative position inside the window + int scrx = w.GetScrX(); + int scry = w.GetScrY(); + // Avoid dividing by 0 + if(scrx == 0) scrx=1; + if(scry == 0) scry=1; + + if ((m_winX != scrx) || (m_winY != scry)) { +#ifdef MATHPLOT_DO_LOGGING + // wxLogMessage(_("mpInfoLayer::Plot() screen size has changed from %d x %d to %d x %d"), m_winX, m_winY, scrx, scry); +#endif + if (m_winX != 1) m_dim.x = (int) floor((double)(m_dim.x*scrx/m_winX)); + if (m_winY != 1) { + m_dim.y = (int) floor((double)(m_dim.y*scry/m_winY)); + UpdateReference(); + } + // Finally update window size + m_winX = scrx; + m_winY = scry; + } + dc.SetPen(m_pen); +// wxImage image0(wxT("pixel.png"), wxBITMAP_TYPE_PNG); +// wxBitmap image1(image0); +// wxBrush semiWhite(image1); + dc.SetBrush(m_brush); + dc.DrawRectangle(m_dim.x, m_dim.y, m_dim.width, m_dim.height); + } +} + +wxPoint mpInfoLayer::GetPosition() +{ + return m_dim.GetPosition(); +} + +wxSize mpInfoLayer::GetSize() +{ + return m_dim.GetSize(); +} + +mpInfoCoords::mpInfoCoords() : mpInfoLayer() +{ + +} + +mpInfoCoords::mpInfoCoords(wxRect rect, const wxBrush* brush) : mpInfoLayer(rect, brush) +{ + +} + +mpInfoCoords::~mpInfoCoords() +{ + +} + +void mpInfoCoords::UpdateInfo(mpWindow& w, wxEvent& event) +{ + if (event.GetEventType() == wxEVT_MOTION) { + int mouseX = ((wxMouseEvent&)event).GetX(); + int mouseY = ((wxMouseEvent&)event).GetY(); +/* It seems that Windows port of wxWidgets don't support multi-line test to be drawn in a wxDC. + wxGTK instead works perfectly with it. + Info on wxForum: http://wxforum.shadonet.com/viewtopic.php?t=3451&highlight=drawtext+eol */ +#ifdef _WINDOWS + m_content.Printf(wxT("x = %f y = %f"), w.p2x(mouseX), w.p2y(mouseY)); +#else + m_content.Printf(wxT("x = %f\ny = %f"), w.p2x(mouseX), w.p2y(mouseY)); +#endif + } +} + +void mpInfoCoords::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + // Adjust relative position inside the window + int scrx = w.GetScrX(); + int scry = w.GetScrY(); + if ((m_winX != scrx) || (m_winY != scry)) { +#ifdef MATHPLOT_DO_LOGGING + // wxLogMessage(_("mpInfoLayer::Plot() screen size has changed from %d x %d to %d x %d"), m_winX, m_winY, scrx, scry); +#endif + if (m_winX != 1) m_dim.x = (int) floor((double)(m_dim.x*scrx/m_winX)); + if (m_winY != 1) { + m_dim.y = (int) floor((double)(m_dim.y*scry/m_winY)); + UpdateReference(); + } + // Finally update window size + m_winX = scrx; + m_winY = scry; + } + dc.SetPen(m_pen); +// wxImage image0(wxT("pixel.png"), wxBITMAP_TYPE_PNG); +// wxBitmap image1(image0); +// wxBrush semiWhite(image1); + dc.SetBrush(m_brush); + dc.SetFont(m_font); + int textX, textY; + dc.GetMultiLineTextExtent(m_content, &textX, &textY); + if (m_dim.width < textX + 10) m_dim.width = textX + 10; + if (m_dim.height < textY + 10) m_dim.height = textY + 10; + dc.DrawRectangle(m_dim.x, m_dim.y, m_dim.width, m_dim.height); + dc.DrawText(m_content, m_dim.x + 5, m_dim.y + 5); + } +} + +mpInfoLegend::mpInfoLegend() : mpInfoLayer() +{ + +} + +mpInfoLegend::mpInfoLegend(wxRect rect, const wxBrush* brush) : mpInfoLayer(rect, brush) +{ + +} + +mpInfoLegend::~mpInfoLegend() +{ + +} + +void mpInfoLegend::UpdateInfo(mpWindow& w, wxEvent& event) +{ + +} + +void mpInfoLegend::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + // Adjust relative position inside the window + int scrx = w.GetScrX(); + int scry = w.GetScrY(); + if ((m_winX != scrx) || (m_winY != scry)) { +#ifdef MATHPLOT_DO_LOGGING + // wxLogMessage(_("mpInfoLayer::Plot() screen size has changed from %d x %d to %d x %d"), m_winX, m_winY, scrx, scry); +#endif + if (m_winX != 1) m_dim.x = (int) floor((double)(m_dim.x*scrx/m_winX)); + if (m_winY != 1) { + m_dim.y = (int) floor((double)(m_dim.y*scry/m_winY)); + UpdateReference(); + } + // Finally update window size + m_winX = scrx; + m_winY = scry; + } +// wxImage image0(wxT("pixel.png"), wxBITMAP_TYPE_PNG); +// wxBitmap image1(image0); +// wxBrush semiWhite(image1); + dc.SetBrush(m_brush); + dc.SetFont(m_font); + const int baseWidth = (mpLEGEND_MARGIN*2 + mpLEGEND_LINEWIDTH); + int textX = baseWidth, textY = mpLEGEND_MARGIN; + int plotCount = 0; + int posY = 0; + int tmpX = 0, tmpY = 0; + mpLayer* ly = NULL; + wxPen lpen; + wxString label; + for (unsigned int p = 0; p < w.CountAllLayers(); p++) { + ly = w.GetLayer(p); + if ((ly->GetLayerType() == mpLAYER_PLOT) && (ly->IsVisible())) { + label = ly->GetName(); + dc.GetTextExtent(label, &tmpX, &tmpY); + textX = (textX > (tmpX + baseWidth)) ? textX : (tmpX + baseWidth + mpLEGEND_MARGIN); + textY += (tmpY); +#ifdef MATHPLOT_DO_LOGGING + // wxLogMessage(_("mpInfoLegend::Plot() Adding layer %d: %s"), p, label.c_str()); +#endif + } + } + dc.SetPen(m_pen); + dc.SetBrush(m_brush); + m_dim.width = textX; + if (textY != mpLEGEND_MARGIN) { // Don't draw any thing if there are no visible layers + textY += mpLEGEND_MARGIN; + m_dim.height = textY; + dc.DrawRectangle(m_dim.x, m_dim.y, m_dim.width, m_dim.height); + for (unsigned int p2 = 0; p2 < w.CountAllLayers(); p2++) { + ly = w.GetLayer(p2); + if ((ly->GetLayerType() == mpLAYER_PLOT) && (ly->IsVisible())) { + label = ly->GetName(); + lpen = ly->GetPen(); + dc.GetTextExtent(label, &tmpX, &tmpY); + dc.SetPen(lpen); + //textX = (textX > (tmpX + baseWidth)) ? textX : (tmpX + baseWidth); + //textY += (tmpY + mpLEGEND_MARGIN); + posY = m_dim.y + mpLEGEND_MARGIN + plotCount*tmpY + (tmpY>>1); + dc.DrawLine(m_dim.x + mpLEGEND_MARGIN, // X start coord + posY, // Y start coord + m_dim.x + mpLEGEND_LINEWIDTH + mpLEGEND_MARGIN, // X end coord + posY); + //dc.DrawRectangle(m_dim.x + 5, m_dim.y + 5 + plotCount*tmpY, 5, 5); + dc.DrawText(label, m_dim.x + baseWidth, m_dim.y + mpLEGEND_MARGIN + plotCount*tmpY); + plotCount++; + } + } + } + } +} + + + +//----------------------------------------------------------------------------- +// mpLayer implementations - functions +//----------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(mpFX, mpLayer) + +mpFX::mpFX(wxString name, int flags) +{ + SetName(name); + m_flags = flags; + m_type = mpLAYER_PLOT; +} + +void mpFX::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + + wxCoord startPx = m_drawOutsideMargins ? 0 : w.GetMarginLeft(); + wxCoord endPx = m_drawOutsideMargins ? w.GetScrX() : w.GetScrX() - w.GetMarginRight(); + wxCoord minYpx = m_drawOutsideMargins ? 0 : w.GetMarginTop(); + wxCoord maxYpx = m_drawOutsideMargins ? w.GetScrY() : w.GetScrY() - w.GetMarginBottom(); + + wxCoord iy = 0; + if (m_pen.GetWidth() <= 1) + { + for (wxCoord i = startPx; i < endPx; ++i) + { + iy = w.y2p( GetY(w.p2x(i))); + // Draw the point only if you can draw outside margins or if the point is inside margins + if (m_drawOutsideMargins || ((iy >= minYpx) && (iy <= maxYpx))) + dc.DrawPoint(i, iy );// (wxCoord) ((w.GetPosY() - GetY( (double)i / w.GetScaleX() + w.GetPosX()) ) * w.GetScaleY())); + } + } + else + { + for (wxCoord i = startPx; i < endPx; ++i) + { + iy = w.y2p( GetY(w.p2x(i))); + // Draw the point only if you can draw outside margins or if the point is inside margins + if (m_drawOutsideMargins || ((iy >= minYpx) && (iy <= maxYpx))) + dc.DrawLine( i, iy, i, iy); + // wxCoord c = w.y2p( GetY(w.p2x(i)) ); //(wxCoord) ((w.GetPosY() - GetY( (double)i / w.GetScaleX() + w.GetPosX()) ) * w.GetScaleY()); + + } + } + + if (!m_name.IsEmpty() && m_showName) + { + dc.SetFont(m_font); + + wxCoord tx, ty; + dc.GetTextExtent(m_name, &tx, &ty); + + /*if ((m_flags & mpALIGNMASK) == mpALIGN_RIGHT) + tx = (w.GetScrX()>>1) - tx - 8; + else if ((m_flags & mpALIGNMASK) == mpALIGN_CENTER) + tx = -tx/2; + else + tx = -(w.GetScrX()>>1) + 8; + */ + if ((m_flags & mpALIGNMASK) == mpALIGN_RIGHT) + tx = (w.GetScrX() - tx) - w.GetMarginRight() - 8; + else if ((m_flags & mpALIGNMASK) == mpALIGN_CENTER) + tx = ((w.GetScrX() - w.GetMarginRight() - w.GetMarginLeft() - tx) / 2) + w.GetMarginLeft(); + else + tx = w.GetMarginLeft() + 8; + dc.DrawText( m_name, tx, w.y2p(GetY(w.p2x(tx))) ); // (wxCoord) ((w.GetPosY() - GetY( (double)tx / w.GetScaleX() + w.GetPosX())) * w.GetScaleY()) ); + } + } +} + +IMPLEMENT_ABSTRACT_CLASS(mpFY, mpLayer) + +mpFY::mpFY(wxString name, int flags) +{ + SetName(name); + m_flags = flags; + m_type = mpLAYER_PLOT; +} + +void mpFY::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + + wxCoord i, ix; + + wxCoord startPx = m_drawOutsideMargins ? 0 : w.GetMarginLeft(); + wxCoord endPx = m_drawOutsideMargins ? w.GetScrX() : w.GetScrX() - w.GetMarginRight(); + wxCoord minYpx = m_drawOutsideMargins ? 0 : w.GetMarginTop(); + wxCoord maxYpx = m_drawOutsideMargins ? w.GetScrY() : w.GetScrY() - w.GetMarginBottom(); + + if (m_pen.GetWidth() <= 1) + { + for (i = minYpx; i < maxYpx; ++i) + { + ix = w.x2p(GetX(w.p2y(i))); + if (m_drawOutsideMargins || ((ix >= startPx) && (ix <= endPx))) + dc.DrawPoint(ix, i); + } + } + else + { + for (i=0;i< w.GetScrY(); ++i) + { + ix = w.x2p(GetX(w.p2y(i))); + if (m_drawOutsideMargins || ((ix >= startPx) && (ix <= endPx))) + dc.DrawLine(ix, i, ix, i); + // wxCoord c = w.x2p(GetX(w.p2y(i))); //(wxCoord) ((GetX( (double)i / w.GetScaleY() + w.GetPosY()) - w.GetPosX()) * w.GetScaleX()); + // dc.DrawLine(c, i, c, i); + } + } + + if (!m_name.IsEmpty() && m_showName) + { + dc.SetFont(m_font); + + wxCoord tx, ty; + dc.GetTextExtent(m_name, &tx, &ty); + + if ((m_flags & mpALIGNMASK) == mpALIGN_TOP) + ty = w.GetMarginTop() + 8; + else if ((m_flags & mpALIGNMASK) == mpALIGN_CENTER) + ty = ((w.GetScrY() - w.GetMarginTop() - w.GetMarginBottom() - ty) / 2) + w.GetMarginTop(); + else + ty = w.GetScrY() - 8 - ty - w.GetMarginBottom(); + + dc.DrawText( m_name, w.x2p(GetX(w.p2y(ty))), ty ); // (wxCoord) ((GetX( (double)i / w.GetScaleY() + w.GetPosY()) - w.GetPosX()) * w.GetScaleX()), -ty); + } + } +} + +IMPLEMENT_ABSTRACT_CLASS(mpFXY, mpLayer) + +mpFXY::mpFXY(wxString name, int flags) +{ + SetName(name); + m_flags = flags; + m_type = mpLAYER_PLOT; +} + +void mpFXY::UpdateViewBoundary(wxCoord xnew, wxCoord ynew) +{ + // Keep track of how many points have been drawn and the bouding box + maxDrawX = (xnew > maxDrawX) ? xnew : maxDrawX; + minDrawX = (xnew < minDrawX) ? xnew : minDrawX; + maxDrawY = (maxDrawY > ynew) ? maxDrawY : ynew; + minDrawY = (minDrawY < ynew) ? minDrawY : ynew; + //drawnPoints++; +} + +void mpFXY::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + + double x, y; + // Do this to reset the counters to evaluate bounding box for label positioning + Rewind(); GetNextXY(x, y); + maxDrawX = x; minDrawX = x; maxDrawY = y; minDrawY = y; + //drawnPoints = 0; + Rewind(); + + wxCoord startPx = m_drawOutsideMargins ? 0 : w.GetMarginLeft(); + wxCoord endPx = m_drawOutsideMargins ? w.GetScrX() : w.GetScrX() - w.GetMarginRight(); + wxCoord minYpx = m_drawOutsideMargins ? 0 : w.GetMarginTop(); + wxCoord maxYpx = m_drawOutsideMargins ? w.GetScrY() : w.GetScrY() - w.GetMarginBottom(); + + wxCoord ix = 0, iy = 0; + + if (!m_continuous) + { + // for some reason DrawPoint does not use the current pen, + // so we use DrawLine for fat pens + if (m_pen.GetWidth() <= 1) + { + while (GetNextXY(x, y)) + { + ix = w.x2p(x); + iy = w.y2p(y); + if (m_drawOutsideMargins || ((ix >= startPx) && (ix <= endPx) && (iy >= minYpx) && (iy <= maxYpx))) { + dc.DrawPoint(ix, iy); + UpdateViewBoundary(ix, iy); + }; + } + } + else + { + while (GetNextXY(x, y)) + { + ix = w.x2p(x); + iy = w.y2p(y); + if (m_drawOutsideMargins || ((ix >= startPx) && (ix <= endPx) && (iy >= minYpx) && (iy <= maxYpx))) { + dc.DrawLine(ix, iy, ix, iy); + UpdateViewBoundary(ix, iy); + } + // dc.DrawLine(cx, cy, cx, cy); + } + } + } + else + { + // Old code + wxCoord x0=0,c0=0; + bool first = TRUE; + std::vector<wxPoint> ptVector; + bool outUp, outDown; + outUp = outDown = true; + while (GetNextXY(x, y)) + { + wxCoord x1 = w.x2p(x); // (wxCoord) ((x - w.GetPosX()) * w.GetScaleX()); + wxCoord c1 = w.y2p(y); // (wxCoord) ((w.GetPosY() - y) * w.GetScaleY()); + if (first) + { + first=FALSE; + x0=x1;c0=c1; + } + if((x1 >= startPx)&&(x0 <= endPx)) { + outDown = (c0 > maxYpx) && (c1 > maxYpx); + outUp = (c0 < minYpx) && (c1 < minYpx); + if (!outUp && !outDown) { + //Thales Lima Oliveira 22/06/2015 + //Comentado para desaparecer a reta limite da curva (porque usar aquele limite??) + /*if (c1 != c0) { + if (c0 < minYpx) { + x0 = (int)(((float)(minYpx - c0))/((float)(c1 - c0))*(x1-x0)) + x0; + c0 = minYpx; + } + if (c0 > maxYpx) { + x0 = (int)(((float)(maxYpx - c0))/((float)(c1 - c0))*(x1-x0)) + x0; + //wxLogDebug(wxT("old x0 = %d, new x0 = %d"), x0, newX0); + //x0 = newX0; + c0 = maxYpx; + } + if (c1 < minYpx) { + x1 = (int)(((float)(minYpx - c0))/((float)(c1 - c0))*(x1-x0)) + x0; + c1 = minYpx; + } + if (c1 > maxYpx) { + x1 = (int)(((float)(maxYpx - c0))/((float)(c1 - c0))*(x1-x0)) + x0; + //wxLogDebug(wxT("old x0 = %d, old x1 = %d, new x1 = %d, c0 = %d, c1 = %d, maxYpx = %d"), x0, x1, newX1, c0, c1, maxYpx); + //x1 = newX1; + c1 = maxYpx; + } + } + if (x1 != x0) { + if (x0 < startPx) { + c0 = (int)(((float)(startPx - x0))/((float)(x1 -x0))*(c1 -c0)) + c0; + x0 = startPx; + } + if (x1 > endPx) { + c1 = (int)(((float)(endPx - x0))/((float)(x1 -x0))*(c1 -c0)) + c0; + x1 = endPx; + } + }*/ + + //dc.DrawLine(x0, c0, x1, c1); + //ptVector.push_back(wxPoint(x1, c1)); + UpdateViewBoundary(x1, c1); + } + } + ptVector.push_back(wxPoint(x1, c1)); + x0=x1; c0=c1; + } + + //modificado a forma de desenhar (desenha agora de forma contínua, permitindo usar diferentes tipos de traços) + wxPoint drawPts[ptVector.size()]; + for(int i = 0; i < (int)ptVector.size(); i++) { + drawPts[i] = ptVector[i]; + } + dc.DrawLines(ptVector.size(), drawPts); + + } + + if (!m_name.IsEmpty() && m_showName) + { + dc.SetFont(m_font); + + wxCoord tx, ty; + dc.GetTextExtent(m_name, &tx, &ty); + + // xxx implement else ... if (!HasBBox()) + { + // const int sx = w.GetScrX(); + // const int sy = w.GetScrY(); + + if ((m_flags & mpALIGNMASK) == mpALIGN_NW) + { + tx = minDrawX + 8; + ty = maxDrawY + 8; + } + else if ((m_flags & mpALIGNMASK) == mpALIGN_NE) + { + tx = maxDrawX - tx - 8; + ty = maxDrawY + 8; + } + else if ((m_flags & mpALIGNMASK) == mpALIGN_SE) + { + tx = maxDrawX - tx - 8; + ty = minDrawY - ty - 8; + } + else + { // mpALIGN_SW + tx = minDrawX + 8; + ty = minDrawY - ty - 8; + } + } + + dc.DrawText( m_name, tx, ty); + } + } +} + +//----------------------------------------------------------------------------- +// mpProfile implementation +//----------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(mpProfile, mpLayer) + +mpProfile::mpProfile(wxString name, int flags) +{ + SetName(name); + m_flags = flags; + m_type = mpLAYER_PLOT; +} + +void mpProfile::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + + wxCoord startPx = m_drawOutsideMargins ? 0 : w.GetMarginLeft(); + wxCoord endPx = m_drawOutsideMargins ? w.GetScrX() : w.GetScrX() - w.GetMarginRight(); + wxCoord minYpx = m_drawOutsideMargins ? 0 : w.GetMarginTop(); + wxCoord maxYpx = m_drawOutsideMargins ? w.GetScrY() : w.GetScrY() - w.GetMarginBottom(); + + // Plot profile linking subsequent point of the profile, instead of mpFY, which plots simple points. + for (wxCoord i = startPx; i < endPx; ++i) { + wxCoord c0 = w.y2p( GetY(w.p2x(i)) ); // (wxCoord) ((w.GetYpos() - GetY( (double)i / w.GetXscl() + w.GetXpos()) ) * w.GetYscl()); + wxCoord c1 = w.y2p( GetY(w.p2x(i+1)) );//(wxCoord) ((w.GetYpos() - GetY( (double)(i+1) / w.GetXscl() + (w.GetXpos() ) ) ) * w.GetYscl()); + // c0 = (c0 <= maxYpx) ? ((c0 >= minYpx) ? c0 : minYpx) : maxYpx; + // c1 = (c1 <= maxYpx) ? ((c1 >= minYpx) ? c1 : minYpx) : maxYpx; + if (!m_drawOutsideMargins) { + c0 = (c0 <= maxYpx) ? ((c0 >= minYpx) ? c0 : minYpx) : maxYpx; + c1 = (c1 <= maxYpx) ? ((c1 >= minYpx) ? c1 : minYpx) : maxYpx; + } + dc.DrawLine(i, c0, i+1, c1); + }; + if (!m_name.IsEmpty()) { + dc.SetFont(m_font); + + wxCoord tx, ty; + dc.GetTextExtent(m_name, &tx, &ty); + + if ((m_flags & mpALIGNMASK) == mpALIGN_RIGHT) + tx = (w.GetScrX() - tx) - w.GetMarginRight() - 8; + else if ((m_flags & mpALIGNMASK) == mpALIGN_CENTER) + tx = ((w.GetScrX() - w.GetMarginRight() - w.GetMarginLeft() - tx) / 2) + w.GetMarginLeft(); + else + tx = w.GetMarginLeft() + 8; + + dc.DrawText( m_name, tx, w.y2p( GetY( w.p2x(tx) ) ) );//(wxCoord) ((w.GetPosY() - GetY( (double)tx / w.GetScaleX() + w.GetPosX())) * w.GetScaleY()) ); + } + } +} + +//----------------------------------------------------------------------------- +// mpLayer implementations - furniture (scales, ...) +//----------------------------------------------------------------------------- + +#define mpLN10 2.3025850929940456840179914546844 + +IMPLEMENT_DYNAMIC_CLASS(mpScaleX, mpLayer) + +mpScaleX::mpScaleX(wxString name, int flags, bool ticks, unsigned int type) +{ + SetName(name); + SetFont( (wxFont&) *wxSMALL_FONT); + SetPen( (wxPen&) *wxGREY_PEN); + m_flags = flags; + m_ticks = ticks; + m_labelType = type; + m_type = mpLAYER_AXIS; + m_labelFormat = wxT(""); +} + +void mpScaleX::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + dc.SetFont( m_font); + int orgy=0; + + const int extend = w.GetScrX(); // /2; + if (m_flags == mpALIGN_CENTER) + orgy = w.y2p(0); //(int)(w.GetPosY() * w.GetScaleY()); + if (m_flags == mpALIGN_TOP) { + if (m_drawOutsideMargins) + orgy = X_BORDER_SEPARATION; + else + orgy = w.GetMarginTop(); + } + if (m_flags == mpALIGN_BOTTOM) { + if (m_drawOutsideMargins) + orgy = X_BORDER_SEPARATION; + else + orgy = w.GetScrY() - w.GetMarginBottom(); + } + if (m_flags == mpALIGN_BORDER_BOTTOM ) + orgy = w.GetScrY() - 1;//dc.LogicalToDeviceY(0) - 1; + if (m_flags == mpALIGN_BORDER_TOP ) + orgy = 1;//-dc.LogicalToDeviceY(0); + + //Thales Lima Oliveira - 23/06/2015 + //Inserido retângulo para tapar a curva que fica fora do gráfico + dc.SetBrush( wxBrush(w.GetBackgroundColour()) ); + dc.SetPen( *wxTRANSPARENT_PEN ); + dc.DrawRectangle( 0, orgy, w.GetScrX(), orgy); + dc.DrawRectangle( 0, 0, w.GetScrX(), w.GetMarginTop()); + dc.SetPen( m_pen); + + dc.DrawLine( w.GetMarginLeft(), orgy, w.GetScrX() - w.GetMarginRight(), orgy); + + // To cut the axis line when draw outside margin is false, use this code + /*if (m_drawOutsideMargins == true) + dc.DrawLine( 0, orgy, w.GetScrX(), orgy); + else + dc.DrawLine( w.GetMarginLeft(), orgy, w.GetScrX() - w.GetMarginRight(), orgy); */ + + const double dig = floor( log( 128.0 / w.GetScaleX() ) / mpLN10 ); + const double step = exp( mpLN10 * dig); + const double end = w.GetPosX() + (double)extend / w.GetScaleX(); + + wxCoord tx, ty; + wxString s; + wxString fmt; + int tmp = (int)dig; + if (m_labelType == mpX_NORMAL) { + if (!m_labelFormat.IsEmpty()) { + fmt = m_labelFormat; + } else { + if (tmp>=1) { + fmt = wxT("%.f"); + } else { + tmp=8-tmp; + fmt.Printf(wxT("%%.%df"), tmp >= -1 ? 2 : -tmp); + } + } + } else { + // Date and/or time axis representation + if (m_labelType == mpX_DATETIME) { + fmt = (wxT("%04.0f-%02.0f-%02.0fT%02.0f:%02.0f:%02.0f")); + } else if (m_labelType == mpX_DATE) { + fmt = (wxT("%04.0f-%02.0f-%02.0f")); + } else if ((m_labelType == mpX_TIME) && (end/60 < 2)) { + fmt = (wxT("%02.0f:%02.3f")); + } else { + fmt = (wxT("%02.0f:%02.0f:%02.0f")); + } + } + + //double n = floor( (w.GetPosX() - (double)extend / w.GetScaleX()) / step ) * step ; + double n0 = floor( (w.GetPosX() /* - (double)(extend - w.GetMarginLeft() - w.GetMarginRight())/ w.GetScaleX() */) / step ) * step ; + double n = 0; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("mpScaleX::Plot: dig: %f , step: %f, end: %f, n: %f"), dig, step, end, n0); +#endif + wxCoord startPx = m_drawOutsideMargins ? 0 : w.GetMarginLeft(); + wxCoord endPx = m_drawOutsideMargins ? w.GetScrX() : w.GetScrX() - w.GetMarginRight(); + wxCoord minYpx = m_drawOutsideMargins ? 0 : w.GetMarginTop(); + wxCoord maxYpx = m_drawOutsideMargins ? w.GetScrY() : w.GetScrY() - w.GetMarginBottom(); + + tmp=-65535; + int labelH = 0; // Control labels heigth to decide where to put axis name (below labels or on top of axis) + int maxExtent = 0; + for (n = n0; n < end; n += step) { + const int p = (int)((n - w.GetPosX()) * w.GetScaleX()); +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("mpScaleX::Plot: n: %f -> p = %d"), n, p); +#endif + if ((p >= startPx) && (p <= endPx)) { + if (m_ticks) { // draw axis ticks + if (m_flags == mpALIGN_BORDER_BOTTOM) + dc.DrawLine( p, orgy, p, orgy-4); + else + dc.DrawLine( p, orgy, p, orgy+4); + } else { // draw grid dotted lines + m_pen.SetStyle(wxDOT); + dc.SetPen(m_pen); + if ((m_flags == mpALIGN_BOTTOM) && !m_drawOutsideMargins) { + dc.DrawLine( p, orgy+4, p, minYpx ); + } else { + if ((m_flags == mpALIGN_TOP) && !m_drawOutsideMargins) { + dc.DrawLine( p, orgy-4, p, maxYpx ); + } else { + dc.DrawLine( p, 0/*-w.GetScrY()*/, p, w.GetScrY() ); + } + } + m_pen.SetStyle(wxSOLID); + dc.SetPen(m_pen); + } + // Write ticks labels in s string + if (m_labelType == mpX_NORMAL) + s.Printf(fmt, n); + else if (m_labelType == mpX_DATETIME) { + time_t when = (time_t)n; + struct tm tm = *localtime(&when); + s.Printf(fmt, (double)tm.tm_year+1900, (double)tm.tm_mon+1, (double)tm.tm_mday, (double)tm.tm_hour, (double)tm.tm_min, (double)tm.tm_sec); + } else if (m_labelType == mpX_DATE) { + time_t when = (time_t)n; + struct tm tm = *localtime(&when); + s.Printf(fmt, (double)tm.tm_year+1900, (double)tm.tm_mon+1, (double)tm.tm_mday); + } else if ((m_labelType == mpX_TIME) || (m_labelType == mpX_HOURS)) { + double modulus = fabs(n); + double sign = n/modulus; + double hh = floor(modulus/3600); + double mm = floor((modulus - hh*3600)/60); + double ss = modulus - hh*3600 - mm*60; + #ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("%02.0f Hours, %02.0f minutes, %02.0f seconds"), sign*hh, mm, ss); + #endif // MATHPLOT_DO_LOGGING + if (fmt.Len() == 20) // Format with hours has 11 chars + s.Printf(fmt, sign*hh, mm, floor(ss)); + else + s.Printf(fmt, sign*mm, ss); + } + dc.GetTextExtent(s, &tx, &ty); + labelH = (labelH <= ty) ? ty : labelH; +/* if ((p-tx/2-tmp) > 64) { // Problem about non-regular axis labels + if ((m_flags == mpALIGN_BORDER_BOTTOM) || (m_flags == mpALIGN_TOP)) { + dc.DrawText( s, p-tx/2, orgy-4-ty); + } else { + dc.DrawText( s, p-tx/2, orgy+4); + } + tmp=p+tx/2; + } + */ + maxExtent = (tx > maxExtent) ? tx : maxExtent; // Keep in mind max label width + } + } + // Actually draw labels, taking care of not overlapping them, and distributing them regularly + double labelStep = ceil((maxExtent + mpMIN_X_AXIS_LABEL_SEPARATION)/(w.GetScaleX()*step))*step; + for (n = n0; n < end; n += labelStep) { + const int p = (int)((n - w.GetPosX()) * w.GetScaleX()); +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("mpScaleX::Plot: n_label = %f -> p_label = %d"), n, p); +#endif + if ((p >= startPx) && (p <= endPx)) { + // Write ticks labels in s string + if (m_labelType == mpX_NORMAL) + s.Printf(fmt, n); + else if (m_labelType == mpX_DATETIME) { + time_t when = (time_t)n; + struct tm tm = *localtime(&when); + s.Printf(fmt, (double)tm.tm_year+1900, (double)tm.tm_mon+1, (double)tm.tm_mday, (double)tm.tm_hour, (double)tm.tm_min, (double)tm.tm_sec); + } else if (m_labelType == mpX_DATE) { + time_t when = (time_t)n; + struct tm tm = *localtime(&when); + s.Printf(fmt, (double)tm.tm_year+1900, (double)tm.tm_mon+1, (double)tm.tm_mday); + } else if ((m_labelType == mpX_TIME) || (m_labelType == mpX_HOURS)) { + double modulus = fabs(n); + double sign = n/modulus; + double hh = floor(modulus/3600); + double mm = floor((modulus - hh*3600)/60); + double ss = modulus - hh*3600 - mm*60; + #ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("%02.0f Hours, %02.0f minutes, %02.0f seconds"), sign*hh, mm, ss); + #endif // MATHPLOT_DO_LOGGING + if (fmt.Len() == 20) // Format with hours has 11 chars + s.Printf(fmt, sign*hh, mm, floor(ss)); + else + s.Printf(fmt, sign*mm, ss); + } + dc.GetTextExtent(s, &tx, &ty); + if ((m_flags == mpALIGN_BORDER_BOTTOM) || (m_flags == mpALIGN_TOP)) { + dc.DrawText( s, p-tx/2, orgy-4-ty); + } else { + dc.DrawText( s, p-tx/2, orgy+4); + } + } + } + + // Draw axis name + dc.GetTextExtent(m_name, &tx, &ty); + switch (m_flags) { + case mpALIGN_BORDER_BOTTOM: + dc.DrawText( m_name, extend - tx - 4, orgy - 8 - ty - labelH); + break; + case mpALIGN_BOTTOM: { + if ((!m_drawOutsideMargins) && (w.GetMarginBottom() > (ty + labelH + 8))) { + dc.DrawText( m_name, (endPx - startPx - tx)>>1, orgy + 6 + labelH); + } else { + dc.DrawText( m_name, extend - tx - 4, orgy - 4 - ty); + } + } break; + case mpALIGN_CENTER: + dc.DrawText( m_name, extend - tx - 4, orgy - 4 - ty); + break; + case mpALIGN_TOP: { + if ((!m_drawOutsideMargins) && (w.GetMarginTop() > (ty + labelH + 8))) { + dc.DrawText( m_name, (endPx - startPx - tx)>>1, orgy - 6 - ty - labelH); + } else { + dc.DrawText( m_name, extend - tx - 4, orgy + 4); + } + } break; + case mpALIGN_BORDER_TOP: + dc.DrawText( m_name, extend - tx - 4, orgy + 6 + labelH); + break; + default: + break; + } + } +/* if (m_flags != mpALIGN_TOP) { + + if ((m_flags == mpALIGN_BORDER_BOTTOM) || (m_flags == mpALIGN_TOP)) { + dc.DrawText( m_name, extend - tx - 4, orgy - 4 - (ty*2)); + } else { + dc.DrawText( m_name, extend - tx - 4, orgy - 4 - ty); //orgy + 4 + ty); + } + }; */ +} + +IMPLEMENT_DYNAMIC_CLASS(mpScaleY, mpLayer) + +mpScaleY::mpScaleY(wxString name, int flags, bool ticks) +{ + SetName(name); + SetFont( (wxFont&) *wxSMALL_FONT); + SetPen( (wxPen&) *wxGREY_PEN); + m_flags = flags; + m_ticks = ticks; + m_type = mpLAYER_AXIS; + m_labelFormat = wxT(""); +} + +void mpScaleY::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + dc.SetFont( m_font); + + int orgx=0; + const int extend = w.GetScrY(); // /2; + if (m_flags == mpALIGN_CENTER) + orgx = w.x2p(0); //(int)(w.GetPosX() * w.GetScaleX()); + if (m_flags == mpALIGN_LEFT) { + if (m_drawOutsideMargins) + orgx = Y_BORDER_SEPARATION; + else + orgx = w.GetMarginLeft(); + } + if (m_flags == mpALIGN_RIGHT) { + if (m_drawOutsideMargins) + orgx = w.GetScrX() - Y_BORDER_SEPARATION; + else + orgx = w.GetScrX() - w.GetMarginRight(); + } + if (m_flags == mpALIGN_BORDER_RIGHT ) + orgx = w.GetScrX() - 1; //dc.LogicalToDeviceX(0) - 1; + if (m_flags == mpALIGN_BORDER_LEFT ) + orgx = 1; //-dc.LogicalToDeviceX(0); + + dc.SetBrush( wxBrush(w.GetBackgroundColour()) ); + dc.SetPen( *wxTRANSPARENT_PEN ); + dc.DrawRectangle( 0, 0, orgx, extend); + dc.DrawRectangle( w.GetScrX() - w.GetMarginRight(), 0, w.GetScrX() - w.GetMarginRight(), extend); + dc.SetPen( m_pen); + + // Draw line + dc.DrawLine( orgx, w.GetMarginTop(), orgx, w.GetScrY() - w.GetMarginBottom()); + + // To cut the axis line when draw outside margin is false, use this code + /* if (m_drawOutsideMargins == true) + dc.DrawLine( orgx, 0, orgx, extend); + else + dc.DrawLine( orgx, w.GetMarginTop(), orgx, w.GetScrY() - w.GetMarginBottom()); */ + + const double dig = floor( log( 128.0 / w.GetScaleY() ) / mpLN10 ); + const double step = exp( mpLN10 * dig); + const double end = w.GetPosY() + (double)extend / w.GetScaleY(); + + wxCoord tx, ty; + wxString s; + wxString fmt; + int tmp = (int)dig; + double maxScaleAbs = fabs(w.GetDesiredYmax()); + double minScaleAbs = fabs(w.GetDesiredYmin()); + double endscale = (maxScaleAbs > minScaleAbs) ? maxScaleAbs : minScaleAbs; + if (m_labelFormat.IsEmpty()) { + if ((endscale < 1e4) && (endscale > 1e-3)) + fmt = wxT("%.2f"); + else + fmt = wxT("%.1e"); + } else { + fmt = m_labelFormat; + } + /* if (tmp>=1) + {*/ + // fmt = wxT("%7.5g"); + // } + // else + // { + // tmp=8-tmp; + // fmt.Printf(wxT("%%.%dg"), (tmp >= -1) ? 2 : -tmp); + // } + + double n = floor( (w.GetPosY() - (double)(extend - w.GetMarginTop() - w.GetMarginBottom())/ w.GetScaleY()) / step ) * step ; + + /* wxCoord startPx = m_drawOutsideMargins ? 0 : w.GetMarginLeft(); */ + wxCoord endPx = m_drawOutsideMargins ? w.GetScrX() : w.GetScrX() - w.GetMarginRight(); + wxCoord minYpx = m_drawOutsideMargins ? 0 : w.GetMarginTop(); + wxCoord maxYpx = m_drawOutsideMargins ? w.GetScrY() : w.GetScrY() - w.GetMarginBottom(); + + tmp=65536; + int labelW = 0; + // Before staring cycle, calculate label height + int labelHeigth = 0; + s.Printf(fmt,n); + dc.GetTextExtent(s, &tx, &labelHeigth); + for (;n < end; n += step) { + const int p = (int)((w.GetPosY() - n) * w.GetScaleY()); + if ((p >= minYpx) && (p <= maxYpx)) { + if (m_ticks) { // Draw axis ticks + if (m_flags == mpALIGN_BORDER_LEFT) { + dc.DrawLine( orgx, p, orgx+4, p); + } else { + dc.DrawLine( orgx-4, p, orgx, p); //( orgx, p, orgx+4, p); + } + } else { + m_pen.SetStyle(wxDOT); + dc.SetPen( m_pen); + if ((m_flags == mpALIGN_LEFT) && !m_drawOutsideMargins) { + dc.DrawLine( orgx-4, p, endPx, p); + } else { + if ((m_flags == mpALIGN_RIGHT) && !m_drawOutsideMargins) { + dc.DrawLine( minYpx, p, orgx+4, p); + } else { + dc.DrawLine( 0/*-w.GetScrX()*/, p, w.GetScrX(), p); + } + } + m_pen.SetStyle(wxSOLID); + dc.SetPen( m_pen); + } + // Print ticks labels + s.Printf(fmt, n); + dc.GetTextExtent(s, &tx, &ty); +#ifdef MATHPLOT_DO_LOGGING + if (ty != labelHeigth) wxLogMessage(wxT("mpScaleY::Plot: ty(%f) and labelHeigth(%f) differ!"), ty, labelHeigth); +#endif + labelW = (labelW <= tx) ? tx : labelW; + if ((tmp-p+labelHeigth/2) > mpMIN_Y_AXIS_LABEL_SEPARATION) { + if ((m_flags == mpALIGN_BORDER_LEFT) || (m_flags == mpALIGN_RIGHT)) + dc.DrawText( s, orgx+4, p-ty/2); + else + dc.DrawText( s, orgx-4-tx, p-ty/2); //( s, orgx+4, p-ty/2); + tmp=p-labelHeigth/2; + } + } + } + // Draw axis name + + dc.GetTextExtent(m_name, &tx, &ty); + switch (m_flags) { + case mpALIGN_BORDER_LEFT: + dc.DrawText( m_name, labelW + 8, 4); + break; + case mpALIGN_LEFT: { + if ((!m_drawOutsideMargins) && (w.GetMarginLeft() > (ty + labelW + 8))) { + dc.DrawRotatedText( m_name, orgx - 6 - labelW - ty, (maxYpx - minYpx + tx)>>1, 90); + } else { + dc.DrawText( m_name, orgx + 4, 4); + } + } break; + case mpALIGN_CENTER: + dc.DrawText( m_name, orgx + 4, 4); + break; + case mpALIGN_RIGHT: { + if ((!m_drawOutsideMargins) && (w.GetMarginRight() > (ty + labelW + 8))) { + dc.DrawRotatedText( m_name, orgx + 6 + labelW, (maxYpx - minYpx + tx)>>1, 90); + } else { + dc.DrawText( m_name, orgx - tx - 4, 4); + } + } break; + case mpALIGN_BORDER_RIGHT: + dc.DrawText( m_name, orgx - 6 - tx -labelW, 4); + break; + default: + break; + } + } + +/* if (m_flags != mpALIGN_RIGHT) { + dc.GetTextExtent(m_name, &tx, &ty); + if (m_flags == mpALIGN_BORDER_LEFT) { + dc.DrawText( m_name, orgx-tx-4, -extend + ty + 4); + } else { + if (m_flags == mpALIGN_BORDER_RIGHT ) + dc.DrawText( m_name, orgx-(tx*2)-4, -extend + ty + 4); + else + dc.DrawText( m_name, orgx + 4, -extend + 4); + } + }; */ +} + +//----------------------------------------------------------------------------- +// mpWindow +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(mpWindow, wxWindow) + +BEGIN_EVENT_TABLE(mpWindow, wxWindow) + EVT_PAINT ( mpWindow::OnPaint) + EVT_SIZE ( mpWindow::OnSize) + EVT_SCROLLWIN_THUMBTRACK(mpWindow::OnScrollThumbTrack) + EVT_SCROLLWIN_PAGEUP(mpWindow::OnScrollPageUp) + EVT_SCROLLWIN_PAGEDOWN(mpWindow::OnScrollPageDown) + EVT_SCROLLWIN_LINEUP(mpWindow::OnScrollLineUp) + EVT_SCROLLWIN_LINEDOWN(mpWindow::OnScrollLineDown) + EVT_SCROLLWIN_TOP(mpWindow::OnScrollTop) + EVT_SCROLLWIN_BOTTOM(mpWindow::OnScrollBottom) + + EVT_MIDDLE_UP( mpWindow::OnShowPopupMenu) + EVT_RIGHT_DOWN( mpWindow::OnMouseRightDown) // JLB + EVT_RIGHT_UP ( mpWindow::OnShowPopupMenu) + EVT_MOUSEWHEEL( mpWindow::OnMouseWheel ) // JLB + EVT_MOTION( mpWindow::OnMouseMove ) // JLB + EVT_LEFT_DOWN( mpWindow::OnMouseLeftDown) + EVT_LEFT_UP( mpWindow::OnMouseLeftRelease) + + EVT_MENU( mpID_CENTER, mpWindow::OnCenter) + EVT_MENU( mpID_FIT, mpWindow::OnFit) + EVT_MENU( mpID_ZOOM_IN, mpWindow::OnZoomIn) + EVT_MENU( mpID_ZOOM_OUT, mpWindow::OnZoomOut) + EVT_MENU( mpID_LOCKASPECT,mpWindow::OnLockAspect) + EVT_MENU( mpID_HELP_MOUSE,mpWindow::OnMouseHelp) +END_EVENT_TABLE() + +mpWindow::mpWindow( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long flag ) + : wxWindow( parent, id, pos, size, flag, wxT("mathplot") ) +{ + selectionRect = wxRect(0,0,0,0); + srColour = *wxBLACK; + + m_scaleX = m_scaleY = 1.0; + m_posX = m_posY = 0; + m_desiredXmin=m_desiredYmin=0; + m_desiredXmax=m_desiredYmax=1; + m_scrX = m_scrY = 64; // Fixed from m_scrX = m_scrX = 64; + m_minX = m_minY = 0; + m_maxX = m_maxY = 0; + m_last_lx= m_last_ly= 0; + m_buff_bmp = NULL; + m_enableDoubleBuffer = FALSE; + m_enableMouseNavigation = TRUE; + m_mouseMovedAfterRightClick = FALSE; + m_movingInfoLayer = NULL; + // Set margins to 0 + m_marginTop = 0; m_marginRight = 0; m_marginBottom = 0; m_marginLeft = 0; + + + m_lockaspect = FALSE; + + m_popmenu.Append( mpID_CENTER, _("Centralizar"), _("Centraliza a vizualização gráfico nesta posição")); + m_popmenu.Append( mpID_FIT, _("Encaixar"), _("Ajusta a vizualização para exibição de todos os itens")); + m_popmenu.Append( mpID_ZOOM_IN, _("Mais Zoom"), _("Mais Zoom na vizualização do gráfico.")); + m_popmenu.Append( mpID_ZOOM_OUT, _("Menos Zoom"), _("Menos Zoom na vizualização do gráfico.")); + m_popmenu.AppendCheckItem( mpID_LOCKASPECT, _("Bloquear proporções"), _("Bloquear as proporções do zoom horizontal e vertical.")); + m_popmenu.Append( mpID_HELP_MOUSE, _("Mostrar comandos do mouse..."), _("Exibe a ajuda sobre os comandos do mouse.")); + + m_layers.clear(); + SetBackgroundColour( *wxWHITE ); + m_bgColour = *wxWHITE; + m_fgColour = *wxBLACK; + + m_enableScrollBars = false; + SetSizeHints(128, 128); + + // J.L.Blanco: Eliminates the "flick" with the double buffer. + SetBackgroundStyle( wxBG_STYLE_CUSTOM ); + + UpdateAll(); +} + +mpWindow::~mpWindow() +{ + // Free all the layers: + DelAllLayers( true, false ); + + if (m_buff_bmp) + { + delete m_buff_bmp; + m_buff_bmp = NULL; + } +} + +// Mouse handler, for detecting when the user drag with the right button or just "clicks" for the menu +// JLB +void mpWindow::OnMouseRightDown(wxMouseEvent &event) +{ + m_mouseMovedAfterRightClick = FALSE; + m_mouseRClick_X = event.GetX(); + m_mouseRClick_Y = event.GetY(); + if (m_enableMouseNavigation) + { + SetCursor( *wxCROSS_CURSOR ); + } +} + +// Process mouse wheel events +// JLB +void mpWindow::OnMouseWheel( wxMouseEvent &event ) +{ + if (!m_enableMouseNavigation) + { + event.Skip(); + return; + } + +// GetClientSize( &m_scrX,&m_scrY); + + if (event.m_controlDown) + { + wxPoint clickPt( event.GetX(),event.GetY() ); + // CTRL key hold: Zoom in/out: + if (event.GetWheelRotation()>0) + ZoomIn( clickPt ); + else ZoomOut( clickPt ); + } + else + { + // Scroll vertically or horizontally (this is SHIFT is hold down). + int change = - event.GetWheelRotation(); // Opposite direction (More intuitive)! + double changeUnitsX = change / m_scaleX; + double changeUnitsY = change / m_scaleY; + + if (event.m_shiftDown) + { + m_posX += changeUnitsX; + m_desiredXmax += changeUnitsX; + m_desiredXmin += changeUnitsX; + } + else + { + m_posY -= changeUnitsY; + m_desiredYmax -= changeUnitsY; + m_desiredYmax -= changeUnitsY; + } + + UpdateAll(); + } +} + +// If the user "drags" with the right buttom pressed, do "pan" +// JLB +void mpWindow::OnMouseMove(wxMouseEvent &event) +{ + if (!m_enableMouseNavigation) + { + event.Skip(); + return; + } + + if (event.m_rightDown) + { + m_mouseMovedAfterRightClick = TRUE; // Hides the popup menu after releasing the button! + + // The change: + int Ax= m_mouseRClick_X - event.GetX(); + int Ay= m_mouseRClick_Y - event.GetY(); + + // For the next event, use relative to this coordinates. + m_mouseRClick_X = event.GetX(); + m_mouseRClick_Y = event.GetY(); + + double Ax_units = Ax / m_scaleX; + double Ay_units = -Ay / m_scaleY; + + m_posX += Ax_units; + m_posY += Ay_units; + m_desiredXmax += Ax_units; + m_desiredXmin += Ax_units; + m_desiredYmax += Ay_units; + m_desiredYmin += Ay_units; + + UpdateAll(); + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("[mpWindow::OnMouseMove] Ax:%i Ay:%i m_posX:%f m_posY:%f"),Ax,Ay,m_posX,m_posY); +#endif + } else { + if (event.m_leftDown) { + if (m_movingInfoLayer == NULL) { + /*wxClientDC dc(this); + wxPen pen(*wxBLACK, 1, wxDOT); + dc.SetPen(pen); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawRectangle(m_mouseLClick_X, m_mouseLClick_Y, event.GetX() - m_mouseLClick_X, event.GetY() - m_mouseLClick_Y);*/ + selectionRect = wxRect(m_mouseLClick_X, m_mouseLClick_Y, event.GetX() - m_mouseLClick_X, event.GetY() - m_mouseLClick_Y); + } else { + wxPoint moveVector(event.GetX() - m_mouseLClick_X, event.GetY() - m_mouseLClick_Y); + m_movingInfoLayer->Move(moveVector); + } + UpdateAll(); + } else { + wxLayerList::iterator li; + for (li = m_layers.begin(); li != m_layers.end(); li++) { + if ((*li)->IsInfo() && (*li)->IsVisible()) { + mpInfoLayer* tmpLyr = (mpInfoLayer*) (*li); + tmpLyr->UpdateInfo(*this, event); + // UpdateAll(); + RefreshRect(tmpLyr->GetRectangle()); + } + } + /* if (m_coordTooltip) { + wxString toolTipContent; + toolTipContent.Printf(_("X = %f\nY = %f"), p2x(event.GetX()), p2y(event.GetY())); + wxTipWindow** ptr = NULL; + wxRect rectBounds(event.GetX(), event.GetY(), 5, 5); + wxTipWindow* tip = new wxTipWindow(this, toolTipContent, 100, ptr, &rectBounds); + + } */ + } + } + event.Skip(); +} + +void mpWindow::OnMouseLeftDown (wxMouseEvent &event) +{ + m_mouseLClick_X = event.GetX(); + m_mouseLClick_Y = event.GetY(); +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::OnMouseLeftDown() X = %d , Y = %d"), event.GetX(), event.GetY());/*m_mouseLClick_X, m_mouseLClick_Y);*/ +#endif + wxPoint pointClicked = event.GetPosition(); + m_movingInfoLayer = IsInsideInfoLayer(pointClicked); + if (m_movingInfoLayer != NULL) { +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::OnMouseLeftDown() started moving layer %lx"), (long int) m_movingInfoLayer);/*m_mouseLClick_X, m_mouseLClick_Y);*/ +#endif + } + /*/Modificação - Thales 22/06/2015 + if(event.Dragging() && m_movingInfoLayer == NULL) + { + wxClientDC dc(this); + wxPen pen(*wxBLACK, 1, wxDOT); + dc.SetPen(pen); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawRectangle(m_mouseLClick_X, m_mouseLClick_Y, event.GetX() - m_mouseLClick_X, event.GetY() - m_mouseLClick_Y); + }*/ + event.Skip(); +} + +void mpWindow::OnMouseLeftRelease (wxMouseEvent &event) +{ + wxPoint release(event.GetX(), event.GetY()); + wxPoint press(m_mouseLClick_X, m_mouseLClick_Y); + if (m_movingInfoLayer != NULL) { + m_movingInfoLayer->UpdateReference(); + m_movingInfoLayer = NULL; + } else { + if (release != press) { + ZoomRect(press, release); + } /*else { + if (m_coordTooltip) { + wxString toolTipContent; + toolTipContent.Printf(_("X = %f\nY = %f"), p2x(event.GetX()), p2y(event.GetY())); + SetToolTip(toolTipContent); + } + } */ + } + selectionRect = wxRect(0,0,0,0); + event.Skip(); +} + +void mpWindow::Fit() +{ + if (UpdateBBox()) + Fit(m_minX ,m_maxX ,m_minY ,m_maxY ); +} + + +// JL +void mpWindow::Fit(double xMin, double xMax, double yMin, double yMax, wxCoord *printSizeX,wxCoord *printSizeY) +{ + // Save desired borders: + m_desiredXmin=xMin; m_desiredXmax=xMax; + m_desiredYmin=yMin; m_desiredYmax=yMax; + + if (printSizeX!=NULL && printSizeY!=NULL) + { + // Printer: + m_scrX = *printSizeX; + m_scrY = *printSizeY; + } + else + { + // Normal case (screen): + GetClientSize( &m_scrX,&m_scrY); + } + + double Ax,Ay; + + Ax = xMax - xMin; + Ay = yMax - yMin; + + m_scaleX = (Ax!=0) ? (m_scrX - m_marginLeft - m_marginRight)/Ax : 1; //m_scaleX = (Ax!=0) ? m_scrX/Ax : 1; + m_scaleY = (Ay!=0) ? (m_scrY - m_marginTop - m_marginBottom)/Ay : 1; //m_scaleY = (Ay!=0) ? m_scrY/Ay : 1; + + if (m_lockaspect) + { +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::Fit()(lock) m_scaleX=%f,m_scaleY=%f"), m_scaleX,m_scaleY); +#endif + // Keep the lowest "scale" to fit the whole range required by that axis (to actually "fit"!): + double s = m_scaleX < m_scaleY ? m_scaleX : m_scaleY; + m_scaleX = s; + m_scaleY = s; + } + + // Adjusts corner coordinates: This should be simply: + // m_posX = m_minX; + // m_posY = m_maxY; + // But account for centering if we have lock aspect: + m_posX = (xMin+xMax)/2 - ((m_scrX - m_marginLeft - m_marginRight)/2 + m_marginLeft)/m_scaleX ; // m_posX = (xMin+xMax)/2 - (m_scrX/2)/m_scaleX; +// m_posY = (yMin+yMax)/2 + ((m_scrY - m_marginTop - m_marginBottom)/2 - m_marginTop)/m_scaleY; // m_posY = (yMin+yMax)/2 + (m_scrY/2)/m_scaleY; + m_posY = (yMin+yMax)/2 + ((m_scrY - m_marginTop - m_marginBottom)/2 + m_marginTop)/m_scaleY; // m_posY = (yMin+yMax)/2 + (m_scrY/2)/m_scaleY; + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::Fit() m_desiredXmin=%f m_desiredXmax=%f m_desiredYmin=%f m_desiredYmax=%f"), xMin,xMax,yMin,yMax); + wxLogMessage(_("mpWindow::Fit() m_scaleX = %f , m_scrX = %d,m_scrY=%d, Ax=%f, Ay=%f, m_posX=%f, m_posY=%f"), m_scaleX, m_scrX,m_scrY, Ax,Ay,m_posX,m_posY); +#endif + + // It is VERY IMPORTANT to DO NOT call Refresh if we are drawing to the printer!! + // Otherwise, the DC dimensions will be those of the window instead of the printer device + if (printSizeX==NULL || printSizeY==NULL) + UpdateAll(); +} + +// Patch ngpaton +void mpWindow::DoZoomInXCalc (const int staticXpixel) +{ + // Preserve the position of the clicked point: + double staticX = p2x( staticXpixel ); + // Zoom in: + m_scaleX = m_scaleX * zoomIncrementalFactor; + // Adjust the new m_posx + m_posX = staticX - (staticXpixel / m_scaleX); + // Adjust desired + m_desiredXmin = m_posX; + m_desiredXmax = m_posX + (m_scrX - (m_marginLeft + m_marginRight)) / m_scaleX; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::DoZoomInXCalc() prior X coord: (%f), new X coord: (%f) SHOULD BE EQUAL!!"), staticX, p2x(staticXpixel)); +#endif +} + +void mpWindow::DoZoomInYCalc (const int staticYpixel) +{ + // Preserve the position of the clicked point: + double staticY = p2y( staticYpixel ); + // Zoom in: + m_scaleY = m_scaleY * zoomIncrementalFactor; + // Adjust the new m_posy: + m_posY = staticY + (staticYpixel / m_scaleY); + // Adjust desired + m_desiredYmax = m_posY; + m_desiredYmin = m_posY - (m_scrY - (m_marginTop + m_marginBottom)) / m_scaleY; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::DoZoomInYCalc() prior Y coord: (%f), new Y coord: (%f) SHOULD BE EQUAL!!"), staticY, p2y(staticYpixel)); +#endif +} + +void mpWindow::DoZoomOutXCalc (const int staticXpixel) +{ + // Preserve the position of the clicked point: + double staticX = p2x( staticXpixel ); + // Zoom out: + m_scaleX = m_scaleX / zoomIncrementalFactor; + // Adjust the new m_posx/y: + m_posX = staticX - (staticXpixel / m_scaleX); + // Adjust desired + m_desiredXmin = m_posX; + m_desiredXmax = m_posX + (m_scrX - (m_marginLeft + m_marginRight)) / m_scaleX; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::DoZoomOutXCalc() prior X coord: (%f), new X coord: (%f) SHOULD BE EQUAL!!"), staticX, p2x(staticXpixel)); +#endif +} + +void mpWindow::DoZoomOutYCalc (const int staticYpixel) +{ + // Preserve the position of the clicked point: + double staticY = p2y( staticYpixel ); + // Zoom out: + m_scaleY = m_scaleY / zoomIncrementalFactor; + // Adjust the new m_posx/y: + m_posY = staticY + (staticYpixel / m_scaleY); + // Adjust desired + m_desiredYmax = m_posY; + m_desiredYmin = m_posY - (m_scrY - (m_marginTop + m_marginBottom)) / m_scaleY; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::DoZoomOutYCalc() prior Y coord: (%f), new Y coord: (%f) SHOULD BE EQUAL!!"), staticY, p2y(staticYpixel)); +#endif +} + + +void mpWindow::ZoomIn(const wxPoint& centerPoint ) +{ + wxPoint c(centerPoint); + if (c == wxDefaultPosition) + { + GetClientSize(&m_scrX, &m_scrY); + c.x = (m_scrX - m_marginLeft - m_marginRight)/2 + m_marginLeft; // c.x = m_scrX/2; + c.y = (m_scrY - m_marginTop - m_marginBottom)/2 - m_marginTop; // c.y = m_scrY/2; +} + + // Preserve the position of the clicked point: + double prior_layer_x = p2x( c.x ); + double prior_layer_y = p2y( c.y ); + + // Zoom in: + m_scaleX = m_scaleX * zoomIncrementalFactor; + m_scaleY = m_scaleY * zoomIncrementalFactor; + + // Adjust the new m_posx/y: + m_posX = prior_layer_x - c.x / m_scaleX; + m_posY = prior_layer_y + c.y / m_scaleY; + + m_desiredXmin = m_posX; + m_desiredXmax = m_posX + (m_scrX - m_marginLeft - m_marginRight) / m_scaleX; // m_desiredXmax = m_posX + m_scrX / m_scaleX; + m_desiredYmax = m_posY; + m_desiredYmin = m_posY - (m_scrY - m_marginTop - m_marginBottom) / m_scaleY; // m_desiredYmin = m_posY - m_scrY / m_scaleY; + + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::ZoomIn() prior coords: (%f,%f), new coords: (%f,%f) SHOULD BE EQUAL!!"), prior_layer_x,prior_layer_y, p2x(c.x),p2y(c.y)); +#endif + + UpdateAll(); +} + +void mpWindow::ZoomOut(const wxPoint& centerPoint ) +{ + wxPoint c(centerPoint); + if (c == wxDefaultPosition) + { + GetClientSize(&m_scrX, &m_scrY); + c.x = (m_scrX - m_marginLeft - m_marginRight)/2 + m_marginLeft; // c.x = m_scrX/2; + c.y = (m_scrY - m_marginTop - m_marginBottom)/2 - m_marginTop; // c.y = m_scrY/2; + } + + // Preserve the position of the clicked point: + double prior_layer_x = p2x( c.x ); + double prior_layer_y = p2y( c.y ); + + // Zoom out: + m_scaleX = m_scaleX / zoomIncrementalFactor; + m_scaleY = m_scaleY / zoomIncrementalFactor; + + // Adjust the new m_posx/y: + m_posX = prior_layer_x - c.x / m_scaleX; + m_posY = prior_layer_y + c.y / m_scaleY; + + m_desiredXmin = m_posX; + m_desiredXmax = m_posX + (m_scrX - m_marginLeft - m_marginRight) / m_scaleX; // m_desiredXmax = m_posX + m_scrX / m_scaleX; + m_desiredYmax = m_posY; + m_desiredYmin = m_posY - (m_scrY - m_marginTop - m_marginBottom) / m_scaleY; // m_desiredYmin = m_posY - m_scrY / m_scaleY; + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::ZoomOut() prior coords: (%f,%f), new coords: (%f,%f) SHOULD BE EQUAL!!"), prior_layer_x,prior_layer_y, p2x(c.x),p2y(c.y)); +#endif + UpdateAll(); +} + +void mpWindow::ZoomInX() +{ + m_scaleX = m_scaleX * zoomIncrementalFactor; + UpdateAll(); +} + +void mpWindow::ZoomOutX() +{ + m_scaleX = m_scaleX / zoomIncrementalFactor; + UpdateAll(); +} + +void mpWindow::ZoomInY() +{ + m_scaleY = m_scaleY * zoomIncrementalFactor; + UpdateAll(); +} + +void mpWindow::ZoomOutY() +{ + m_scaleY = m_scaleY / zoomIncrementalFactor; + UpdateAll(); +} + +void mpWindow::ZoomRect(wxPoint p0, wxPoint p1) +{ + // Compute the 2 corners in graph coordinates: + double p0x = p2x(p0.x); + double p0y = p2y(p0.y); + double p1x = p2x(p1.x); + double p1y = p2y(p1.y); + + // Order them: + double zoom_x_min = p0x<p1x ? p0x:p1x; + double zoom_x_max = p0x>p1x ? p0x:p1x; + double zoom_y_min = p0y<p1y ? p0y:p1y; + double zoom_y_max = p0y>p1y ? p0y:p1y; + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("Zoom: (%f,%f)-(%f,%f)"),zoom_x_min,zoom_y_min,zoom_x_max,zoom_y_max); +#endif + + Fit(zoom_x_min,zoom_x_max,zoom_y_min,zoom_y_max); +} + +void mpWindow::LockAspect(bool enable) +{ + m_lockaspect = enable; + m_popmenu.Check(mpID_LOCKASPECT, enable); + + // Try to fit again with the new config: + Fit( m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax ); +} + +void mpWindow::OnShowPopupMenu(wxMouseEvent &event) +{ + // Only display menu if the user has not "dragged" the figure + if (m_enableMouseNavigation) + { + SetCursor( *wxSTANDARD_CURSOR ); + } + + if (!m_mouseMovedAfterRightClick) // JLB + { + m_clickedX = event.GetX(); + m_clickedY = event.GetY(); + PopupMenu( &m_popmenu, event.GetX(), event.GetY()); + } +} + +void mpWindow::OnLockAspect(wxCommandEvent& WXUNUSED(event)) +{ + LockAspect( !m_lockaspect ); +} + +void mpWindow::OnMouseHelp(wxCommandEvent& WXUNUSED(event)) +{ + wxMessageBox(_("Comandos suportados:\n \ + - Botão esquerdo e arrastar: Zoom no retângulo\n \ + - Botão direito e arrastar: Arrasta o gráfico\n \ + - Wheel: Deslocamento vertical\n \ + - Wheel + SHIFT: Deslocamento horizontal\n \ + - Wheel + CTRL: Mais Zoom/Menos Zoom"),_("Ajuda"),wxOK,this); +} + +void mpWindow::OnFit(wxCommandEvent& WXUNUSED(event)) +{ + Fit(); +} + +void mpWindow::OnCenter(wxCommandEvent& WXUNUSED(event)) +{ + GetClientSize(&m_scrX, &m_scrY); + int centerX = (m_scrX - m_marginLeft - m_marginRight)/2; // + m_marginLeft; // c.x = m_scrX/2; + int centerY = (m_scrY - m_marginTop - m_marginBottom)/2; // - m_marginTop; // c.y = m_scrY/2; + SetPos( p2x(m_clickedX - centerX), p2y(m_clickedY - centerY) ); + //SetPos( p2x(m_clickedX-m_scrX/2), p2y(m_clickedY-m_scrY/2) ); //SetPos( (double)(m_clickedX-m_scrX/2) / m_scaleX + m_posX, (double)(m_scrY/2-m_clickedY) / m_scaleY + m_posY); +} + +void mpWindow::OnZoomIn(wxCommandEvent& WXUNUSED(event)) +{ + ZoomIn( wxPoint(m_mouseRClick_X,m_mouseRClick_Y) ); +} + +void mpWindow::OnZoomOut(wxCommandEvent& WXUNUSED(event)) +{ + ZoomOut(); +} + +void mpWindow::OnSize( wxSizeEvent& WXUNUSED(event) ) +{ + // Try to fit again with the new window size: + Fit( m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax ); +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::OnSize() m_scrX = %d, m_scrY = %d"), m_scrX, m_scrY); +#endif // MATHPLOT_DO_LOGGING +} + +bool mpWindow::AddLayer( mpLayer* layer, bool refreshDisplay ) +{ + if (layer != NULL) { + m_layers.push_back( layer ); + if (refreshDisplay) UpdateAll(); + return true; + }; + return false; +} + +bool mpWindow::DelLayer( + mpLayer* layer, + bool alsoDeleteObject, + bool refreshDisplay ) +{ + wxLayerList::iterator layIt; + for (layIt = m_layers.begin(); layIt != m_layers.end(); layIt++) + { + if (*layIt == layer) + { + // Also delete the object? + if (alsoDeleteObject) + delete *layIt; + m_layers.erase(layIt); // this deleted the reference only + if (refreshDisplay) + UpdateAll(); + return true; + } + } + return false; +} + +void mpWindow::DelAllLayers( bool alsoDeleteObject, bool refreshDisplay) +{ + while ( m_layers.size()>0 ) + { + // Also delete the object? + if (alsoDeleteObject) delete m_layers[0]; + m_layers.erase( m_layers.begin() ); // this deleted the reference only + } + if (refreshDisplay) UpdateAll(); +} + +// void mpWindow::DoPrepareDC(wxDC& dc) +// { +// dc.SetDeviceOrigin(x2p(m_minX), y2p(m_maxY)); +// } + +void mpWindow::OnPaint( wxPaintEvent& WXUNUSED(event) ) +{ + wxPaintDC dc(this); + dc.GetSize(&m_scrX, &m_scrY); // This is the size of the visible area only! +// DoPrepareDC(dc); + +#ifdef MATHPLOT_DO_LOGGING + { + int px, py; + GetViewStart( &px, &py ); + wxLogMessage(_("[mpWindow::OnPaint] vis.area:%ix%i px=%i py=%i"),m_scrX,m_scrY,px,py); + } +#endif + + // Selects direct or buffered draw: + wxDC *trgDc; + + // J.L.Blanco @ Aug 2007: Added double buffer support + if (m_enableDoubleBuffer) + { + if (m_last_lx!=m_scrX || m_last_ly!=m_scrY) + { + if (m_buff_bmp) delete m_buff_bmp; + m_buff_bmp = new wxBitmap(m_scrX,m_scrY); + m_buff_dc.SelectObject(*m_buff_bmp); + m_last_lx=m_scrX; + m_last_ly=m_scrY; + } + trgDc = &m_buff_dc; + } + else + { + trgDc = &dc; + } + + // Draw background: + //trgDc->SetDeviceOrigin(0,0); + trgDc->SetPen( *wxTRANSPARENT_PEN ); + wxBrush brush( GetBackgroundColour() ); + trgDc->SetBrush( brush ); + trgDc->SetTextForeground(m_fgColour); + trgDc->DrawRectangle(0,0,m_scrX,m_scrY); + + // Draw all the layers: + //trgDc->SetDeviceOrigin( m_scrX>>1, m_scrY>>1); // Origin at the center + wxLayerList::iterator li; + for (li = m_layers.begin(); li != m_layers.end(); li++) + { + (*li)->Plot(*trgDc, *this); + }; + + // If doublebuffer, draw now to the window: + if (m_enableDoubleBuffer) + { + //trgDc->SetDeviceOrigin(0,0); + //dc.SetDeviceOrigin(0,0); // Origin at the center + dc.Blit(0,0,m_scrX,m_scrY,trgDc,0,0); + } + +/* if (m_coordTooltip) { + wxString toolTipContent; + wxPoint mousePoint = wxGetMousePosition(); + toolTipContent.Printf(_("X = %f\nY = %f"), p2x(mousePoint.x), p2y(mousePoint.y)); + SetToolTip(toolTipContent); + }*/ + // If scrollbars are enabled, refresh them + if (m_enableScrollBars) { +/* m_scrollX = (int) floor((m_posX - m_minX)*m_scaleX); + m_scrollY = (int) floor((m_maxY - m_posY )*m_scaleY); + Scroll(m_scrollX, m_scrollY);*/ + // Scroll(x2p(m_posX), y2p(m_posY)); +// SetVirtualSize((int) ((m_maxX - m_minX)*m_scaleX), (int) ((m_maxY - m_minY)*m_scaleY)); +// int centerX = (m_scrX - m_marginLeft - m_marginRight)/2; // + m_marginLeft; // c.x = m_scrX/2; +// int centerY = (m_scrY - m_marginTop - m_marginBottom)/2; // - m_marginTop; // c.y = m_scrY/2; + /*SetScrollbars(1, 1, (int) ((m_maxX - m_minX)*m_scaleX), (int) ((m_maxY - m_minY)*m_scaleY));*/ //, x2p(m_posX + centerX/m_scaleX), y2p(m_posY - centerY/m_scaleY), true); +} + wxPen pen(srColour, 1, wxDOT); + dc.SetPen(pen); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawRectangle(selectionRect); +} + +// void mpWindow::OnScroll2(wxScrollWinEvent &event) +// { +// #ifdef MATHPLOT_DO_LOGGING +// wxLogMessage(_("[mpWindow::OnScroll2] Init: m_posX=%f m_posY=%f, sc_pos = %d"),m_posX,m_posY, event.GetPosition()); +// #endif +// // If scrollbars are not enabled, Skip operation +// if (!m_enableScrollBars) { +// event.Skip(); +// return; +// } +// // m_scrollX = (int) floor((m_posX - m_minX)*m_scaleX); +// // m_scrollY = (int) floor((m_maxY - m_posY /*- m_minY*/)*m_scaleY); +// // Scroll(m_scrollX, m_scrollY); +// +// // GetClientSize( &m_scrX, &m_scrY); +// //Scroll(x2p(m_desiredXmin), y2p(m_desiredYmin)); +// int pixelStep = 1; +// if (event.GetOrientation() == wxHORIZONTAL) { +// //m_desiredXmin -= (m_scrollX - event.GetPosition())/m_scaleX; +// //m_desiredXmax -= (m_scrollX - event.GetPosition())/m_scaleX; +// m_posX -= (m_scrollX - event.GetPosition())/m_scaleX; +// m_scrollX = event.GetPosition(); +// } +// Fit(m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax); +// // /* int pixelStep = 1; +// // if (event.GetOrientation() == wxHORIZONTAL) { +// // m_posX -= (px - event.GetPosition())/m_scaleX;//(pixelStep/m_scaleX); +// // m_desiredXmax -= (px - event.GetPosition())/m_scaleX;//(pixelStep/m_scaleX); +// // m_desiredXmin -= (px - event.GetPosition())/m_scaleX;//(pixelStep/m_scaleX); +// // //SetPosX( (double)px / GetScaleX() + m_minX + (double)(width>>1)/GetScaleX()); +// // // m_posX = p2x(px); //m_minX + (double)(px /*+ (m_scrX)*/)/GetScaleX(); +// // } else { +// // m_posY += (py - event.GetPosition())/m_scaleY;//(pixelStep/m_scaleY); +// // m_desiredYmax += (py - event.GetPosition())/m_scaleY;//(pixelStep/m_scaleY); +// // m_desiredYmax += (py - event.GetPosition())/m_scaleY;//(pixelStep/m_scaleY); +// // //SetPosY( m_maxY - (double)py / GetScaleY() - (double)(height>>1)/GetScaleY()); +// // //m_posY = m_maxY - (double)py / GetScaleY() - (double)(height>>1)/GetScaleY(); +// // // m_posY = p2y(py);//m_maxY - (double)(py /*+ (m_scrY)*/)/GetScaleY(); +// // }*/ +// #ifdef MATHPLOT_DO_LOGGING +// int px, py; +// GetViewStart( &px, &py); +// wxLogMessage(_("[mpWindow::OnScroll2] End: m_posX = %f, m_posY = %f, px = %f, py = %f"),m_posX, m_posY, px, py); +// #endif +// +// UpdateAll(); +// // event.Skip(); +// } + +void mpWindow::SetMPScrollbars(bool status) +{ + // Temporary behaviour: always disable scrollbars + m_enableScrollBars = status; //false; + if (status == false) + { + SetScrollbar(wxHORIZONTAL, 0, 0, 0); + SetScrollbar(wxVERTICAL, 0, 0, 0); + } + // else the scroll bars will be updated in UpdateAll(); + UpdateAll(); + +// EnableScrolling(false, false); +// m_enableScrollBars = status; +// EnableScrolling(status, status); +/* m_scrollX = (int) floor((m_posX - m_minX)*m_scaleX); + m_scrollY = (int) floor((m_posY - m_minY)*m_scaleY);*/ +// int scrollWidth = (int) floor((m_maxX - m_minX)*m_scaleX) - m_scrX; +// int scrollHeight = (int) floor((m_minY - m_maxY)*m_scaleY) - m_scrY; + +// /* m_scrollX = (int) floor((m_posX - m_minX)*m_scaleX); +// m_scrollY = (int) floor((m_maxY - m_posY /*- m_minY*/)*m_scaleY); +// int scrollWidth = (int) floor(((m_maxX - m_minX) - (m_desiredXmax - m_desiredXmin))*m_scaleX); +// int scrollHeight = (int) floor(((m_maxY - m_minY) - (m_desiredYmax - m_desiredYmin))*m_scaleY); +// #ifdef MATHPLOT_DO_LOGGING +// wxLogMessage(_("mpWindow::SetMPScrollbars() scrollWidth = %d, scrollHeight = %d"), scrollWidth, scrollHeight); +// #endif +// if(status) { +// SetScrollbars(1, +// 1, +// scrollWidth, +// scrollHeight, +// m_scrollX, +// m_scrollY); +// // SetVirtualSize((int) (m_maxX - m_minX), (int) (m_maxY - m_minY)); +// } +// Refresh(false);*/ +}; + +bool mpWindow::UpdateBBox() +{ + bool first = TRUE; + + for (wxLayerList::iterator li = m_layers.begin(); li != m_layers.end(); li++) + { + mpLayer* f = *li; + + if (f->HasBBox()) + { + if (first) + { + first = FALSE; + m_minX = f->GetMinX(); m_maxX=f->GetMaxX(); + m_minY = f->GetMinY(); m_maxY=f->GetMaxY(); + } + else + { + if (f->GetMinX()<m_minX) m_minX=f->GetMinX(); if (f->GetMaxX()>m_maxX) m_maxX=f->GetMaxX(); + if (f->GetMinY()<m_minY) m_minY=f->GetMinY(); if (f->GetMaxY()>m_maxY) m_maxY=f->GetMaxY(); + } + } + //node = node->GetNext(); + } +#ifdef MATHPLOT_DO_LOGGING + wxLogDebug(wxT("[mpWindow::UpdateBBox] Bounding box: Xmin = %f, Xmax = %f, Ymin = %f, YMax = %f"), m_minX, m_maxX, m_minY, m_maxY); +#endif // MATHPLOT_DO_LOGGING + return first == FALSE; +} + +// void mpWindow::UpdateAll() +// { + // GetClientSize( &m_scrX,&m_scrY); +/* if (m_enableScrollBars) { + // The "virtual size" of the scrolled window: + const int sx = (int)((m_maxX - m_minX) * GetScaleX()); + const int sy = (int)((m_maxY - m_minY) * GetScaleY()); + SetVirtualSize(sx, sy); + SetScrollRate(1, 1);*/ +// const int px = (int)((GetPosX() - m_minX) * GetScaleX());// - m_scrX); //(cx>>1)); + + // J.L.Blanco, Aug 2007: Formula fixed: +// const int py = (int)((m_maxY - GetPosY()) * GetScaleY());// - m_scrY); //(cy>>1)); +// int px, py; +// GetViewStart(&px0, &py0); +// px = (int)((m_posX - m_minX)*m_scaleX); +// py = (int)((m_maxY - m_posY)*m_scaleY); + +// SetScrollbars( 1, 1, sx - m_scrX, sy - m_scrY, px, py, TRUE); +// } + +// Working code +// UpdateBBox(); +// Refresh( FALSE ); +// end working code + +// Old version +/* bool box = UpdateBBox(); + if (box) +{ + int cx, cy; + GetClientSize( &cx, &cy); + + // The "virtual size" of the scrolled window: + const int sx = (int)((m_maxX - m_minX) * GetScaleX()); + const int sy = (int)((m_maxY - m_minY) * GetScaleY()); + + const int px = (int)((GetPosX() - m_minX) * GetScaleX() - (cx>>1)); + + // J.L.Blanco, Aug 2007: Formula fixed: + const int py = (int)((m_maxY - GetPosY()) * GetScaleY() - (cy>>1)); + + SetScrollbars( 1, 1, sx, sy, px, py, TRUE); + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("[mpWindow::UpdateAll] Size:%ix%i ScrollBars:%i,%i"),sx,sy,px,py); +#endif +} + + FitInside(); + Refresh( FALSE ); +*/ +// } + +void mpWindow::UpdateAll() +{ + if (UpdateBBox()) + { + if (m_enableScrollBars) + { + int cx, cy; + GetClientSize( &cx, &cy); + // Do x scroll bar + { + // Convert margin sizes from pixels to coordinates + double leftMargin = m_marginLeft / m_scaleX; + // Calculate the range in coords that we want to scroll over + double maxX = (m_desiredXmax > m_maxX) ? m_desiredXmax : m_maxX; + double minX = (m_desiredXmin < m_minX) ? m_desiredXmin : m_minX; + if ((m_posX + leftMargin) < minX) + minX = m_posX + leftMargin; + // Calculate scroll bar size and thumb position + int sizeX = (int) ((maxX - minX) * m_scaleX); + int thumbX = (int)(((m_posX + leftMargin) - minX) * m_scaleX); + SetScrollbar(wxHORIZONTAL, thumbX, cx - (m_marginRight + m_marginLeft), sizeX); + } + // Do y scroll bar + { + // Convert margin sizes from pixels to coordinates + double topMargin = m_marginTop / m_scaleY; + // Calculate the range in coords that we want to scroll over + double maxY = (m_desiredYmax > m_maxY) ? m_desiredYmax : m_maxY; + if ((m_posY - topMargin) > maxY) + maxY = m_posY - topMargin; + double minY = (m_desiredYmin < m_minY) ? m_desiredYmin : m_minY; + // Calculate scroll bar size and thumb position + int sizeY = (int)((maxY - minY) * m_scaleY); + int thumbY = (int)((maxY - (m_posY - topMargin)) * m_scaleY); + SetScrollbar(wxVERTICAL, thumbY, cy - (m_marginTop + m_marginBottom), sizeY); + } + } + } + + Refresh( FALSE ); +} + +void mpWindow::DoScrollCalc (const int position, const int orientation) +{ + if (orientation == wxVERTICAL) + { + // Y axis + // Get top margin in coord units + double topMargin = m_marginTop / m_scaleY; + // Calculate maximum Y coord to be shown in the graph + double maxY = m_desiredYmax > m_maxY ? m_desiredYmax : m_maxY; + // Set new position + SetPosY((maxY - (position / m_scaleY)) + topMargin); + } + else + { + // X Axis + // Get left margin in coord units + double leftMargin = m_marginLeft / m_scaleX; + // Calculate minimum X coord to be shown in the graph + double minX = (m_desiredXmin < m_minX) ? m_desiredXmin : m_minX; + // Set new position + SetPosX((minX + (position / m_scaleX)) - leftMargin); + } +} + +void mpWindow::OnScrollThumbTrack (wxScrollWinEvent &event) +{ + DoScrollCalc(event.GetPosition(), event.GetOrientation()); +} + +void mpWindow::OnScrollPageUp (wxScrollWinEvent &event) +{ + int scrollOrientation = event.GetOrientation(); + // Get position before page up + int position = GetScrollPos(scrollOrientation); + // Get thumb size + int thumbSize = GetScrollThumb(scrollOrientation); + // Need to adjust position by a page + position -= thumbSize; + if (position < 0) + position = 0; + + DoScrollCalc(position, scrollOrientation); +} +void mpWindow::OnScrollPageDown (wxScrollWinEvent &event) +{ + int scrollOrientation = event.GetOrientation(); + // Get position before page up + int position = GetScrollPos(scrollOrientation); + // Get thumb size + int thumbSize = GetScrollThumb(scrollOrientation); + // Get scroll range + int scrollRange = GetScrollRange(scrollOrientation); + // Need to adjust position by a page + position += thumbSize; + if (position > (scrollRange - thumbSize)) + position = scrollRange - thumbSize; + + DoScrollCalc(position, scrollOrientation); +} + +void mpWindow::OnScrollLineUp (wxScrollWinEvent &event) +{ + int scrollOrientation = event.GetOrientation(); + // Get position before page up + int position = GetScrollPos(scrollOrientation); + // Need to adjust position by a line + position -= mpSCROLL_NUM_PIXELS_PER_LINE; + if (position < 0) + position = 0; + + DoScrollCalc(position, scrollOrientation); +} + +void mpWindow::OnScrollLineDown (wxScrollWinEvent &event) +{ + int scrollOrientation = event.GetOrientation(); + // Get position before page up + int position = GetScrollPos(scrollOrientation); + // Get thumb size + int thumbSize = GetScrollThumb(scrollOrientation); + // Get scroll range + int scrollRange = GetScrollRange(scrollOrientation); + // Need to adjust position by a page + position += mpSCROLL_NUM_PIXELS_PER_LINE; + if (position > (scrollRange - thumbSize)) + position = scrollRange - thumbSize; + + DoScrollCalc(position, scrollOrientation); +} + +void mpWindow::OnScrollTop(wxScrollWinEvent &event) +{ + DoScrollCalc(0, event.GetOrientation()); +} + +void mpWindow::OnScrollBottom(wxScrollWinEvent &event) +{ + int scrollOrientation = event.GetOrientation(); + // Get thumb size + int thumbSize = GetScrollThumb(scrollOrientation); + // Get scroll range + int scrollRange = GetScrollRange(scrollOrientation); + + DoScrollCalc(scrollRange - thumbSize, scrollOrientation); +} +// End patch ngpaton + +void mpWindow::SetScaleX(double scaleX) +{ + if (scaleX!=0) m_scaleX=scaleX; + UpdateAll(); +} + +// New methods implemented by Davide Rondini + +unsigned int mpWindow::CountLayers() +{ + //wxNode *node = m_layers.GetFirst(); + unsigned int layerNo = 0; + for(wxLayerList::iterator li = m_layers.begin(); li != m_layers.end(); li++)//while(node) + { + if ((*li)->HasBBox()) layerNo++; + // node = node->GetNext(); + }; + return layerNo; +} + +mpLayer* mpWindow::GetLayer(int position) +{ + if ((position >= (int) m_layers.size()) || position < 0) return NULL; + return m_layers[position]; +} + +mpLayer* mpWindow::GetLayerByName( const wxString &name) +{ + for (wxLayerList::iterator it=m_layers.begin();it!=m_layers.end();it++) + if (! (*it)->GetName().Cmp( name ) ) + return *it; + return NULL; // Not found +} + +void mpWindow::GetBoundingBox(double* bbox) +{ + bbox[0] = m_minX; + bbox[1] = m_maxX; + bbox[2] = m_minY; + bbox[3] = m_maxY; +} + +bool mpWindow::SaveScreenshot(const wxString& filename, wxBitmapType type, wxSize imageSize, bool fit) +{ + int sizeX, sizeY; + int bk_scrX, bk_scrY; + if (imageSize == wxDefaultSize) { + sizeX = m_scrX; + sizeY = m_scrY; + } else { + sizeX = imageSize.x; + sizeY = imageSize.y; + bk_scrX = m_scrX; + bk_scrY = m_scrY; + SetScr(sizeX, sizeY); + } + + wxBitmap screenBuffer(sizeX,sizeY); + wxMemoryDC screenDC; + screenDC.SelectObject(screenBuffer); + screenDC.SetPen( *wxTRANSPARENT_PEN ); + wxBrush brush( GetBackgroundColour() ); + screenDC.SetBrush( brush ); + screenDC.DrawRectangle(0,0,sizeX,sizeY); + + if (fit) { + Fit(m_minX, m_maxX, m_minY, m_maxY, &sizeX, &sizeY); + } else { + Fit(m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax, &sizeX, &sizeY); + } + // Draw all the layers: + wxLayerList::iterator li; + for (li = m_layers.begin(); li != m_layers.end(); li++) + (*li)->Plot(screenDC, *this); + + if (imageSize != wxDefaultSize) { + // Restore dimensions + SetScr(bk_scrX, bk_scrY); + Fit(m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax, &bk_scrX, &bk_scrY); + UpdateAll(); + } + // Once drawing is complete, actually save screen shot + wxImage screenImage = screenBuffer.ConvertToImage(); + return screenImage.SaveFile(filename, type); +} + +void mpWindow::SetMargins(int top, int right, int bottom, int left) +{ + m_marginTop = top; + m_marginRight = right; + m_marginBottom = bottom; + m_marginLeft = left; +} + +mpInfoLayer* mpWindow::IsInsideInfoLayer(wxPoint& point) +{ + wxLayerList::iterator li; + for (li = m_layers.begin(); li != m_layers.end(); li++) { +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::IsInsideInfoLayer() examinining layer = %p"), (*li)); +#endif // MATHPLOT_DO_LOGGING + if ((*li)->IsInfo()) { + mpInfoLayer* tmpLyr = (mpInfoLayer*) (*li); +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("mpWindow::IsInsideInfoLayer() layer = %p"), (*li)); +#endif // MATHPLOT_DO_LOGGING + if (tmpLyr->Inside(point)) { + return tmpLyr; + } + } + } + return NULL; +} + +void mpWindow::SetLayerVisible(const wxString &name, bool viewable) +{ + mpLayer* lx = GetLayerByName(name); + if ( lx ) { + lx->SetVisible(viewable); + UpdateAll(); + } +} + +bool mpWindow::IsLayerVisible(const wxString &name ) +{ + mpLayer* lx = GetLayerByName(name); + return (lx) ? lx->IsVisible() : false; +} + +void mpWindow::SetLayerVisible(const unsigned int position, bool viewable) +{ + mpLayer* lx = GetLayer(position); + if ( lx ) { + lx->SetVisible(viewable); + UpdateAll(); + } +} + +bool mpWindow::IsLayerVisible(const unsigned int position ) +{ + mpLayer* lx = GetLayer(position); + return (lx) ? lx->IsVisible() : false; +} + +void mpWindow::SetColourTheme(const wxColour& bgColour, const wxColour& drawColour, const wxColour& axesColour) +{ + SetBackgroundColour(bgColour); + SetForegroundColour(drawColour); + m_bgColour = bgColour; + m_fgColour = drawColour; + m_axColour = axesColour; + // cycle between layers to set colours and properties to them + wxLayerList::iterator li; + for (li = m_layers.begin(); li != m_layers.end(); li++) { + if ((*li)->GetLayerType() == mpLAYER_AXIS) { + wxPen axisPen = (*li)->GetPen(); // Get the old pen to modify only colour, not style or width + axisPen.SetColour(axesColour); + (*li)->SetPen(axisPen); + } + if ((*li)->GetLayerType() == mpLAYER_INFO) { + wxPen infoPen = (*li)->GetPen(); // Get the old pen to modify only colour, not style or width + infoPen.SetColour(drawColour); + (*li)->SetPen(infoPen); + } + } + + srColour = drawColour; +} + +// void mpWindow::EnableCoordTooltip(bool value) +// { +// m_coordTooltip = value; +// // if (value) GetToolTip()->SetDelay(100); +// } + +/* +double mpWindow::p2x(wxCoord pixelCoordX, bool drawOutside ) +{ + if (drawOutside) { + return m_posX + pixelCoordX/m_scaleX; + } + // Draw inside margins + double marginScaleX = ((double)(m_scrX - m_marginLeft - m_marginRight))/m_scrX; + return m_marginLeft + (m_posX + pixelCoordX/m_scaleX)/marginScaleX; +} + +double mpWindow::p2y(wxCoord pixelCoordY, bool drawOutside ) +{ + if (drawOutside) { + return m_posY - pixelCoordY/m_scaleY; + } + // Draw inside margins + double marginScaleY = ((double)(m_scrY - m_marginTop - m_marginBottom))/m_scrY; + return m_marginTop + (m_posY - pixelCoordY/m_scaleY)/marginScaleY; +} + +wxCoord mpWindow::x2p(double x, bool drawOutside) +{ + if (drawOutside) { + return (wxCoord) ((x-m_posX) * m_scaleX); + } + // Draw inside margins + double marginScaleX = ((double)(m_scrX - m_marginLeft - m_marginRight))/m_scrX; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("x2p ScrX = %d, marginRight = %d, marginLeft = %d, marginScaleX = %f"), m_scrX, m_marginRight, m_marginLeft, marginScaleX); +#endif // MATHPLOT_DO_LOGGING + return (wxCoord) (int)(((x-m_posX) * m_scaleX)*marginScaleX) - m_marginLeft; +} + +wxCoord mpWindow::y2p(double y, bool drawOutside) +{ + if (drawOutside) { + return (wxCoord) ( (m_posY-y) * m_scaleY); + } + // Draw inside margins + double marginScaleY = ((double)(m_scrY - m_marginTop - m_marginBottom))/m_scrY; +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("y2p ScrY = %d, marginTop = %d, marginBottom = %d, marginScaleY = %f"), m_scrY, m_marginTop, m_marginBottom, marginScaleY); +#endif // MATHPLOT_DO_LOGGING + return (wxCoord) ((int)((m_posY-y) * m_scaleY)*marginScaleY) - m_marginTop; +} +*/ + + +//----------------------------------------------------------------------------- +// mpFXYVector implementation - by Jose Luis Blanco (AGO-2007) +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(mpFXYVector, mpFXY) + +// Constructor +mpFXYVector::mpFXYVector(wxString name, int flags ) : mpFXY(name,flags) +{ + m_index = 0; + m_minX = -1; + m_maxX = 1; + m_minY = -1; + m_maxY = 1; + m_type = mpLAYER_PLOT; +} + +void mpFXYVector::Rewind() +{ + m_index = 0; +} + +bool mpFXYVector::GetNextXY(double & x, double & y) +{ + if (m_index>=m_xs.size()) + return FALSE; + else + { + x = m_xs[m_index]; + y = m_ys[m_index++]; + return m_index<=m_xs.size(); + } +} + +void mpFXYVector::Clear() +{ + m_xs.clear(); + m_ys.clear(); +} + +void mpFXYVector::SetData( const std::vector<double> &xs,const std::vector<double> &ys) +{ + // Check if the data vectora are of the same size + if (xs.size() != ys.size()) { + //wxLogError(_("wxMathPlot error: X and Y vector are not of the same length!")); + return; + } + // Copy the data: + m_xs = xs; + m_ys = ys; + + + // Update internal variables for the bounding box. + if (xs.size()>0) + { + m_minX = xs[0]; + m_maxX = xs[0]; + m_minY = ys[0]; + m_maxY = ys[0]; + + std::vector<double>::const_iterator it; + + for (it=xs.begin();it!=xs.end();it++) + { + if (*it<m_minX) m_minX=*it; + if (*it>m_maxX) m_maxX=*it; + } + for (it=ys.begin();it!=ys.end();it++) + { + if (*it<m_minY) m_minY=*it; + if (*it>m_maxY) m_maxY=*it; + } + //Thales Lima - 03/07/2015 -> diminuindo offset de y e retirando de x + /*m_minX-=0.5f; + m_minY-=0.5f; + m_maxX+=0.5f; + m_maxY+=0.5f;*/ + m_minY -= m_minY > 0.0 ? 0.005f*m_minY : -0.005f*m_minY;//0,5% de offset + m_maxY += m_maxY > 0.0 ? 0.005f*m_maxY : -0.005f*m_maxY; + } + else + { + m_minX = -1; + m_maxX = 1; + m_minY = -1; + m_maxY = 1; + } +} + +//----------------------------------------------------------------------------- +// mpText - provided by Val Greene +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(mpText, mpLayer) + + +/** @param name text to be displayed +@param offsetx x position in percentage (0-100) +@param offsetx y position in percentage (0-100) +*/ +mpText::mpText( wxString name, int offsetx, int offsety ) +{ + SetName(name); + + if (offsetx >= 0 && offsetx <= 100) + m_offsetx = offsetx; + else + m_offsetx = 5; + + if (offsety >= 0 && offsety <= 100) + m_offsety = offsety; + else + m_offsetx = 50; + m_type = mpLAYER_INFO; +} + +/** mpText Layer plot handler. +This implementation will plot the text adjusted to the visible area. +*/ + +void mpText::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen(m_pen); + dc.SetFont(m_font); + + wxCoord tw=0, th=0; + dc.GetTextExtent( GetName(), &tw, &th); + + // int left = -dc.LogicalToDeviceX(0); + // int width = dc.LogicalToDeviceX(0) - left; + // int bottom = dc.LogicalToDeviceY(0); + // int height = bottom - -dc.LogicalToDeviceY(0); + + /* dc.DrawText( GetName(), + (int)((((float)width/100.0) * m_offsety) + left - (tw/2)), + (int)((((float)height/100.0) * m_offsetx) - bottom) );*/ + int px = m_offsetx*(w.GetScrX() - w.GetMarginLeft() - w.GetMarginRight())/100; + int py = m_offsety*(w.GetScrY() - w.GetMarginTop() - w.GetMarginBottom())/100; + dc.DrawText( GetName(), px, py); + } +} + +//----------------------------------------------------------------------------- +// mpPrintout - provided by Davide Rondini +//----------------------------------------------------------------------------- + +mpPrintout::mpPrintout(mpWindow *drawWindow, const wxChar *title) : wxPrintout(title) +{ + drawn = false; + plotWindow = drawWindow; +} + +bool mpPrintout::OnPrintPage(int page) +{ + + wxDC *trgDc = GetDC(); + if ((trgDc) && (page == 1)) { + wxCoord m_prnX, m_prnY; + int marginX = 50; + int marginY = 50; + trgDc->GetSize(&m_prnX, &m_prnY); + + m_prnX -= (2*marginX); + m_prnY -= (2*marginY); + trgDc->SetDeviceOrigin(marginX, marginY); + +#ifdef MATHPLOT_DO_LOGGING + wxLogMessage(wxT("Print Size: %d x %d\n"), m_prnX, m_prnY); + wxLogMessage(wxT("Screen Size: %d x %d\n"), plotWindow->GetScrX(), plotWindow->GetScrY()); +#endif + + // Set the scale according to the page: + plotWindow->Fit( + plotWindow->GetDesiredXmin(), + plotWindow->GetDesiredXmax(), + plotWindow->GetDesiredYmin(), + plotWindow->GetDesiredYmax(), + &m_prnX, + &m_prnY ); + + // Get the colours of the plotWindow to restore them ath the end + wxColour oldBgColour = plotWindow->GetBackgroundColour(); + wxColour oldFgColour = plotWindow->GetForegroundColour(); + wxColour oldAxColour = plotWindow->GetAxesColour(); + + // Draw background, ensuring to use white background for printing. + trgDc->SetPen( *wxTRANSPARENT_PEN ); + // wxBrush brush( plotWindow->GetBackgroundColour() ); + wxBrush brush = *wxWHITE_BRUSH; + trgDc->SetBrush( brush ); + trgDc->DrawRectangle(0,0,m_prnX,m_prnY); + + // Draw all the layers: + //trgDc->SetDeviceOrigin( m_prnX>>1, m_prnY>>1); // Origin at the center + mpLayer *layer; + for (unsigned int li = 0; li < plotWindow->CountAllLayers(); li++) { + layer = plotWindow->GetLayer(li); + layer->Plot(*trgDc, *plotWindow); + }; + // Restore device origin + // trgDc->SetDeviceOrigin(0, 0); + // Restore colours + plotWindow->SetColourTheme(oldBgColour, oldFgColour, oldAxColour); + // Restore drawing + plotWindow->Fit(plotWindow->GetDesiredXmin(), plotWindow->GetDesiredXmax(), plotWindow->GetDesiredYmin(), plotWindow->GetDesiredYmax(), NULL, NULL); + plotWindow->UpdateAll(); + } + return true; +} + +bool mpPrintout::HasPage(int page) +{ + return (page == 1); +} + + +//----------------------------------------------------------------------------- +// mpMovableObject - provided by Jose Luis Blanco +//----------------------------------------------------------------------------- +void mpMovableObject::TranslatePoint( double x,double y, double &out_x, double &out_y ) +{ + double ccos = cos( m_reference_phi ); // Avoid computing cos/sin twice. + double csin = sin( m_reference_phi ); + + out_x = m_reference_x + ccos * x - csin * y; + out_y = m_reference_y + csin * x + ccos * y; +} + +// This method updates the buffers m_trans_shape_xs/ys, and the precomputed bounding box. +void mpMovableObject::ShapeUpdated() +{ + // Just in case... + if (m_shape_xs.size()!=m_shape_ys.size()) + { + //::wxLogError(wxT("[mpMovableObject::ShapeUpdated] Error, m_shape_xs and m_shape_ys have different lengths!")); + } + else + { + double ccos = cos( m_reference_phi ); // Avoid computing cos/sin twice. + double csin = sin( m_reference_phi ); + + m_trans_shape_xs.resize(m_shape_xs.size()); + m_trans_shape_ys.resize(m_shape_xs.size()); + + std::vector<double>::iterator itXi, itXo; + std::vector<double>::iterator itYi, itYo; + + m_bbox_min_x=1e300; + m_bbox_max_x=-1e300; + m_bbox_min_y=1e300; + m_bbox_max_y=-1e300; + + for (itXo=m_trans_shape_xs.begin(),itYo=m_trans_shape_ys.begin(),itXi=m_shape_xs.begin(),itYi=m_shape_ys.begin(); + itXo!=m_trans_shape_xs.end(); itXo++,itYo++,itXi++,itYi++) + { + *itXo = m_reference_x + ccos * (*itXi) - csin * (*itYi); + *itYo = m_reference_y + csin * (*itXi) + ccos * (*itYi); + + // Keep BBox: + if (*itXo < m_bbox_min_x) m_bbox_min_x = *itXo; + if (*itXo > m_bbox_max_x) m_bbox_max_x = *itXo; + if (*itYo < m_bbox_min_y) m_bbox_min_y = *itYo; + if (*itYo > m_bbox_max_y) m_bbox_max_y = *itYo; + } + } +} + +void mpMovableObject::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible) { + dc.SetPen( m_pen); + + + std::vector<double>::iterator itX=m_trans_shape_xs.begin(); + std::vector<double>::iterator itY=m_trans_shape_ys.begin(); + + if (!m_continuous) + { + // for some reason DrawPoint does not use the current pen, + // so we use DrawLine for fat pens + if (m_pen.GetWidth() <= 1) + { + while (itX!=m_trans_shape_xs.end()) + { + dc.DrawPoint( w.x2p(*(itX++)), w.y2p( *(itY++) ) ); + } + } + else + { + while (itX!=m_trans_shape_xs.end()) + { + wxCoord cx = w.x2p(*(itX++)); + wxCoord cy = w.y2p(*(itY++)); + dc.DrawLine(cx, cy, cx, cy); + } + } + } + else + { + wxCoord cx0=0,cy0=0; + bool first = TRUE; + while (itX!=m_trans_shape_xs.end()) + { + wxCoord cx = w.x2p(*(itX++)); + wxCoord cy = w.y2p(*(itY++)); + if (first) + { + first=FALSE; + cx0=cx;cy0=cy; + } + dc.DrawLine(cx0, cy0, cx, cy); + cx0=cx; cy0=cy; + } + } + + if (!m_name.IsEmpty() && m_showName) + { + dc.SetFont(m_font); + + wxCoord tx, ty; + dc.GetTextExtent(m_name, &tx, &ty); + + if (HasBBox()) + { + wxCoord sx = (wxCoord) (( m_bbox_max_x - w.GetPosX()) * w.GetScaleX()); + wxCoord sy = (wxCoord) ((w.GetPosY() - m_bbox_max_y ) * w.GetScaleY()); + + tx = sx - tx - 8; + ty = sy - 8 - ty; + } + else + { + const int sx = w.GetScrX()>>1; + const int sy = w.GetScrY()>>1; + + if ((m_flags & mpALIGNMASK) == mpALIGN_NE) + { + tx = sx - tx - 8; + ty = -sy + 8; + } + else if ((m_flags & mpALIGNMASK) == mpALIGN_NW) + { + tx = -sx + 8; + ty = -sy + 8; + } + else if ((m_flags & mpALIGNMASK) == mpALIGN_SW) + { + tx = -sx + 8; + ty = sy - 8 - ty; + } + else + { + tx = sx - tx - 8; + ty = sy - 8 - ty; + } + } + + dc.DrawText( m_name, tx, ty); + } + } +} + +//----------------------------------------------------------------------------- +// mpCovarianceEllipse - provided by Jose Luis Blanco +//----------------------------------------------------------------------------- + +// Called to update the m_shape_xs, m_shape_ys vectors, whenever a parameter changes. +void mpCovarianceEllipse::RecalculateShape() +{ + m_shape_xs.clear(); + m_shape_ys.clear(); + + // Preliminar checks: + if (m_quantiles<0) { /*::wxLogError(wxT("[mpCovarianceEllipse] Error: quantiles must be non-negative"));*/ return; } + if (m_cov_00<0) { /*::wxLogError(wxT("[mpCovarianceEllipse] Error: cov(0,0) must be non-negative"));*/ return; } + if (m_cov_11<0) { /*::wxLogError(wxT("[mpCovarianceEllipse] Error: cov(1,1) must be non-negative"));*/ return; } + + m_shape_xs.resize( m_segments,0 ); + m_shape_ys.resize( m_segments,0 ); + + // Compute the two eigenvalues of the covariance: + // ------------------------------------------------- + double b = -m_cov_00 - m_cov_11; + double c = m_cov_00*m_cov_11 - m_cov_01*m_cov_01; + + double D = b*b - 4*c; + + if (D<0) { /*::wxLogError(wxT("[mpCovarianceEllipse] Error: cov is not positive definite"));*/ return; } + + double eigenVal0 =0.5*( -b + sqrt(D) ); + double eigenVal1 =0.5*( -b - sqrt(D) ); + + // Compute the two corresponding eigenvectors: + // ------------------------------------------------- + double eigenVec0_x,eigenVec0_y; + double eigenVec1_x,eigenVec1_y; + + if (fabs(eigenVal0 - m_cov_00)>1e-6) + { + double k1x = m_cov_01 / ( eigenVal0 - m_cov_00 ); + eigenVec0_y = 1; + eigenVec0_x = eigenVec0_y * k1x; + } + else + { + double k1y = m_cov_01 / ( eigenVal0 - m_cov_11 ); + eigenVec0_x = 1; + eigenVec0_y = eigenVec0_x * k1y; + } + + if (fabs(eigenVal1 - m_cov_00)>1e-6) + { + double k2x = m_cov_01 / ( eigenVal1 - m_cov_00 ); + eigenVec1_y = 1; + eigenVec1_x = eigenVec1_y * k2x; + } + else + { + double k2y = m_cov_01 / ( eigenVal1 - m_cov_11 ); + eigenVec1_x = 1; + eigenVec1_y = eigenVec1_x * k2y; + } + + // Normalize the eigenvectors: + double len = sqrt( eigenVec0_x*eigenVec0_x + eigenVec0_y*eigenVec0_y ); + eigenVec0_x /= len; // It *CANNOT* be zero + eigenVec0_y /= len; + + len = sqrt( eigenVec1_x*eigenVec1_x + eigenVec1_y*eigenVec1_y ); + eigenVec1_x /= len; // It *CANNOT* be zero + eigenVec1_y /= len; + + + // Take the sqrt of the eigenvalues (required for the ellipse scale): + eigenVal0 = sqrt(eigenVal0); + eigenVal1 = sqrt(eigenVal1); + + // Compute the 2x2 matrix M = diag(eigVal) * (~eigVec) (each eigen vector is a row): + double M_00 = eigenVec0_x * eigenVal0; + double M_01 = eigenVec0_y * eigenVal0; + + double M_10 = eigenVec1_x * eigenVal1; + double M_11 = eigenVec1_y * eigenVal1; + + // The points of the 2D ellipse: + double ang; + double Aang = 6.283185308/(m_segments-1); + int i; + for (i=0,ang=0;i<m_segments;i++,ang+= Aang ) + { + double ccos = cos(ang); + double csin = sin(ang); + + m_shape_xs[i] = m_quantiles * (ccos * M_00 + csin * M_10 ); + m_shape_ys[i] = m_quantiles * (ccos * M_01 + csin * M_11 ); + } // end for points on ellipse + + + ShapeUpdated(); +} + +//----------------------------------------------------------------------------- +// mpPolygon - provided by Jose Luis Blanco +//----------------------------------------------------------------------------- +void mpPolygon::setPoints( + const std::vector<double>& points_xs, + const std::vector<double>& points_ys, + bool closedShape ) +{ + if ( points_xs.size()!=points_ys.size() ) + { + //::wxLogError(wxT("[mpPolygon] Error: points_xs and points_ys must have the same number of elements")); + } + else + { + m_shape_xs = points_xs; + m_shape_ys = points_ys; + + if ( closedShape && points_xs.size()) + { + m_shape_xs.push_back( points_xs[0] ); + m_shape_ys.push_back( points_ys[0] ); + } + + ShapeUpdated(); + } +} + +//----------------------------------------------------------------------------- +// mpBitmapLayer - provided by Jose Luis Blanco +//----------------------------------------------------------------------------- +void mpBitmapLayer::GetBitmapCopy( wxImage &outBmp ) const +{ + if (m_validImg) + outBmp = m_bitmap; +} + +void mpBitmapLayer::SetBitmap( const wxImage &inBmp, double x, double y, double lx, double ly ) +{ + if (!inBmp.Ok()) + { + //::wxLogError(wxT("[mpBitmapLayer] Assigned bitmap is not Ok()!")); + } + else + { + m_bitmap = inBmp; //.GetSubBitmap( wxRect(0, 0, inBmp.GetWidth(), inBmp.GetHeight())); + m_min_x = x; + m_min_y = y; + m_max_x = x+lx; + m_max_y = y+ly; + m_validImg = true; + } +} + + +void mpBitmapLayer::Plot(wxDC & dc, mpWindow & w) +{ + if (m_visible && m_validImg) + { + /* 1st: We compute (x0,y0)-(x1,y1), the pixel coordinates of the real outer limits + of the image rectangle within the (screen) mpWindow. Note that these coordinates + might fall well far away from the real view limits when the user zoom in. + + 2nd: We compute (dx0,dy0)-(dx1,dy1), the pixel coordinates the rectangle that will + be actually drawn into the mpWindow, i.e. the clipped real rectangle that + avoids the non-visible parts. (offset_x,offset_y) are the pixel coordinates + that correspond to the window point (dx0,dy0) within the image "m_bitmap", and + (b_width,b_height) is the size of the bitmap patch that will be drawn. + + (x0,y0) ................. (x1,y0) + . . + . . + (x0,y1) ................ (x1,y1) + (In pixels!!) + */ + + // 1st step ------------------------------- + wxCoord x0 = w.x2p(m_min_x); + wxCoord y0 = w.y2p(m_max_y); + wxCoord x1 = w.x2p(m_max_x); + wxCoord y1 = w.y2p(m_min_y); + + // 2nd step ------------------------------- + // Precompute the size of the actual bitmap pixel on the screen (e.g. will be >1 if zoomed in) + double screenPixelX = ( x1-x0 ) / (double)m_bitmap.GetWidth(); + double screenPixelY = ( y1-y0 ) / (double)m_bitmap.GetHeight(); + + // The minimum number of pixels that the streched image will overpass the actual mpWindow borders: + wxCoord borderMarginX = (wxCoord)(screenPixelX+1); // ceil + wxCoord borderMarginY = (wxCoord)(screenPixelY+1); // ceil + + // The actual drawn rectangle (dx0,dy0)-(dx1,dy1) is (x0,y0)-(x1,y1) clipped: + wxCoord dx0=x0,dx1=x1,dy0=y0,dy1=y1; + if (dx0<0) dx0=-borderMarginX; + if (dy0<0) dy0=-borderMarginY; + if (dx1>w.GetScrX()) dx1=w.GetScrX()+borderMarginX; + if (dy1>w.GetScrY()) dy1=w.GetScrY()+borderMarginY; + + // For convenience, compute the width/height of the rectangle to be actually drawn: + wxCoord d_width = dx1-dx0+1; + wxCoord d_height = dy1-dy0+1; + + // Compute the pixel offsets in the internally stored bitmap: + wxCoord offset_x= (wxCoord) ( (dx0-x0)/screenPixelX ); + wxCoord offset_y= (wxCoord) ( (dy0-y0)/screenPixelY ); + + // and the size in pixel of the area to be actually drawn from the internally stored bitmap: + wxCoord b_width = (wxCoord) ( (dx1-dx0+1)/screenPixelX ); + wxCoord b_height = (wxCoord) ( (dy1-dy0+1)/screenPixelY ); + + #ifdef MATHPLOT_DO_LOGGING + wxLogMessage(_("[mpBitmapLayer::Plot] screenPixel: x=%f y=%f d_width=%ix%i"),screenPixelX,screenPixelY,d_width,d_height); + wxLogMessage(_("[mpBitmapLayer::Plot] offset: x=%i y=%i bmpWidth=%ix%i"),offset_x,offset_y,b_width,b_height); + #endif + + // Is there any visible region? + if (d_width>0 && d_height>0) + { + // Build the scaled bitmap from the image, only if it has changed: + if (m_scaledBitmap.GetWidth()!=d_width || + m_scaledBitmap.GetHeight()!=d_height || + m_scaledBitmap_offset_x != offset_x || + m_scaledBitmap_offset_y != offset_y ) + { + wxRect r(wxRect(offset_x,offset_y,b_width,b_height)); + // Just for the case.... + if (r.x<0) r.x=0; + if (r.y<0) r.y=0; + if (r.width>m_bitmap.GetWidth()) r.width=m_bitmap.GetWidth(); + if (r.height>m_bitmap.GetHeight()) r.height=m_bitmap.GetHeight(); + + m_scaledBitmap = wxBitmap( + wxBitmap(m_bitmap).GetSubBitmap( r ).ConvertToImage() + .Scale(d_width,d_height) ); + m_scaledBitmap_offset_x = offset_x; + m_scaledBitmap_offset_y = offset_y; + } + + // Draw it: + dc.DrawBitmap( m_scaledBitmap, dx0,dy0, true ); + } + } + + // Draw the name label + if (!m_name.IsEmpty() && m_showName) + { + dc.SetFont(m_font); + + wxCoord tx, ty; + dc.GetTextExtent(m_name, &tx, &ty); + + if (HasBBox()) + { + wxCoord sx = (wxCoord) (( m_max_x - w.GetPosX()) * w.GetScaleX()); + wxCoord sy = (wxCoord) ((w.GetPosY() - m_max_y ) * w.GetScaleY()); + + tx = sx - tx - 8; + ty = sy - 8 - ty; + } + else + { + const int sx = w.GetScrX()>>1; + const int sy = w.GetScrY()>>1; + + if ((m_flags & mpALIGNMASK) == mpALIGN_NE) + { + tx = sx - tx - 8; + ty = -sy + 8; + } + else if ((m_flags & mpALIGNMASK) == mpALIGN_NW) + { + tx = -sx + 8; + ty = -sy + 8; + } + else if ((m_flags & mpALIGNMASK) == mpALIGN_SW) + { + tx = -sx + 8; + ty = sy - 8 - ty; + } + else + { + tx = sx - tx - 8; + ty = sy - 8 - ty; + } + } + + dc.DrawText( m_name, tx, ty); + } +} |