KiCad PCB EDA Suite: mpWindow Class Reference

double m_posX

Definition: mathplot.h:1488

double mpWindow::GetPosY ( void ) const

inline

Definition at line 1123 of file mathplot.h.

Referenced by mpInfoLegend::Plot(), mpScaleY::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1123 { return m_posY; }

double m_posY

Definition: mathplot.h:1489

double mpWindow::GetScaleX ( void ) const

inline

Definition at line 1102 of file mathplot.h.

Referenced by mpInfoLegend::Plot(), mpScaleXBase::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1102 { return m_scaleX; }; // Schaling's method: maybe another method esists with the same name

double m_scaleX

Definition: mathplot.h:1486

double mpWindow::GetScaleY ( void ) const

inline

Definition at line 1109 of file mathplot.h.

Referenced by mpInfoLegend::Plot(), mpScaleY::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1109 { return m_scaleY; } // Schaling's method: maybe another method exists with the same name

double m_scaleY

Definition: mathplot.h:1487

int mpWindow::GetScrX ( void ) const

inline

Get current view's X dimension in device context units.

Usually this is equal to wxDC::GetSize, but it might differ thus mpLayer implementations should rely on the value returned by the function. See rules for coordinate transformation

Returns: X dimension.

Definition at line 1131 of file mathplot.h.

Referenced by mpScaleXBase::getVisibleDataRange(), mpPrintout::OnPrintPage(), CURSOR::Plot(), mpInfoLayer::Plot(), mpInfoCoords::Plot(), mpInfoLegend::Plot(), mpFX::Plot(), mpFY::Plot(), mpFXY::Plot(), mpProfile::Plot(), mpScaleXBase::Plot(), mpScaleY::Plot(), mpText::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1131 { return m_scrX; }

mpWindow::m_scrX

int m_scrX

Definition: mathplot.h:1490

int mpWindow::GetScrY ( void ) const

inline

Get current view's Y dimension in device context units.

Usually this is equal to wxDC::GetSize, but it might differ thus mpLayer implementations should rely on the value returned by the function. See rules for coordinate transformation

Returns: Y dimension.

Definition at line 1140 of file mathplot.h.

Referenced by mpScaleY::getVisibleDataRange(), mpPrintout::OnPrintPage(), CURSOR::Plot(), mpInfoLayer::Plot(), mpInfoCoords::Plot(), mpInfoLegend::Plot(), mpFX::Plot(), mpFY::Plot(), mpFXY::Plot(), mpProfile::Plot(), mpScaleXBase::Plot(), mpScaleY::Plot(), mpText::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1140 { return m_scrY; }

mpWindow::m_scrY

int m_scrY

Definition: mathplot.h:1491

double mpWindow::GetXpos ( ) const

inline

Get current view's X position.

Returns: X Position in layer coordinate system, that corresponds to the center point of the view.

Definition at line 1115 of file mathplot.h.

1115 { return m_posX; }

double m_posX

Definition: mathplot.h:1488

double mpWindow::GetXscl ( )

inline

Get current view's X scale.

Returns: Scale

Definition at line 1101 of file mathplot.h.

1101 { return m_scaleX; }

double m_scaleX

Definition: mathplot.h:1486

int mpWindow::GetXScreen ( void ) const

inline

Definition at line 1132 of file mathplot.h.

Referenced by SIM_PLOT_PANEL::EnableCursor().

1132 { return m_scrX; }

mpWindow::m_scrX

int m_scrX

Definition: mathplot.h:1490

double mpWindow::GetYpos ( ) const

inline

Get current view's Y position.

Returns: Y Position in layer coordinate system, that corresponds to the center point of the view.

Definition at line 1122 of file mathplot.h.

1122 { return m_posY; }

double m_posY

Definition: mathplot.h:1489

double mpWindow::GetYscl ( ) const

inline

Get current view's Y scale.

Returns: Scale

Definition at line 1108 of file mathplot.h.

1108 { return m_scaleY; }

double m_scaleY

Definition: mathplot.h:1487

int mpWindow::GetYScreen ( void ) const

inline

Definition at line 1141 of file mathplot.h.

1141 { return m_scrY; }

mpWindow::m_scrY

int m_scrY

Definition: mathplot.h:1491

bool mpWindow::IsAspectLocked ( )

