mathplot.h

Go to the documentation of this file.

// Name:        mathplot.h
// Purpose:     Framework for mathematical graph plotting in wxWindows
// Author:      David Schalig
// Modified by:
// Created:     21/07/2003
// Copyright:   (c) David Schalig
// Licence:     wxWindows licence

#ifndef _MP_MATHPLOT_H_
#define _MP_MATHPLOT_H_
#define ZOOM_FACTOR 1.5

/* @file mathplot.h */
/* @mainpage wxMathPlot
wxMathPlot is a framework for mathematical graph plotting in wxWindows.

The framework is designed for convenience and ease of use.

@section screenshots Screenshots
<a href="screenshots.html">Go to the screenshots page.</a>

@section overview Overview
The heart of wxMathPlot is mpWindow, which is a 2D canvas for plot layers.
mpWindow can be embedded as subwindow in a wxPane, a wxFrame, or any other wxWindow.
mpWindow provides a zoomable and moveable view of the layers. The current view can
be controlled with the mouse, the scrollbars, and a context menu.

Plot layers are implementations of the abstract base class mpLayer. Those can
be function plots, scale rulers, or any other vector data visualisation. wxMathPlot provides
two mpLayer implementations for plotting horizontal and vertical rulers: mpScaleX and mpScaleY.
For convenient function plotting three more abstract base classes derived from mpLayer
are provided: mpFX, mpFY and mpFXY. These base classes already come with plot code, own
functions can be implemented by overiding just one member for retrieving a function value.

@section coding Coding conventions
wxMathPlot sticks to wxWindow's coding conventions. All entities defined by wxMathPlot
have the prefix <i>mp</i>.

@section author Author and license
wxMathPlot is published under the terms of the wxWindow license.
The author David Schalig can be contacted via the wxMathPlot's homepage at
http://sourceforge.net/projects/wxmathplot
*/

/*
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "mathplot.h"
#endif
*/

#include "marTypes.h"
#include "wx/defs.h"
#include <wx/wx.h>

/*
#include "wx/menu.h"
#include "wx/scrolwin.h"
#include "wx/event.h"
#include "wx/dynarray.h"
*/

//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------

class  mpLayer;
class  mpFX;
class  mpFY;
class  mpFXY;
class  mpScaleX;
class  mpScaleY;
class  mpWindow;

enum
{
        mpID_FIT = 2000,    
        mpID_ZOOM_IN,       
        mpID_ZOOM_OUT,      
        mpID_CENTER,        
        mpID_LOCKASPECT,    
        mpID_LINE_GUIDES,       
};

//-----------------------------------------------------------------------------
// mpLayer
//-----------------------------------------------------------------------------

class creaMaracasVisu_EXPORT mpLayer : public wxObject
{
public:
        mpLayer();

        virtual bool   HasBBox() { return TRUE; }

        virtual double GetMinX() { return -1.0; }

        virtual double GetMaxX() { return  1.0; }

        virtual double GetMinY() { return -1.0; }

        virtual double GetMaxY() { return  1.0; }

        virtual void   Plot(wxDC & dc, mpWindow & w) = 0;

        wxString       GetName() const { return m_name; }

        const wxFont&  GetFont() const { return m_font; }

        const wxPen&   GetPen()  const { return m_pen;  }

        void SetName(wxString name) { m_name = name; }

        void SetFont(wxFont& font)  { m_font = font; }

        void SetPen(wxPen& pen)     { m_pen  = pen;  }

        int GetYTranslated(double sizey, double y){
                return -y+sizey;
        }

protected:
        wxFont   m_font;    
        wxPen    m_pen;     
        wxString m_name;    

        DECLARE_CLASS(mpLayer)
};

//-----------------------------------------------------------------------------
// mpLayer implementations - functions
//-----------------------------------------------------------------------------

#define mpALIGNMASK    0x03

#define mpALIGN_RIGHT  0x00

#define mpALIGN_CENTER 0x01

#define mpALIGN_LEFT   0x02

#define mpALIGN_TOP    mpALIGN_RIGHT

#define mpALIGN_BOTTOM mpALIGN_LEFT

#define mpALIGN_NE     0x00

#define mpALIGN_NW     0x01

#define mpALIGN_SW     0x02

#define mpALIGN_SE     0x03

class  mpFX : public mpLayer
{
public:
        mpFX(wxString name = wxEmptyString, int flags = mpALIGN_RIGHT);

        virtual double GetY( double x ) = 0;

        virtual void Plot(wxDC & dc, mpWindow & w);

protected:
        int m_flags; 

