-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "Plot2d_Curve.h"
#include "Plot2d_PlotItems.h"
#include "Plot2d_FitDataDlg.h"
+#ifndef NO_SUIT
#include "Plot2d_ViewWindow.h"
+#endif
#include "Plot2d_SetupViewDlg.h"
+#ifndef NO_ANALYTICAL_CURVES
#include "Plot2d_AnalyticalCurveDlg.h"
#include "Plot2d_AnalyticalCurve.h"
+#endif
#include "Plot2d_ToolTip.h"
+#ifndef NO_SUIT
#include "SUIT_Tools.h"
#include "SUIT_Session.h"
#include "SUIT_MessageBox.h"
#include "SUIT_ResourceMgr.h"
#include "SUIT_Application.h"
+#else
+#include <QMessageBox>
+#endif
#include <QApplication>
#include <QToolBar>
#include <QXmlStreamReader>
#include <qwt_math.h>
+#include <qwt_plot_layout.h>
#include <qwt_plot_canvas.h>
#include <qwt_scale_div.h>
#include <qwt_plot_marker.h>
#include <qwt_scale_engine.h>
#include <qwt_plot_zoomer.h>
#include <qwt_curve_fitter.h>
-
-#include <stdlib.h>
-#include <qprinter.h>
-
+#include <qwt_plot_renderer.h>
#include <qwt_legend.h>
#include <qwt_scale_widget.h>
+#include <stdlib.h>
+#include <limits>
+
#define DEFAULT_LINE_WIDTH 0 // (default) line width
#define DEFAULT_MARKER_SIZE 9 // default marker size
#define MIN_RECT_SIZE 11 // min sensibility area size
#define FITALL_EVENT ( QEvent::User + 9999 )
-const char* imageZoomCursor[] = {
+const char* imageZoomCursor[] = {
"32 32 3 1",
". c None",
"a c #000000",
"................................",
"................................"};
-const char* imageCrossCursor[] = {
+const char* imageCrossCursor[] = {
"32 32 3 1",
". c None",
"a c #000000",
"................................",
"................................",
"................................"};
-
+
+#ifdef WIN32
+ #ifdef max
+ #undef max
+ #endif
+
+ #ifdef min
+ #undef min
+ #endif
+#endif
+
/*!
Constructor
*/
Plot2d_ViewFrame::Plot2d_ViewFrame( QWidget* parent, const QString& title )
: QWidget (parent, 0),
- myOperation( NoOpId ),
- myCurveType( 1 ),
- myShowLegend( true ), myLegendPos( 1 ), myLegendFont("Helvetic",12),
- myLegendColor(Qt::black),
+ myOperation( NoOpId ),
+ myCurveType( 1 ),
+ myShowLegend( true ), myLegendPos( 1 ), myLegendSymbolType( 0 ), myLegendFont("Helvetic",12),
+ myLegendColor(Qt::black), mySelectedLegendFontColor( Qt::darkBlue ),
myMarkerSize( DEFAULT_MARKER_SIZE ),
myBackground( Qt::white ),
+ mySelectionColor( Qt::gray ),
myTitle( "" ), myXTitle( "" ), myYTitle( "" ), myY2Title( "" ),
myTitleEnabled( true ), myXTitleEnabled( true ),
myYTitleEnabled( true ), myY2TitleEnabled (true),
- myXGridMajorEnabled( true ), myYGridMajorEnabled( true ), myY2GridMajorEnabled( true ),
+ myXGridMajorEnabled( true ), myYGridMajorEnabled( true ), myY2GridMajorEnabled( true ),
myXGridMinorEnabled( false ), myYGridMinorEnabled( false ), myY2GridMinorEnabled( false ),
myXGridMaxMajor( 8 ), myYGridMaxMajor( 8 ), myY2GridMaxMajor( 8 ),
myXGridMaxMinor( 5 ), myYGridMaxMinor( 5 ), myY2GridMaxMinor( 5 ),
myRNormAlgo = new Plot2d_NormalizeAlgorithm(this);
myLNormAlgo = new Plot2d_NormalizeAlgorithm(this);
/* Plot 2d View */
- QVBoxLayout* aLayout = new QVBoxLayout( this );
+ QVBoxLayout* aLayout = new QVBoxLayout( this );
+ aLayout->setMargin(0);
myPlot = new Plot2d_Plot2d( this );
new Plot2d_ToolTip( this );
aLayout->addWidget( myPlot );
- // createActions();
- connect( myPlot, SIGNAL( legendClicked( QwtPlotItem* ) ),
- this, SIGNAL( legendClicked( QwtPlotItem* ) ) );
-
- // IPAL 21465
- /* connect( myPlot->axisWidget( QwtPlot::xBottom ), SIGNAL( scaleDivChanged() ),
- myPlot, SLOT( onScaleDivChanged() ) );
- connect( myPlot->axisWidget( QwtPlot::yLeft ), SIGNAL( scaleDivChanged() ),
- myPlot, SLOT( onScaleDivChanged() ) );
- if (mySecondY)
- connect( myPlot->axisWidget( QwtPlot::yRight ), SIGNAL( scaleDivChanged() ),
- myPlot, SLOT( onScaleDivChanged() ) );*/
-
+#ifndef NO_SUIT
+ Init();
+#endif
+}
+/*!
+ Destructor
+*/
+Plot2d_ViewFrame::~Plot2d_ViewFrame()
+{
+}
+/*!
+ Performs the initial setup.
+*/
+void Plot2d_ViewFrame::Init()
+{
/* Initial Setup - get from the preferences */
readPreferences();
- myPlot->setMargin( 5 );
setCurveType( myCurveType, false );
setXGrid( myXGridMajorEnabled, myXGridMaxMajor, myXGridMinorEnabled, myXGridMaxMinor, false );
setYGrid( myYGridMajorEnabled, myYGridMaxMajor, myYGridMinorEnabled, myYGridMaxMinor,
setHorScaleMode( myXMode, false );
setVerScaleMode( myYMode, false );
setBackgroundColor( myBackground );
+ setSelectionColor( mySelectionColor );
setLegendPos( myLegendPos );
+ setLegendSymbolType( myLegendSymbolType );
setLegendFont( myLegendFont );
setLegendFontColor( myLegendColor );
+ setSelectedLegendFontColor( mySelectedLegendFontColor );
showLegend( myShowLegend, false );
myPlot->replot();
- if ( parent ) {
- resize( (int)(0.8 * parent->width()), (int)(0.8 * parent->height()) );
+ QWidget* aParent = parentWidget();
+ if ( aParent ) {
+ resize( (int)(0.8 * aParent->width()), (int)(0.8 * aParent->height()) );
}
QwtScaleMap xMap = myPlot->canvasMap( QwtPlot::xBottom );
QwtScaleMap yMap = myPlot->canvasMap( QwtPlot::yLeft );
}
myPlot->canvas()->installEventFilter( this );
}
-/*!
- Destructor
-*/
-Plot2d_ViewFrame::~Plot2d_ViewFrame()
+void Plot2d_ViewFrame::SetPreference()
{
+ readPreferences();
+ setBackgroundColor( myBackground );
+ setSelectionColor( mySelectionColor );
+ setCurveType( myCurveType, true );
+ setMarkerSize( myMarkerSize, true );
+ showLegend( myShowLegend, true );
+ setLegendPos( myLegendPos );
+ setLegendSymbolType( myLegendSymbolType );
+ setLegendFont( myLegendFont );
+ setLegendFontColor( myLegendColor );
+ setSelectedLegendFontColor( mySelectedLegendFontColor );
+ myPlot->replot();
}
/*!
Gets window's central widget
/*!
Removes all curves from the view
*/
-void Plot2d_ViewFrame::EraseAll()
+void Plot2d_ViewFrame::EraseAll()
{
objectList anObjects;
getObjects( anObjects );
myIntermittentSegmentList.clear();
}
- // 2)- Erase all curves points markers
-
- int nbMark = myMarkerList.size();
- if (nbMark > 0)
- {
- for (int imar=0; imar < nbMark; imar++)
- {
- QwtPlotMarker *marker = myMarkerList[imar];
-
- marker->detach(); // erase in QwtPlot window
- delete marker;
- }
- myMarkerList.clear();
- }
-
- // The graphic view's picker
- Plot2d_QwtPlotPicker *picker = myPlot->getPicker();
-
- // Clear points markers list and associations (marker,tooltip)
- picker->pMarkers.clear(); // QList<QwtPlotMarker*>
- picker->pMarkersToolTip.clear(); // QMap<QwtPlotMarker*, QwtText>
-
// 3)- Erase all QwtPlotCurve associated with the Plot2d_Curve
int nbCur1 = myQwtPlotCurveList.size();
*/
void Plot2d_ViewFrame::readPreferences()
{
+#ifndef NO_SUIT
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
myCurveType = resMgr->integerValue( "Plot2d", "CurveType", myCurveType );
myShowLegend = resMgr->booleanValue( "Plot2d", "ShowLegend", myShowLegend );
myLegendPos = resMgr->integerValue( "Plot2d", "LegendPos", myLegendPos );
+ myLegendSymbolType = resMgr->integerValue( "Plot2d", "LegendSymbolType", myLegendSymbolType );
myLegendFont = resMgr->fontValue( "Plot2d", "LegendFont", myLegendFont );
myLegendColor = resMgr->colorValue( "Plot2d", "LegendFontColor", myLegendColor );
+ mySelectedLegendFontColor = resMgr->colorValue( "Plot2d", "SelectedLegendFontColor", mySelectedLegendFontColor );
myMarkerSize = resMgr->integerValue( "Plot2d", "MarkerSize", myMarkerSize );
myBackground = resMgr->colorValue( "Plot2d", "Background", myBackground );
+ mySelectionColor = resMgr->colorValue( "Plot2d", "SelectionColor", mySelectionColor );
myTitleEnabled = resMgr->booleanValue( "Plot2d", "ShowTitle", myTitleEnabled );
myXTitleEnabled = resMgr->booleanValue( "Plot2d", "ShowHorTitle", myXTitleEnabled );
setNormRMaxMode( resMgr->booleanValue( "Plot2d", "VerNormRMaxMode", myNormRMax ) );
QColor c = resMgr->colorValue( "Plot2d", "DeviationMarkerColor", QColor(255,0,0));
myPlot->setProperty(PLOT2D_DEVIATION_COLOR, c);
- myPlot->setProperty(PLOT2D_DEVIATION_LW,
+ myPlot->setProperty(PLOT2D_DEVIATION_LW,
resMgr->integerValue( "Plot2d", "DeviationMarkerLineWidth", 1));
- myPlot->setProperty(PLOT2D_DEVIATION_TS,
+ myPlot->setProperty(PLOT2D_DEVIATION_TS,
resMgr->integerValue( "Plot2d", "DeviationMarkerTickSize", 2));
-
+#endif
}
/*!
*/
void Plot2d_ViewFrame::writePreferences()
{
+#ifndef NO_SUIT
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
resMgr->setValue( "Plot2d", "CurveType", myCurveType );
resMgr->setValue( "Plot2d", "ShowLegend", myShowLegend );
resMgr->setValue( "Plot2d", "LegendPos", myLegendPos );
+ resMgr->setValue( "Plot2d", "LegendSymbolType", myLegendSymbolType );
resMgr->setValue( "Plot2d", "LegendFont", myLegendFont );
resMgr->setValue( "Plot2d", "LegendFontColor", myLegendColor );
+ resMgr->setValue( "Plot2d", "SelectedLegendFontColor", mySelectedLegendFontColor );
resMgr->setValue( "Plot2d", "MarkerSize", myMarkerSize );
resMgr->setValue( "Plot2d", "Background", myBackground );
+ resMgr->setValue( "Plot2d", "SelectionColor", mySelectionColor );
resMgr->setValue( "Plot2d", "ShowTitle", myTitleEnabled );
resMgr->setValue( "Plot2d", "ShowHorTitle", myXTitleEnabled );
resMgr->setValue( "Plot2d", "ShowVerLeftTitle", myYTitleEnabled );
+ resMgr->setValue( "Plot2d", "DeviationMarkerColor", myPlot->property(PLOT2D_DEVIATION_COLOR).value<QColor>() );
+ resMgr->setValue( "Plot2d", "DeviationMarkerLineWidth", myPlot->property(PLOT2D_DEVIATION_LW).toInt() );
+ resMgr->setValue( "Plot2d", "DeviationMarkerTickSize", myPlot->property(PLOT2D_DEVIATION_TS).toInt() );
if ( mySecondY )
resMgr->setValue( "Plot2d", "ShowVerRightTitle", myY2TitleEnabled );
resMgr->setValue( "Plot2d", "VerNormLMaxMode", myNormLMax );
resMgr->setValue( "Plot2d", "VerNormRMinMode", myNormRMin );
resMgr->setValue( "Plot2d", "VerNormRMaxMode", myNormRMax );
+#endif
}
/*!
Prints mouse cursor coordinates into string
*/
-QString Plot2d_ViewFrame::getInfo( const QPoint& pnt )
+QString Plot2d_ViewFrame::getInfo( const QPoint& pnt )
{
int i;
QwtValueList aTicks;
bool xFound = false, yFound = false;
double xCoord, yCoord;
- const QwtScaleDiv* aXscale = myPlot->axisScaleDiv( QwtPlot::xBottom );
- aTicks = aXscale->ticks( QwtScaleDiv::MajorTick );
+ const QwtScaleDiv& aXscale = myPlot->axisScaleDiv( QwtPlot::xBottom );
+ aTicks = aXscale.ticks( QwtScaleDiv::MajorTick );
for ( i = 0; i < aTicks.count(); i++ ) {
double majXmark = aTicks[i];
int xmark = myPlot->transform( QwtPlot::xBottom, majXmark );
if ( xmark-2 == pnt.x() ) {
- xCoord = majXmark;
+ xCoord = majXmark;
xFound = true;
break;
}
}
if ( !xFound ) {
- aTicks = aXscale->ticks( QwtScaleDiv::MinorTick );
+ aTicks = aXscale.ticks( QwtScaleDiv::MinorTick );
for ( i = 0; i < aTicks.count(); i++ ) {
double minXmark = aTicks[i];
int xmark = myPlot->transform( QwtPlot::xBottom, minXmark );
if ( xmark-2 == pnt.x() ) {
- xCoord = minXmark;
+ xCoord = minXmark;
xFound = true;
break;
}
}
- }
- const QwtScaleDiv* aYscale = myPlot->axisScaleDiv( QwtPlot::yLeft );
- aTicks = aYscale->ticks( QwtScaleDiv::MajorTick );
+ }
+ const QwtScaleDiv& aYscale = myPlot->axisScaleDiv( QwtPlot::yLeft );
+ aTicks = aYscale.ticks( QwtScaleDiv::MajorTick );
for ( i = 0; i < aTicks.count(); i++ ) {
double majYmark = aTicks[i];
int ymark = myPlot->transform( QwtPlot::yLeft, majYmark );
if ( ymark-2 == pnt.y() ) {
- yCoord = majYmark;
+ yCoord = majYmark;
yFound = true;
break;
}
}
if ( !yFound ) {
- aTicks = aYscale->ticks( QwtScaleDiv::MinorTick );
+ aTicks = aYscale.ticks( QwtScaleDiv::MinorTick );
for ( i = 0; i < aTicks.count(); i++ ) {
double minYmark = aTicks[i];
int ymark = myPlot->transform( QwtPlot::yLeft, minYmark );
if ( ymark-2 == pnt.y() ) {
- yCoord = minYmark;
+ yCoord = minYmark;
yFound = true;
break;
}
}
- }
+ }
QString strX = QString::number( xFound ? xCoord : myPlot->invTransform( QwtPlot::xBottom, pnt.x() ) ).trimmed();
if ( strX == "-0" )
bool yFound2 = false;
double yCoord2;
- const QwtScaleDiv* aYscale2 = myPlot->axisScaleDiv( QwtPlot::yRight );
- aTicks = aYscale2->ticks( QwtScaleDiv::MajorTick );
+ const QwtScaleDiv& aYscale2 = myPlot->axisScaleDiv( QwtPlot::yRight );
+ aTicks = aYscale2.ticks( QwtScaleDiv::MajorTick );
for ( i = 0; i < aTicks.count(); i++ ) {
double majYmark = aTicks[i];
int ymark = myPlot->transform( QwtPlot::yRight, majYmark );
if ( ymark-2 == pnt.y() ) {
- yCoord2 = majYmark;
+ yCoord2 = majYmark;
yFound2 = true;
break;
}
}
if ( !yFound2 ) {
- aTicks = aYscale2->ticks( QwtScaleDiv::MinorTick );
+ aTicks = aYscale2.ticks( QwtScaleDiv::MinorTick );
for ( i = 0; i < aTicks.count(); i++ ) {
double minYmark = aTicks[i];
int ymark = myPlot->transform( QwtPlot::yRight, minYmark );
if ( ymark-2 == pnt.y() ) {
- yCoord2 = minYmark;
+ yCoord2 = minYmark;
yFound2 = true;
break;
}
}
}
- QString strY2 = QString::number( yFound2 ? yCoord2 :
+ QString strY2 = QString::number( yFound2 ? yCoord2 :
myPlot->invTransform( QwtPlot::yRight, pnt.y() ) ).trimmed();
if ( strY2 == "-0" )
strY2 = "0";
return info;
}
-/*!
- * Create markers and tooltips associated with curve points
- */
-void Plot2d_ViewFrame::createCurveTooltips( Plot2d_Curve *curve,
- Plot2d_QwtPlotPicker *picker)
-{
- // Dans Plot2d.h : pointList == QList<Plot2d_Point>
- double x, y;
- QString tooltip;
-
- pointList points = curve->getPointList();
- QColor color = curve->getColor();
-
- // Point marker
- QwtSymbol symbol;
- symbol.setStyle(QwtSymbol::Ellipse);
- symbol.setSize(1,1);
- symbol.setPen( QPen(color));
- symbol.setBrush( QBrush(color));
-
- for (int ip=0; ip < points.count(); ip++)
- {
- x = points[ip].x;
- y = points[ip].y;
- tooltip = points[ip].text;
-
- QwtPlotMarker *marker = myPlot->createMarkerAndTooltip( symbol,
- x,
- y,
- tooltip,
- picker);
- // To deallocate in EraseAll()
- myMarkerList.append( marker);
- }
-}
-
-
/*!
* Display curves of the list of lists by systems and components
* - the first level list contains NbSytems lists of second level
*
* Draw points markers and create associated tooltips.
* Draw connection segments (intermittent line) between all the curves of a component.
+ * \return the list of underlying plot curve that defines the complex cuve at once. In case of success the vector is at least of size 1. The first one is the curve used by the legend.
*/
-void Plot2d_ViewFrame::displayPlot2dCurveList( QList< QList<Plot2d_Curve*> > sysCoCurveList,
- Plot2d_QwtPlotPicker* picker,
- bool displayLegend)
+QVector< QVector<QwtPlotCurve *> > Plot2d_ViewFrame::displayPlot2dCurveList( const QList< QList<Plot2d_Curve*> >& sysCoCurveList,
+ bool displayLegend,
+ const QList< QList<bool> >& sides)
{
//std::cout << "Plot2d_ViewFrame::displayPlot2dCurveList() 1" << std::endl;
int nbComponent = (sysCoCurveList.at(0)).size();
// Total number of curves
- //int nbAllCurve = nbSystem*nbComponent;
-
- //std::cout << " Number of systems = " << nbSystem << std::endl;
- //std::cout << " Number of components = " << nbComponent << std::endl;
- //std::cout << " Number total of courbes = " << nbAllCurve << std::endl;
// 1)- Construction of a list by component and by system
-
+
// | component 1 | component 2 | ..... | component M |
// | syst1 syst2 ... systN | syst1 syst2 ... systN | ..... | syst1 syst2 ... systN |
QList<Plot2d_Curve*> plot2dCurveCoSysList;
-
- //std::cout << " Liste par composant et par systeme :" << std::endl;
-
+ QList<bool> sidesList;
for (int icom = 0; icom < nbComponent; icom++)
{
for (int isys = 0; isys < nbSystem; isys++)
{
- //std::cout << " icom= " << icom << " idev= " << isys << std::endl;
-
// The system curves list
- QList<Plot2d_Curve*> sysCurveList = sysCoCurveList.at(isys);
-
- Plot2d_Curve *curve = sysCurveList.at(icom);
-
- plot2dCurveCoSysList.append( curve);
+ const QList<Plot2d_Curve*>& sysCurveList=sysCoCurveList.at(isys);
+ plot2dCurveCoSysList.append(sysCurveList.at(icom));
+ //
+ const QList<bool>& sysSideList=sides.at(isys);
+ sidesList.append(sysSideList.at(icom));
}
}
-
// 2)- Display list curves by a component's curves group
// Draw connection segments (intermittent line) between the curves
-
- displayPlot2dCurveList( plot2dCurveCoSysList, nbSystem, picker, displayLegend);
-
+ QVector< QVector<QwtPlotCurve *> > ret=displayPlot2dCurveList( plot2dCurveCoSysList, nbSystem, displayLegend, sidesList);
// 3)- Size of graduations labels and texts under X axis
-
QwtScaleWidget *wid = myPlot->axisWidget( QwtPlot::xBottom);
- wid->setTitle( " "); // indispensable pour que les noms des systemes apparaissent
- // sous l'axe des X !!
-
+ wid->setTitle(" "); // to make the names readable under X axis.
QFont xFont = myPlot->axisFont(QwtPlot::xBottom);
- xFont.setPointSize(8);
- myPlot->setAxisFont( QwtPlot::xBottom, xFont);
-
- //std::cout << "Ok for Plot2d_ViewFrame::displayPlot2dCurveList() 1" << std::endl;
+ xFont.setPointSize(8);
+ myPlot->setAxisFont(QwtPlot::xBottom, xFont);
+ return ret;
}
*
* Draw points markers and create associated tooltips
* Draw connection segments (intermittent line) between the curves
+ * \param [in] sides sorted as in \b curveList. If true->right if false->left
+ * \return the list of underlying plot curve that defines the complex cuve at once. In case of success the vector is at least of size 1. The first one is the curve used by the legend.
*/
-void Plot2d_ViewFrame::displayPlot2dCurveList( QList<Plot2d_Curve*> curveList,
- int groupSize,
- Plot2d_QwtPlotPicker* picker,
- bool displayLegend)
+QVector< QVector<QwtPlotCurve *> > Plot2d_ViewFrame::displayPlot2dCurveList( const QList<Plot2d_Curve*>& curveList,
+ int groupSize,
+ bool displayLegend, const QList< bool >& sides)
{
- //std::cout << "Plot2d_ViewFrame::displayPlot2dCurveList() 2" << std::endl;
-
// Consider the new legend's entries
- // (PB: to update the legend we must remove it and put a new QwtLegend in the QwtPlot)
- myPlot->insertLegend( (QwtLegend*)NULL); // we remove here, we shall put at the end
+ // (PB: to update the legend we must remove it and put a new QwtAbstractLegend in the QwtPlot)
+ myPlot->insertLegend( (QwtAbstractLegend*)NULL); // we remove here, we shall put at the end
int nbAllCurves = curveList.size();
int nbGroups = nbAllCurves / groupSize;
+ QVector< QVector<QwtPlotCurve *> > vectCurve(nbGroups);
int ig, icur;
int icur1, icur2; // curves indices in a group
- //std::cout << " " << nbGroups << " groupes a " << groupSize << " courbes" << std::endl;
// I)- Compute X range and Y range for all the curves' points of all groups
// In the graphic view, set the Y range 's bounds for all groups of curves
// For all groups of curves
- double XallGroupMin, XallGroupMax;
- double YallGroupMin, YallGroupMax;
- bool isFirstGroup = true;
-
+ double XallGroupMin=std::numeric_limits<double>::max(), XallGroupMax=-std::numeric_limits<double>::max();
+ double YRightallGroupMin=std::numeric_limits<double>::max(), YRightallGroupMax=-std::numeric_limits<double>::max();
+ double YLeftallGroupMin=std::numeric_limits<double>::max(), YLeftallGroupMax=-std::numeric_limits<double>::max();
icur1 = 0;
for (ig=0; ig < nbGroups; ig++) //*1*
{
icur2 = icur1 + groupSize -1;
// For all curves in one group
- double XgroupMin, XgroupMax;
- double YgroupMin, YgroupMax;
+ double XgroupMin = 0., XgroupMax = 0.;
+ double YgroupMin = 0., YgroupMax = 0.;
// For one curve
- double XcurveMin, XcurveMax;
- double YcurveMin, YcurveMax;
+ double XcurveMin = 0., XcurveMax = 0.;
+ double YcurveMin = 0., YcurveMax = 0.;
double *Xval;
double *Yval;
int nbPoints;
// Compute X range and Y range for all the curves' points in the group
-
+ bool side=false;
for (icur=icur1; icur <= icur2; icur++) //*2*
{
Plot2d_Curve *plot2dCurve = curveList.at(icur);
-
+ side=sides.at(icur);
// Curve points
nbPoints = plot2dCurve->getData( &Xval, &Yval); // dynamic allocation
delete [] Xval;
delete [] Yval;
- //std::cout << " Pour la courbe d'indice " << icur << " :" << std::endl;
- //std::cout << " Xmin= " << XcurveMin << " Xmax= " << XcurveMax << std::endl;
- //std::cout << " Ymin= " << YcurveMin << " Ymax= " << YcurveMax << std::endl;
-
if (icur == icur1) // first curve
{
XgroupMin = XcurveMin; XgroupMax = XcurveMax;
}
} //*2*
- //std::cout << " Pour les courbes du groupe d'indice " << ig << " :" << std::endl;
- //std::cout << " Xmin= " << XgroupMin << " Xmax= " << XgroupMax << std::endl;
- //std::cout << " Ymin= " << YgroupMin << " Ymax= " << YgroupMax << std::endl;
-
- if (isFirstGroup)
- {
- XallGroupMin = XgroupMin; XallGroupMax = XgroupMax;
- YallGroupMin = YgroupMin; YallGroupMax = YgroupMax;
- isFirstGroup = false;
- }
+ if (XgroupMin < XallGroupMin) XallGroupMin = XgroupMin;
+ if (XgroupMax > XallGroupMax) XallGroupMax = XgroupMax;
+ if(side)
+ {
+ if (YgroupMin < YRightallGroupMin) YRightallGroupMin = YgroupMin;
+ if (YgroupMax > YRightallGroupMax) YRightallGroupMax = YgroupMax;
+ }
else
- {
- if (XgroupMin < XallGroupMin) XallGroupMin = XgroupMin;
- if (XgroupMax > XallGroupMax) XallGroupMax = XgroupMax;
- if (YgroupMin < YallGroupMin) YallGroupMin = YgroupMin;
- if (YgroupMax > YallGroupMax) YallGroupMax = YgroupMax;
- }
-
+ {
+ if (YgroupMin < YLeftallGroupMin) YLeftallGroupMin = YgroupMin;
+ if (YgroupMax > YLeftallGroupMax) YLeftallGroupMax = YgroupMax;
+ }
// First curve of the following group
icur1 = icur2 + 1;
} //*1*
-
- //std::cout << " Pour tous les groupes de courbes :" << std::endl;
- //std::cout << " Xmin= " << XallGroupMin << " Xmax= " << XallGroupMax << std::endl;
- //std::cout << " Ymin= " << YallGroupMin << " Ymax= " << YallGroupMax << std::endl;
-
- double deltaY = YallGroupMax - YallGroupMin;
-
// Set the XY range 's bounds for all groups of curves
-//myPlot->setAxisScale( QwtPlot::xBottom, XallGroupMin, XallGroupMax);
- myPlot->setAxisScale( QwtPlot::yLeft, YallGroupMin - 0.05*deltaY, YallGroupMax + 0.05*deltaY);
-
+ if(YRightallGroupMin!=std::numeric_limits<double>::max())
+ {
+ double deltaY = YRightallGroupMax - YRightallGroupMin;
+ YRightallGroupMin-=0.05*deltaY; YRightallGroupMax+= 0.05*deltaY;
+ myPlot->setAxisScale( QwtPlot::yRight, YRightallGroupMin,YRightallGroupMax);
+ }
+ if(YLeftallGroupMin!=std::numeric_limits<double>::max())
+ {
+ double deltaY = YLeftallGroupMax - YLeftallGroupMin;
+ YLeftallGroupMin-=0.05*deltaY; YLeftallGroupMax+= 0.05*deltaY;
+ myPlot->setAxisScale( QwtPlot::yLeft, YLeftallGroupMin, YLeftallGroupMax);
+ }
// II)- Drawing curves, points markers and connection segments
icur1 = 0;
for (ig=0; ig < nbGroups; ig++)
{
- icur2 = icur1 + groupSize -1;
-
- //std::cout << " Indices des courbes du groupe " << ig << " : " << icur1
- // << " a " << icur2 << std::endl;
- int nbCurves = icur2 - icur1 + 1;
- //std::cout << " groupe a " << nbCurves << " courbes" << std::endl;
-
// 1)- Graphical attributs of group's curves
// Graphical attributes of the first group's curve
Plot2d::LineType linetype1 = plot2dCurve1->getLine();
int lineWidth1 = plot2dCurve1->getLineWidth();
QwtSymbol::Style symbolStyle1 = plot2dCurve1->getMarkerStyle();
+ // We attribute to the current group's curve, the color, the line's kind
+ // and the marker's kind of the first group's curve
- if (nbCurves > 1)
- {
- // We attribute to the current group's curve, the color, the line's kind
- // and the marker's kind of the first group's curve
-
- for (icur=icur1 +1; icur <= icur2; icur++)
- {
- Plot2d_Curve *plot2dCurve = curveList.at(icur);
- //
- plot2dCurve->setColor( color1);
- plot2dCurve->setLine( linetype1, lineWidth1);
- plot2dCurve->setMarkerStyle( symbolStyle1);
- }
- }
+ for (icur=icur1+1; icur<icur1+groupSize; icur++)
+ {
+ Plot2d_Curve *plot2dCurve = curveList.at(icur);
+ //
+ plot2dCurve->setColor(color1);
+ plot2dCurve->setLine(linetype1,lineWidth1);
+ plot2dCurve->setMarkerStyle(symbolStyle1);
+ }
// 2)- Display the group's curves
- for (icur=icur1; icur <= icur2; icur++)
+ for (icur=icur1; icur<icur1+groupSize; icur++)
{
Plot2d_Curve *plot2dCurve = curveList.at(icur);
QString title = plot2dCurve->getVerTitle();
std::string std_title = title.toStdString();
- //const char *c_title = std_title.c_str();
- //std::cout << " courbe d'indice " << icur << " : |" << c_title << "|" << std::endl;
-
// Create the graphic curve (QwtPlotCurve) et display it in the drawing zone
// (Qwtplot)
- displayCurve( plot2dCurve);
-
- // Draw the points' markers and create the associated tooltips
- createCurveTooltips( plot2dCurve, picker);
+ displayCurve(plot2dCurve);
// Get the graphic curve
- QwtPlotCurve* plotCurve = dynamic_cast<QwtPlotCurve *>( getPlotObject( plot2dCurve));
-
+ QwtPlotCurve* plotCurve = dynamic_cast<QwtPlotCurve *>(getPlotObject(plot2dCurve));
+ vectCurve[ig].push_back(plotCurve);
// Modify the points' markers
- QwtSymbol symbol (plotCurve->symbol()) ;
- symbol.setStyle( symbolStyle1);
- symbol.setPen( QPen( color1, lineWidth1));
- symbol.setBrush( QBrush( color1));
- QSize size = 0.5*(symbol.size());
- symbol.setSize(size);
+ QwtSymbol* symbol = new QwtSymbol(plotCurve->symbol()->style(), plotCurve->symbol()->brush(),
+ plotCurve->symbol()->pen(), plotCurve->symbol()->size()) ;
+ symbol->setStyle(symbolStyle1);
+ symbol->setPen(QPen(color1,lineWidth1));
+ //symbol.setBrush( QBrush( color1));
+ //QSize size = 0.5*(symbol.size());
+ //symbol.setSize(size);
//
- plotCurve->setPen( QPen( color1, lineWidth1));
- plotCurve->setSymbol( symbol);
+ plotCurve->setPen(QPen(color1,lineWidth1));
+ plotCurve->setSymbol(symbol);
if (icur > icur1)
{
// 3)- Intermittent segments to connect all the group's curves
- if (nbCurves > 1)
+ if (groupSize > 1)
{
double *Xval;
double *Yval;
int nbPoints;
double Xseg[2], Yseg[2];
Plot2d_Curve *plot2dCurve1 = curveList.at(icur1);
-
+ bool side = sides.at(icur1);
// Last point of the first curve
nbPoints = plot2dCurve1->getData( &Xval, &Yval); // dynamic allocation
Xseg[0] = Xval[ nbPoints -1];
delete [] Xval;
delete [] Yval;
- for (icur=icur1 +1; icur <= icur2; icur++)
+ for (icur=icur1+1; icur<icur1+groupSize; icur++)
{
Plot2d_Curve *plot2dCurve = curveList.at(icur);
Xseg[1] = Xval[0];
Yseg[1] = Yval[0];
- createSegment( Xseg, Yseg, 2,
- Qt::DotLine,
- lineWidth1,
- color1,
- QwtSymbol::NoSymbol);
+ vectCurve[ig].push_back(createSegment(Xseg,Yseg,2,Qt::DotLine,lineWidth1,color1,QwtSymbol::NoSymbol,side));
// Last curve's point
Xseg[0] = Xval[ nbPoints -1];
}
}
// First curve of the following group
- icur1 = icur2 + 1;
+ icur1 += groupSize;
}
if (displayLegend)
{
// Consider the new legend's entries
- showLegend( true, true); // show, update
+ if(!curveList.empty())
+ showLegend( true, true); // show, update
}
-
- //std::cout << "Ok for Plot2d_ViewFrame::displayPlot2dCurveList() 2" << std::endl;
+ return vectCurve;
}
int lineWidth,
QColor & lineColor,
QwtSymbol::Style markerKind,
- Plot2d_QwtPlotPicker* picker,
+ Plot2d_QwtPlotPicker* /*picker*/,
bool toDraw,
bool displayLegend)
{
{
if (!displayLegend)
{
- myPlot->insertLegend( (QwtLegend*)NULL);
+ myPlot->insertLegend( (QwtAbstractLegend*)NULL);
}
displayCurve( plot2dCurve);
- // plot points marker create associated tooltips
- createCurveTooltips( plot2dCurve, picker);
-
// Get the graphical curve
QwtPlotCurve* plotCurve = dynamic_cast<QwtPlotCurve *>( getPlotObject( plot2dCurve));
}
// Modify points' markers
- QwtSymbol symbol (plotCurve->symbol()) ;
- symbol.setStyle( markerKind);
+ QwtSymbol* symbol = new QwtSymbol( plotCurve->symbol()->style(), plotCurve->symbol()->brush(),
+ plotCurve->symbol()->pen(), plotCurve->symbol()->size() ) ;
+ symbol->setStyle( markerKind );
//
if (markerKind != QwtSymbol::NoSymbol)
{
- symbol.setPen( QPen( theColor, lineWidth));
- symbol.setBrush( QBrush( theColor));
- QSize size = 2.0*(symbol.size()); //0.5
- symbol.setSize(size);
+ symbol->setPen( QPen( theColor, lineWidth));
+ symbol->setBrush( QBrush( theColor));
+ QSize size = 2.0*(symbol->size()); //0.5
+ symbol->setSize(size);
}
plotCurve->setSymbol( symbol);
/*!
* Create and display a segment with nbPoint=2 points
*/
-void Plot2d_ViewFrame::createSegment( double *X, double *Y, int nbPoint,
- Qt::PenStyle lineKind,
- int lineWidth,
- QColor & lineColor,
- QwtSymbol::Style markerKind)
+QwtPlotCurve *Plot2d_ViewFrame::createSegment( double *X, double *Y, int nbPoint,
+ Qt::PenStyle lineKind,
+ int lineWidth,
+ QColor & lineColor,
+ QwtSymbol::Style markerKind, bool side)
{
- QwtPlotCurve* aPCurve = new QwtPlotCurve();
+ QwtPlotCurve* aPCurve = new QwtPlotCurve( QString::null );
- aPCurve->setData( X, Y, nbPoint);
+ aPCurve->setSamples( X, Y, nbPoint);
aPCurve->setPen( QPen( lineColor, lineWidth, lineKind));
- QwtSymbol aSymbol;
- aSymbol.setStyle( markerKind);
- aPCurve->setSymbol( aSymbol);
+ QwtSymbol* aSymbol = new QwtSymbol();
+ aSymbol->setStyle( markerKind );
+ aPCurve->setSymbol( aSymbol );
// The segment must not have legend's entry
aPCurve->setItemAttribute( QwtPlotItem::Legend, false);
- aPCurve->attach( myPlot);
+ aPCurve->attach(myPlot);
+ aPCurve->setYAxis(side ? QwtPlot::yRight : QwtPlot::yLeft);
// To deallocate in EraseAll()
- myIntermittentSegmentList.append( aPCurve);
+ myIntermittentSegmentList.append(aPCurve);
+ return aPCurve;
}
/*!
updateObject( curve, update );
}
-void Plot2d_ViewFrame::processFiltering(bool update)
+void Plot2d_ViewFrame::processFiltering(bool update)
{
CurveDict aCurves = getCurves();
AlgoPlot2dInputData aLData, aRData;
// Normalization by left Y axis
if (!myNormLMin && !myNormLMax)
myLNormAlgo->setNormalizationMode(Plot2d_NormalizeAlgorithm::NormalizeNone);
- if(myNormLMin && myNormLMax)
+ if(myNormLMin && myNormLMax)
myLNormAlgo->setNormalizationMode(Plot2d_NormalizeAlgorithm::NormalizeToMinMax);
else if(myNormLMin)
myLNormAlgo->setNormalizationMode(Plot2d_NormalizeAlgorithm::NormalizeToMin);
// Normalization by right Y axis
if (!myNormRMin && !myNormRMax)
myRNormAlgo->setNormalizationMode(Plot2d_NormalizeAlgorithm::NormalizeNone);
- if(myNormRMin && myNormRMax)
+ if(myNormRMin && myNormRMax)
myRNormAlgo->setNormalizationMode(Plot2d_NormalizeAlgorithm::NormalizeToMinMax);
else if(myNormRMin)
myRNormAlgo->setNormalizationMode(Plot2d_NormalizeAlgorithm::NormalizeToMin);
QwtPlotItem* anItem = 0;
if ( !object )
return anItem;
-
+
if ( object->getYAxis() == QwtPlot::yRight )
mySecondY = true;
- // san -- Protection against QwtCurve bug in Qwt 0.4.x:
+ // san -- Protection against QwtCurve bug in Qwt 0.4.x:
// it crashes if switched to X/Y logarithmic mode, when one or more points have
// non-positive X/Y coordinate
if ( myXMode && object->getMinX() <= 0. )
if ( object->isAutoAssign() )
object->autoFill( myPlot );
-
+
if ( hasPlotObject( object ) ) {
processFiltering(update);
updateObject( object, update );
Plot2d_Curve* aCurve = dynamic_cast<Plot2d_Curve*>( object );
if ( aCurve )
{
- //myMarkerSize = 1;
- //aCurve->setMarkerSize( myMarkerSize );
-
- if (aCurve->getMarkerSize() == 0)
- {
- aCurve->setMarkerSize( myMarkerSize );
- }
+ if ( aCurve->getMarkerSize() == 0 )
+ aCurve->setMarkerSize( myMarkerSize );
processFiltering(update);
updatePlotItem( aCurve, anItem );
}
}
}
- updateTitles();
+ updateTitles( false );
myPlot->updateYAxisIdentifiers();
- if ( update )
+ if ( update ) {
myPlot->replot();
- if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+ if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase(false);
+ }
return anItem;
}
if ( hasPlotObject( object ) ) {
QwtPlotItem* anObject = getPlotObject( object );
- anObject->hide();
- anObject->detach();
- myObjects.remove( anObject );
- updateTitles();
- myPlot->updateYAxisIdentifiers();
- if ( update )
- myPlot->replot();
+ eraseBasicObject(anObject,update);
}
- if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+ if (update) {
+ if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+ }
+}
+
+void Plot2d_ViewFrame::eraseBasicObject( QwtPlotItem *object, bool update )
+{
+ if(!object)
+ return;
+ object->hide();
+ object->detach();
+ myObjects.remove(object);
+ updateTitles(update);
+ myPlot->updateYAxisIdentifiers();
+ if ( update )
+ myPlot->replot();
}
/*!
if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
}
+void Plot2d_ViewFrame::eraseBasicObjects( const QList<QwtPlotItem*> &objects, bool update)
+{
+ foreach ( QwtPlotItem* object, objects )
+ eraseBasicObject( object, false );
+ // fitAll();
+ if ( update )
+ myPlot->replot();
+ if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+}
+
/*!
Updates objects attributes
*/
return;
updatePlotItem(object, anItem );
anItem->setVisible( true );
- if ( update )
+ if ( update ) {
myPlot->replot();
- if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+ if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase(false);
+ }
}
}
bool Plot2d_ViewFrame::isVisible( Plot2d_Object* object ) const
{
return object && hasPlotObject( object ) && getPlotObject( object )->isVisible();
-}
+}
/*!
update legend
update legend
*/
void Plot2d_ViewFrame::updateLegend() {
- if ( myPlot->getLegend() ) {
- ObjectDict::iterator it = myObjects.begin();
- for( ; it != myObjects.end(); ++it )
- it.key()->updateLegend(myPlot->getLegend());
+ const QwtPlotItemList& items = myPlot->itemList();
+ QwtPlotItemIterator it;
+ for ( it = items.begin(); it != items.end(); it++ ) {
+ QwtPlotItem* item = *it;
+ if ( item )
+ item->updateLegend( item, item->legendData() );
}
}
*/
void Plot2d_ViewFrame::fitAll()
{
- // Postpone fitAll operation until QwtPlot geometry
- // has been fully defined
- if ( !myPlot->polished() ){
- QApplication::postEvent( this, new QEvent( (QEvent::Type)FITALL_EVENT ) );
- return;
- }
-
- myPlot->setAxisAutoScale( QwtPlot::yLeft );
- myPlot->setAxisAutoScale( QwtPlot::xBottom );
- myPlot->replot();
+ // no need to set auto scaling, it will be disabled by setAxisScale() method call
+ // myPlot->setAxisAutoScale( QwtPlot::yLeft );
+ // myPlot->setAxisAutoScale( QwtPlot::xBottom );
+ // myPlot->replot();
double xmin, xmax, y1min, y1max, y2min, y2max;
getFitRangeByCurves(xmin, xmax, y1min, y1max, y2min, y2max);
+ getFitRangeByMarkers(xmin, xmax, y1min, y1max, y2min, y2max);
myPlot->setAxisScale( QwtPlot::xBottom, xmin, xmax );
myPlot->setAxisScale( QwtPlot::yLeft, y1min, y1max );
myPlot->setAxisScale( QwtPlot::yRight, y2min, y2max );
}
myPlot->replot();
- if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+ if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase(false);
}
/*!
rect.setHeight( MIN_RECT_SIZE );
rect.setTop( rect.top() - MIN_RECT_SIZE/2 );
}
- myPlot->setAxisScale( QwtPlot::yLeft,
- myPlot->invTransform( QwtPlot::yLeft, rect.top() ),
+ myPlot->setAxisScale( QwtPlot::yLeft,
+ myPlot->invTransform( QwtPlot::yLeft, rect.top() ),
myPlot->invTransform( QwtPlot::yLeft, rect.bottom() ) );
if (mySecondY)
- myPlot->setAxisScale( QwtPlot::yRight,
- myPlot->invTransform( QwtPlot::yRight, rect.top() ),
+ myPlot->setAxisScale( QwtPlot::yRight,
+ myPlot->invTransform( QwtPlot::yRight, rect.top() ),
myPlot->invTransform( QwtPlot::yRight, rect.bottom() ) );
- myPlot->setAxisScale( QwtPlot::xBottom,
- myPlot->invTransform( QwtPlot::xBottom, rect.left() ),
+ myPlot->setAxisScale( QwtPlot::xBottom,
+ myPlot->invTransform( QwtPlot::xBottom, rect.left() ),
myPlot->invTransform( QwtPlot::xBottom, rect.right() ) );
myPlot->replot();
if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
if (mySecondY)
myPlot->setAxisScale( QwtPlot::yRight, y2Min, y2Max );
}
- if ( mode == 0 || mode == 1 )
- myPlot->setAxisScale( QwtPlot::xBottom, xMin, xMax );
+ if ( mode == 0 || mode == 1 )
+ myPlot->setAxisScale( QwtPlot::xBottom, xMin, xMax );
myPlot->replot();
if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
}
}
}
+/*!
+ Gets current fit ranges by Markers
+ All parameters are inout.
+*/
+void Plot2d_ViewFrame::getFitRangeByMarkers(double& xMin, double& xMax,
+ double& yMin, double& yMax,
+ double& y2Min, double& y2Max)
+{
+ Plot2d_QwtPlotPicker *picker=myPlot->getPicker();
+ if(!picker)
+ return;
+ if(picker->pMarkers.empty())
+ return;
+ foreach(QwtPlotMarker *mrker,picker->pMarkers)
+ {
+ bool isV2 = mrker->yAxis() == QwtPlot::yRight;
+ xMin = qMin( xMin, mrker->xValue() );
+ xMax = qMax( xMax, mrker->xValue() );
+ if ( isV2 ) {
+ y2Min = qMin( y2Min, mrker->yValue() );
+ y2Max = qMax( y2Max, mrker->yValue() );
+ }
+ else {
+ yMin = qMin( yMin, mrker->yValue() );
+ yMax = qMax( yMax, mrker->yValue() );
+ }
+ if ( xMin == xMax ) {
+ xMin = xMin == 0. ? -1. : xMin - xMin/10.;
+ xMax = xMax == 0. ? 1. : xMax + xMax/10.;
+ }
+ if ( yMin == yMax ) {
+ yMin = yMin == 0. ? -1. : yMin - yMin/10.;
+ yMax = yMax == 0. ? 1 : yMax + yMax/10.;
+ }
+ if ( y2Min == y2Max ) {
+ y2Min = y2Min == 0. ? -1. : y2Min - y2Min/10.;
+ y2Max = y2Max == 0. ? 1 : y2Max + y2Max/10.;
+ }
+ }
+}
+
/*!
Tests if it is necessary to start operation on mouse action
*/
int Plot2d_ViewFrame::testOperation( const QMouseEvent& me )
{
- int btn = me.button() | me.modifiers();
- const int zoomBtn = Qt::ControlModifier | Qt::LeftButton;
- const int panBtn = Qt::ControlModifier | Qt::MidButton;
- const int fitBtn = Qt::ControlModifier | Qt::RightButton;
+ int btn = (int)me.button() | (int)me.modifiers();
+ const int zoomBtn = (int)Qt::ControlModifier | (int)Qt::LeftButton;
+ const int panBtn = (int)Qt::ControlModifier | (int)Qt::MidButton;
+ const int fitBtn = (int)Qt::ControlModifier | (int)Qt::RightButton;
int op = NoOpId;
if ( btn == zoomBtn ) {
cols[ "blue-min" ] = color.blue();
}
#endif
-
+
Plot2d_SetupViewDlg* dlg = new Plot2d_SetupViewDlg( this, true, mySecondY );
dlg->setMainTitle( myTitleEnabled, myTitle );
dlg->setXTitle( myXTitleEnabled, myXTitle );
if (mySecondY)
dlg->setY2Title( myY2TitleEnabled, myY2Title );
dlg->setCurveType( myCurveType );
- dlg->setLegend( myShowLegend, myLegendPos, myLegendFont, myLegendColor );
+ dlg->setLegend( myShowLegend, myLegendPos, myLegendSymbolType, myLegendFont,
+ myLegendColor, mySelectedLegendFontColor );
dlg->setMarkerSize( myMarkerSize );
dlg->setBackgroundColor( myBackground );
+ dlg->setSelectionColor( mySelectionColor );
dlg->setScaleMode(myXMode, myYMode);
dlg->setLMinNormMode(myNormLMin);
dlg->setLMaxNormMode(myNormLMax);
setTitle( dlg->isY2TitleEnabled(), dlg->getY2Title(), Y2Title, false );
// main title
- if( dlg->isMainTitleEnabled() && myTitle != dlg->getMainTitle() )
+ if( dlg->isMainTitleEnabled() && myTitle != dlg->getMainTitle() )
myIsDefTitle = false;
setTitle( dlg->isMainTitleEnabled(), dlg->getMainTitle(), MainTitle, true );
// curve type
}
if ( myLegendPos != dlg->getLegendPos() ) {
setLegendPos( dlg->getLegendPos() );
+ }
+ if ( myLegendSymbolType != dlg->getLegendSymbolType() ) {
+ setLegendSymbolType( dlg->getLegendSymbolType() );
}
if ( myLegendFont != dlg->getLegendFont() ) {
setLegendFont( dlg->getLegendFont() );
if ( myLegendColor != dlg->getLegendColor() ) {
setLegendFontColor( dlg->getLegendColor() );
}
+ if ( mySelectedLegendFontColor != dlg->getSelectedLegendColor() ) {
+ setSelectedLegendFontColor( dlg->getSelectedLegendColor() );
+ }
// marker size
if ( myMarkerSize != dlg->getMarkerSize() ) {
if ( myBackground != dlg->getBackgroundColor() ) {
setBackgroundColor( dlg->getBackgroundColor() );
}
+ // selection color
+ if ( mySelectionColor != dlg->getSelectionColor() ) {
+ setSelectionColor( dlg->getSelectionColor() );
+ }
// grid
bool aXGridMajorEnabled, aXGridMinorEnabled, aYGridMajorEnabled, aYGridMinorEnabled,
aY2GridMajorEnabled, aY2GridMinorEnabled;
setNormRMaxMode( dlg->getRMaxNormMode() );
}
- myPlot->setProperty(PLOT2D_DEVIATION_COLOR,
+ myPlot->setProperty(PLOT2D_DEVIATION_COLOR,
dlg->getDeviationMarkerCl());
- myPlot->setProperty(PLOT2D_DEVIATION_LW,
+ myPlot->setProperty(PLOT2D_DEVIATION_LW,
dlg->getDeviationMarkerLw());
- myPlot->setProperty(PLOT2D_DEVIATION_TS,
+ myPlot->setProperty(PLOT2D_DEVIATION_TS,
dlg->getDeviationMarkerTs());
// update view
myPlot->replot();
// update preferences
- if ( dlg->isSetAsDefault() )
+ if ( dlg->isSetAsDefault() )
writePreferences();
}
delete dlg;
}
+#ifndef NO_ANALYTICAL_CURVES
/*!
"Analytical Curves" toolbar action slot
*/
void Plot2d_ViewFrame::onAnalyticalCurve()
{
-#ifndef DISABLE_PYCONSOLE
Plot2d_AnalyticalCurveDlg dlg( this, this );
dlg.exec();
updateAnalyticalCurves();
-#endif
}
void Plot2d_ViewFrame::addAnalyticalCurve( Plot2d_AnalyticalCurve* theCurve)
{
-#ifndef DISABLE_PYCONSOLE
- myAnalyticalCurves.append(theCurve);
-#endif
+ myAnalyticalCurves.append(theCurve);
}
void Plot2d_ViewFrame::removeAnalyticalCurve( Plot2d_AnalyticalCurve* theCurve)
{
-#ifndef DISABLE_PYCONSOLE
- theCurve->setAction(Plot2d_AnalyticalCurve::ActRemoveFromView);
-#endif
+ theCurve->setAction(Plot2d_AnalyticalCurve::ActRemoveFromView);
}
/*
*/
void Plot2d_ViewFrame::updateAnalyticalCurve(Plot2d_AnalyticalCurve* c, bool updateView)
{
-#ifndef DISABLE_PYCONSOLE
if(!c) return;
- QwtScaleDiv* div = myPlot->axisScaleDiv(QwtPlot::xBottom);
- c->setRangeBegin(div->lowerBound());
- c->setRangeEnd(div->upperBound());
+ QwtScaleDiv div = myPlot->axisScaleDiv(QwtPlot::xBottom);
+ c->setRangeBegin(div.lowerBound());
+ c->setRangeEnd(div.upperBound());
c->calculate();
c->setMarkerSize(myMarkerSize);
QwtPlotItem* item = c->plotItem();
-
+
switch( c->getAction() ) {
case Plot2d_AnalyticalCurve::ActAddInView:
if( c->isActive() ) {
c->updatePlotItem();
item->attach( myPlot );
+ item->itemChanged();
item->show();
}
c->setAction(Plot2d_AnalyticalCurve::ActNothing);
break;
-
+
case Plot2d_AnalyticalCurve::ActUpdateInView:
if(c->isActive()) {
c->updatePlotItem();
item->show();
- } else {
+ } else {
item->hide();
item->detach();
}
-
+
c->setAction(Plot2d_AnalyticalCurve::ActNothing);
- break;
+ break;
case Plot2d_AnalyticalCurve::ActRemoveFromView:
item->hide();
item->detach();
- myAnalyticalCurves.removeAll(c);
- delete c;
break;
}
if(updateView)
myPlot->replot();
-#endif
}
/*
*/
void Plot2d_ViewFrame::updateAnalyticalCurves()
{
-#ifndef DISABLE_PYCONSOLE
AnalyticalCurveList::iterator it = myAnalyticalCurves.begin();
+ AnalyticalCurveList toDelete;
for( ; it != myAnalyticalCurves.end(); it++) {
- updateAnalyticalCurve(*it);
+ Plot2d_AnalyticalCurve* c = (*it);
+ updateAnalyticalCurve(c);
+ if(c && c->getAction() == Plot2d_AnalyticalCurve::ActRemoveFromView)
+ toDelete.push_back(c);
+ }
+ it = toDelete.begin();
+ for( ; it != toDelete.end(); it++) {
+ Plot2d_AnalyticalCurve* c = (*it);
+ myAnalyticalCurves.removeAll(c);
+ delete c;
+ c = NULL;
}
myPlot->replot();
-#endif
}
/*!
*/
AnalyticalCurveList Plot2d_ViewFrame::getAnalyticalCurves() const
{
- return myAnalyticalCurves;
+ return myAnalyticalCurves ;
}
/*!
Get analytical curve by plot item.
*/
Plot2d_AnalyticalCurve* Plot2d_ViewFrame::getAnalyticalCurve(QwtPlotItem * theItem) {
-#ifndef DISABLE_PYCONSOLE
AnalyticalCurveList::iterator it = myAnalyticalCurves.begin();
for( ; it != myAnalyticalCurves.end(); it++) {
- if((*it)->plotItem() == theItem);
- return (*it);
+ if((*it)->plotItem() == theItem)
+ return (*it);
}
return 0;
-#endif
}
+#endif
/*!
"Fit Data" command slot
Plot2d_FitDataDlg* dlg = new Plot2d_FitDataDlg( this, mySecondY );
double xMin,xMax,yMin,yMax,y2Min,y2Max;
getFitRanges(xMin,xMax,yMin,yMax,y2Min,y2Max);
-
+
dlg->setRange( xMin, xMax, yMin, yMax, y2Min, y2Max );
if ( dlg->exec() == QDialog::Accepted ) {
int mode = dlg->getRange( xMin, xMax, yMin, yMax, y2Min, y2Max );
fitData(mode,xMin,xMax,yMin,yMax,y2Min,y2Max);
}
delete dlg;
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
*/
void Plot2d_ViewFrame::onChangeBackground()
{
- QColor selColor = QColorDialog::getColor ( backgroundColor(), this );
+ QColor selColor = QColorDialog::getColor ( backgroundColor(), this );
if ( selColor.isValid() ) {
setBackgroundColor( selColor );
}
if ( crv )
setCurveType( crv, myCurveType );
}
+ for(int i=0 ; i < myAnalyticalCurves.count(); i++) {
+ QwtPlotCurve* aPCurve = dynamic_cast<QwtPlotCurve*>( myAnalyticalCurves[i]->plotItem() );
+ Plot2d_AnalyticalCurve* aCurve = dynamic_cast<Plot2d_AnalyticalCurve*>( myAnalyticalCurves[i] );
+ if ( aPCurve && aCurve ) {
+ setCurveType( aPCurve, myCurveType );
+ }
+ }
if ( update )
myPlot->replot();
emit vpCurveChanged();
\param curveKey - curve id
\param title - new title
*/
-void Plot2d_ViewFrame::setCurveTitle( Plot2d_Curve* curve, const QString& title )
+void Plot2d_ViewFrame::setCurveTitle( Plot2d_Curve* curve, const QString& title )
{
setObjectTitle( curve, title );
}
\param object - object id
\param title - new title
*/
-void Plot2d_ViewFrame::setObjectTitle( Plot2d_Object* object, const QString& title )
-{
+void Plot2d_ViewFrame::setObjectTitle( Plot2d_Object* object, const QString& title )
+{
if ( object && hasPlotObject( object ) )
getPlotObject( object )->setTitle( title );
-}
+}
/*!
Shows/hides legend
{
myShowLegend = show;
if ( myShowLegend ) {
- QwtLegend* legend = myPlot->legend();
- if ( !legend ) {
- legend = new QwtLegend( myPlot );
- legend->setFrameStyle( QFrame::Box | QFrame::Sunken );
+ QwtAbstractLegend* absLegend = myPlot->legend();
+ QwtLegend* legend = 0;
+ if ( !absLegend ) {
+ legend = new Plot2d_QwtLegend( myPlot );
+ legend->setDefaultItemMode(QwtLegendData::Clickable);
+ connect( legend, SIGNAL( clicked (const QVariant&, int) ),
+ this, SIGNAL( clicked (const QVariant&, int) ) );
+ legend->setFrameStyle( QFrame::Box | QFrame::Sunken );
+ }
+ else {
+ legend = dynamic_cast<QwtLegend*>(absLegend);
+ }
+ if(legend) {
+ myPlot->insertLegend( legend );
+ setLegendPos( myLegendPos );
+ setLegendFont( myLegendFont );
+ setLegendFontColor( myLegendColor );
}
- legend->setItemMode( QwtLegend::ClickableItem );
- myPlot->insertLegend( legend );
- setLegendPos( myLegendPos );
- setLegendFont( myLegendFont );
- setLegendFontColor( myLegendColor );
}
else
myPlot->insertLegend( 0 );
+
+ if( show && update )
+ updateLegend();
+
if ( update )
myPlot->replot();
}
void Plot2d_ViewFrame::setLegendPos( int pos )
{
myLegendPos = pos;
- QwtLegend* legend = myPlot->legend();
+ QwtAbstractLegend* legend = myPlot->legend();
if ( legend ) {
switch( pos ) {
case 0:
return myLegendPos;
}
+/*!
+ Sets legend symbol type : 0 - marker on line, 1 - marker above line
+*/
+void Plot2d_ViewFrame::setLegendSymbolType( int type )
+{
+ myLegendSymbolType = type;
+ myPlot->setLegendSymbolType( type );
+ updateLegend();
+}
+
+/*!
+ Gets legend symbol type : 0 - marker on line, 1 - marker above line
+*/
+int Plot2d_ViewFrame::getLegendSymbolType() const
+{
+ return myLegendSymbolType;
+}
+
/*!
Sets legend font
*/
void Plot2d_ViewFrame::setLegendFont( const QFont& fnt )
{
myLegendFont = fnt;
- QwtLegend* legend = myPlot->legend();
+ QwtAbstractLegend* legend = myPlot->legend();
if ( legend ) {
legend->setFont(fnt);
}
return myLegendFont;
}
-/*!
- Gets legend font color
-*/
-QColor Plot2d_ViewFrame::getLegendFontColor() const
-{
- return myLegendColor;
-}
-
/*!
Sets legend font color
*/
void Plot2d_ViewFrame::setLegendFontColor( const QColor& col )
{
myLegendColor = col;
- QwtLegend* legend = myPlot->legend();
+ QwtAbstractLegend* legend = myPlot->legend();
if ( legend ) {
QPalette pal = legend->palette();
pal.setColor( QPalette::Text, col );
}
}
+/*!
+ Gets legend font color
+*/
+QColor Plot2d_ViewFrame::getLegendFontColor() const
+{
+ return myLegendColor;
+}
+
+/*!
+ Sets selected legend font color
+*/
+void Plot2d_ViewFrame::setSelectedLegendFontColor( const QColor& col )
+{
+ mySelectedLegendFontColor = col;
+ Plot2d_Object::setHighlightedLegendTextColor( col );
+}
+
+/*!
+ Gets selected legend font color
+*/
+QColor Plot2d_ViewFrame::getSelectedLegendFontColor() const
+{
+ return mySelectedLegendFontColor;
+}
+
/*!
Sets new marker size
*/
QwtPlotCurve* crv = it.key();
if ( crv )
{
- QwtSymbol aSymbol = crv->symbol();
- aSymbol.setSize( myMarkerSize, myMarkerSize );
+ QwtSymbol* aSymbol = new QwtSymbol( crv->symbol()->style(), crv->symbol()->brush(),
+ crv->symbol()->pen(), QSize( myMarkerSize, myMarkerSize ) );
crv->setSymbol( aSymbol );
- if(it.value())
- it.value()->setMarkerSize( myMarkerSize );
+ if( it.value() )
+ it.value()->setMarkerSize( myMarkerSize );
}
}
if ( update )
}
Repaint();
}
+
/*!
Gets background color
*/
{
return myBackground;
}
+
+/*!
+ Sets selection color
+*/
+void Plot2d_ViewFrame::setSelectionColor( const QColor& color )
+{
+ mySelectionColor = color;
+ Plot2d_Object::setSelectionColor( color );
+}
+
+/*!
+ Gets selection color
+*/
+QColor Plot2d_ViewFrame::selectionColor() const
+{
+ return mySelectionColor;
+}
+
/*!
Sets hor.axis grid parameters
*/
-void Plot2d_ViewFrame::setXGrid( bool xMajorEnabled, const int xMajorMax,
- bool xMinorEnabled, const int xMinorMax,
+void Plot2d_ViewFrame::setXGrid( bool xMajorEnabled, const int xMajorMax,
+ bool xMinorEnabled, const int xMinorMax,
bool update )
{
myXGridMajorEnabled = xMajorEnabled;
myPlot->setAxisMaxMinor( QwtPlot::xBottom, myXGridMaxMinor );
QwtPlotGrid* grid = myPlot->grid();
- if ( myPlot->axisScaleDiv( QwtPlot::xBottom ) )
- grid->setXDiv( *myPlot->axisScaleDiv( QwtPlot::xBottom ) );
+ if ( !myPlot->axisScaleDiv( QwtPlot::xBottom ).isEmpty() )
+ grid->setXDiv( myPlot->axisScaleDiv( QwtPlot::xBottom ) );
grid->enableX( myXGridMajorEnabled );
grid->enableXMin( myXGridMinorEnabled );
/*!
Sets ver.axis grid parameters
*/
-void Plot2d_ViewFrame::setYGrid( bool yMajorEnabled, const int yMajorMax,
+void Plot2d_ViewFrame::setYGrid( bool yMajorEnabled, const int yMajorMax,
bool yMinorEnabled, const int yMinorMax,
- bool y2MajorEnabled, const int y2MajorMax,
- bool y2MinorEnabled, const int y2MinorMax,
+ bool y2MajorEnabled, const int y2MajorMax,
+ bool y2MinorEnabled, const int y2MinorMax,
bool update )
{
myYGridMajorEnabled = yMajorEnabled;
}
QwtPlotGrid* grid = myPlot->grid();
- if ( myPlot->axisScaleDiv( QwtPlot::yLeft ) )
- grid->setYDiv( *myPlot->axisScaleDiv( QwtPlot::yLeft ) );
+ if ( !myPlot->axisScaleDiv( QwtPlot::yLeft ).isEmpty() )
+ grid->setYDiv( myPlot->axisScaleDiv( QwtPlot::yLeft ) );
if (mySecondY) {
if (myYGridMajorEnabled) {
grid->enableYMin( myYGridMinorEnabled );
}
else if (myY2GridMajorEnabled) {
- if ( myPlot->axisScaleDiv( QwtPlot::yRight ) )
- grid->setYDiv( *myPlot->axisScaleDiv( QwtPlot::yRight ) );
+ if ( !myPlot->axisScaleDiv( QwtPlot::yRight ).isEmpty() )
+ grid->setYDiv( myPlot->axisScaleDiv( QwtPlot::yRight ) );
grid->enableY( myY2GridMajorEnabled );
grid->enableYMin( myY2GridMinorEnabled );
}
if ( myXMode == mode )
return;
- // san -- Protection against QwtCurve bug in Qwt 0.4.x:
+ // san -- Protection against QwtCurve bug in Qwt 0.4.x:
// it crashes if switched to X/Y logarithmic mode, when one or more points have
// non-positive X/Y coordinate
if ( mode && !isXLogEnabled() ){
- SUIT_MessageBox::warning(this, tr("WARNING"), tr("WRN_XLOG_NOT_ALLOWED"));
+#ifndef NO_SUIT
+ SUIT_MessageBox::warning(this, tr("WRN_WARNING"), tr("WRN_XLOG_NOT_ALLOWED"));
+#else
+ QMessageBox::warning(this, tr("WRN_WARNING"), tr("WRN_XLOG_NOT_ALLOWED"));
+#endif
return;
}
myXMode = mode;
+ // set bounds of logarithmic scale
+ if( myXMode != 0 ) {
+ myPlot->setAxisScale( QwtPlot::xBottom, 1.0, 1e5 );
+ myPlot->updateAxes();
+ }
+
myPlot->setLogScale(QwtPlot::xBottom, myXMode != 0);
if ( update )
if ( myYMode == mode )
return;
- // san -- Protection against QwtCurve bug in Qwt 0.4.x:
+ // san -- Protection against QwtCurve bug in Qwt 0.4.x:
// it crashes if switched to X/Y logarithmic mode, when one or more points have
// non-positive X/Y coordinate
if ( mode && !isYLogEnabled() ){
- SUIT_MessageBox::warning(this, tr("WARNING"), tr("WRN_YLOG_NOT_ALLOWED"));
+#ifndef NO_SUIT
+ SUIT_MessageBox::warning(this, tr("WRN_WARNING"), tr("WRN_YLOG_NOT_ALLOWED"));
+#else
+ QMessageBox::warning(this, tr("WRN_WARNING"), tr("WRN_YLOG_NOT_ALLOWED"));
+#endif
return;
}
myYMode = mode;
+
+ // set bounds of logarithmic scale
+ if( myYMode != 0 ){
+ myPlot->setAxisScale( QwtPlot::yLeft, 1.0, 1e5 );
+ myPlot->updateAxes();
+ }
+
myPlot->setLogScale(QwtPlot::yLeft, myYMode != 0);
- if (mySecondY)
+ if (mySecondY) {
+ if( myYMode != 0 ){
+ myPlot->setAxisScale( QwtPlot::yRight, 1.0, 1e5 );
+ myPlot->updateAxes();
+ }
myPlot->setLogScale( QwtPlot::yRight, myYMode != 0 );
+ }
if ( update )
fitAll();
*/
void Plot2d_ViewFrame::plotMousePressed( const QMouseEvent& me )
{
+#ifndef NO_SUIT
Plot2d_ViewWindow* aParent = dynamic_cast<Plot2d_ViewWindow*>(parent());
if (aParent)
aParent->putInfo(getInfo(me.pos()));
+#endif
if ( myOperation == NoOpId )
myOperation = testOperation( me );
if ( myOperation != NoOpId ) {
myPnt = me.pos();
if ( myOperation == GlPanId ) {
myPlot->setAxisScale( QwtPlot::yLeft,
- myPlot->invTransform( QwtPlot::yLeft, myPnt.y() ) - myYDistance/2,
+ myPlot->invTransform( QwtPlot::yLeft, myPnt.y() ) - myYDistance/2,
myPlot->invTransform( QwtPlot::yLeft, myPnt.y() ) + myYDistance/2 );
- myPlot->setAxisScale( QwtPlot::xBottom,
- myPlot->invTransform( QwtPlot::xBottom, myPnt.x() ) - myXDistance/2,
+ myPlot->setAxisScale( QwtPlot::xBottom,
+ myPlot->invTransform( QwtPlot::xBottom, myPnt.x() ) - myXDistance/2,
myPlot->invTransform( QwtPlot::xBottom, myPnt.x() ) + myXDistance/2 );
if (mySecondY)
myPlot->setAxisScale( QwtPlot::yRight,
- myPlot->invTransform( QwtPlot::yRight, myPnt.y() ) - myYDistance2/2,
+ myPlot->invTransform( QwtPlot::yRight, myPnt.y() ) - myYDistance2/2,
myPlot->invTransform( QwtPlot::yRight, myPnt.y() ) + myYDistance2/2 );
myPlot->replot();
}
}
else {
- int btn = me.button() | me.modifiers();
+ int btn = (int)me.button() | (int)me.modifiers();
if (btn == Qt::RightButton) {
QMouseEvent* aEvent = new QMouseEvent(QEvent::MouseButtonPress,
me.pos(), me.button(), me.buttons(), me.modifiers() );
parent()->eventFilter(this, aEvent);
}
}
- setFocus();
+ setFocus();
}
/*!
Slot, called when user moves mouse
bool aRes = false;
if ( myOperation != NoOpId) {
if ( myOperation == ZoomId ) {
- this->incrementalZoom( dx, dy );
+ this->incrementalZoom( dx, dy );
myPnt = me.pos();
aRes = true;
}
}
}
else {
+#ifndef NO_SUIT
Plot2d_ViewWindow* aParent = dynamic_cast<Plot2d_ViewWindow*>(parent());
if (aParent)
aParent->putInfo(getInfo(me.pos()));
+#endif
}
return aRes;
}
QContextMenuEvent aEvent( QContextMenuEvent::Mouse,
me.pos(), me.globalPos() );
emit contextMenuRequested( &aEvent );
- }
+ }
else {
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
myPlot->canvas()->setCursor( QCursor( Qt::CrossCursor ) );
myPlot->defaultPicker();
+#ifndef NO_SUIT
Plot2d_ViewWindow* aParent = dynamic_cast<Plot2d_ViewWindow*>(parent());
if (aParent)
aParent->putInfo(tr("INF_READY"));
+#endif
myOperation = NoOpId;
}
/*!
Slot, called when user wheeling mouse
*/
void Plot2d_ViewFrame::wheelEvent(QWheelEvent* event)
-{
- double aDelta = event->delta();
- double aScale = (aDelta < 0) ? 100./(-aDelta) : aDelta/100.;
+{
+ QwtPlotLayout* pl = myPlot->plotLayout();
- QwtScaleMap xMap = myPlot->canvasMap( QwtPlot::xBottom );
- QwtScaleMap yMap = myPlot->canvasMap( QwtPlot::yLeft );
+ // compute zooming factor
+ double aDelta = event->delta();
+ double aScale = (aDelta < 0) ? 100./(-aDelta) : aDelta/100.;
+
+ bool scaleXBottom = pl->scaleRect(QwtPlot::xBottom).contains( event->pos() ) ||
+ pl->canvasRect().contains( event->pos() );
+ bool scaleYLeft = pl->scaleRect(QwtPlot::yLeft).contains( event->pos() ) ||
+ pl->canvasRect().contains( event->pos() );
+ bool scaleYRight = mySecondY && ( pl->scaleRect(QwtPlot::yRight).contains( event->pos() ) ||
+ pl->canvasRect().contains( event->pos() ) );
+
+ // scale x bottom axis
+ if ( scaleXBottom ) {
+ QwtScaleMap xMap = myPlot->canvasMap( QwtPlot::xBottom );
+ if ( xMap.s2() - xMap.s1() > 1.0e-12 || aScale > 1 )
+ myPlot->setAxisScale( QwtPlot::xBottom, xMap.s1(), xMap.s1() + aScale*(xMap.s2() - xMap.s1()) );
+ }
- if ( ((yMap.s2() - yMap.s1()) < 10e-13 || (xMap.s2() - xMap.s1()) < 10e-13 ) && aScale < 1 )
- return;
+ // scale y left axis
+ if ( scaleYLeft ) {
+ QwtScaleMap yMap = myPlot->canvasMap( QwtPlot::yLeft );
+ if ( yMap.s2() - yMap.s1() > 1.0e-12 || aScale > 1 )
+ myPlot->setAxisScale( QwtPlot::yLeft, yMap.s1(), yMap.s1() + aScale*(yMap.s2() - yMap.s1()) );
+ }
- myPlot->setAxisScale( QwtPlot::yLeft, yMap.s1(), yMap.s1() + aScale*(yMap.s2() - yMap.s1()) );
- myPlot->setAxisScale( QwtPlot::xBottom, xMap.s1(), xMap.s1() + aScale*(xMap.s2() - xMap.s1()) );
- if (mySecondY) {
- QwtScaleMap y2Map = myPlot->canvasMap( QwtPlot::yRight );
- if ( ((y2Map.s2() - y2Map.s1()) < 10e-13 ) && aScale < 1 ) return;
- myPlot->setAxisScale( QwtPlot::yRight, y2Map.s1(), y2Map.s1() + aScale*(y2Map.s2() - y2Map.s1()) );
+ // scale y right axis (note: mySecondY value is checked above)
+ if ( scaleYRight ) {
+ QwtScaleMap yMap = myPlot->canvasMap( QwtPlot::yRight );
+ if ( yMap.s2() - yMap.s1() > 10e-12 || aScale > 1 )
+ myPlot->setAxisScale( QwtPlot::yRight, yMap.s1(), yMap.s1() + aScale*(yMap.s2() - yMap.s1()) );
}
+
+ // redraw
myPlot->replot();
+ // update zoomer
if ( myPlot->zoomer() ) myPlot->zoomer()->setZoomBase();
+ // store current mouse position
myPnt = event->pos();
+#ifndef NO_ANALYTICAL_CURVES
+ // update analytical curves
updateAnalyticalCurves();
+#endif
}
/*!
/*!
Sets curve type
*/
-void Plot2d_ViewFrame::setCurveType( QwtPlotCurve* curve, int curveType )
+void Plot2d_ViewFrame::setCurveType( QwtPlotCurve* curve, int /*curveType*/ )
{
if ( !curve )
return;
View operations : Pan view
*/
void Plot2d_ViewFrame::onViewPan()
-{
+{
+ // reset the previous operation
+ myPlot->defaultPicker();
+
QCursor panCursor (Qt::SizeAllCursor);
myPlot->canvas()->setCursor( panCursor );
myOperation = PanId;
/*!
View operations : Zoom view
*/
-void Plot2d_ViewFrame::onViewZoom()
+void Plot2d_ViewFrame::onViewZoom()
{
+ // reset the previous operation
+ myPlot->defaultPicker();
+
QPixmap zoomPixmap (imageZoomCursor);
QCursor zoomCursor (zoomPixmap);
myPlot->canvas()->setCursor( zoomCursor );
myOperation = ZoomId;
}
/*!
- View operations : Fot All
+ View operations : Fit All
*/
-void Plot2d_ViewFrame::onViewFitAll()
-{
+void Plot2d_ViewFrame::onViewFitAll()
+{
fitAll();
+
+ // reset the previous operation
+ myPlot->defaultPicker();
+ myPlot->canvas()->setCursor( QCursor(Qt::CrossCursor) );
+ myOperation = NoOpId;
}
/*!
View operations : Fit Area
*/
-void Plot2d_ViewFrame::onViewFitArea()
+void Plot2d_ViewFrame::onViewFitArea()
{
myPlot->canvas()->setCursor( QCursor( Qt::PointingHandCursor ) );
myOperation = FitAreaId;
/*!
View operations : Global panning
*/
-void Plot2d_ViewFrame::onViewGlobalPan()
+void Plot2d_ViewFrame::onViewGlobalPan()
{
+ // reset the previous operation
+ myPlot->defaultPicker();
+
QPixmap globalPanPixmap (imageCrossCursor);
QCursor glPanCursor (globalPanPixmap);
myPlot->canvas()->setCursor( glPanCursor );
QwtScaleMap yMap2 = myPlot->canvasMap( QwtPlot::yRight );
myYDistance2 = yMap2.s2() - yMap2.s1();
}
- fitAll();
+ // don't make fit all
+ // fitAll();
myOperation = GlPanId;
}
class Plot2d_QwtPlotZoomer : public QwtPlotZoomer
{
public:
- Plot2d_QwtPlotZoomer( int xAxis, int yAxis, QwtPlotCanvas* canvas )
+ Plot2d_QwtPlotZoomer( int xAxis, int yAxis, QWidget* canvas )
: QwtPlotZoomer( xAxis, yAxis, canvas )
{
qApp->installEventFilter( this );
*/
Plot2d_Plot2d::Plot2d_Plot2d( QWidget* parent )
: QwtPlot( parent ),
- myIsPolished( false )
+ myPicker( 0 )
{
// Create alternative scales
setAxisScaleDraw( QwtPlot::yLeft, new Plot2d_ScaleDraw() );
setAxisScaleDraw( QwtPlot::yRight, new Plot2d_ScaleDraw() );
myPlotZoomer = new Plot2d_QwtPlotZoomer( QwtPlot::xBottom, QwtPlot::yLeft, canvas() );
- myPlotZoomer->setSelectionFlags( QwtPicker::DragSelection | QwtPicker::CornerToCorner );
myPlotZoomer->setTrackerMode( QwtPicker::AlwaysOff );
myPlotZoomer->setRubberBand( QwtPicker::RectRubberBand );
myPlotZoomer->setRubberBandPen( QColor( Qt::green ) );
setAxisAutoScale( QwtPlot::yLeft );
setAxisAutoScale( QwtPlot::yRight );
setAxisAutoScale( QwtPlot::xBottom );
-
+
myScaleDraw = NULL;
// grid
myGrid = new QwtPlotGrid();
- QPen aMajPen = myGrid->majPen();
+ QPen aMajPen = myGrid->majorPen();
aMajPen.setStyle( Qt::DashLine );
myGrid->setPen( aMajPen );
void Plot2d_Plot2d::setLogScale( int axisId, bool log10 )
{
if ( log10 )
- setAxisScaleEngine( axisId, new QwtLog10ScaleEngine() );
+ setAxisScaleEngine( axisId, new QwtLogScaleEngine() );
else
setAxisScaleEngine( axisId, new QwtLinearScaleEngine() );
}
/*!
- Recalculates and redraws Plot 2d view
+ Recalculates and redraws Plot 2d view
*/
void Plot2d_Plot2d::replot()
{
enableAxis( QwtPlot::yRight, enableYRight );
updateLayout(); // to fix bug(?) of Qwt - view is not updated when title is changed
- QwtPlot::replot();
+ QwtPlot::replot();
}
/*!
Get legend
*/
-QwtLegend* Plot2d_Plot2d::getLegend()
+QwtAbstractLegend* Plot2d_Plot2d::getLegend()
{
#if QWT_VERSION < 0x040200
return d_legend;
-#else
+#else
return legend(); /* mpv: porting to the Qwt 4.2.0 */
#endif
}
myPlotZoomer->setMousePattern( QwtEventPattern::MouseSelect1,
Qt::RightButton, Qt::ControlModifier ); // zooming button
for ( int i = QwtEventPattern::MouseSelect2; i < QwtEventPattern::MouseSelect6; i++ )
- myPlotZoomer->setMousePattern( i, Qt::NoButton, Qt::NoButton );
+ myPlotZoomer->setMousePattern( (QwtEventPattern::MousePatternCode)i, Qt::NoButton,
+ Qt::NoModifier );
}
void Plot2d_Plot2d::setPickerMousePattern( int button, int state )
{
- myPlotZoomer->setMousePattern( QwtEventPattern::MouseSelect1, button, state );
+ myPlotZoomer->setMousePattern( QwtEventPattern::MouseSelect1, (Qt::MouseButton)button,
+ (Qt::KeyboardModifiers)state );
}
/*!
/*!
* Create marker and tooltip associed with a point
*/
-QwtPlotMarker* Plot2d_Plot2d::createMarkerAndTooltip( QwtSymbol symbol,
- double X,
- double Y,
- QString & tooltip,
- Plot2d_QwtPlotPicker *picker)
+QwtPlotMarker* Plot2d_Plot2d::createMarkerAndTooltip( QwtSymbol* symbol,
+ double X,
+ double Y,
+ QString & tooltip,
+ Plot2d_QwtPlotPicker *picker)
{
QwtPlotMarker* aPlotMarker = new QwtPlotMarker();
aPlotMarker->setYValue(Y);
//
aPlotMarker->attach(this);
-
+
// Associate a tooltip with the point's marker
// PB: how to obtain a tooltip with a rectangular frame ?
//QwtText tooltip ("X=" + QString::number(X) + " Y=" + QString::number(Y) );
QColor tooltipColor( 253, 245, 230); // OldLace
text.setBackgroundBrush( QBrush(tooltipColor)); //, Qt::SolidPattern));
//
- picker->pMarkers.append( aPlotMarker);
- picker->pMarkersToolTip[ aPlotMarker] = text;
+ if ( picker ) {
+ picker->pMarkers.append( aPlotMarker);
+ picker->pMarkersToolTip[ aPlotMarker] = text;
+ }
return aPlotMarker;
}
-bool Plot2d_Plot2d::polished() const
-{
- return myIsPolished;
-}
-
QwtPlotGrid* Plot2d_Plot2d::grid() const
{
return myGrid;
-};
+}
QwtPlotZoomer* Plot2d_Plot2d::zoomer() const
{
return myPlotZoomer;
}
-/*!
- Slot: checks the current labels format and change it if needed
-*/
-void Plot2d_Plot2d::onScaleDivChanged()
-{
- QwtScaleWidget* aSW = 0;
- if ( ( aSW = dynamic_cast<QwtScaleWidget*>(sender()) ) ) {
- int axisId = -1;
- switch ( aSW->alignment() ) {
- case QwtScaleDraw::BottomScale:
- axisId = QwtPlot::xBottom;
- break;
- case QwtScaleDraw::LeftScale:
- axisId = QwtPlot::yLeft;
- break;
- case QwtScaleDraw::RightScale:
- axisId = QwtPlot::yRight;
- break;
- default:
- break;
- }
-
- if ( axisId >= 0 ) {
- QwtScaleMap map = canvasMap(axisId);
- double aDist = fabs(map.s2()-map.s1()) / (axisMaxMajor(axisId)*axisMaxMinor(axisId));
-
- QString aDistStr;
- aDistStr.sprintf("%e",aDist);
- int aPrecision = aDistStr.right(aDistStr.length()-aDistStr.indexOf('e')-2).toInt();
-
- QwtScaleDraw* aQwtSD = axisScaleDraw(axisId);
- Plot2d_ScaleDraw* aPlot2dSD = dynamic_cast<Plot2d_ScaleDraw*>(aQwtSD);
- if ( ( !aPlot2dSD && aPrecision > 6 ) || ( aPlot2dSD && aPlot2dSD->precision() != aPrecision ) )
- setAxisScaleDraw( axisId, new Plot2d_ScaleDraw(*aQwtSD, 'f', aPrecision) );
- }
- }
-}
-
/*!
Updates identifiers of Y axis type in the legend.
*/
if ( Plot2d_QwtPlotCurve* aPCurve = dynamic_cast<Plot2d_QwtPlotCurve*>( item ) )
aPCurve->setYAxisIdentifierEnabled( enableYLeft && enableYRight );
if ( item && item->isVisible() && legend() )
- item->updateLegend( legend() );
+ item->updateLegend( item, item->legendData() );
}
}
-/*!
- Sets the flag saying that QwtPlot geometry has been fully defined.
-*/
-void Plot2d_Plot2d::polish()
-{
- QwtPlot::polish();
- myIsPolished = true;
-}
-
// Methods to manage axis graduations
/* Create definition and graduations of axes
QList<double> allTicks;
double devXmin, devXmax; // X interval of a system
- double gapXmin, gapXmax; // X interval between two systems
+ double gapXmin = 0., gapXmax = 0.; // X interval between two systems
double devLabPos; // Label's position of a system
double segmentPos; // Position of the vertical segment between current system and the next
mySeparationLineList.clear();
}
+/* Set type of legend symbol
+ */
+void Plot2d_Plot2d::setLegendSymbolType( const int type )
+{
+ myLegendSymbolType = type;
+}
+
+/* Get type of legend symbol
+ */
+int Plot2d_Plot2d::getLegendSymbolType()
+{
+ return myLegendSymbolType;
+}
+
/*!
Creates presentation of object
Default implementation is empty
myCurveType = vf->myCurveType;
myShowLegend = vf->myShowLegend;
myLegendPos = vf->myLegendPos;
+ myLegendSymbolType = vf->myLegendSymbolType;
+ myLegendFont = vf->myLegendFont;
+ mySelectedLegendFontColor = vf->mySelectedLegendFontColor;
myMarkerSize = vf->myMarkerSize;
myBackground = vf->myBackground;
- myTitle = vf->myTitle;
+ mySelectionColor = vf->mySelectionColor;
+ myTitle = vf->myTitle;
myXTitle = vf->myXTitle;
myYTitle = vf->myYTitle;
myY2Title = vf->myY2Title;
Updates titles according to curves
*/
#define BRACKETIZE(x) QString( "[ " ) + x + QString( " ]" )
-void Plot2d_ViewFrame::updateTitles()
+void Plot2d_ViewFrame::updateTitles( const bool update )
{
ObjectDict::iterator it = myObjects.begin();
QStringList aXTitles;
QString yTitle = anObject->getVerTitle().trimmed();
QString xUnits = anObject->getHorUnits().trimmed();
QString yUnits = anObject->getVerUnits().trimmed();
-
+
if ( anObject->getYAxis() == QwtPlot::yLeft ) {
if ( !aYTitles.contains( yTitle ) )
aYTitles.append( yTitle );
if ( !y2Title.isEmpty() && !y2Units.isEmpty() )
y2Title += " ";
- setTitle( myXTitleEnabled, xTitle + xUnits, XTitle, true );
- setTitle( myYTitleEnabled, yTitle + yUnits, YTitle, true );
+ setTitle( myXTitleEnabled, xTitle + xUnits, XTitle, false );
+ setTitle( myYTitleEnabled, yTitle + yUnits, YTitle, false );
if ( mySecondY )
- setTitle( myY2TitleEnabled, y2Title + y2Units, Y2Title, true );
- if( myIsDefTitle )
- setTitle( true, aTables.join("; "), MainTitle, true );
+ setTitle( myY2TitleEnabled, y2Title + y2Units, Y2Title, false );
+ if( myIsDefTitle )
+ setTitle( true, aTables.join("; "), MainTitle, false );
+
+ // do update if necessary
+ if ( update ) {
+ myPlot->replot();
+ }
}
/*!
if( myPlot )
{
QPaintDevice* pd = 0;
- if( format=="PS" || format=="EPS" )
+ if( format=="PS" || format=="EPS" || format == "PDF" )
{
QPrinter* pr = new QPrinter( QPrinter::HighResolution );
+ if(format == "PDF")
+ pr->setOutputFormat(QPrinter::PdfFormat);
pr->setPageSize( QPrinter::A4 );
pr->setOutputFileName( file );
pr->setPrintProgram( "" );
if( pd )
{
- myPlot->print( *pd );
+ QwtPlotRenderer* pr = new QwtPlotRenderer();
+ pr->renderTo( myPlot, *pd );
res = true;
delete pd;
}
}
return res;
#endif
+
}
/**
* Print Plot2d window
*/
-void Plot2d_ViewFrame::printPlot( QPainter* p, const QRect& rect,
- const QwtPlotPrintFilter& filter ) const
+void Plot2d_ViewFrame::printPlot( QPainter* p, const QRectF& rect) const
{
- myPlot->print( p, rect, filter );
+ QwtPlotRenderer* pr = new QwtPlotRenderer();
+ pr->render( myPlot, p, rect );
}
/*!
getFitRanges( xmin, xmax, ymin, ymax, y2min, y2max );
QString retStr;
//Store font in the visual parameters string as:
- //
+ //
// ...*FontFamily|FontSize|B|I|U|r:g:b*...
-
+
retStr.sprintf( "%d*%d*%d*%.12e*%.12e*%.12e*%.12e*%.12e*%.12e*%s|%i|%i|%i|%i|%i:%i:%i",
myXMode, myYMode, mySecondY, xmin, xmax, ymin, ymax, y2min, y2max,
qPrintable(myLegendFont.family()), myLegendFont.pointSize(),myLegendFont.bold(),
myLegendFont.italic(), myLegendFont.underline(),myLegendColor.red(),
myLegendColor.green(), myLegendColor.blue());
-
+
//store all Analytical curves
//store each curve in the following format
// ...*Name|isActive|Expresion|NbInervals|isAutoAssign[|MarkerType|LineType|LineWidth|r:g:b]
// parameters in the [ ] is optional in case if isAutoAssign == true
AnalyticalCurveList::iterator it = myAnalyticalCurves.begin();
Plot2d_AnalyticalCurve* c = 0;
- bool isAuto;
+ bool isAuto;
for( ; it != myAnalyticalCurves.end(); it++) {
c = (*it);
if(!c) continue;
}
}
retStr += QString( "*%1" ).arg( Qtx::colorToString( backgroundColor() ) );
- return retStr;
+ return retStr;
*/
}
setTitle( myY2TitleEnabled, myY2Title, Y2Title, false );
setHorScaleMode( myXMode, /*update=*/false );
setVerScaleMode( myYMode, /*update=*/false );
-
+
if (mySecondY) {
QwtScaleMap yMap2 = myPlot->canvasMap( QwtPlot::yRight );
myYDistance2 = yMap2.s2() - yMap2.s1();
}
-
+
fitData( 0, xmin, xmax, ymin, ymax, y2min, y2max );
fitData( 0, xmin, xmax, ymin, ymax, y2min, y2max );
}
colorList[2].toInt());
setLegendFontColor( myLegendColor );
}
- }
+ }
}
+#ifndef NO_ANALYTICAL_CURVES
//Restore all Analytical curves
int startCurveIndex = 10;
if( paramsLst.size() >= startCurveIndex+1 ) {
}
myPlot->replot();
}
+#endif
}
/*!
aWriter.writeEndElement();
aWriter.writeEndElement();
+#ifndef NO_ANALYTICAL_CURVES
//AnalyticalCurve
- aWriter.writeStartElement("AnalyticalCurves");
+ aWriter.writeStartElement("AnalyticalCurves");
AnalyticalCurveList::iterator it = myAnalyticalCurves.begin();
Plot2d_AnalyticalCurve* c = 0;
- bool isAuto;
+ bool isAuto;
int id = 1;
for( ; it != myAnalyticalCurves.end(); it++) {
c = (*it);
aWriter.writeAttribute("Name",c->getName());
aWriter.writeAttribute("IsActive", QString("").sprintf("%d", c->isActive()));
aWriter.writeAttribute("Expression", c->getExpression());
- aWriter.writeAttribute("NbIntervals", QString("").sprintf("%d", c->getNbIntervals()));
+ aWriter.writeAttribute("NbIntervals", QString("").sprintf("%ld", c->getNbIntervals()));
aWriter.writeAttribute("isAuto", QString("").sprintf("%d",isAuto));
if(!isAuto) {
aWriter.writeAttribute("Marker", QString("").sprintf("%d",(int)c->getMarker()));
id++;
}
aWriter.writeEndElement(); //AnalyticalCurve
+#endif
//Background
- aWriter.writeStartElement(QString("Background").arg(id));
- aWriter.writeStartElement(QString("BackgroundColor").arg(id));
+ aWriter.writeStartElement(QString("Background"));
+ aWriter.writeStartElement(QString("BackgroundColor"));
aWriter.writeAttribute("R", QString("").sprintf("%d",backgroundColor().red()));
aWriter.writeAttribute("G", QString("").sprintf("%d",backgroundColor().green()));
aWriter.writeAttribute("B", QString("").sprintf("%d",backgroundColor().blue()));
*/
bool Plot2d_ViewFrame::setXmlVisualParameters(const QString& parameters) {
QXmlStreamReader aReader(parameters);
- double xmin, xmax, ymin, ymax, y2min, y2max;
+ double xmin = 0., xmax = 0., ymin = 0., ymax = 0., y2min = 0., y2max = 0.;
bool leftMin,leftMax,rightMin,rightMax;
leftMin = leftMax = rightMin = rightMax = false;
while(!aReader.atEnd()) {
setLegendFontColor( myLegendColor );
setLegendFont(myLegendFont);
} else if(aReader.name().toString().indexOf("AnalyticalCurve_") >= 0) {
+#ifndef NO_ANALYTICAL_CURVES
Plot2d_AnalyticalCurve* c = new Plot2d_AnalyticalCurve();
c->setName(aAttr.value("Name").toString());
c->setActive((bool)aAttr.value("IsActive").toString().toInt());
if( !c->isAutoAssign() ) {
c->setMarker((Plot2d::MarkerType)aAttr.value("Marker").toString().toInt());
c->setLine((Plot2d::LineType)aAttr.value("Line").toString().toInt());
- c->setLineWidth(aAttr.value("LineWidth").toString().toInt());
+ c->setLineWidth(aAttr.value("LineWidth").toString().toInt());
c->setColor(QColor(aAttr.value("R").toString().toInt(),
aAttr.value("G").toString().toInt(),
aAttr.value("B").toString().toInt()));
}
addAnalyticalCurve(c);
updateAnalyticalCurve(c);
+#endif
} else if(aReader.name().toString() == "BackgroundColor") {
setBackgroundColor(QColor(aAttr.value("R").toString().toInt(),
aAttr.value("G").toString().toInt(),
if (mySecondY)
setTitle( myY2TitleEnabled, myY2Title, Y2Title, false );
setHorScaleMode( myXMode, /*update=*/false );
- setVerScaleMode( myYMode, /*update=*/false );
+ setVerScaleMode( myYMode, /*update=*/false );
if (mySecondY) {
QwtScaleMap yMap2 = myPlot->canvasMap( QwtPlot::yRight );
myYDistance2 = yMap2.s2() - yMap2.s1();
- }
+ }
setNormLMinMode(leftMin);
setNormLMaxMode(leftMax);
setNormRMinMode(rightMin);
showLegend( myShowLegend, false );
- fitData( 0, xmin, xmax, ymin, ymax, y2min, y2max );
+ fitData( 0, xmin, xmax, ymin, ymax, y2min, y2max );
return true;
}
void Plot2d_ViewFrame::incrementalPan( const int incrX, const int incrY ) {
QwtScaleMap xMap = myPlot->canvasMap( QwtPlot::xBottom );
QwtScaleMap yMap = myPlot->canvasMap( QwtPlot::yLeft );
-
- myPlot->setAxisScale( QwtPlot::yLeft,
- myPlot->invTransform( QwtPlot::yLeft, yMap.transform( yMap.s1() )-incrY ),
+
+ myPlot->setAxisScale( QwtPlot::yLeft,
+ myPlot->invTransform( QwtPlot::yLeft, yMap.transform( yMap.s1() )-incrY ),
myPlot->invTransform( QwtPlot::yLeft, yMap.transform( yMap.s2() )-incrY ) );
- myPlot->setAxisScale( QwtPlot::xBottom,
+ myPlot->setAxisScale( QwtPlot::xBottom,
myPlot->invTransform( QwtPlot::xBottom, xMap.transform( xMap.s1() )-incrX ),
- myPlot->invTransform( QwtPlot::xBottom, xMap.transform( xMap.s2() )-incrX ) );
+ myPlot->invTransform( QwtPlot::xBottom, xMap.transform( xMap.s2() )-incrX ) );
if (mySecondY) {
QwtScaleMap y2Map = myPlot->canvasMap( QwtPlot::yRight );
myPlot->setAxisScale( QwtPlot::yRight,
- myPlot->invTransform( QwtPlot::yRight, y2Map.transform( y2Map.s1() )-incrY ),
+ myPlot->invTransform( QwtPlot::yRight, y2Map.transform( y2Map.s1() )-incrY ),
myPlot->invTransform( QwtPlot::yRight, y2Map.transform( y2Map.s2() )-incrY ) );
}
myPlot->replot();
void Plot2d_ViewFrame::incrementalZoom( const int incrX, const int incrY ) {
QwtScaleMap xMap = myPlot->canvasMap( QwtPlot::xBottom );
QwtScaleMap yMap = myPlot->canvasMap( QwtPlot::yLeft );
-
- myPlot->setAxisScale( QwtPlot::yLeft, yMap.s1(),
+
+ myPlot->setAxisScale( QwtPlot::yLeft, yMap.s1(),
myPlot->invTransform( QwtPlot::yLeft, yMap.transform( yMap.s2() ) + incrY ) );
- myPlot->setAxisScale( QwtPlot::xBottom, xMap.s1(),
+ myPlot->setAxisScale( QwtPlot::xBottom, xMap.s1(),
myPlot->invTransform( QwtPlot::xBottom, xMap.transform( xMap.s2() ) - incrX ) );
if (mySecondY) {
QwtScaleMap y2Map = myPlot->canvasMap( QwtPlot::yRight );
}
/*
- Update plot item
+ Update plot item
*/
void Plot2d_ViewFrame::updatePlotItem(Plot2d_Object* theObject, QwtPlotItem* theItem) {
theObject->updatePlotItem( theItem );
xNew[j] = itTmp.value().at(j).first;
yNew[j] = itTmp.value().at(j).second;
}
- cu->setData(xNew, yNew,j);
+ cu->setSamples(xNew, yNew,j);
delete [] xNew;
delete [] yNew;
if(aNormAlgo->getNormalizationMode() != Plot2d_NormalizeAlgorithm::NormalizeNone) {
*/
QwtPlotCanvas* Plot2d_ViewFrame::getPlotCanvas() const
{
- return myPlot ? myPlot->canvas() : 0;
+ return myPlot ? (QwtPlotCanvas*)myPlot->canvas() : 0;
}
/*!
{
CurveDict aCurves = getCurves();
CurveDict::iterator it = aCurves.begin();
- QwtPlotCurve* aCurve;
+ Plot2d_Curve* pCurve = 0;
+ distance = -1.;
for ( ; it != aCurves.end(); it++ ) {
- aCurve = it.key();
+ QwtPlotCurve* aCurve = it.key();
if ( !aCurve )
continue;
- index = aCurve->closestPoint( p, &distance );
- if ( index > -1 )
- return it.value();
+ double d;
+ int i = aCurve->closestPoint( p, &d );
+ if ( i > -1 && ( distance < 0 || d < distance ) ) {
+ pCurve = it.value();
+ distance = d;
+ index = i;
+ }
}
- return 0;
+ return pCurve;
}
+#ifndef NO_ANALYTICAL_CURVES
/*!
\brief Deselect all analytical curves.
*/
c->setSelected(false);
}
}
+#endif
/*!
\brief Deselect all objects, except analytical curves.
void Plot2d_ViewFrame::onPanLeft()
{
this->incrementalPan( -INCREMENT_FOR_OP, 0 );
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
void Plot2d_ViewFrame::onPanRight()
{
this->incrementalPan( INCREMENT_FOR_OP, 0 );
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
void Plot2d_ViewFrame::onPanUp()
{
this->incrementalPan( 0, -INCREMENT_FOR_OP );
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
void Plot2d_ViewFrame::onPanDown()
{
this->incrementalPan( 0, INCREMENT_FOR_OP );
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
void Plot2d_ViewFrame::onZoomIn()
{
this->incrementalZoom( INCREMENT_FOR_OP, INCREMENT_FOR_OP );
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
void Plot2d_ViewFrame::onZoomOut()
{
this->incrementalZoom( -INCREMENT_FOR_OP, -INCREMENT_FOR_OP );
+#ifndef NO_ANALYTICAL_CURVES
updateAnalyticalCurves();
+#endif
}
/*!
*
*/
Plot2d_Object* Plot2d_ViewFrame::getPlotObject( QwtPlotItem* plotItem ) const {
-
+
ObjectDict::const_iterator it = myObjects.begin();
for( ; it != myObjects.end(); ++it ) {
if ( it.key() == plotItem ) {
invalidateCache();
}
-Plot2d_ScaleDraw::Plot2d_ScaleDraw( const QwtScaleDraw& scaleDraw, char f, int prec )
- : QwtScaleDraw(scaleDraw),
- myFormat(f),
- myPrecision(prec)
-{
- invalidateCache();
-}
-
QwtText Plot2d_ScaleDraw::label( double value ) const
{
- QwtScaleMap m = map();
+ QwtScaleMap m = scaleMap();
QString str1 = QwtScaleDraw::label( m.s1() ).text();
QString str2 = QwtScaleDraw::label( m.s2() ).text();
if ( str1 == str2 ) {
- double aDist = fabs(map().s2()-map().s1())/5;
+ double aDist = fabs(scaleMap().s2()-scaleMap().s1())/5;
int precision = 0;
while (aDist < 1 ) {
- precision++;
- aDist *= 10.;
+ precision++;
+ aDist *= 10.;
}
if ( precision > 0 && value > 0 )
return QLocale::system().toString( value,'f', precision );
major_ticks.clear();
major_ticks.append( myTicks);
- myPlot->axisScaleDiv(QwtPlot::xBottom)->setTicks(QwtScaleDiv::MajorTick, major_ticks);
- myPlot->axisScaleDiv(QwtPlot::xBottom)->setTicks(QwtScaleDiv::MediumTick, medium_ticks);
- myPlot->axisScaleDiv(QwtPlot::xBottom)->setTicks(QwtScaleDiv::MinorTick, minor_ticks);
+
+ QwtScaleDiv aScaleDiv = myPlot->axisScaleDiv( QwtPlot::xBottom );
+ aScaleDiv.setTicks( QwtScaleDiv::MajorTick, major_ticks );
+ aScaleDiv.setTicks( QwtScaleDiv::MediumTick, medium_ticks );
+ aScaleDiv.setTicks( QwtScaleDiv::MinorTick, minor_ticks );
+ myPlot->setAxisScaleDiv( QwtPlot::xBottom, aScaleDiv );
+
QwtScaleDraw *scale = myPlot->axisScaleDraw(QwtPlot::xBottom);
((Plot2d_AxisScaleDraw*)(scale))->applyTicks();
for (int i = 0; i < myTicks.size(); i++)
{
- drawLabel( painter, myTicks[i]);
- }
-
+ drawLabel( painter, myTicks[i]);
+ }
+
//std::cout << "Ok for Plot2d_AxisScaleDraw::draw()" << std::endl;
}
+double Plot2d_AxisScaleDraw::extent( const QFont &font ) const
+{
+ QFontMetrics fm( font );
+ return QwtScaleDraw::extent( font ) + fm.height() * 2;
+}
+
QwtText Plot2d_AxisScaleDraw::label( double value) const
{
if (myLabelX.contains(value))
medium_ticks.clear();
minor_ticks.clear();
- myPlot->axisScaleDiv(QwtPlot::xBottom)->setTicks(QwtScaleDiv::MajorTick, myTicks);
- myPlot->axisScaleDiv(QwtPlot::xBottom)->setTicks(QwtScaleDiv::MediumTick, medium_ticks);
- myPlot->axisScaleDiv(QwtPlot::xBottom)->setTicks(QwtScaleDiv::MinorTick, minor_ticks);
+ QwtScaleDiv aQwtScaleDiv = myPlot->axisScaleDiv( QwtPlot::xBottom );
+ aQwtScaleDiv.setTicks( QwtScaleDiv::MajorTick, myTicks );
+ aQwtScaleDiv.setTicks( QwtScaleDiv::MediumTick, medium_ticks );
+ aQwtScaleDiv.setTicks( QwtScaleDiv::MinorTick, minor_ticks );
+ myPlot->setAxisScaleDiv( QwtPlot::xBottom, aQwtScaleDiv );
QwtScaleDiv* aScaleDiv = (QwtScaleDiv*) &scaleDiv();
if (myLowerBound != -1 && myUpperBound != -1)
aScaleDiv->setInterval(myLowerBound, myUpperBound);
-
+
//for (int i = 0; i < myTicks.size(); i++){
// QPoint p = labelPosition( i );
// qDebug() << i<< ") applyTicks -> LABEL" <<p;
//const char *c_label = std_label.c_str();
//std::cout << " deviceLabel= |" << c_label << "|" << std::endl;
- QPoint p = labelPosition( value );
+ QPointF p = labelPosition( value );
p += QPoint(0, DEVICE_BY);
QFont prevf = painter->font();
//QColor prevc = (painter->pen()).color();
-
+
QFont devicef( DEVICE_FONT, DEVICE_FONT_SIZE, QFont::Bold);
//
//painter->setPen( QColor("blue") );
QwtScaleDraw::drawLabel( painter, value );
}
}
-
+
void Plot2d_AxisScaleDraw::drawTick( QPainter* painter, double value, int len) const
{
if ( myLabelX.contains(value) )
{
QwtScaleDraw::drawTick( painter, value, len);
- }
+ }
}
/* Management of tooltips associated with markers for curves points or others points
*/
const double Plot2d_QwtPlotPicker::BOUND_HV_SIZE = 0.2;
-
+
Plot2d_QwtPlotPicker::Plot2d_QwtPlotPicker( int xAxis,
int yAxis,
- int selectionFlags,
RubberBand rubberBand,
DisplayMode trackerMode,
QwtPlotCanvas *canvas)
: QwtPlotPicker( xAxis,
yAxis,
- selectionFlags,
rubberBand,
trackerMode,
canvas) // of drawing zone QwtPlot
{
}
-
+
Plot2d_QwtPlotPicker::Plot2d_QwtPlotPicker( int xAxis,
int yAxis,
QwtPlotCanvas *canvas)
/* Return the tooltip associated with a point when the mouse cursor pass near
*/
-QwtText Plot2d_QwtPlotPicker::trackerText( const QwtDoublePoint & pos ) const
+QwtText Plot2d_QwtPlotPicker::trackerText( const QPoint & pos ) const
{
- for (QList<QwtPlotMarker* >::const_iterator pMarkerIt = pMarkers.begin();
- pMarkerIt != pMarkers.end();
- ++pMarkerIt )
- {
+ for (QList<QwtPlotMarker* >::const_iterator pMarkerIt = pMarkers.begin();pMarkerIt != pMarkers.end(); ++pMarkerIt )
+ {
QwtPlotMarker* pMarker = *pMarkerIt;
if ( pMarker != NULL )
- {
- QwtDoubleRect bound0 = pMarker->boundingRect();
- QwtDoublePoint center_bound0 = bound0.center();
- double left = center_bound0.x()-(BOUND_HV_SIZE/2.);
- double top = center_bound0.y()-(BOUND_HV_SIZE/2.);
+ {
+ const QwtSymbol* symb=pMarker->symbol();
+ const QSize& sz=symb->size();
+ const QwtScaleMap yMapRef=plot()->canvasMap(QwtPlot::yLeft);
+ const QwtScaleMap xMap=plot()->canvasMap(pMarker->xAxis());
+ const QwtScaleMap yMap=plot()->canvasMap(pMarker->yAxis());
+ QwtDoubleRect bound0=pMarker->boundingRect();
+ int x1 = qRound(xMap.transform(bound0.left()));
+ int x2 = qRound(xMap.transform(bound0.right()));
+ int y1 = qRound(yMap.transform(bound0.top()));
+ int y2 = qRound(yMap.transform(bound0.bottom()));
- QwtDoubleRect bound( left, top , BOUND_HV_SIZE, BOUND_HV_SIZE);
+ if ( x2 < x1 )
+ qSwap(x1, x2);
+ if ( y2 < y1 )
+ qSwap(y1, y2);
- if( bound.contains(pos) )
- {
- //QString toolTip = "X=" + QString::number( pMarker->xValue() )
- // + " Y=" + QString::number( pMarker->yValue() );
- return pMarkersToolTip[pMarker];
- }
- }
+ QRect bound00=QRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
+ QPoint toto(xMap.transform(pos.x()),yMapRef.transform(pos.y()));
+ bound00.setX(bound00.x()-sz.width());
+ bound00.setY(bound00.y()-sz.height());
+ bound00.setWidth(bound00.width()+sz.width());
+ bound00.setHeight(bound00.height()+sz.height());
+ if( bound00.contains(toto) )
+ {
+ return pMarkersToolTip[pMarker];
+ }
+ }
}
-
- return QwtText();
+ return QwtText();
}