inline

Checks whether the X/Y scale aspect is locked.

Return values

TRUE	Locked
FALSE	Unlocked

Definition at line 1222 of file mathplot.h.

1222 { return m_lockaspect; }

mpWindow::m_lockaspect

bool m_lockaspect

Definition: mathplot.h:1476

mpInfoLayer * mpWindow::IsInsideInfoLayer ( wxPoint & point )

Check if a given point is inside the area of a mpInfoLayer and eventually returns its pointer.

Parameters

point The position to be checked

Returns: If an info layer is found, returns its pointer, NULL otherwise

Definition at line 3110 of file mathplot.cpp.

References mpInfoLayer::Inside().

 {
     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;
 }

bool mpWindow::IsLayerVisible ( const wxString & name )

Check whether a layer with given name is visible.

Parameters

name	The layer name

Returns: layer visibility status

Definition at line 3150 of file mathplot.cpp.

References mpLayer::IsVisible().

 {
     mpLayer* lx = GetLayerByName( name );
 
     return (lx) ? lx->IsVisible() : false;
 }

bool mpWindow::IsLayerVisible ( const unsigned int position )

Check whether the layer at given position is visible.

Parameters

position The layer position in layer list

Returns: layer visibility status

Definition at line 3170 of file mathplot.cpp.

References GetLayer(), and mpLayer::IsVisible().

 {
     mpLayer* lx = GetLayer( position );
 
     return (lx) ? lx->IsVisible() : false;
 }

void mpWindow::LimitView ( bool aEnable )

inline

Limit zooming & panning to the area used by the plots.

Definition at line 1404 of file mathplot.h.

Referenced by SIM_PLOT_PANEL::SIM_PLOT_PANEL().

     {
         m_enableLimitedView = aEnable;
     }

void mpWindow::LockAspect ( bool enable = TRUE )

Enable or disable X/Y scale aspect locking for the view.

Note: Explicit calls to mpWindow::SetScaleX and mpWindow::SetScaleY will set an unlocked aspect, but any other action changing the view scale will lock the aspect again.

Definition at line 2404 of file mathplot.cpp.

References mpID_LOCKASPECT.

 {
     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::OnCenter ( wxCommandEvent & event )

protected

Definition at line 2434 of file mathplot.cpp.

 {
     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::OnFit ( wxCommandEvent & event )

protected

Definition at line 2428 of file mathplot.cpp.

 {
     Fit();
 }

void mpWindow::OnLockAspect ( wxCommandEvent & event )

protected

Definition at line 2422 of file mathplot.cpp.

 {
     LockAspect( !m_lockaspect );
 }

void mpWindow::OnMouseLeftDown ( wxMouseEvent & event )

protected

Definition at line 1953 of file mathplot.cpp.

 {
     m_mouseLClick.x = event.GetX();
     m_mouseLClick.y = event.GetY();
     m_zooming = true;
 #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
     }
 
     event.Skip();
 }

void mpWindow::OnMouseLeftRelease ( wxMouseEvent & event )

protected

Definition at line 1976 of file mathplot.cpp.

 {
     wxPoint release( event.GetX(), event.GetY() );
     wxPoint press( m_mouseLClick.x, m_mouseLClick.y );
 
     m_zooming = false;
 
     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);
               *  }
               *  } */
     }
 
     event.Skip();
 }

void mpWindow::OnMouseMiddleDown ( wxMouseEvent & event )

protected

Definition at line 1802 of file mathplot.cpp.

 {
     m_mouseMClick.x = event.GetX();
     m_mouseMClick.y = event.GetY();
 }

void mpWindow::OnMouseMove ( wxMouseEvent & event )

protected

Definition at line 1853 of file mathplot.cpp.