        DECLARE_CLASS(mpFX)
};

class  mpFY : public mpLayer
{
public:
        mpFY(wxString name = wxEmptyString, int flags = mpALIGN_TOP);

        virtual double GetX( double y ) = 0;

        virtual void Plot(wxDC & dc, mpWindow & w);

protected:
        int m_flags; 

        DECLARE_CLASS(mpFY)
};

class  mpFXY : public mpLayer
{
public:
        mpFXY(wxString name = wxEmptyString, int flags = mpALIGN_NE);

        virtual void Rewind() = 0;

        virtual bool GetNextXY(double & x, double & y) = 0;

        virtual void Plot(wxDC & dc, mpWindow & w);

protected:
        int m_flags; 

        DECLARE_CLASS(mpFXY)
};

//-----------------------------------------------------------------------------
// mpLayer implementations - furniture (scales, ...)
//-----------------------------------------------------------------------------

class  mpScaleX : public mpLayer
{
public:
        mpScaleX(wxString name = wxT("X"));

        virtual void Plot(wxDC & dc, mpWindow & w);

        virtual bool HasBBox() { return FALSE; }

        DECLARE_CLASS(mpScaleX)
};

class  mpScaleY : public mpLayer
{
public:
        mpScaleY(wxString name = wxT("Y"));

        virtual void Plot(wxDC & dc, mpWindow & w, int orgy);

        virtual bool HasBBox() { return FALSE; }

protected:

        DECLARE_CLASS(mpScaleY)
};

//-----------------------------------------------------------------------------
// mpWindow
//-----------------------------------------------------------------------------

#define mpMOUSEMODE_DRAG    0

#define mpMOUSEMODE_ZOOMBOX 1

class creaMaracasVisu_EXPORT mpWindow : public wxScrolledWindow
{
public:
        mpWindow() {}
        mpWindow( wxWindow *parent, wxWindowID id,
                const wxPoint &pos = wxDefaultPosition, 
                const wxSize &size = wxDefaultSize,
                int flags = 0);
        ~mpWindow();

        wxMenu* GetPopupMenu() { return &m_popmenu; }

        //-----------------------
        // new methods for plotter
        //-----------------------
        /*
         Set Type
        */
        void setType(int t)
        {
                type=t;
        }
        /*
         Get Type
        */
        int getType()
        {
                return type;
        }
                
        
        void setMaxScrX(int maxX)
        {
                maxScrX=maxX;
        }
        void setMaxScrY(int maxY)
        {
                maxScrY=maxY;
        }
        
        
        double getMaxScrX()
        {
                return maxScrX;
        }
        double getMaxScrY()
        {
                return maxScrY;
        }
        /*
         returns the zoomFactor
        */
        float getZoomFactor()
        {
                return zoomFactor;
        }
        void setMinScrX(int minX)
        {
                minScrX=minX;
        }
        void setMinScrY(int minY)
        {
                minScrY=minY;
        }
        
        
        double getMinScrX()
        {
                return minScrX;
        }
        double getMinScrY()
        {
                return minScrY;
        }

        int getClickedX()
        {
                return m_clickedX;
        }

        int getClickedY()
        {
                return m_clickedY;
        }
        
        int getOffsetPixelsX()
        {
                return offsetPixelX;
        }       
        
        int getOffsetPixelsY()
        {
                return offsetPixelY;
        }
        void setOffsetPixelX(int offX)
        {
                offsetPixelX=offX;
        }
        void setOffsetPixelY(int offY)
        {
                offsetPixelY=offY;
        }       
        
        int getOffsetX()
        {
                return offsetX;
        }       
        
        int getOffsetY()
        {
                return offsetY;
        }
        void setOffsetX(int offX)
        {
                offsetX=offX;
        }
        void setOffsetY(int offY)
        {
                offsetY=offY;
        }       
        
        /*
        * Sets real value of the y-coord for the vertical guide line
        * @param newX_realGuide The new value to assing for the vertical guide
        */
        void setRealGuideX(int newX_realGuide)
        {               
                real_guideLine_X = newX_realGuide;      
                if(real_guideLine_X!=-1)
                        UpdateAll();
        }

        /*
        * Gets the real value of the y-coord for the vertical guide line
        * @retval real_guideLine_X The assigned value for the vertical guide
        */
        int getRealGuideX()
        {
                return real_guideLine_X;
        }       

        /*
        * Sets real value of the y-coord for the vertical guide line
        * @param newY_realGuide The new value to assing for the vertical guide
        */
        void setRealGuideY(int newY_realGuide)
        {               
                real_guideLine_Y = newY_realGuide;      
                if(real_guideLine_Y!=-1)
                        UpdateAll();
        }

