QDebug operator<<( QDebug debug, const QwtScaleDiv &scaleDiv )
{
debug << scaleDiv.lowerBound() << "<->" << scaleDiv.upperBound();
debug << "Major: " << scaleDiv.ticks( QwtScaleDiv::MajorTick );
debug << "Medium: " << scaleDiv.ticks( QwtScaleDiv::MediumTick );
debug << "Minor: " << scaleDiv.ticks( QwtScaleDiv::MinorTick );
return debug;
}
void ScaleDraw::drawTick(QPainter *p, double value, int len) const
{
int axis = this->axis();
ScaleEngine *sc_engine = (ScaleEngine *)d_plot->axisScaleEngine(axis);
if (sc_engine->hasBreak()){
double dlb = sc_engine->axisBreakLeft();
double drb = sc_engine->axisBreakRight();
if ((dlb < value && drb > value) ||
((axis == QwtPlot::yLeft || axis == QwtPlot::xBottom) && value == dlb) ||
((axis == QwtPlot::yRight || axis == QwtPlot::xTop) && value == drb) ||
(sc_engine->testAttribute(QwtScaleEngine::Inverted) && (value == dlb || value == drb)))
return;
if (d_plot->isPrinting()){
QwtScaleMap scaleMap = map();
double val = scaleMap.transform(value);
if (val >= scaleMap.transform(dlb) && val <= scaleMap.transform(drb))
return;
}
}
QwtScaleDiv scDiv = scaleDiv();
QwtValueList majTicks = scDiv.ticks(QwtScaleDiv::MajorTick);
if (majTicks.contains(value)){
if (d_majTicks == In || d_majTicks == None)
return;
switch (d_show_ticks_policy){
case ShowAll:
break;
case HideBegin:
if (majTicks.first() == value)
return;
break;
case HideEnd:
if (majTicks.last() == value)
return;
break;
case HideBeginEnd:
if (majTicks.first() == value || majTicks.last() == value)
return;
break;
}
}
QwtValueList medTicks = scDiv.ticks(QwtScaleDiv::MediumTick);
if (medTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtValueList minTicks = scDiv.ticks(QwtScaleDiv::MinorTick);
if (minTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtScaleDraw::drawTick(p, value, len);
}
virtual void updateScaleDiv( const QwtScaleDiv &xMap,
const QwtScaleDiv &yMap )
{
QList<double> ticks[QwtScaleDiv::NTickTypes];
ticks[QwtScaleDiv::MajorTick] =
xMap.ticks( QwtScaleDiv::MediumTick );
ticks[QwtScaleDiv::MinorTick] =
xMap.ticks( QwtScaleDiv::MinorTick );
QwtPlotGrid::updateScaleDiv(
QwtScaleDiv( xMap.lowerBound(), xMap.upperBound(), ticks ),
yMap );
}
vector<double> AxisImp::getMinorTickLocations() const
{
vector<double> minorTicks;
QwtScaleDiv scaleDiv = mScaleDraw.scaleDiv();
QwtValueList minorTickList = scaleDiv.ticks(QwtScaleDiv::MinorTick) + scaleDiv.ticks(QwtScaleDiv::MediumTick);
for (int i = 0; i < minorTickList.size(); ++i)
{
double dValue = minorTickList[i];
minorTicks.push_back(dValue);
}
return minorTicks;
}
void OscilloscopePlot::incrementInterval()
{
d_interval = QwtInterval( d_interval.maxValue(),
d_interval.maxValue() + d_interval.width() );
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->values().clearStaleValues( d_interval.minValue() );
// To avoid, that the grid is jumping, we disable
// the autocalculation of the ticks and shift them
// manually instead.
QwtScaleDiv scaleDiv = axisScaleDiv( QwtPlot::xBottom );
scaleDiv.setInterval( d_interval );
for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
{
QList<double> ticks = scaleDiv.ticks( i );
for ( int j = 0; j < ticks.size(); j++ )
ticks[j] += d_interval.width();
scaleDiv.setTicks( i, ticks );
}
setAxisScaleDiv( QwtPlot::xBottom, scaleDiv );
d_origin->setValue( d_interval.minValue() + d_interval.width() / 2.0, 0.0 );
d_paintedPoints = 0;
replot();
}
Knob::Knob(const QString &title, double min, double max, QWidget *parent):
QWidget(parent)
{
QFont font("Helvetica", 10);
d_knob = new QwtKnob(this);
d_knob->setFont(font);
d_knob->setRange(min, max);
QwtScaleDiv scaleDiv =
d_knob->scaleEngine()->divideScale(min, max, 5, 3);
QList<double> ticks = scaleDiv.ticks(QwtScaleDiv::MajorTick);
if ( ticks.size() > 0 && ticks[0] > min )
{
if ( ticks.first() > min )
ticks.prepend(min);
if ( ticks.last() < max )
ticks.append(max);
}
scaleDiv.setTicks(QwtScaleDiv::MajorTick, ticks);
d_knob->setScale(scaleDiv);
d_knob->setKnobWidth(50);
font.setBold(true);
d_label = new QLabel(title, this);
d_label->setFont(font);
d_label->setAlignment(Qt::AlignTop | Qt::AlignHCenter);
setSizePolicy(QSizePolicy::MinimumExpanding,
QSizePolicy::MinimumExpanding);
connect(d_knob, SIGNAL(valueChanged(double)),
this, SIGNAL(valueChanged(double)));
}
void Plot::incrementInterval()
{
d_interval = QwtInterval(d_interval.maxValue(),
d_interval.maxValue() + d_interval.width());
CurveData *data0 = static_cast<CurveData *>( d_curve0->data() );
CurveData *data1 = static_cast<CurveData *>( d_curve1->data() );
data0->clearStaleVal(d_interval.minValue());
data1->clearStaleVal(d_interval.minValue());
QwtScaleDiv scaleDiv = *axisScaleDiv(QwtPlot::xBottom);
scaleDiv.setInterval(d_interval);
for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
{
QList<double> ticks = scaleDiv.ticks(i);
for ( int j = 0; j < ticks.size(); j++ )
ticks[j] += d_interval.width();
scaleDiv.setTicks(i, ticks);
}
setAxisScaleDiv(QwtPlot::xBottom, scaleDiv);
d_origin->setValue(d_interval.minValue() + d_interval.width() / 2.0, 0.0);
d_paintedPoints0 = 0;
d_paintedPoints1 = 0;
replot();
}
QVector<double> qwtTickList( const QwtScaleDiv &scaleDiv )
{
QVector<double> values;
double lowerLimit = scaleDiv.interval().minValue();
double upperLimit = scaleDiv.interval().maxValue();
if ( upperLimit < lowerLimit )
qSwap( lowerLimit, upperLimit );
values += lowerLimit;
for ( int tickType = QwtScaleDiv::MinorTick;
tickType < QwtScaleDiv::NTickTypes; tickType++ )
{
const QList<double> ticks = scaleDiv.ticks( tickType );
for ( int i = 0; i < ticks.count(); i++ )
{
const double v = ticks[i];
if ( v > lowerLimit && v < upperLimit )
values += v;
}
}
values += upperLimit;
return values;
}
void ScaleDraw::drawTick(QPainter *p, double value, int len) const
{
QwtScaleDiv scDiv = scaleDiv();
QwtValueList majTicks = scDiv.ticks(QwtScaleDiv::MajorTick);
if (majTicks.contains(value) && (d_majTicks == In || d_majTicks == None))
return;
QwtValueList medTicks = scDiv.ticks(QwtScaleDiv::MediumTick);
if (medTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtValueList minTicks = scDiv.ticks(QwtScaleDiv::MinorTick);
if (minTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtScaleDraw::drawTick(p, value, len);
}
QwtText QwtTextScaleDraw::label(double value) const
{
const QwtScaleDiv scDiv = scaleDiv();
if (!scDiv.contains (value))
return QwtText();
QwtValueList lst = scDiv.ticks (QwtScaleDiv::MajorTick);
lst.pop_front();
lst.pop_back();
int index = lst.indexOf(value);
if (index >= 0 && index < (int)labels.count())
return QwtText(labels[index]);
else
return QwtText();
}
KnobSpin::KnobSpin(const QString &title, double min, double max, double step, QWidget *parent):
QWidget(parent)
{
QFont font("Helvetica", 10);
knob_ = new QwtKnob(this);
knob_->setFont(font);
knob_->setRange(min, max);
QwtScaleDiv scaleDiv =
knob_->scaleEngine()->divideScale(min, max, 5, 3);
QList<double> ticks = scaleDiv.ticks(QwtScaleDiv::MajorTick);
if ( ticks.size() > 0 && ticks[0] > min )
{
if ( ticks.first() > min )
ticks.prepend(min);
if ( ticks.last() < max )
ticks.append(max);
}
scaleDiv.setTicks(QwtScaleDiv::MajorTick, ticks);
knob_->setScale(scaleDiv);
knob_->setKnobWidth(150);
knob_->setStep(step);
spin_ = new QDoubleSpinBox(this);
spin_->setRange(min, max);
spin_->setSingleStep(step);
font.setBold(true);
label_ = new QLabel(title, this);
label_->setFont(font);
label_->setAlignment(Qt::AlignTop | Qt::AlignHCenter);
setSizePolicy(QSizePolicy::MinimumExpanding,
QSizePolicy::MinimumExpanding);
connect(spin_, SIGNAL(valueChanged(double)),
this, SIGNAL(valueChanged(double)));
connect(knob_, SIGNAL(valueChanged(double)),
spin_, SLOT(setValue(double)) );
connect(spin_, SIGNAL(valueChanged(double)),
knob_, SLOT(setValue(double)) );
}
void Plot::setTransformation( QwtTransform *transform )
{
QwtLinearScaleEngine *scaleEngine = new QwtLinearScaleEngine();
scaleEngine->setTransformation( transform );
setAxisScaleEngine( QwtAxis::xBottom, scaleEngine );
// we have to reassign the axis settinge, because they are
// invalidated, when the scale engine has changed
QwtScaleDiv scaleDiv =
axisScaleEngine( QwtAxis::xBottom )->divideScale( 10.0, 1000.0, 8, 10 );
QList<double> ticks;
ticks += 10.0;
ticks += scaleDiv.ticks( QwtScaleDiv::MajorTick );
scaleDiv.setTicks( QwtScaleDiv::MajorTick, ticks );
setAxisScaleDiv( QwtAxis::xBottom, scaleDiv );
replot();
}
/**
* Set the scale of the horizontal axis
* @param from :: Minimum value
* @param to :: Maximum value
*/
void OneCurvePlot::setXScale(double from, double to)
{
QFontMetrics fm(axisFont(QwtPlot::xBottom));
int n = from != 0.0 ? abs(static_cast<int>(floor(log10(fabs(from))))) : 0;
int n1 = to != 0.0 ? abs(static_cast<int>(floor(log10(fabs(to))))) : 0;
if (n1 > n) n = n1;
n += 4;
// approxiamte width of a tick label in pixels
int labelWidth = n * fm.width("0");
// calculate number of major ticks
int nMajorTicks = this->width() / labelWidth;
if ( nMajorTicks > 6 ) nMajorTicks = 6;
// try creating a scale
const QwtScaleDiv div = axisScaleEngine(QwtPlot::xBottom)->divideScale(from,to,nMajorTicks,nMajorTicks);
// Major ticks are placed at round numbers so the first or last tick could be missing making
// scale look ugly. Trying to fix it if possible
bool rescaled = false;
// get actual tick positions
const QwtValueList& ticks = div.ticks(QwtScaleDiv::MajorTick);
if (!ticks.empty() && ticks.size() < nMajorTicks)
{
// how much first tick is shifted from the lower bound
double firstShift = ticks.front() - div.lBound();
// how much last tick is shifted from the upper bound
double lastShift = div.hBound() - ticks.back();
// range of the scale
double range = fabs(div.hBound() - div.lBound());
// we say that 1st tick is missing if first tick is father away from its end of the scale
// than the last tick is from its end
bool isFirstMissing = fabs(firstShift) > fabs(lastShift) ;
// if first tick is missing
if (isFirstMissing)
{
// distance between nearest major ticks
double tickSize = 0;
if (ticks.size() == 1)
{
// guess the tick size in case of only one visible
double tickLog = log10(firstShift);
tickLog = tickLog > 0 ? ceil(tickLog) : floor(tickLog);
tickSize = pow(10.,tickLog);
}
else if (ticks.size() > 1)
{
// take the difference between the two first ticks
tickSize = ticks[1] - ticks[0];
}
// claculate how much lower bound must be moved to make the missing tick visible
double shift = (ticks.front() - tickSize) - from;
// if the shift is not very big rescale the axis
if (fabs(shift/range) < 0.1)
{
from += shift;
const QwtScaleDiv updatedDiv = axisScaleEngine(QwtPlot::xBottom)->divideScale(from,to,nMajorTicks,nMajorTicks);
setAxisScaleDiv(xBottom,updatedDiv);
rescaled = true;
}
}
else // last tick is missing
{
// distance between nearest major ticks
double tickSize = 0;
if (ticks.size() == 1)
{
// guess the tick size in case of only one visible
double tickLog = log10(lastShift);
tickLog = tickLog > 0 ? ceil(tickLog) : floor(tickLog);
tickSize = pow(10.,tickLog);
}
else if (ticks.size() > 1)
{
// take the difference between the two first ticks
tickSize = ticks[1] - ticks[0];
}
// claculate how much upper bound must be moved to make the missing tick visible
double shift = (ticks.back() + tickSize) - to;
// if the shift is not very big rescale the axis
if (fabs(shift/range) < 0.1)
{
to += shift;
const QwtScaleDiv updatedDiv = axisScaleEngine(QwtPlot::xBottom)->divideScale(from,to,nMajorTicks,nMajorTicks);
setAxisScaleDiv(xBottom,updatedDiv);
rescaled = true;
}
}
}
if (!rescaled)
{
setAxisScaleDiv(xBottom,div);
}
m_zoomer->setZoomBase();
}
QwtText ScaleDraw::label(double value) const
{
switch (d_type){
case Numeric:
{
QLocale locale = ((Graph *)d_plot->parent())->multiLayer()->locale();
if (d_numeric_format == Superscripts){
QString txt = locale.toString(transformValue(value), 'e', d_prec);
QStringList list = txt.split("e", QString::SkipEmptyParts);
if (list[0].toDouble() == 0.0)
return QString("0");
QString s = list[1];
int l = s.length();
QChar sign = s[0];
s.remove (sign);
while (l>1 && s.startsWith ("0", false)){
s.remove ( 0, 1 );
l = s.length();
}
if (sign == '-')
s.prepend(sign);
if (list[0] == "1")
return QwtText("10<sup>" + s + "</sup>");
else
return QwtText(list[0] + "x10<sup>" + s + "</sup>");
} else
return QwtText(locale.toString(transformValue(value), d_fmt, d_prec));
break;
}
case Day:
{
int val = static_cast<int>(transformValue(value))%7;
if (val < 0)
val = 7 - abs(val);
else if (val == 0)
val = 7;
QString day;
switch(d_name_format){
case ShortName:
day = QDate::shortDayName (val);
break;
case LongName:
day = QDate::longDayName (val);
break;
case Initial:
day = (QDate::shortDayName (val)).left(1);
break;
}
return QwtText(day);
break;
}
case Month:
{
int val = static_cast<int>(transformValue(value))%12;
if (val < 0)
val = 12 - abs(val);
else if (val == 0)
val = 12;
QString day;
switch(d_name_format){
case ShortName:
day = QDate::shortMonthName (val);
break;
case LongName:
day = QDate::longMonthName (val);
break;
case Initial:
day = (QDate::shortMonthName (val)).left(1);
break;
}
return QwtText(day);
break;
}
case Time:
return QwtText(d_date_time_origin.time().addMSecs((int)value).toString(d_format_info));
break;
case Date:
return QwtText(d_date_time_origin.addSecs((int)value).toString(d_format_info));
break;
case ColHeader:
case Text:
{
const QwtScaleDiv scDiv = scaleDiv();
if (!scDiv.contains (value))
return QwtText();
QwtValueList ticks = scDiv.ticks (QwtScaleDiv::MajorTick);
double break_offset = 0;
ScaleEngine *se = (ScaleEngine *)d_plot->axisScaleEngine(axis());
/*QwtScaleEngine *qwtsc_engine=d_plot->axisScaleEngine(axis());
ScaleEngine *se =dynamic_cast<ScaleEngine*>(qwtsc_engine);
if(se!=NULL)
{*/
bool inverted = se->testAttribute(QwtScaleEngine::Inverted);
if(se->hasBreak()){
double lb = se->axisBreakLeft();
double rb = se->axisBreakRight();
if(inverted){
if (value <= lb){
int n_ticks = (int)ticks.count() - 1;
double val0 = ticks[0];
double val1 = ticks[n_ticks];
for (int i = 1; i < n_ticks; i++){
double aux = ticks[i];
if(aux >= rb && val0 > aux){
val0 = aux;
continue;
}
if(aux <= lb && val1 < aux)
val1 = aux;
}
break_offset = fabs(val1 - val0);
}
} else {
if (value >= rb){
double val0 = ticks[0];
for (int i = 1; i < (int)ticks.count(); i++){
double val = ticks[i];
if(val0 <= lb && val >= rb){
break_offset = fabs(val - val0);
break;
}
val0 = val;
}
}
}
}
double step = ticks[1] - ticks[0];
int index = static_cast<int>(ticks[0] + step*ticks.indexOf(value) - 1);
int offset = abs((int)floor(break_offset/step));
if (offset)
offset--;
if (step > 0)
index += offset;
else
index -= offset;
if (index >= 0 && index < (int)d_text_labels.count())
return QwtText(d_text_labels[index]);
else
return QwtText();
//}
break;
}
}
return QwtText();
}
void QwtPolarGrid::updateScaleDiv( const QwtScaleDiv &azimuthScaleDiv,
const QwtScaleDiv &radialScaleDiv, const QwtDoubleInterval &interval )
{
GridData &radialGrid = d_data->gridData[QwtPolar::Radius];
const QwtPolarPlot *plt = plot();
if ( plt && testGridAttribute( AutoScaling ) )
{
const QwtScaleEngine *se = plt->scaleEngine( QwtPolar::Radius );
radialGrid.scaleDiv = se->divideScale(
interval.minValue(), interval.maxValue(),
plt->scaleMaxMajor( QwtPolar::Radius ),
plt->scaleMaxMinor( QwtPolar::Radius ), 0 );
}
else
{
if ( radialGrid.scaleDiv != radialScaleDiv )
radialGrid.scaleDiv = radialScaleDiv;
}
GridData &azimuthGrid = d_data->gridData[QwtPolar::Azimuth];
if ( azimuthGrid.scaleDiv != azimuthScaleDiv )
{
azimuthGrid.scaleDiv = azimuthScaleDiv;
}
bool hasOrigin = false;
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
AxisData &axis = d_data->axisData[axisId];
if ( axis.isVisible && axis.scaleDraw )
{
if ( axisId == QwtPolar::AxisAzimuth )
{
axis.scaleDraw->setScaleDiv( azimuthGrid.scaleDiv );
if ( testDisplayFlag( SmartScaleDraw ) )
{
axis.scaleDraw->enableComponent(
QwtAbstractScaleDraw::Ticks, !azimuthGrid.isVisible );
}
}
else
{
QwtScaleDiv sd = radialGrid.scaleDiv;
QwtValueList &ticks =
( QwtValueList & )sd.ticks( QwtScaleDiv::MajorTick );
if ( testDisplayFlag( SmartOriginLabel ) )
{
bool skipOrigin = hasOrigin;
if ( !skipOrigin )
{
if ( axisId == QwtPolar::AxisLeft
|| axisId == QwtPolar::AxisRight )
{
if ( d_data->axisData[QwtPolar::AxisBottom].isVisible )
skipOrigin = true;
}
else
{
if ( d_data->axisData[QwtPolar::AxisLeft].isVisible )
skipOrigin = true;
}
}
#if QWT_VERSION < 0x050200
if ( ticks.size() > 0 && ticks.first() == sd.lBound() )
#else
if ( ticks.size() > 0 && ticks.first() == sd.lowerBound() )
#endif
{
if ( skipOrigin )
{
#if QT_VERSION < 0x040000
ticks.pop_front();
#else
ticks.removeFirst();
#endif
}
else
hasOrigin = true;
}
}
if ( testDisplayFlag( HideMaxRadiusLabel ) )
{
#if QWT_VERSION < 0x050200
if ( ticks.size() > 0 && ticks.last() == sd.hBound() )
#else
if ( ticks.size() > 0 && ticks.last() == sd.upperBound() )
#endif
#if QT_VERSION < 0x040000
ticks.pop_back();
#else
ticks.removeLast();
#endif
}
axis.scaleDraw->setScaleDiv( sd );
if ( testDisplayFlag( SmartScaleDraw ) )
{
axis.scaleDraw->enableComponent(
QwtAbstractScaleDraw::Ticks, !radialGrid.isVisible );
}
}
}
}
}
QString ScaleDraw::labelString(double value) const
{
switch (d_type){
case Numeric:
{
QLocale locale = d_plot->locale();
if (d_plot->parent())
locale = d_plot->multiLayer()->locale();
if ((d_numeric_format == Superscripts)||(d_numeric_format == SuperscriptsGER)){
QString txt = locale.toString(transformValue(value), 'e', d_prec);
QStringList list = txt.split("e", QString::SkipEmptyParts);
if (list.isEmpty())
return QString::null;
if (list[0].toDouble() == 0.0)
return "0";
QString s = list[1];
int l = s.length();
QChar sign = s[0];
s.remove (sign);
while (l>1 && s.startsWith ("0", false)){
s.remove ( 0, 1 );
l = s.length();
}
if (sign == '-')
s.prepend(sign);
if (list[0] == "1")
return "10<sup>" + s + "</sup>";
else {
if (d_numeric_format == SuperscriptsGER)
return list[0] + "·10<sup>" + s + "</sup>";
else
return list[0] + QString(QChar(0x00D7)) + "10<sup>" + s + "</sup>";
}
} else if (d_numeric_format == Engineering){
QString eng_suff;
double new_value = value;
if(fabs(new_value) >= 1e18){
eng_suff = 'E';
new_value /= 1e18;
} else if(fabs(new_value) >= 1e15){
eng_suff = 'P';
new_value /= 1e15;
} else if(fabs(new_value) >= 1e12){
eng_suff = 'T';
new_value /= 1e12;
} else if(fabs(new_value) >= 1e9){
eng_suff = 'G';
new_value /= 1e9;
} else if(fabs(new_value) >= 1e6){
eng_suff = 'M';
new_value /= 1e6;
} else if(fabs(new_value) >= 1e3){
eng_suff = 'k';
new_value /= 1e3;
} else if(fabs(new_value) >= 1){
eng_suff = "";
new_value /= 1.0;
} else if(fabs(new_value) >= 1e-3){
eng_suff = 'm';
new_value /= 1e-3;
} else if(fabs(new_value) >= 1e-6){
eng_suff = 'µ';
new_value /= 1e-6;
} else if(fabs(new_value) >= 1e-9){
eng_suff = 'n';
new_value /= 1e-9;
} else if(fabs(new_value) >= 1e-12){
eng_suff = 'p';
new_value /= 1e-12;
} else if(fabs(new_value) >= 1e-15){
eng_suff = 'f';
new_value /= 1e-15;
} else {
eng_suff = 'a';
new_value /= 1e-18;
}
QString txt = locale.toString((new_value), 'f', d_prec);
if(txt.contains(QRegExp("^0[\\.,]?0*$")))
return "0";
return txt + eng_suff;
} else
return locale.toString(transformValue(value), d_fmt, d_prec);
break;
}
case Day:
{
int val = int(transformValue(value))%7;
if (val < 0)
val = 7 - abs(val);
else if (val == 0)
val = 7;
QString day;
switch(d_name_format){
case ShortName:
day = QDate::shortDayName (val);
break;
case LongName:
day = QDate::longDayName (val);
break;
case Initial:
day = (QDate::shortDayName (val)).left(1);
break;
}
return day;
break;
}
case Month:
{
int val = int(transformValue(value))%12;
if (val < 0)
val = 12 - abs(val);
else if (val == 0)
val = 12;
QString day;
switch(d_name_format){
case ShortName:
day = QDate::shortMonthName (val);
break;
case LongName:
day = QDate::longMonthName (val);
break;
case Initial:
day = (QDate::shortMonthName (val)).left(1);
break;
}
return day;
break;
}
case Time:
{
QTime time = Table::dateTime(value).time();
if (d_format_info == "M")
return QString::number(60*time.hour() + time.minute());
else if (d_format_info == "S")
return QString::number(3600*time.hour() + 60*time.minute() + time.second());
return time.toString(d_format_info);
break;
}
case Date:
return Table::dateTime(value).toString(d_format_info);
break;
case ColHeader:
case Text:
{
const QwtScaleDiv scDiv = scaleDiv();
if (!scDiv.contains (value) || floor(value) < value)
return QString::null;
QwtValueList ticks = scDiv.ticks (QwtScaleDiv::MajorTick);
double break_offset = 0;
ScaleEngine *se = (ScaleEngine *)d_plot->axisScaleEngine(axis());
bool inverted = se->testAttribute(QwtScaleEngine::Inverted);
if(se->hasBreak()){
double lb = se->axisBreakLeft();
double rb = se->axisBreakRight();
if(inverted){
if (value <= lb){
int n_ticks = (int)ticks.count() - 1;
double val0 = ticks[0];
double val1 = ticks[n_ticks];
for (int i = 1; i < n_ticks; i++){
double aux = ticks[i];
if(aux >= rb && val0 > aux){
val0 = aux;
continue;
}
if(aux <= lb && val1 < aux)
val1 = aux;
}
break_offset = fabs(val1 - val0);
}
} else {
if (value >= rb){
double val0 = ticks[0];
for (int i = 1; i < (int)ticks.count(); i++){
double val = ticks[i];
if(val0 <= lb && val >= rb){
break_offset = fabs(val - val0);
break;
}
val0 = val;
}
}
}
}
if (ticks.size() < 2)
return QString::null;
double step = ticks[1] - ticks[0];
int index = int(ticks[0] + step*ticks.indexOf(value) - 1);
int offset = abs((int)floor(break_offset/step));
if (offset)
offset--;
if (step > 0)
index += offset;
else
index -= offset;
if (index >= 0 && index < (int)d_text_labels.count())
return d_text_labels[index];
else
return QString::null;
break;
}
}
return QString::null;
}
void ScaleDraw::drawTick(QPainter *p, double value, int len) const
{
ScaleEngine *sc_engine = (ScaleEngine *)d_plot->axisScaleEngine(axis());
/*QwtScaleEngine *qwtsc_engine=d_plot->axisScaleEngine(axis());
ScaleEngine *sc_engine =dynamic_cast< ScaleEngine*>(qwtsc_engine);
if(sc_engine!=NULL)
{*/
if (sc_engine->hasBreak()){
int align = alignment();
bool invertedScale = sc_engine->testAttribute(QwtScaleEngine::Inverted);
if (align == BottomScale || align == LeftScale){
if (invertedScale && sc_engine->axisBreakRight() == value)
return;
if (!invertedScale && sc_engine->axisBreakLeft() == value)
return;
} else {
if (!invertedScale && sc_engine->axisBreakRight() == value)
return;
if (invertedScale && sc_engine->axisBreakLeft() == value)
return;
}
}
//}
QwtScaleDiv scDiv = scaleDiv();
QwtValueList majTicks = scDiv.ticks(QwtScaleDiv::MajorTick);
if (majTicks.contains(value) && (d_majTicks == In || d_majTicks == None))
return;
QwtValueList medTicks = scDiv.ticks(QwtScaleDiv::MediumTick);
if (medTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtValueList minTicks = scDiv.ticks(QwtScaleDiv::MinorTick);
if (minTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtScaleDraw::drawTick(p, value, len);
}