References mpInfoLayer::GetRectangle(), and mpInfoLayer::UpdateInfo().

 {
     if( !m_enableMouseNavigation )
     {
         event.Skip();
         return;
     }
 
     if( event.m_middleDown )
     {
         // The change:
         int Ax  = m_mouseMClick.x - event.GetX();
         int Ay  = m_mouseMClick.y - event.GetY();
 
         // For the next event, use relative to this coordinates.
         m_mouseMClick.x = event.GetX();
         m_mouseMClick.y = event.GetY();
 
         double  Ax_units    = Ax / m_scaleX;
         double  Ay_units    = -Ay / m_scaleY;
 
         bool updateRequired = false;
         updateRequired  |= SetXView( m_posX + Ax_units,
                 m_desiredXmax + Ax_units,
                 m_desiredXmin + Ax_units );
         updateRequired  |= SetYView( m_posY + Ay_units,
                 m_desiredYmax + Ay_units,
                 m_desiredYmin + Ay_units );
 
         if( updateRequired )
             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( m_fgColour, 1, wxPENSTYLE_DOT );
                 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 );
                 m_zooming = true;
                 m_zoomRect.x    = m_mouseLClick.x;
                 m_zoomRect.y    = m_mouseLClick.y;
                 m_zoomRect.width    = event.GetX() - m_mouseLClick.x;
                 m_zoomRect.height   = event.GetY() - m_mouseLClick.y;
             }
             else
             {
                 wxPoint moveVector( event.GetX() - m_mouseLClick.x,
                         event.GetY() - m_mouseLClick.y );
                 m_movingInfoLayer->Move( moveVector );
                 m_zooming = false;
             }
 
             UpdateAll();
         }
         else
         {
 #if 0
             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() );
                 }
             }
 
 #endif
             /* 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::OnMouseWheel ( wxMouseEvent & event )

protected

Definition at line 1811 of file mathplot.cpp.

 {
     if( !m_enableMouseNavigation )
     {
         event.Skip();
         return;
     }
 
     // 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_controlDown )
     {
         // horizontal scroll
         SetXView( m_posX + changeUnitsX, m_desiredXmax + changeUnitsX,
                 m_desiredXmin + changeUnitsX );
     }
     else if( event.m_shiftDown )
     {
         // vertical scroll
         SetYView( m_posY - changeUnitsY, m_desiredYmax - changeUnitsY,
                 m_desiredYmin - changeUnitsY );
     }
     else
     {
         // zoom in/out
         wxPoint clickPt( event.GetX(), event.GetY() );
 
         if( event.GetWheelRotation() > 0 )
             ZoomIn( clickPt );
         else
             ZoomOut( clickPt );
     }
 
     UpdateAll();
 }

void mpWindow::OnPaint ( wxPaintEvent & event )

protected

Definition at line 2526 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     wxPaintDC dc( this );
 
     dc.GetSize( &m_scrX, &m_scrY );    // This is the size of the visible area only!
 
 #ifdef MATHPLOT_DO_LOGGING
         wxLogMessage( "[mpWindow::OnPaint] vis.area: x %i y%i", m_scrX, m_scrY );
 #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( m_zooming )
     {
         wxPen pen( m_fgColour, 1, wxPENSTYLE_DOT );
         trgDc->SetPen( pen );
         trgDc->SetBrush( *wxTRANSPARENT_BRUSH );
         trgDc->DrawRectangle( m_zoomRect );
     }
 
     // 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_scroll.x = (int) floor((m_posX - m_minX)*m_scaleX);
          *        m_scroll.y = (int) floor((m_maxY - m_posY )*m_scaleY);
          *        Scroll(m_scroll.x, m_scroll.y);*/
         // 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);
     }
 }

void mpWindow::OnScrollBottom ( wxScrollWinEvent & event )

protected

Definition at line 2972 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     int scrollOrientation = event.GetOrientation();
     // Get thumb size
     int thumbSize = GetScrollThumb( scrollOrientation );
     // Get scroll range
     int scrollRange = GetScrollRange( scrollOrientation );
 
     DoScrollCalc( scrollRange - thumbSize, scrollOrientation );
 }

void mpWindow::OnScrollLineDown ( wxScrollWinEvent & event )

protected

Definition at line 2946 of file mathplot.cpp.

References mpSCROLL_NUM_PIXELS_PER_LINE.

Referenced by mpScaleY::Plot().

 {
     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::OnScrollLineUp ( wxScrollWinEvent & event )

protected

Definition at line 2930 of file mathplot.cpp.

References mpSCROLL_NUM_PIXELS_PER_LINE.

Referenced by mpScaleY::Plot().

 {
     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::OnScrollPageDown ( wxScrollWinEvent & event )

protected

Definition at line 2910 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     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::OnScrollPageUp ( wxScrollWinEvent & event )

protected

Definition at line 2892 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     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::OnScrollThumbTrack ( wxScrollWinEvent & event )

protected

Definition at line 2886 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     DoScrollCalc( event.GetPosition(), event.GetOrientation() );
 }

void mpWindow::OnScrollTop ( wxScrollWinEvent & event )

protected

Definition at line 2966 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     DoScrollCalc( 0, event.GetOrientation() );
 }