        /*
        * Gets the real value of the y-coord for the vertical guide line
        * @retval real_guideLine_Y The assigned value for the vertical guide
        */
        int getRealGuideY()
        {
                return real_guideLine_Y;
        }               

        /*
        * Sets the condition for drawing or not the guide lines
        * @param ifDrawing The new condition to assing 
        */
        /*void setLineGuidesCondition(bool ifDrawing)
        {               
                drawGuides = ifDrawing;         
        }
        */
        
        /*
        * Gets the condition for drawing or not the guide lines
        * @retval drawGuides The assigned condition
        */
        bool drawGuideLines();

        /*
        * Guide lines menu handler method that reacts to the mpID_LINE_GUIDES cimmand event
        * event The corresponding event to handle
        */
        
        //void OnGuideLines (wxCommandEvent   &event); 

        //----------------------------------------------------------------------------------
        // Previous methods
        //----------------------------------------------------------------------------------
        
        
        bool AddLayer( mpLayer* layer);

        void DelLayer( mpLayer* layer);

        double GetScaleX(void) const { return m_scaleX; }

        double GetScaleY(void) const { return m_scaleY; }

        double GetPosX(void) const { return m_posX; }

        double GetPosY(void) const { return m_posY; }

        int GetScrX(void) const { return m_scrX; }

        int GetScrY(void) const { return m_scrY; }
        //void SetScrY(int x) const { return m_scrY; }

        void SetScaleX(double scaleX) { if (scaleX!=0) m_scaleX=scaleX; /*UpdateAll();*/ }

        void SetScaleY(double scaleY) { if (scaleY!=0) m_scaleY=scaleY; /*UpdateAll();*/ }

        void SetPosX(double posX) { m_posX=posX; UpdateAll(); }

        void SetPosY(double posY) { m_posY=posY; UpdateAll(); }

        void SetPos( double posX, double posY) { m_posX=posX; m_posY=posY; UpdateAll(); }

        void LockAspect(bool enable = TRUE);

        inline bool IsAspectLocked() { return m_lockaspect; }

        void Fit();

        void ZoomIn();

        void ZoomOut();

        void UpdateAll();

        int GetYTranslated(wxSize size, double y){
                return size.GetHeight()-y;
        }

protected:

        void Refresh(bool eraseBackground = true, const wxRect* rect = NULL);
        void OnPaint         (wxPaintEvent     &event); 
        void OnSize          (wxSizeEvent      &event); 
        void OnScroll2       (wxScrollWinEvent &event); 
        void OnShowPopupMenu (wxMouseEvent     &event); 
        void OnCenter        (wxCommandEvent   &event); 
        void OnFit           (wxCommandEvent   &event); 
        void OnZoomIn        (wxCommandEvent   &event); 
        void OnZoomOut       (wxCommandEvent   &event); 
        void OnLockAspect    (wxCommandEvent   &event); 
        

        bool UpdateBBox(); 

        wxList m_layers;    
        wxMenu m_popmenu;   
        bool   m_lockaspect;

        double m_minX;      
        double m_maxX;      
        double m_minY;      
        double m_maxY;      
        double m_scaleX;    
        double m_scaleY;    
        double m_posX;      
        double m_posY;      
        int    m_scrX;      
        int    m_scrY;      
        int    m_clickedX;  
        int    m_clickedY;  
        
        //----------------------------------------------
        //NEW ATTRIBUTES FOR COMPATIBILITY WITH PPlotter
        //----------------------------------------------
        int    maxScrX;
        
        int    maxScrY;
        int  minScrX;
        
        int  minScrY;
        /*
         the zoom factor
         of the zoom
        */
        float      zoomFactor;

        
        int offsetPixelX;
        int offsetPixelY;
        /*
         Offsets in real value according to the actual function
        */
        int offsetX;
        int offsetY;

        /*
        * The real value of the y-coord for the horizontal guide line
        */
        int real_guideLine_X;
        /*
        * The real value of the y-coord for the vertical guide line
        */
        int real_guideLine_Y;

        /*
        * Represents the condition for drawing or not the line guides, default color is red and assigned to draw them
        */
        bool drawGuides;
        /*
         Use to know which type of plotter is
         1= default Plotter
         2= histogram plotter
        */
         int type;

 private:
        //bitmap of functions
        wxBitmap        *_bitmap_functions;


        DECLARE_CLASS(mpWindow)
        DECLARE_EVENT_TABLE()
};

#endif // _MP_MATHPLOT_H_