void mpWindow::OnShowPopupMenu ( wxMouseEvent & event )

protected

Definition at line 2414 of file mathplot.cpp.

 {
     m_clickedX  = event.GetX();
     m_clickedY  = event.GetY();
     PopupMenu( &m_popmenu, event.GetX(), event.GetY() );
 }

void mpWindow::OnSize ( wxSizeEvent & event )

protected

Definition at line 2456 of file mathplot.cpp.

Referenced by mpScaleY::Plot().

 {
     // 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
 }

void mpWindow::OnZoomIn ( wxCommandEvent & event )

protected

Definition at line 2444 of file mathplot.cpp.

 {
     ZoomIn( wxPoint( m_mouseMClick.x, m_mouseMClick.y ) );
 }

void mpWindow::OnZoomOut ( wxCommandEvent & event )

protected

Definition at line 2450 of file mathplot.cpp.

 {
     ZoomOut();
 }

double mpWindow::p2x ( wxCoord pixelCoordX )

inline

Converts mpWindow (screen) pixel coordinates into graph (floating point) coordinates, using current mpWindow position and scale.

See also: p2y,x2p,y2p

Definition at line 1185 of file mathplot.h.

Referenced by mpScaleXBase::getVisibleDataRange(), CURSOR::Plot(), mpFX::Plot(), and mpProfile::Plot().

1185 { return m_posX + pixelCoordX / m_scaleX; }

double m_posX

Definition: mathplot.h:1488

double m_scaleX

Definition: mathplot.h:1486

double mpWindow::p2y ( wxCoord pixelCoordY )

inline

Converts mpWindow (screen) pixel coordinates into graph (floating point) coordinates, using current mpWindow position and scale.

See also: p2x,x2p,y2p

Definition at line 1190 of file mathplot.h.

Referenced by mpScaleY::getVisibleDataRange(), and mpFY::Plot().

1190 { return m_posY - pixelCoordY / m_scaleY; }

double m_scaleY

Definition: mathplot.h:1487

double m_posY

Definition: mathplot.h:1489

bool mpWindow::SaveScreenshot	(	const wxString &	filename,
		wxBitmapType	type = `wxBITMAP_TYPE_BMP`,
		wxSize	imageSize = `wxDefaultSize`,
		bool	fit = `false`
	)

Draw the window on a wxBitmap, then save it to a file.

Parameters

filename	File name where to save the screenshot
type	image type to be saved: see wxImage output file types for flags
imageSize	Set a size for the output image. Default is the same as the screen size
fit	Decide whether to fit the plot into the size

Definition at line 3044 of file mathplot.cpp.

Referenced by SIM_PLOT_FRAME::menuSaveImage().

 {
     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::SetColourTheme	(	const wxColour &	bgColour,
		const wxColour &	drawColour,
		const wxColour &	axesColour
	)

Set Color theme.

Provide colours to set a new colour theme.

Parameters

bgColour	Background colour
drawColour	The colour used to draw all elements in foreground, axes excluded
axesColour	The colour used to draw axes (but not their labels)

Definition at line 3178 of file mathplot.cpp.

References mpLAYER_AXIS, and mpLAYER_INFO.

Referenced by mpPrintout::OnPrintPage(), and SIM_PLOT_PANEL::SIM_PLOT_PANEL().

 {
     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 );
         }
     }
 }

void mpWindow::SetLayerVisible	(	const wxString &	name,
		bool	viewable
	)

Sets the visibility of a layer by its name.

Parameters

name	The layer name to set visibility
viewable	the view status to be set

Definition at line 3138 of file mathplot.cpp.

References mpLayer::SetVisible().

 {
     mpLayer* lx = GetLayerByName( name );
 
     if( lx )
     {
         lx->SetVisible( viewable );
         UpdateAll();
     }
 }

void mpWindow::SetLayerVisible	(	const unsigned int	position,
		bool	viewable
	)

Sets the visibility of a layer by its position in layer list.

Parameters

position	The layer position in layer list
viewable	the view status to be set

Definition at line 3158 of file mathplot.cpp.

References GetLayer(), and mpLayer::SetVisible().

 {
     mpLayer* lx = GetLayer( position );
 
     if( lx )
     {
         lx->SetVisible( viewable );
         UpdateAll();
     }
 }

void mpWindow::SetMarginBottom ( int bottom )

inline

Set the bottom margin.

Parameters

bottom Bottom Margin

Definition at line 1341 of file mathplot.h.

1341 { m_marginBottom = bottom; };

mpWindow::m_marginBottom

int m_marginBottom

Definition: mathplot.h:1499

void mpWindow::SetMarginLeft ( int left )

inline

Set the left margin.

Parameters

left	Left Margin

Definition at line 1343 of file mathplot.h.

1343 { m_marginLeft = left; };

mpWindow::m_marginLeft

int m_marginLeft

Definition: mathplot.h:1499

void mpWindow::SetMarginRight ( int right )

inline

Set the right margin.

Parameters

right Right Margin

Definition at line 1339 of file mathplot.h.

1339 { m_marginRight = right; };

mpWindow::m_marginRight

int m_marginRight

Definition: mathplot.h:1499

void mpWindow::SetMargins	(	int	top,
		int	right,
		int	bottom,
		int	left
	)

Set window margins, creating a blank area where some kinds of layers cannot draw.

This is useful for example to draw axes outside the area where the plots are drawn.

Parameters

top	Top border
right	Right border
bottom	Bottom border
left	Left border

Definition at line 3101 of file mathplot.cpp.

Referenced by SIM_PLOT_PANEL::SIM_PLOT_PANEL().

 {
     m_marginTop = top;
     m_marginRight   = right;
     m_marginBottom  = bottom;
     m_marginLeft = left;
 }

void mpWindow::SetMarginTop ( int top )

inline

Set the top margin.

Parameters

top	Top Margin

Definition at line 1337 of file mathplot.h.

1337 { m_marginTop = top; };

mpWindow::m_marginTop

int m_marginTop

Definition: mathplot.h:1499

void mpWindow::SetMPScrollbars ( bool status )

Enable/disable scrollbars.

Parameters

status Set to true to show scrollbars

m_scroll.x = (int) floor((m_posX - m_minX)*m_scaleX);

Definition at line 2665 of file mathplot.cpp.

 {
     // 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_scroll.x = (int) floor((m_posX - m_minX)*m_scaleX);
      *     m_scroll.y = (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_scroll.y = (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_scroll.x,
     // m_scroll.y);
     // }
     // Refresh(false);*/
 }

void mpWindow::SetPos	(	double	posX,
		double	posY
	)

inline

Set current view's X and Y position and refresh display.

Parameters

posX	New position that corresponds to the center point of the view.
posY	New position that corresponds to the center point of the view.

Definition at line 1173 of file mathplot.h.

1173 { m_posX = posX; m_posY = posY; UpdateAll(); }

double m_posX

Definition: mathplot.h:1488

mpWindow::UpdateAll

void UpdateAll()

Refresh display.

Definition: mathplot.cpp:2814

double m_posY

Definition: mathplot.h:1489

void mpWindow::SetPosX ( double posX )

inline

Set current view's X position and refresh display.

Parameters

posX	New position that corresponds to the center point of the view.

Definition at line 1162 of file mathplot.h.

1162 { m_posX = posX; UpdateAll(); }

double m_posX

Definition: mathplot.h:1488

mpWindow::UpdateAll

void UpdateAll()

Refresh display.

Definition: mathplot.cpp:2814

void mpWindow::SetPosY ( double posY )

inline

Set current view's Y position and refresh display.

Parameters

posY	New position that corresponds to the center point of the view.

Definition at line 1167 of file mathplot.h.

1167 { m_posY = posY; UpdateAll(); }

mpWindow::UpdateAll

void UpdateAll()

Refresh display.

Definition: mathplot.cpp:2814

double m_posY

Definition: mathplot.h:1489

void mpWindow::SetScaleX ( double scaleX )

Set current view's X scale and refresh display.

Parameters

scaleX New scale, must not be 0.

Definition at line 2986 of file mathplot.cpp.

 {
     if( scaleX!=0 )
         m_scaleX = scaleX;
 
     UpdateAll();
 }

void mpWindow::SetScaleY ( double scaleY )

inline

Set current view's Y scale and refresh display.

Parameters

scaleY New scale, must not be 0.

Definition at line 1151 of file mathplot.h.

     {
         if( scaleY!=0 )
             m_scaleY = scaleY;
 
         UpdateAll();
     }

void mpWindow::SetScr	(	int	scrX,
		int	scrY
	)

inline

Set current view's dimensions in device context units.

Needed by plotting functions. It doesn't refresh display.

Parameters

scrX	New position that corresponds to the center point of the view.
scrY	New position that corresponds to the center point of the view.

Definition at line 1180 of file mathplot.h.

1180 { m_scrX = scrX; m_scrY = scrY; }

mpWindow::m_scrY

int m_scrY

Definition: mathplot.h:1491

mpWindow::m_scrX

int m_scrX

Definition: mathplot.h:1490

bool mpWindow::SetXView	(	double	pos,
		double	desiredMax,
		double	desiredMin
	)

protectedvirtual

Applies new X view coordinates depending on the settings.

Returns: true if the changes were applied

Definition at line 2221 of file mathplot.cpp.

 {
     // if(!CheckXLimits(desiredMax, desiredMin))
     // return false;
 
     m_posX = pos;
     m_desiredXmax   = desiredMax;
     m_desiredXmin   = desiredMin;
     AdjustLimitedView();
 
     return true;
 }

bool mpWindow::SetYView	(	double	pos,
		double	desiredMax,
		double	desiredMin
	)

protectedvirtual

Applies new Y view coordinates depending on the settings.

Returns: true if the changes were applied

Definition at line 2235 of file mathplot.cpp.

 {
     // if(!CheckYLimits(desiredMax, desiredMin))
     // return false;
 
     m_posY = pos;
     m_desiredYmax   = desiredMax;
     m_desiredYmin   = desiredMin;
     AdjustLimitedView();
 
     return true;
 }

void mpWindow::UpdateAll ( )

Refresh display.

Definition at line 2814 of file mathplot.cpp.

References Refresh().

Referenced by SIM_PLOT_PANEL::AddTrace(), mpPrintout::OnPrintPage(), SIM_PLOT_FRAME::onSimFinished(), and SIM_PLOT_PANEL::SIM_PLOT_PANEL().

 {
     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 );
 }

bool mpWindow::UpdateBBox ( )

protectedvirtual

Recalculate global layer bounding box, and save it in m_minX,...

Returns: true if there is any valid BBox information.

Definition at line 2706 of file mathplot.cpp.

References mpLayer::GetMaxX(), mpLayer::GetMaxY(), mpLayer::GetMinX(), mpLayer::GetMinY(), and mpLayer::HasBBox().

 {
     m_minX  = 0.0;
     m_maxX  = 1.0;
     m_minY  = 0.0;
     m_maxY  = 1.0;
 
     return true;
 
 #if 0
     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;
 #endif
 }

wxCoord mpWindow::x2p ( double x )

inline

Converts graph (floating point) coordinates into mpWindow (screen) pixel coordinates, using current mpWindow position and scale.

See also: p2x,p2y,y2p

Definition at line 1195 of file mathplot.h.

Referenced by CURSOR::Plot(), mpFY::Plot(), mpFXY::Plot(), mpScaleY::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1195 { return (wxCoord) ( (x - m_posX) * m_scaleX ); }

double m_posX

Definition: mathplot.h:1488

double m_scaleX

Definition: mathplot.h:1486

wxCoord mpWindow::y2p ( double y )

inline

Converts graph (floating point) coordinates into mpWindow (screen) pixel coordinates, using current mpWindow position and scale.

See also: p2x,p2y,x2p

Definition at line 1200 of file mathplot.h.

Referenced by CURSOR::Plot(), mpFX::Plot(), mpFXY::Plot(), mpProfile::Plot(), mpScaleXBase::Plot(), mpMovableObject::Plot(), and mpBitmapLayer::Plot().

1200 { return (wxCoord) ( (m_posY - y) * m_scaleY ); }

double m_scaleY

Definition: mathplot.h:1487