Skip to content
GitLab
Commit c96458cf authored by Bryant's avatar Bryant
Browse files

Update Qwt to 6.1. 

We also document how we got the source code and keep our modifications out of the Qwt directory.
parent 2e4ac6be
Expand all Hide whitespace changes
Inline Side-by-side
libs/README.md 0 → 100644
View file @ c96458cf
This folder contains the various required libraries for QGC to compile. They are distributed with the codebase to ease development.
# Qwt
Qt Widgets for Technical Applications
Version: 6.1
Source obtained: `svn checkout svn://svn.code.sf.net/p/qwt/code/branches/qwt-6.1 qwt`
Contents of `/libs/qwt` is the contents of the `/src` directory from the Qwt repository.
qwt.pri file is custom made to compile all necessary Qwt code in with QGC.
libs/qwt.pri 0 → 100644
View file @ c96458cf
######################################################################
# Automatically generated by qmake (2.01a) Wed Feb 10 11:43:43 2010
######################################################################
QWTSRCDIR = libs/qwt
DEPENDPATH += $$QWTSRCDIR
INCLUDEPATH += $$QWTSRCDIR
# Input
HEADERS += $$QWTSRCDIR/qwt.h \
$$QWTSRCDIR/qwt_abstract_legend.h \
$$QWTSRCDIR/qwt_abstract_scale.h \
$$QWTSRCDIR/qwt_abstract_scale_draw.h \
$$QWTSRCDIR/qwt_abstract_slider.h \
$$QWTSRCDIR/qwt_analog_clock.h \
$$QWTSRCDIR/qwt_arrow_button.h \
$$QWTSRCDIR/qwt_clipper.h \
$$QWTSRCDIR/qwt_color_map.h \
$$QWTSRCDIR/qwt_compass.h \
$$QWTSRCDIR/qwt_compass_rose.h \
$$QWTSRCDIR/qwt_counter.h \
$$QWTSRCDIR/qwt_curve_fitter.h \
$$QWTSRCDIR/qwt_dial.h \
$$QWTSRCDIR/qwt_dial_needle.h \
$$QWTSRCDIR/qwt_dyngrid_layout.h \
$$QWTSRCDIR/qwt_event_pattern.h \
$$QWTSRCDIR/qwt_global.h \
$$QWTSRCDIR/qwt_graphic.h \
$$QWTSRCDIR/qwt_interval.h \
$$QWTSRCDIR/qwt_knob.h \
$$QWTSRCDIR/qwt_legend.h \
$$QWTSRCDIR/qwt_legend_data.h \
$$QWTSRCDIR/qwt_legend_label.h \
$$QWTSRCDIR/qwt_magnifier.h \
$$QWTSRCDIR/qwt_math.h \
$$QWTSRCDIR/qwt_null_paintdevice.h \
$$QWTSRCDIR/qwt_painter.h \
$$QWTSRCDIR/qwt_painter_command.h \
$$QWTSRCDIR/qwt_panner.h \
$$QWTSRCDIR/qwt_picker.h \
$$QWTSRCDIR/qwt_picker_machine.h \
$$QWTSRCDIR/qwt_pixel_matrix.h \
$$QWTSRCDIR/qwt_plot.h \
$$QWTSRCDIR/qwt_plot_canvas.h \
$$QWTSRCDIR/qwt_plot_curve.h \
$$QWTSRCDIR/qwt_plot_dict.h \
$$QWTSRCDIR/qwt_plot_grid.h \
$$QWTSRCDIR/qwt_plot_item.h \
$$QWTSRCDIR/qwt_plot_layout.h \
$$QWTSRCDIR/qwt_plot_magnifier.h \
$$QWTSRCDIR/qwt_plot_marker.h \
$$QWTSRCDIR/qwt_plot_panner.h \
$$QWTSRCDIR/qwt_plot_picker.h \
$$QWTSRCDIR/qwt_plot_rasteritem.h \
$$QWTSRCDIR/qwt_plot_scaleitem.h \
$$QWTSRCDIR/qwt_plot_seriesitem.h \
$$QWTSRCDIR/qwt_plot_spectrogram.h \
$$QWTSRCDIR/qwt_plot_svgitem.h \
$$QWTSRCDIR/qwt_plot_zoomer.h \
$$QWTSRCDIR/qwt_point_mapper.h \
$$QWTSRCDIR/qwt_point_data.h \
$$QWTSRCDIR/qwt_raster_data.h \
$$QWTSRCDIR/qwt_round_scale_draw.h \
$$QWTSRCDIR/qwt_scale_div.h \
$$QWTSRCDIR/qwt_scale_draw.h \
$$QWTSRCDIR/qwt_scale_engine.h \
$$QWTSRCDIR/qwt_scale_map.h \
$$QWTSRCDIR/qwt_scale_widget.h \
$$QWTSRCDIR/qwt_series_data.h \
$$QWTSRCDIR/qwt_slider.h \
$$QWTSRCDIR/qwt_spline.h \
$$QWTSRCDIR/qwt_symbol.h \
$$QWTSRCDIR/qwt_text.h \
$$QWTSRCDIR/qwt_text_engine.h \
$$QWTSRCDIR/qwt_text_label.h \
$$QWTSRCDIR/qwt_thermo.h \
$$QWTSRCDIR/qwt_transform.h \
$$QWTSRCDIR/qwt_wheel.h \
$$QWTSRCDIR/qwt_widget_overlay.h
SOURCES += $$QWTSRCDIR/qwt_abstract_legend.cpp \
$$QWTSRCDIR/qwt_abstract_scale.cpp \
$$QWTSRCDIR/qwt_abstract_scale_draw.cpp \
$$QWTSRCDIR/qwt_abstract_slider.cpp \
$$QWTSRCDIR/qwt_analog_clock.cpp \
$$QWTSRCDIR/qwt_arrow_button.cpp \
$$QWTSRCDIR/qwt_clipper.cpp \
$$QWTSRCDIR/qwt_color_map.cpp \
$$QWTSRCDIR/qwt_compass.cpp \
$$QWTSRCDIR/qwt_compass_rose.cpp \
$$QWTSRCDIR/qwt_counter.cpp \
$$QWTSRCDIR/qwt_curve_fitter.cpp \
$$QWTSRCDIR/qwt_dial.cpp \
$$QWTSRCDIR/qwt_dial_needle.cpp \
$$QWTSRCDIR/qwt_dyngrid_layout.cpp \
$$QWTSRCDIR/qwt_event_pattern.cpp \
$$QWTSRCDIR/qwt_graphic.cpp \
$$QWTSRCDIR/qwt_interval.cpp \
$$QWTSRCDIR/qwt_knob.cpp \
$$QWTSRCDIR/qwt_legend.cpp \
$$QWTSRCDIR/qwt_legend_data.cpp \
$$QWTSRCDIR/qwt_legend_label.cpp \
$$QWTSRCDIR/qwt_magnifier.cpp \
$$QWTSRCDIR/qwt_math.cpp \
$$QWTSRCDIR/qwt_null_paintdevice.cpp \
$$QWTSRCDIR/qwt_painter.cpp \
$$QWTSRCDIR/qwt_painter_command.cpp \
$$QWTSRCDIR/qwt_panner.cpp \
$$QWTSRCDIR/qwt_picker.cpp \
$$QWTSRCDIR/qwt_picker_machine.cpp \
$$QWTSRCDIR/qwt_pixel_matrix.cpp \
$$QWTSRCDIR/qwt_plot.cpp \
$$QWTSRCDIR/qwt_plot_axis.cpp \
$$QWTSRCDIR/qwt_plot_canvas.cpp \
$$QWTSRCDIR/qwt_plot_curve.cpp \
$$QWTSRCDIR/qwt_plot_dict.cpp \
$$QWTSRCDIR/qwt_plot_grid.cpp \
$$QWTSRCDIR/qwt_plot_item.cpp \
$$QWTSRCDIR/qwt_plot_layout.cpp \
$$QWTSRCDIR/qwt_plot_magnifier.cpp \
$$QWTSRCDIR/qwt_plot_marker.cpp \
$$QWTSRCDIR/qwt_plot_panner.cpp \
$$QWTSRCDIR/qwt_plot_picker.cpp \
$$QWTSRCDIR/qwt_plot_rasteritem.cpp \
$$QWTSRCDIR/qwt_plot_scaleitem.cpp \
$$QWTSRCDIR/qwt_plot_seriesitem.cpp \
$$QWTSRCDIR/qwt_plot_spectrogram.cpp \
$$QWTSRCDIR/qwt_plot_svgitem.cpp \
$$QWTSRCDIR/qwt_plot_xml.cpp \
$$QWTSRCDIR/qwt_plot_zoomer.cpp \
$$QWTSRCDIR/qwt_point_mapper.cpp \
$$QWTSRCDIR/qwt_point_data.cpp \
$$QWTSRCDIR/qwt_raster_data.cpp \
$$QWTSRCDIR/qwt_round_scale_draw.cpp \
$$QWTSRCDIR/qwt_scale_div.cpp \
$$QWTSRCDIR/qwt_scale_draw.cpp \
$$QWTSRCDIR/qwt_scale_engine.cpp \
$$QWTSRCDIR/qwt_scale_map.cpp \
$$QWTSRCDIR/qwt_scale_widget.cpp \
$$QWTSRCDIR/qwt_series_data.cpp \
$$QWTSRCDIR/qwt_slider.cpp \
$$QWTSRCDIR/qwt_spline.cpp \
$$QWTSRCDIR/qwt_symbol.cpp \
$$QWTSRCDIR/qwt_text.cpp \
$$QWTSRCDIR/qwt_text_engine.cpp \
$$QWTSRCDIR/qwt_text_label.cpp \
$$QWTSRCDIR/qwt_thermo.cpp \
$$QWTSRCDIR/qwt_transform.cpp \
$$QWTSRCDIR/qwt_wheel.cpp \
$$QWTSRCDIR/qwt_widget_overlay.cpp
libs/qwt/qwt_abstract_legend.cpp 0 → 100644
View file @ c96458cf
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
* Qwt Widget Library
* Copyright (C) 1997 Josef Wilgen
* Copyright (C) 2002 Uwe Rathmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
#include "qwt_abstract_legend.h"
/*!
Constructor
\param parent Parent widget
*/
QwtAbstractLegend::QwtAbstractLegend( QWidget *parent ):
QFrame( parent )
{
}
//! Destructor
QwtAbstractLegend::~QwtAbstractLegend()
{
}
/*!
Return the extent, that is needed for elements to scroll
the legend ( usually scrollbars ),
\param orientation Orientation
\return Extent of the corresponding scroll element
*/
int QwtAbstractLegend::scrollExtent( Qt::Orientation orientation ) const
{
Q_UNUSED( orientation );
return 0;
}
libs/qwt/qwt_abstract_legend.h 0 → 100644
View file @ c96458cf
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
* Qwt Widget Library
* Copyright (C) 1997 Josef Wilgen
* Copyright (C) 2002 Uwe Rathmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
#ifndef QWT_ABSTRACT_LEGEND_H
#define QWT_ABSTRACT_LEGEND_H
#include "qwt_global.h"
#include "qwt_legend_data.h"
#include <qframe.h>
#include <qlist.h>
class QVariant;
/*!
\brief Abstract base class for legend widgets
Legends, that need to be under control of the QwtPlot layout system
need to be derived from QwtAbstractLegend.
\note Other type of legends can be implemented by connecting to
the QwtPlot::legendDataChanged() signal. But as these legends
are unknown to the plot layout system the layout code
( on screen and for QwtPlotRenderer ) need to be organized
in application code.
\sa QwtLegend
*/
class QWT_EXPORT QwtAbstractLegend : public QFrame
{
Q_OBJECT
public:
explicit QwtAbstractLegend( QWidget *parent = NULL );
virtual ~QwtAbstractLegend();
/*!
Render the legend into a given rectangle.
\param painter Painter
\param rect Bounding rectangle
\param fillBackground When true, fill rect with the widget background
\sa renderLegend() is used by QwtPlotRenderer
*/
virtual void renderLegend( QPainter *painter,
const QRectF &rect, bool fillBackground ) const = 0;
//! \return True, when no plot item is inserted
virtual bool isEmpty() const = 0;
virtual int scrollExtent( Qt::Orientation ) const;
public Q_SLOTS:
/*!
\brief Update the entries for a plot item
\param itemInfo Info about an item
\param data List of legend entry attributes for the item
*/
virtual void updateLegend( const QVariant &itemInfo,
const QList<QwtLegendData> &data ) = 0;
};
#endif
libs/qwt/qwt_abstract_scale.cpp
View file @ c96458cf
......@@ -7,26 +7,27 @@
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
#include "qwt_abstract_scale.h"
#include "qwt_scale_engine.h"
#include "qwt_scale_draw.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_double_interval.h"
#include "qwt_abstract_scale.h"
#include "qwt_interval.h"
class QwtAbstractScale::PrivateData
{
public:
PrivateData():
maxMajor(5),
maxMinor(3),
stepSize(0.0),
autoScale(true) {
scaleEngine = new QwtLinearScaleEngine;
maxMajor( 5 ),
maxMinor( 3 ),
stepSize( 0.0 )
{
scaleEngine = new QwtLinearScaleEngine();
scaleDraw = new QwtScaleDraw();
}
~PrivateData() {
~PrivateData()
{
delete scaleEngine;
delete scaleDraw;
}
......@@ -37,21 +38,25 @@ public:
int maxMajor;
int maxMinor;
double stepSize;
bool autoScale;
};
/*!
Constructor
\param parent Parent widget
Creates a default QwtScaleDraw and a QwtLinearScaleEngine.
Autoscaling is enabled, and the stepSize is initialized by 0.0.
The initial scale boundaries are set to [ 0.0, 100.0 ]
The scaleStepSize() is initialized to 0.0, scaleMaxMajor() to 5
and scaleMaxMajor to 3.
*/
QwtAbstractScale::QwtAbstractScale()
QwtAbstractScale::QwtAbstractScale( QWidget *parent ):
QWidget( parent )
{
d_data = new PrivateData;
rescale(0.0, 100.0);
rescale( 0.0, 100.0, d_data->stepSize );
}
//! Destructor
......@@ -61,138 +66,166 @@ QwtAbstractScale::~QwtAbstractScale()
}
/*!
\brief Specify a scale.
Set the lower bound of the scale
Disable autoscaling and define a scale by an interval and a step size
\param value Lower bound
\param vmin lower limit of the scale interval
\param vmax upper limit of the scale interval
\param stepSize major step size
\sa setAutoScale()
\sa lowerBound(), setScale(), setUpperBound()
\note For inverted scales the lower bound
is greater than the upper bound
*/
void QwtAbstractScale::setScale(double vmin, double vmax, double stepSize)
void QwtAbstractScale::setLowerBound( double value )
{
d_data->autoScale = false;
d_data->stepSize = stepSize;
setScale( value, upperBound() );
}
rescale(vmin, vmax, stepSize);
/*!
\return Lower bound of the scale
\sa setLowerBound(), setScale(), upperBound()
*/
double QwtAbstractScale::lowerBound() const
{
return d_data->scaleDraw->scaleDiv().lowerBound();
}
/*!
\brief Specify a scale.
Set the upper bound of the scale
Disable autoscaling and define a scale by an interval and a step size
\param value Upper bound
\param interval Interval
\param stepSize major step size
\sa setAutoScale()
\sa upperBound(), setScale(), setLowerBound()
\note For inverted scales the lower bound
is greater than the upper bound
*/
void QwtAbstractScale::setScale(const QwtDoubleInterval &interval,
double stepSize)
void QwtAbstractScale::setUpperBound( double value )
{
setScale(interval.minValue(), interval.maxValue(), stepSize);
setScale( lowerBound(), value );
}
/*!
\return Upper bound of the scale
\sa setUpperBound(), setScale(), lowerBound()
*/
double QwtAbstractScale::upperBound() const
{
return d_data->scaleDraw->scaleDiv().upperBound();
}
/*!
\brief Specify a scale.
Disable autoscaling and define a scale by a scale division
Define a scale by an interval
\param scaleDiv Scale division
\sa setAutoScale()
The ticks are calculated using scaleMaxMinor(),
scaleMaxMajor() and scaleStepSize().
\param lowerBound lower limit of the scale interval
\param upperBound upper limit of the scale interval
\note For inverted scales the lower bound
is greater than the upper bound
*/
void QwtAbstractScale::setScale(const QwtScaleDiv &scaleDiv)
void QwtAbstractScale::setScale( double lowerBound, double upperBound )
{
d_data->autoScale = false;
if (scaleDiv != d_data->scaleDraw->scaleDiv()) {
d_data->scaleDraw->setScaleDiv(scaleDiv);
scaleChange();
}
rescale( lowerBound, upperBound, d_data->stepSize );
}
/*!
Recalculate the scale division and update the scale draw.
\brief Specify a scale.
\param vmin Lower limit of the scale interval
\param vmax Upper limit of the scale interval
\param stepSize Major step size
Define a scale by an interval
\sa scaleChange()
The ticks are calculated using scaleMaxMinor(),
scaleMaxMajor() and scaleStepSize().
\param interval Interval
*/
void QwtAbstractScale::rescale(double vmin, double vmax, double stepSize)
void QwtAbstractScale::setScale( const QwtInterval &interval )
{
const QwtScaleDiv scaleDiv = d_data->scaleEngine->divideScale(
vmin, vmax, d_data->maxMajor, d_data->maxMinor, stepSize);
if ( scaleDiv != d_data->scaleDraw->scaleDiv() ) {
d_data->scaleDraw->setTransformation(
d_data->scaleEngine->transformation());
d_data->scaleDraw->setScaleDiv(scaleDiv);
scaleChange();
}
setScale( interval.minValue(), interval.maxValue() );
}
/*!
\brief Advise the widget to control the scale range internally.
\brief Specify a scale.
Autoscaling is on by default.
\sa setScale(), autoScale()
scaleMaxMinor(), scaleMaxMajor() and scaleStepSize() and have no effect.
\param scaleDiv Scale division
\sa setAutoScale()
*/
void QwtAbstractScale::setAutoScale()
void QwtAbstractScale::setScale( const QwtScaleDiv &scaleDiv )
{
if (!d_data->autoScale) {
d_data->autoScale = true;
if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
{
#if 1
if ( d_data->scaleEngine )
{
d_data->scaleDraw->setTransformation(
d_data->scaleEngine->transformation() );
}
#endif
d_data->scaleDraw->setScaleDiv( scaleDiv );
scaleChange();
}
}
/*!
\return \c true if autoscaling is enabled
*/
bool QwtAbstractScale::autoScale() const
{
return d_data->autoScale;
}
/*!
\brief Set the maximum number of major tick intervals.
The scale's major ticks are calculated automatically such that
the number of major intervals does not exceed ticks.
The default value is 5.
\param ticks maximal number of major ticks.
\sa QwtAbstractScaleDraw
\param ticks Maximal number of major ticks.
\sa scaleMaxMajor(), setScaleMaxMinor(),
setScaleStepSize(), QwtScaleEngine::divideInterval()
*/
void QwtAbstractScale::setScaleMaxMajor(int ticks)
void QwtAbstractScale::setScaleMaxMajor( int ticks )
{
if (ticks != d_data->maxMajor) {
if ( ticks != d_data->maxMajor )
{
d_data->maxMajor = ticks;
updateScaleDraw();
}
}
/*!
\return Maximal number of major tick intervals
\sa setScaleMaxMajor(), scaleMaxMinor()
*/
int QwtAbstractScale::scaleMaxMajor() const
{
return d_data->maxMajor;
}
/*!
\brief Set the maximum number of minor tick intervals
The scale's minor ticks are calculated automatically such that
the number of minor intervals does not exceed ticks.
The default value is 3.
\param ticks
\sa QwtAbstractScaleDraw
\param ticks Maximal number of minor ticks.
\sa scaleMaxMajor(), setScaleMaxMinor(),
setScaleStepSize(), QwtScaleEngine::divideInterval()
*/
void QwtAbstractScale::setScaleMaxMinor(int ticks)
void QwtAbstractScale::setScaleMaxMinor( int ticks )
{
if ( ticks != d_data->maxMinor) {
if ( ticks != d_data->maxMinor )
{
d_data->maxMinor = ticks;
updateScaleDraw();
}
}
/*!
\return Max. number of minor tick intervals
The default value is 3.
\return Maximal number of minor tick intervals
\sa setScaleMaxMinor(), scaleMaxMajor()
*/
int QwtAbstractScale::scaleMaxMinor() const
{
......@@ -200,27 +233,52 @@ int QwtAbstractScale::scaleMaxMinor() const
}
/*!
\return Max. number of major tick intervals
The default value is 5.
\brief Set the step size used for calculating a scale division
The step size is hint for calculating the intervals for
the major ticks of the scale. A value of 0.0 is interpreted
as no hint.
\param stepSize Hint for the step size of the scale
\sa scaleStepSize(), QwtScaleEngine::divideScale()
\note Position and distance between the major ticks also
depends on scaleMaxMajor().
*/
int QwtAbstractScale::scaleMaxMajor() const
void QwtAbstractScale::setScaleStepSize( double stepSize )
{
return d_data->maxMajor;
if ( stepSize != d_data->stepSize )
{
d_data->stepSize = stepSize;
updateScaleDraw();
}
}
/*!
\return Hint for the step size of the scale
\sa setScaleStepSize(), QwtScaleEngine::divideScale()
*/
double QwtAbstractScale::scaleStepSize() const
{
return d_data->stepSize;
}
/*!
\brief Set a scale draw
scaleDraw has to be created with new and will be deleted in
~QwtAbstractScale or the next call of setAbstractScaleDraw.
the destructor or the next call of setAbstractScaleDraw().
\sa abstractScaleDraw()
*/
void QwtAbstractScale::setAbstractScaleDraw(QwtAbstractScaleDraw *scaleDraw)
void QwtAbstractScale::setAbstractScaleDraw( QwtAbstractScaleDraw *scaleDraw )
{
if ( scaleDraw == NULL || scaleDraw == d_data->scaleDraw )
return;
if ( d_data->scaleDraw != NULL )
scaleDraw->setScaleDiv(d_data->scaleDraw->scaleDiv());
scaleDraw->setScaleDiv( d_data->scaleDraw->scaleDiv() );
delete d_data->scaleDraw;
d_data->scaleDraw = scaleDraw;
......@@ -244,32 +302,27 @@ const QwtAbstractScaleDraw *QwtAbstractScale::abstractScaleDraw() const
return d_data->scaleDraw;
}
void QwtAbstractScale::updateScaleDraw()
{
rescale( d_data->scaleDraw->scaleDiv().lBound(),
d_data->scaleDraw->scaleDiv().hBound(), d_data->stepSize);
}
/*!
\brief Set a scale engine
The scale engine is responsible for calculating the scale division,
and in case of auto scaling how to align the scale.
The scale engine is responsible for calculating the scale division
and provides a transformation between scale and widget coordinates.
scaleEngine has to be created with new and will be deleted in
~QwtAbstractScale or the next call of setScaleEngine.
the destructor or the next call of setScaleEngine.
*/
void QwtAbstractScale::setScaleEngine(QwtScaleEngine *scaleEngine)
void QwtAbstractScale::setScaleEngine( QwtScaleEngine *scaleEngine )
{
if ( scaleEngine != NULL && scaleEngine != d_data->scaleEngine ) {
if ( scaleEngine != NULL && scaleEngine != d_data->scaleEngine )
{
delete d_data->scaleEngine;
d_data->scaleEngine = scaleEngine;
}
}
/*!
\return Scale engine
\sa setScaleEngine()
\return Scale engine
\sa setScaleEngine()
*/
const QwtScaleEngine *QwtAbstractScale::scaleEngine() const
{
......@@ -277,8 +330,8 @@ const QwtScaleEngine *QwtAbstractScale::scaleEngine() const
}
/*!
\return Scale engine
\sa setScaleEngine()
\return Scale engine
\sa setScaleEngine()
*/
QwtScaleEngine *QwtAbstractScale::scaleEngine()
{
......@@ -286,18 +339,111 @@ QwtScaleEngine *QwtAbstractScale::scaleEngine()
}
/*!
\brief Notify changed scale
\return Scale boundaries and positions of the ticks
Dummy empty implementation, intended to be overloaded by derived classes
*/
void QwtAbstractScale::scaleChange()
The scale division might have been assigned explicitly
or calculated implicitly by rescale().
*/
const QwtScaleDiv &QwtAbstractScale::scaleDiv() const
{
return d_data->scaleDraw->scaleDiv();
}
/*!
\return abstractScaleDraw()->scaleMap()
*/
\return Map to translate between scale and widget coordinates
*/
const QwtScaleMap &QwtAbstractScale::scaleMap() const
{
return d_data->scaleDraw->scaleMap();
}
/*!
Translate a scale value into a widget coordinate
\param value Scale value
\return Corresponding widget coordinate for value
\sa scaleMap(), invTransform()
*/
int QwtAbstractScale::transform( double value ) const
{
return qRound( d_data->scaleDraw->scaleMap().transform( value ) );
}
/*!
Translate a widget coordinate into a scale value
\param value Widget coordinate
\return Corresponding scale coordinate for value
\sa scaleMap(), transform()
*/
double QwtAbstractScale::invTransform( int value ) const
{
return d_data->scaleDraw->scaleMap().invTransform( value );
}
/*!
\return True, when the scale is increasing in opposite direction
to the widget coordinates
*/
bool QwtAbstractScale::isInverted() const
{
return d_data->scaleDraw->scaleMap().isInverting();
}
/*!
\return The boundary with the smaller value
\sa maximum(), lowerBound(), upperBound()
*/
double QwtAbstractScale::minimum() const
{
return qMin( d_data->scaleDraw->scaleDiv().lowerBound(),
d_data->scaleDraw->scaleDiv().upperBound() );
}
/*!
\return The boundary with the larger value
\sa minimum(), lowerBound(), upperBound()
*/
double QwtAbstractScale::maximum() const
{
return qMax( d_data->scaleDraw->scaleDiv().lowerBound(),
d_data->scaleDraw->scaleDiv().upperBound() );
}
//! Notify changed scale
void QwtAbstractScale::scaleChange()
{
}
/*!
Recalculate the scale division and update the scale.
\param lowerBound Lower limit of the scale interval
\param upperBound Upper limit of the scale interval
\param stepSize Major step size
\sa scaleChange()
*/
void QwtAbstractScale::rescale(
double lowerBound, double upperBound, double stepSize )
{
const QwtScaleDiv scaleDiv = d_data->scaleEngine->divideScale(
lowerBound, upperBound, d_data->maxMajor, d_data->maxMinor, stepSize );
if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
{
#if 1
d_data->scaleDraw->setTransformation(
d_data->scaleEngine->transformation() );
#endif
d_data->scaleDraw->setScaleDiv( scaleDiv );
scaleChange();
}
}
void QwtAbstractScale::updateScaleDraw()
{
rescale( d_data->scaleDraw->scaleDiv().lowerBound(),
d_data->scaleDraw->scaleDiv().upperBound(), d_data->stepSize );
}
libs/qwt/qwt_abstract_scale.h
View file @ c96458cf
......@@ -11,50 +11,85 @@
#define QWT_ABSTRACT_SCALE_H
#include "qwt_global.h"
#include <qwidget.h>
class QwtScaleEngine;
class QwtAbstractScaleDraw;
class QwtScaleDiv;
class QwtScaleMap;
class QwtDoubleInterval;
class QwtInterval;
/*!
\brief An abstract base class for classes containing a scale
\brief An abstract base class for widgets having a scale
QwtAbstractScale is used to provide classes with a QwtScaleDraw,
and a QwtScaleDiv. The QwtScaleDiv might be set explicitely
or calculated by a QwtScaleEngine.
The scale of an QwtAbstractScale is determined by a QwtScaleDiv
definition, that contains the boundaries and the ticks of the scale.
The scale is painted using a QwtScaleDraw object.
The scale division might be assigned explicitly - but usually
it is calculated from the boundaries using a QwtScaleEngine.
The scale engine also decides the type of transformation of the scale
( linear, logarithmic ... ).
*/
class QWT_EXPORT QwtAbstractScale
class QWT_EXPORT QwtAbstractScale: public QWidget
{
Q_OBJECT
Q_PROPERTY( double lowerBound READ lowerBound WRITE setLowerBound )
Q_PROPERTY( double upperBound READ upperBound WRITE setUpperBound )
Q_PROPERTY( int scaleMaxMajor READ scaleMaxMajor WRITE setScaleMaxMajor )
Q_PROPERTY( int scaleMaxMinor READ scaleMaxMinor WRITE setScaleMaxMinor )
Q_PROPERTY( double scaleStepSize READ scaleStepSize WRITE setScaleStepSize )
public:
QwtAbstractScale();
QwtAbstractScale( QWidget *parent = NULL );
virtual ~QwtAbstractScale();
void setScale(double vmin, double vmax, double step = 0.0);
void setScale(const QwtDoubleInterval &, double step = 0.0);
void setScale(const QwtScaleDiv &s);
void setScale( double lowerBound, double upperBound );
void setScale( const QwtInterval & );
void setScale( const QwtScaleDiv & );
const QwtScaleDiv& scaleDiv() const;
void setAutoScale();
bool autoScale() const;
void setLowerBound( double value );
double lowerBound() const;
void setScaleMaxMajor( int ticks);
void setUpperBound( double value );
double upperBound() const;
void setScaleStepSize( double stepSize );
double scaleStepSize() const;
void setScaleMaxMajor( int ticks );
int scaleMaxMinor() const;
void setScaleMaxMinor( int ticks);
void setScaleMaxMinor( int ticks );
int scaleMaxMajor() const;
void setScaleEngine(QwtScaleEngine *);
void setScaleEngine( QwtScaleEngine * );
const QwtScaleEngine *scaleEngine() const;
QwtScaleEngine *scaleEngine();
int transform( double ) const;
double invTransform( int ) const;
bool isInverted() const;
double minimum() const;
double maximum() const;
const QwtScaleMap &scaleMap() const;
protected:
void rescale(double vmin, double vmax, double step = 0.0);
void rescale( double lowerBound,
double upperBound, double stepSize );
void setAbstractScaleDraw( QwtAbstractScaleDraw * );
void setAbstractScaleDraw(QwtAbstractScaleDraw *);
const QwtAbstractScaleDraw *abstractScaleDraw() const;
QwtAbstractScaleDraw *abstractScaleDraw();
......
libs/qwt/qwt_abstract_scale_draw.cpp
View file @ c96458cf
......@@ -7,39 +7,43 @@
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
// vim: expandtab
#include <qpainter.h>
#include <qpalette.h>
#include <qmap.h>
#include <qlocale.h>
#include "qwt_abstract_scale_draw.h"
#include "qwt_math.h"
#include "qwt_text.h"
#include "qwt_painter.h"
#include "qwt_scale_map.h"
#include "qwt_scale_draw.h"
#include <qpainter.h>
#include <qpalette.h>
#include <qmap.h>
#include <qlocale.h>
class QwtAbstractScaleDraw::PrivateData
{
public:
PrivateData():
components(Backbone | Ticks | Labels),
spacing(4),
minExtent(0) {
tickLength[QwtScaleDiv::MinorTick] = 4;
tickLength[QwtScaleDiv::MediumTick] = 6;
tickLength[QwtScaleDiv::MajorTick] = 8;
spacing( 4.0 ),
penWidth( 0 ),
minExtent( 0.0 )
{
components = QwtAbstractScaleDraw::Backbone
| QwtAbstractScaleDraw::Ticks
| QwtAbstractScaleDraw::Labels;
tickLength[QwtScaleDiv::MinorTick] = 4.0;
tickLength[QwtScaleDiv::MediumTick] = 6.0;
tickLength[QwtScaleDiv::MajorTick] = 8.0;
}
int components;
ScaleComponents components;
QwtScaleMap map;
QwtScaleDiv scldiv;
QwtScaleDiv scaleDiv;
int spacing;
int tickLength[QwtScaleDiv::NTickTypes];
double spacing;
double tickLength[QwtScaleDiv::NTickTypes];
int penWidth;
int minExtent;
double minExtent;
QMap<double, QwtText> labelCache;
};
......@@ -56,23 +60,11 @@ QwtAbstractScaleDraw::QwtAbstractScaleDraw()
d_data = new QwtAbstractScaleDraw::PrivateData;
}
//! Copy constructor
QwtAbstractScaleDraw::QwtAbstractScaleDraw(const QwtAbstractScaleDraw &other)
{
d_data = new QwtAbstractScaleDraw::PrivateData(*other.d_data);
}
//! Destructor
QwtAbstractScaleDraw::~QwtAbstractScaleDraw()
{
delete d_data;
}
//! Assignment operator
QwtAbstractScaleDraw &QwtAbstractScaleDraw::operator=(const QwtAbstractScaleDraw &other)
{
*d_data = *other.d_data;
return *this;
}
/*!
En/Disable a component of the scale
......@@ -80,10 +72,10 @@ QwtAbstractScaleDraw &QwtAbstractScaleDraw::operator=(const QwtAbstractScaleDraw
\param component Scale component
\param enable On/Off
\sa QwtAbstractScaleDraw::hasComponent
\sa hasComponent()
*/
void QwtAbstractScaleDraw::enableComponent(
ScaleComponent component, bool enable)
ScaleComponent component, bool enable )
{
if ( enable )
d_data->components |= component;
......@@ -93,21 +85,24 @@ void QwtAbstractScaleDraw::enableComponent(
/*!
Check if a component is enabled
\sa QwtAbstractScaleDraw::enableComponent
\param component Component type
\return true, when component is enabled
\sa enableComponent()
*/
bool QwtAbstractScaleDraw::hasComponent(ScaleComponent component) const
bool QwtAbstractScaleDraw::hasComponent( ScaleComponent component ) const
{
return (d_data->components & component);
return ( d_data->components & component );
}
/*!
Change the scale division
\param sd New scale division
\param scaleDiv New scale division
*/
void QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &sd)
void QwtAbstractScaleDraw::setScaleDiv( const QwtScaleDiv &scaleDiv )
{
d_data->scldiv = sd;
d_data->map.setScaleInterval(sd.lBound(), sd.hBound());
d_data->scaleDiv = scaleDiv;
d_data->map.setScaleInterval( scaleDiv.lowerBound(), scaleDiv.upperBound() );
d_data->labelCache.clear();
}
......@@ -116,13 +111,13 @@ void QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &sd)
\param transformation New scale transformation
*/
void QwtAbstractScaleDraw::setTransformation(
QwtScaleTransformation *transformation)
QwtTransform *transformation )
{
d_data->map.setTransformation(transformation);
d_data->map.setTransformation( transformation );
}
//! \return Map how to translate between scale and pixel values
const QwtScaleMap &QwtAbstractScaleDraw::map() const
const QwtScaleMap &QwtAbstractScaleDraw::scaleMap() const
{
return d_data->map;
}
......@@ -136,22 +131,31 @@ QwtScaleMap &QwtAbstractScaleDraw::scaleMap()
//! \return scale division
const QwtScaleDiv& QwtAbstractScaleDraw::scaleDiv() const
{
return d_data->scldiv;
return d_data->scaleDiv;
}
#if QT_VERSION < 0x040000
/*!
\brief Draw the scale
\brief Specify the width of the scale pen
\param width Pen width
\sa penWidth()
*/
void QwtAbstractScaleDraw::setPenWidth( int width )
{
if ( width < 0 )
width = 0;
\param painter The painter
if ( width != d_data->penWidth )
d_data->penWidth = width;
}
\param colorGroup Color group, text color is used for the labels,
foreground color for ticks and backbone
/*!
\return Scale pen width
\sa setPenWidth()
*/
void QwtAbstractScaleDraw::draw(QPainter *painter,
const QColorGroup& colorGroup) const
#else
int QwtAbstractScaleDraw::penWidth() const
{
return d_data->penWidth;
}
/*!
\brief Draw the scale
......@@ -161,70 +165,75 @@ void QwtAbstractScaleDraw::draw(QPainter *painter,
\param palette Palette, text color is used for the labels,
foreground color for ticks and backbone
*/
void QwtAbstractScaleDraw::draw(QPainter *painter,
const QPalette& palette) const
#endif
void QwtAbstractScaleDraw::draw( QPainter *painter,
const QPalette& palette ) const
{
if ( hasComponent(QwtAbstractScaleDraw::Labels) ) {
painter->save();
painter->save();
#if QT_VERSION < 0x040000
painter->setPen(colorGroup.text()); // ignore pen style
#else
painter->setPen(palette.color(QPalette::Text)); // ignore pen style
#endif
QPen pen = painter->pen();
pen.setWidth( d_data->penWidth );
pen.setCosmetic( false );
painter->setPen( pen );
const QwtValueList &majorTicks =
d_data->scldiv.ticks(QwtScaleDiv::MajorTick);
if ( hasComponent( QwtAbstractScaleDraw::Labels ) )
{
painter->save();
painter->setPen( palette.color( QPalette::Text ) ); // ignore pen style
const QList<double> &majorTicks =
d_data->scaleDiv.ticks( QwtScaleDiv::MajorTick );
for (int i = 0; i < (int)majorTicks.count(); i++) {
for ( int i = 0; i < majorTicks.count(); i++ )
{
const double v = majorTicks[i];
if ( d_data->scldiv.contains(v) )
drawLabel(painter, majorTicks[i]);
if ( d_data->scaleDiv.contains( v ) )
drawLabel( painter, v );
}
painter->restore();
}
if ( hasComponent(QwtAbstractScaleDraw::Ticks) ) {
if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
{
painter->save();
QPen pen = painter->pen();
#if QT_VERSION < 0x040000
pen.setColor(colorGroup.foreground());
#else
pen.setColor(palette.color(QPalette::Foreground));
#endif
painter->setPen(pen);
pen.setColor( palette.color( QPalette::WindowText ) );
pen.setCapStyle( Qt::FlatCap );
painter->setPen( pen );
for ( int tickType = QwtScaleDiv::MinorTick;
tickType < QwtScaleDiv::NTickTypes; tickType++ ) {
const QwtValueList &ticks = d_data->scldiv.ticks(tickType);
for (int i = 0; i < (int)ticks.count(); i++) {
tickType < QwtScaleDiv::NTickTypes; tickType++ )
{
const QList<double> &ticks = d_data->scaleDiv.ticks( tickType );
for ( int i = 0; i < ticks.count(); i++ )
{
const double v = ticks[i];
if ( d_data->scldiv.contains(v) )
drawTick(painter, v, d_data->tickLength[tickType]);
if ( d_data->scaleDiv.contains( v ) )
drawTick( painter, v, d_data->tickLength[tickType] );
}
}
painter->restore();
}
if ( hasComponent(QwtAbstractScaleDraw::Backbone) ) {
if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
{
painter->save();
QPen pen = painter->pen();
#if QT_VERSION < 0x040000
pen.setColor(colorGroup.foreground());
#else
pen.setColor(palette.color(QPalette::Foreground));
#endif
painter->setPen(pen);
pen.setColor( palette.color( QPalette::WindowText ) );
pen.setCapStyle( Qt::FlatCap );
painter->setPen( pen );
drawBackbone(painter);
drawBackbone( painter );
painter->restore();
}
painter->restore();
}
/*!
......@@ -235,9 +244,9 @@ void QwtAbstractScaleDraw::draw(QPainter *painter,
\param spacing Spacing
\sa QwtAbstractScaleDraw::spacing
\sa spacing()
*/
void QwtAbstractScaleDraw::setSpacing(int spacing)
void QwtAbstractScaleDraw::setSpacing( double spacing )
{
if ( spacing < 0 )
spacing = 0;
......@@ -251,9 +260,10 @@ void QwtAbstractScaleDraw::setSpacing(int spacing)
The spacing is the distance between ticks and labels.
The default spacing is 4 pixels.
\sa QwtAbstractScaleDraw::setSpacing
\return Spacing
\sa setSpacing()
*/
int QwtAbstractScaleDraw::spacing() const
double QwtAbstractScaleDraw::spacing() const
{
return d_data->spacing;
}
......@@ -261,7 +271,7 @@ int QwtAbstractScaleDraw::spacing() const
/*!
\brief Set a minimum for the extent
The extent is calculated from the coomponents of the
The extent is calculated from the components of the
scale draw. In situations, where the labels are
changing and the layout depends on the extent (f.e scrolling
a scale), setting an upper limit as minimum extent will
......@@ -271,19 +281,20 @@ int QwtAbstractScaleDraw::spacing() const
\sa extent(), minimumExtent()
*/
void QwtAbstractScaleDraw::setMinimumExtent(int minExtent)
void QwtAbstractScaleDraw::setMinimumExtent( double minExtent )
{
if ( minExtent < 0 )
minExtent = 0;
if ( minExtent < 0.0 )
minExtent = 0.0;
d_data->minExtent = minExtent;
}
/*!
Get the minimum extent
\return Minimum extent
\sa extent(), setMinimumExtent()
*/
int QwtAbstractScaleDraw::minimumExtent() const
double QwtAbstractScaleDraw::minimumExtent() const
{
return d_data->minExtent;
}
......@@ -297,33 +308,33 @@ int QwtAbstractScaleDraw::minimumExtent() const
\warning the length is limited to [0..1000]
*/
void QwtAbstractScaleDraw::setTickLength(
QwtScaleDiv::TickType tickType, int length)
QwtScaleDiv::TickType tickType, double length )
{
if ( tickType < QwtScaleDiv::MinorTick ||
tickType > QwtScaleDiv::MajorTick ) {
tickType > QwtScaleDiv::MajorTick )
{
return;
}
if ( length < 0 )
length = 0;
if ( length < 0.0 )
length = 0.0;
const int maxTickLen = 1000;
const double maxTickLen = 1000.0;
if ( length > maxTickLen )
length = 1000;
length = maxTickLen;
d_data->tickLength[tickType] = length;
}
/*!
Return the length of the ticks
\sa QwtAbstractScaleDraw::setTickLength,
QwtAbstractScaleDraw::majTickLength
\return Length of the ticks
\sa setTickLength(), maxTickLength()
*/
int QwtAbstractScaleDraw::tickLength(QwtScaleDiv::TickType tickType) const
double QwtAbstractScaleDraw::tickLength( QwtScaleDiv::TickType tickType ) const
{
if ( tickType < QwtScaleDiv::MinorTick ||
tickType > QwtScaleDiv::MajorTick ) {
tickType > QwtScaleDiv::MajorTick )
{
return 0;
}
......@@ -331,27 +342,34 @@ int QwtAbstractScaleDraw::tickLength(QwtScaleDiv::TickType tickType) const
}
/*!
The same as QwtAbstractScaleDraw::tickLength(QwtScaleDiv::MajorTick).
\return Length of the longest tick
Useful for layout calculations
\sa tickLength(), setTickLength()
*/
int QwtAbstractScaleDraw::majTickLength() const
double QwtAbstractScaleDraw::maxTickLength() const
{
return d_data->tickLength[QwtScaleDiv::MajorTick];
double length = 0.0;
for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
length = qMax( length, d_data->tickLength[i] );
return length;
}
/*!
\brief Convert a value into its representing label
The value is converted to a plain text using
QLocale::system().toString(value).
QLocale().toString(value).
This method is often overloaded by applications to have individual
labels.
\param value Value
\return Label string.
*/
QwtText QwtAbstractScaleDraw::label(double value) const
QwtText QwtAbstractScaleDraw::label( double value ) const
{
return QLocale::system().toString(value);
return QLocale().toString( value );
}
/*!
......@@ -368,28 +386,29 @@ QwtText QwtAbstractScaleDraw::label(double value) const
\return Tick label
*/
const QwtText &QwtAbstractScaleDraw::tickLabel(
const QFont &font, double value) const
const QFont &font, double value ) const
{
QMap<double, QwtText>::const_iterator it = d_data->labelCache.find(value);
if ( it == d_data->labelCache.end() ) {
QwtText lbl = label(value);
lbl.setRenderFlags(0);
lbl.setLayoutAttribute(QwtText::MinimumLayout);
QMap<double, QwtText>::const_iterator it = d_data->labelCache.find( value );
if ( it == d_data->labelCache.end() )
{
QwtText lbl = label( value );
lbl.setRenderFlags( 0 );
lbl.setLayoutAttribute( QwtText::MinimumLayout );
(void)lbl.textSize(font); // initialize the internal cache
( void )lbl.textSize( font ); // initialize the internal cache
it = d_data->labelCache.insert(value, lbl);
it = d_data->labelCache.insert( value, lbl );
}
return (*it);
return ( *it );
}
/*!
Invalidate the cache used by QwtAbstractScaleDraw::tickLabel
Invalidate the cache used by tickLabel()
The cache is invalidated, when a new QwtScaleDiv is set. If
the labels need to be changed. while the same QwtScaleDiv is set,
QwtAbstractScaleDraw::invalidateCache needs to be called manually.
invalidateCache() needs to be called manually.
*/
void QwtAbstractScaleDraw::invalidateCache()
{
......
libs/qwt/qwt_abstract_scale_draw.h
View file @ c96458cf
......@@ -14,15 +14,10 @@
#include "qwt_scale_div.h"
#include "qwt_text.h"
#if QT_VERSION < 0x040000
class QColorGroup;
#else
class QPalette;
#endif
class QPainter;
class QFont;
class QwtScaleTransformation;
class QwtTransform;
class QwtScaleMap;
/*!
......@@ -31,8 +26,7 @@ class QwtScaleMap;
QwtAbstractScaleDraw can be used to draw linear or logarithmic scales.
After a scale division has been specified as a QwtScaleDiv object
using QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &s),
the scale can be drawn with the QwtAbstractScaleDraw::draw() member.
using setScaleDiv(), the scale can be drawn with the draw() member.
*/
class QWT_EXPORT QwtAbstractScaleDraw
{
......@@ -40,66 +34,66 @@ public:
/*!
Components of a scale
\sa enableComponent(), hasComponent
*/
enum ScaleComponent
{
//! Backbone = the line where the ticks are located
Backbone = 0x01,
- Backbone
- Ticks
- Labels
\sa QwtAbstractScaleDraw::enableComponent,
QwtAbstractScaleDraw::hasComponent
*/
//! Ticks
Ticks = 0x02,
enum ScaleComponent {
Backbone = 1,
Ticks = 2,
Labels = 4
//! Labels
Labels = 0x04
};
//! Scale components
typedef QFlags<ScaleComponent> ScaleComponents;
QwtAbstractScaleDraw();
QwtAbstractScaleDraw( const QwtAbstractScaleDraw & );
virtual ~QwtAbstractScaleDraw();
QwtAbstractScaleDraw &operator=(const QwtAbstractScaleDraw &);
void setScaleDiv(const QwtScaleDiv &s);
void setScaleDiv( const QwtScaleDiv &s );
const QwtScaleDiv& scaleDiv() const;
void setTransformation(QwtScaleTransformation *);
const QwtScaleMap &map() const;
void setTransformation( QwtTransform * );
const QwtScaleMap &scaleMap() const;
QwtScaleMap &scaleMap();
void enableComponent(ScaleComponent, bool enable = true);
bool hasComponent(ScaleComponent) const;
void enableComponent( ScaleComponent, bool enable = true );
bool hasComponent( ScaleComponent ) const;
void setTickLength(QwtScaleDiv::TickType, int length);
int tickLength(QwtScaleDiv::TickType) const;
int majTickLength() const;
void setTickLength( QwtScaleDiv::TickType, double length );
double tickLength( QwtScaleDiv::TickType ) const;
double maxTickLength() const;
void setSpacing(int margin);
int spacing() const;
void setSpacing( double margin );
double spacing() const;
#if QT_VERSION < 0x040000
virtual void draw(QPainter *, const QColorGroup &) const;
#else
virtual void draw(QPainter *, const QPalette &) const;
#endif
void setPenWidth( int width );
int penWidth() const;
virtual void draw( QPainter *, const QPalette & ) const;
virtual QwtText label(double) const;
virtual QwtText label( double ) const;
/*!
Calculate the extent
The extent is the distcance from the baseline to the outermost
The extent is the distance from the baseline to the outermost
pixel of the scale draw in opposite to its orientation.
It is at least minimumExtent() pixels.
\param font Font used for drawing the tick labels
\return Number of pixels
\sa setMinimumExtent(), minimumExtent()
*/
virtual int extent(const QPen &, const QFont &) const = 0;
virtual double extent( const QFont &font ) const = 0;
void setMinimumExtent(int);
int minimumExtent() const;
QwtScaleMap &scaleMap();
void setMinimumExtent( double );
double minimumExtent() const;
protected:
/*!
......@@ -107,11 +101,11 @@ protected:
\param painter Painter
\param value Value of the tick
\param len Lenght of the tick
\param len Length of the tick
\sa drawBackbone(), drawLabel()
*/
virtual void drawTick(QPainter *painter, double value, int len) const = 0;
virtual void drawTick( QPainter *painter, double value, double len ) const = 0;
/*!
Draws the baseline of the scale
......@@ -119,7 +113,7 @@ protected:
\sa drawTick(), drawLabel()
*/
virtual void drawBackbone(QPainter *painter) const = 0;
virtual void drawBackbone( QPainter *painter ) const = 0;
/*!
Draws the label for a major scale tick
......@@ -127,19 +121,21 @@ protected:
\param painter Painter
\param value Value
\sa drawTick, drawBackbone
\sa drawTick(), drawBackbone()
*/
virtual void drawLabel(QPainter *painter, double value) const = 0;
virtual void drawLabel( QPainter *painter, double value ) const = 0;
void invalidateCache();
const QwtText &tickLabel(const QFont &, double value) const;
const QwtText &tickLabel( const QFont &, double value ) const;
private:
int operator==(const QwtAbstractScaleDraw &) const;
int operator!=(const QwtAbstractScaleDraw &) const;
QwtAbstractScaleDraw( const QwtAbstractScaleDraw & );
QwtAbstractScaleDraw &operator=( const QwtAbstractScaleDraw & );
class PrivateData;
PrivateData *d_data;
};
Q_DECLARE_OPERATORS_FOR_FLAGS( QwtAbstractScaleDraw::ScaleComponents )
#endif
libs/qwt/qwt_abstract_slider.cpp
View file @ c96458cf
This diff is collapsed.
libs/qwt/qwt_abstract_slider.h
View file @ c96458cf
......@@ -10,112 +10,95 @@
#ifndef QWT_ABSTRACT_SLIDER_H
#define QWT_ABSTRACT_SLIDER_H
#include <qwidget.h>
#include "qwt_global.h"
#include "qwt_double_range.h"
#include "qwt_abstract_scale.h"
/*!
\brief An abstract base class for slider widgets
QwtAbstractSlider is a base class for
slider widgets. It handles mouse events
and updates the slider's value accordingly. Derived classes
only have to implement the getValue() and
getScrollMode() members, and should react to a
valueChange(), which normally requires repainting.
\brief An abstract base class for slider widgets with a scale
A slider widget displays a value according to a scale.
The class is designed as a common super class for widgets like
QwtKnob, QwtDial and QwtSlider.
When the slider is nor readOnly() its value can be modified
by keyboard, mouse and wheel inputs.
The range of the slider is divided into a number of steps from
which the value increments according to user inputs depend.
Only for linear scales the number of steps correspond with
a fixed step size.
*/
class QWT_EXPORT QwtAbstractSlider : public QWidget, public QwtDoubleRange
class QWT_EXPORT QwtAbstractSlider: public QwtAbstractScale
{
Q_OBJECT
Q_PROPERTY( double value READ value WRITE setValue )
Q_PROPERTY( uint totalSteps READ totalSteps WRITE setTotalSteps )
Q_PROPERTY( uint singleSteps READ singleSteps WRITE setSingleSteps )
Q_PROPERTY( uint pageSteps READ pageSteps WRITE setPageSteps )
Q_PROPERTY( bool stepAlignment READ stepAlignment WRITE setStepAlignment )
Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly )
Q_PROPERTY( bool valid READ isValid WRITE setValid )
Q_PROPERTY( double mass READ mass WRITE setMass )
#ifndef Q_MOC_RUN // Qt3 moc
#define QWT_PROPERTY Q_PROPERTY
Q_PROPERTY( Orientation orientation
READ orientation WRITE setOrientation )
#else // Qt4 moc
// MOC_SKIP_BEGIN
Q_PROPERTY( Qt::Orientation orientation
READ orientation WRITE setOrientation )
// MOC_SKIP_END
#endif
Q_PROPERTY( bool tracking READ isTracking WRITE setTracking )
Q_PROPERTY( bool wrapping READ wrapping WRITE setWrapping )
Q_PROPERTY( bool invertedControls READ invertedControls WRITE setInvertedControls )
public:
/*!
Scroll mode
\sa getScrollMode()
*/
enum ScrollMode {
ScrNone,
ScrMouse,
ScrTimer,
ScrDirect,
ScrPage
};
explicit QwtAbstractSlider(Qt::Orientation, QWidget *parent = NULL);
explicit QwtAbstractSlider( QWidget *parent = NULL );
virtual ~QwtAbstractSlider();
void setUpdateTime(int t);
void stopMoving();
void setTracking(bool enable);
void setValid( bool );
bool isValid() const;
virtual void setMass(double val);
virtual double mass() const;
double value() const;
#if QT_VERSION >= 0x040000
virtual void setOrientation(Qt::Orientation o);
Qt::Orientation orientation() const;
#else
virtual void setOrientation(Orientation o);
Orientation orientation() const;
#endif
void setWrapping( bool );
bool wrapping() const;
bool isReadOnly() const;
void setTotalSteps( uint );
uint totalSteps() const;
/*
Wrappers for QwtDblRange::isValid/QwtDblRange::setValid made
to be available as Q_PROPERTY in the designer.
*/
void setSingleSteps( uint );
uint singleSteps() const;
/*!
\sa QwtDblRange::isValid
*/
bool isValid() const {
return QwtDoubleRange::isValid();
}
void setPageSteps( uint );
uint pageSteps() const;
/*!
\sa QwtDblRange::isValid
*/
void setValid(bool valid) {
QwtDoubleRange::setValid(valid);
}
void setStepAlignment( bool );
bool stepAlignment() const;
public slots:
virtual void setValue(double val);
virtual void fitValue(double val);
virtual void incValue(int steps);
void setTracking( bool );
bool isTracking() const;
void setReadOnly( bool );
bool isReadOnly() const;
virtual void setReadOnly(bool);
void setInvertedControls( bool );
bool invertedControls() const;
signals:
public Q_SLOTS:
void setValue( double val );
Q_SIGNALS:
/*!
\brief Notify a change of value.
In the default setting
(tracking enabled), this signal will be emitted every
time the value changes ( see setTracking() ).
\param value new value
When tracking is enabled (default setting),
this signal will be emitted every time the value changes.
\param value New value
\sa setTracking(), sliderMoved()
*/
void valueChanged(double value);
void valueChanged( double value );
/*!
This signal is emitted when the user presses the
movable part of the slider (start ScrMouse Mode).
movable part of the slider.
*/
void sliderPressed();
......@@ -123,70 +106,59 @@ signals:
This signal is emitted when the user releases the
movable part of the slider.
*/
void sliderReleased();
/*!
This signal is emitted when the user moves the
slider with the mouse.
\param value new value
\param value New value
\sa valueChanged()
*/
void sliderMoved(double value);
void sliderMoved( double value );
protected:
virtual void setPosition(const QPoint &);
virtual void valueChange();
virtual void timerEvent(QTimerEvent *e);
virtual void mousePressEvent(QMouseEvent *e);
virtual void mouseReleaseEvent(QMouseEvent *e);
virtual void mouseMoveEvent(QMouseEvent *e);
virtual void keyPressEvent(QKeyEvent *e);
virtual void wheelEvent(QWheelEvent *e);
virtual void mousePressEvent( QMouseEvent * );
virtual void mouseReleaseEvent( QMouseEvent * );
virtual void mouseMoveEvent( QMouseEvent * );
virtual void keyPressEvent( QKeyEvent * );
virtual void wheelEvent( QWheelEvent * );
/*!
\brief Determine the value corresponding to a specified poind
\brief Determine what to do when the user presses a mouse button.
\param pos Mouse position
This is an abstract virtual function which is called when
the user presses or releases a mouse button or moves the
mouse. It has to be implemented by the derived class.
\param p point
\retval True, when pos is a valid scroll position
\sa scrolledTo()
*/
virtual double getValue(const QPoint & p) = 0;
virtual bool isScrollPosition( const QPoint &pos ) const = 0;
/*!
\brief Determine what to do when the user presses a mouse button.
\brief Determine the value for a new position of the
movable part of the slider
This function is abstract and has to be implemented by derived classes.
It is called on a mousePress event. The derived class can determine
what should happen next in dependence of the position where the mouse
was pressed by returning scrolling mode and direction. QwtAbstractSlider
knows the following modes:<dl>
<dt>QwtAbstractSlider::ScrNone
<dd>Scrolling switched off. Don't change the value.
<dt>QwtAbstractSlider::ScrMouse
<dd>Change the value while the user keeps the
button pressed and moves the mouse.
<dt>QwtAbstractSlider::ScrTimer
<dd>Automatic scrolling. Increment the value
in the specified direction as long as
the user keeps the button pressed.
<dt>QwtAbstractSlider::ScrPage
<dd>Automatic scrolling. Same as ScrTimer, but
increment by page size.</dl>
\param p point where the mouse was pressed
\retval scrollMode The scrolling mode
\retval direction direction: 1, 0, or -1.
\param pos Mouse position
\return Value for the mouse position
\sa isScrollPosition()
*/
virtual void getScrollMode( const QPoint &p,
int &scrollMode, int &direction) = 0;
virtual double scrolledTo( const QPoint &pos ) const = 0;
void incrementValue( int numSteps );
void setMouseOffset(double);
double mouseOffset() const;
virtual void scaleChange();
protected:
virtual void sliderChange();
int scrollMode() const;
double incrementedValue(
double value, int stepCount ) const;
private:
void buttonReleased();
double alignedValue( double ) const;
double boundedValue( double ) const;
class PrivateData;
PrivateData *d_data;
......
libs/qwt/qwt_analog_clock.cpp
View file @ c96458cf
......@@ -8,69 +8,94 @@
*****************************************************************************/
#include "qwt_analog_clock.h"
#include "qwt_round_scale_draw.h"
#include <qmath.h>
#include <qlocale.h>
/*!
Constructor
\param parent Parent widget
*/
QwtAnalogClock::QwtAnalogClock(QWidget *parent):
QwtDial(parent)
class QwtAnalogClockScaleDraw: public QwtRoundScaleDraw
{
initClock();
}
public:
QwtAnalogClockScaleDraw()
{
setSpacing( 8 );
enableComponent( QwtAbstractScaleDraw::Backbone, false );
setTickLength( QwtScaleDiv::MinorTick, 2 );
setTickLength( QwtScaleDiv::MediumTick, 4 );
setTickLength( QwtScaleDiv::MajorTick, 8 );
setPenWidth( 1 );
}
virtual QwtText label( double value ) const
{
if ( qFuzzyCompare( value + 1.0, 1.0 ) )
value = 60.0 * 60.0 * 12.0;
return QLocale().toString( qRound( value / ( 60.0 * 60.0 ) ) );
}
};
#if QT_VERSION < 0x040000
/*!
Constructor
\param parent Parent widget
\param name Object name
*/
QwtAnalogClock::QwtAnalogClock(QWidget* parent, const char *name):
QwtDial(parent, name)
QwtAnalogClock::QwtAnalogClock( QWidget *parent ):
QwtDial( parent )
{
initClock();
}
#endif
setWrapping( true );
setReadOnly( true );
void QwtAnalogClock::initClock()
{
setWrapping(true);
setReadOnly(true);
setOrigin( 270.0 );
setScaleDraw( new QwtAnalogClockScaleDraw() );
setTotalSteps( 60 );
const int secondsPerHour = 60.0 * 60.0;
setOrigin(270.0);
setRange(0.0, 60.0 * 60.0 * 12.0); // seconds
setScale(-1, 5, 60.0 * 60.0);
QList<double> majorTicks;
QList<double> minorTicks;
setScaleOptions(ScaleTicks | ScaleLabel);
setScaleTicks(1, 0, 8);
scaleDraw()->setSpacing(8);
for ( int i = 0; i < 12; i++ )
{
majorTicks += i * secondsPerHour;
QColor knobColor =
#if QT_VERSION < 0x040000
palette().color(QPalette::Active, QColorGroup::Text);
#else
palette().color(QPalette::Active, QPalette::Text);
#endif
knobColor = knobColor.dark(120);
for ( int j = 1; j < 5; j++ )
minorTicks += i * secondsPerHour + j * secondsPerHour / 5.0;
}
QwtScaleDiv scaleDiv;
scaleDiv.setInterval( 0.0, 12.0 * secondsPerHour );
scaleDiv.setTicks( QwtScaleDiv::MajorTick, majorTicks );
scaleDiv.setTicks( QwtScaleDiv::MinorTick, minorTicks );
setScale( scaleDiv );
QColor knobColor = palette().color( QPalette::Active, QPalette::Text );
knobColor = knobColor.dark( 120 );
QColor handColor;
int width;
for ( int i = 0; i < NHands; i++ ) {
if ( i == SecondHand ) {
for ( int i = 0; i < NHands; i++ )
{
if ( i == SecondHand )
{
width = 2;
handColor = knobColor.dark(120);
} else {
handColor = knobColor.dark( 120 );
}
else
{
width = 8;
handColor = knobColor;
}
QwtDialSimpleNeedle *hand = new QwtDialSimpleNeedle(
QwtDialSimpleNeedle::Arrow, true, handColor, knobColor);
hand->setWidth(width);
QwtDialSimpleNeedle::Arrow, true, handColor, knobColor );
hand->setWidth( width );
d_hand[i] = NULL;
setHand((Hand)i, hand);
setHand( static_cast<Hand>( i ), hand );
}
}
......@@ -82,24 +107,25 @@ QwtAnalogClock::~QwtAnalogClock()
}
/*!
Nop method, use setHand instead
\sa QwtAnalogClock::setHand
Nop method, use setHand() instead
\sa setHand()
*/
void QwtAnalogClock::setNeedle(QwtDialNeedle *)
void QwtAnalogClock::setNeedle( QwtDialNeedle * )
{
// no op
return;
}
/*!
Set a clockhand
Set a clock hand
\param hand Specifies the type of hand
\param needle Hand
\sa QwtAnalogClock::hand()
\sa hand()
*/
void QwtAnalogClock::setHand(Hand hand, QwtDialNeedle *needle)
void QwtAnalogClock::setHand( Hand hand, QwtDialNeedle *needle )
{
if ( hand >= 0 || hand < NHands ) {
if ( hand >= 0 && hand < NHands )
{
delete d_hand[hand];
d_hand[hand] = needle;
}
......@@ -108,9 +134,9 @@ void QwtAnalogClock::setHand(Hand hand, QwtDialNeedle *needle)
/*!
\return Clock hand
\param hd Specifies the type of hand
\sa QwtAnalogClock::setHand
\sa setHand()
*/
QwtDialNeedle *QwtAnalogClock::hand(Hand hd)
QwtDialNeedle *QwtAnalogClock::hand( Hand hd )
{
if ( hd < 0 || hd >= NHands )
return NULL;
......@@ -121,81 +147,75 @@ QwtDialNeedle *QwtAnalogClock::hand(Hand hd)
/*!
\return Clock hand
\param hd Specifies the type of hand
\sa QwtAnalogClock::setHand
\sa setHand()
*/
const QwtDialNeedle *QwtAnalogClock::hand(Hand hd) const
const QwtDialNeedle *QwtAnalogClock::hand( Hand hd ) const
{
return ((QwtAnalogClock *)this)->hand(hd);
return const_cast<QwtAnalogClock *>( this )->hand( hd );
}
/*!
\brief Set the current time
This is the same as QwtAnalogClock::setTime(), but Qt < 3.0
can't handle default parameters for slots.
*/
void QwtAnalogClock::setCurrentTime()
{
setTime(QTime::currentTime());
setTime( QTime::currentTime() );
}
/*!
Set a time
\param time Time to display
*/
void QwtAnalogClock::setTime(const QTime &time)
{
if ( time.isValid() ) {
setValue((time.hour() % 12) * 60.0 * 60.0
+ time.minute() * 60.0 + time.second());
} else
setValid(false);
}
/*!
Find the scale label for a given value
\param value Value
\return Label
*/
QwtText QwtAnalogClock::scaleLabel(double value) const
void QwtAnalogClock::setTime( const QTime &time )
{
if ( value == 0.0 )
value = 60.0 * 60.0 * 12.0;
return QString::number(int(value / (60.0 * 60.0)));
if ( time.isValid() )
{
setValue( ( time.hour() % 12 ) * 60.0 * 60.0
+ time.minute() * 60.0 + time.second() );
}
else
setValid( false );
}
/*!
\brief Draw the needle
A clock has no single needle but three hands instead. drawNeedle
A clock has no single needle but three hands instead. drawNeedle()
translates value() into directions for the hands and calls
drawHand().
\param painter Painter
\param center Center of the clock
\param radius Maximum length for the hands
\param direction Dummy, not used.
\param cg ColorGroup
\param dir Dummy, not used.
\param colorGroup ColorGroup
\sa QwtAnalogClock::drawHand()
\sa drawHand()
*/
void QwtAnalogClock::drawNeedle(QPainter *painter, const QPoint &center,
int radius, double, QPalette::ColorGroup cg) const
void QwtAnalogClock::drawNeedle( QPainter *painter, const QPointF &center,
double radius, double dir, QPalette::ColorGroup colorGroup ) const
{
if ( isValid() ) {
const double hours = value() / (60.0 * 60.0);
const double minutes = (value() - (int)hours * 60.0 * 60.0) / 60.0;
const double seconds = value() - (int)hours * 60.0 * 60.0
- (int)minutes * 60.0;
drawHand(painter, HourHand, center, radius,
360.0 - (origin() + 360.0 * hours / 12.0), cg);
drawHand(painter, MinuteHand, center, radius,
360.0 - (origin() + 360.0 * minutes / 60.0), cg);
drawHand(painter, SecondHand, center, radius,
360.0 - (origin() + 360.0 * seconds / 60.0), cg);
Q_UNUSED( dir );
if ( isValid() )
{
const double hours = value() / ( 60.0 * 60.0 );
const double minutes =
( value() - qFloor(hours) * 60.0 * 60.0 ) / 60.0;
const double seconds = value() - qFloor(hours) * 60.0 * 60.0
- qFloor(minutes) * 60.0;
double angle[NHands];
angle[HourHand] = 360.0 * hours / 12.0;
angle[MinuteHand] = 360.0 * minutes / 60.0;
angle[SecondHand] = 360.0 * seconds / 60.0;
for ( int hand = 0; hand < NHands; hand++ )
{
const double d = 360.0 - angle[hand] - origin();
drawHand( painter, static_cast<Hand>( hand ),
center, radius, d, colorGroup );
}
}
}
......@@ -209,15 +229,16 @@ void QwtAnalogClock::drawNeedle(QPainter *painter, const QPoint &center,
\param direction Direction of the hand in degrees, counter clockwise
\param cg ColorGroup
*/
void QwtAnalogClock::drawHand(QPainter *painter, Hand hd,
const QPoint &center, int radius, double direction,
QPalette::ColorGroup cg) const
void QwtAnalogClock::drawHand( QPainter *painter, Hand hd,
const QPointF &center, double radius, double direction,
QPalette::ColorGroup cg ) const
{
const QwtDialNeedle *needle = hand(hd);
if ( needle ) {
const QwtDialNeedle *needle = hand( hd );
if ( needle )
{
if ( hd == HourHand )
radius = qRound(0.8 * radius);
radius = qRound( 0.8 * radius );
needle->draw(painter, center, radius, direction, cg);
needle->draw( painter, center, radius, direction, cg );
}
}
libs/qwt/qwt_analog_clock.h
View file @ c96458cf
......@@ -10,10 +10,10 @@
#ifndef QWT_ANALOG_CLOCK_H
#define QWT_ANALOG_CLOCK_H
#include <qdatetime.h>
#include "qwt_global.h"
#include "qwt_dial.h"
#include "qwt_dial_needle.h"
#include <qdatetime.h>
/*!
\brief An analog clock
......@@ -21,7 +21,8 @@
\image html analogclock.png
\par Example
\verbatim #include <qwt_analog_clock.h>
\code
#include <qwt_analog_clock.h>
QwtAnalogClock *clock = new QwtAnalogClock(...);
clock->scaleDraw()->setPenWidth(3);
......@@ -34,10 +35,7 @@
timer->connect(timer, SIGNAL(timeout()), clock, SLOT(setCurrentTime()));
timer->start(1000);
\endverbatim
Qwt is missing a set of good looking hands.
Contributions are very welcome.
\endcode
\note The examples/dials example shows how to use QwtAnalogClock.
*/
......@@ -51,41 +49,43 @@ public:
Hand type
\sa setHand(), hand()
*/
enum Hand {
enum Hand
{
//! Needle displaying the seconds
SecondHand,
//! Needle displaying the minutes
MinuteHand,
//! Needle displaying the hours
HourHand,
//! Number of needles
NHands
};
explicit QwtAnalogClock(QWidget* parent = NULL);
#if QT_VERSION < 0x040000
explicit QwtAnalogClock(QWidget* parent, const char *name);
#endif
explicit QwtAnalogClock( QWidget* parent = NULL );
virtual ~QwtAnalogClock();
virtual void setHand(Hand, QwtDialNeedle *);
const QwtDialNeedle *hand(Hand) const;
QwtDialNeedle *hand(Hand);
void setHand( Hand, QwtDialNeedle * );
public slots:
const QwtDialNeedle *hand( Hand ) const;
QwtDialNeedle *hand( Hand );
public Q_SLOTS:
void setCurrentTime();
void setTime(const QTime & = QTime::currentTime());
void setTime( const QTime & );
protected:
virtual QwtText scaleLabel(double) const;
virtual void drawNeedle(QPainter *, const QPoint &,
int radius, double direction, QPalette::ColorGroup) const;
virtual void drawNeedle( QPainter *, const QPointF &,
double radius, double direction, QPalette::ColorGroup ) const;
virtual void drawHand(QPainter *, Hand, const QPoint &,
int radius, double direction, QPalette::ColorGroup) const;
virtual void drawHand( QPainter *, Hand, const QPointF &,
double radius, double direction, QPalette::ColorGroup ) const;
private:
virtual void setNeedle(QwtDialNeedle *);
void initClock();
// use setHand instead
void setNeedle( QwtDialNeedle * );
QwtDialNeedle *d_hand[NHands];
};
......
libs/qwt/qwt_arrow_button.cpp
View file @ c96458cf
......@@ -7,12 +7,13 @@
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
#include "qwt_arrow_button.h"
#include "qwt_math.h"
#include <qpainter.h>
#include <qstyle.h>
#include <qstyleoption.h>
#include <qevent.h>
#include "qwt_math.h"
#include "qwt_polygon.h"
#include "qwt_arrow_button.h"
#include <qapplication.h>
static const int MaxNum = 3;
static const int Margin = 2;
......@@ -25,56 +26,53 @@ public:
Qt::ArrowType arrowType;
};
#if QT_VERSION >= 0x040000
#include <qstyleoption.h>
static QStyleOptionButton styleOpt(const QwtArrowButton* btn)
static QStyleOptionButton styleOpt( const QwtArrowButton* btn )
{
QStyleOptionButton option;
option.init(btn);
option.init( btn );
option.features = QStyleOptionButton::None;
if (btn->isFlat())
if ( btn->isFlat() )
option.features |= QStyleOptionButton::Flat;
if (btn->menu())
if ( btn->menu() )
option.features |= QStyleOptionButton::HasMenu;
if (btn->autoDefault() || btn->isDefault())
if ( btn->autoDefault() || btn->isDefault() )
option.features |= QStyleOptionButton::AutoDefaultButton;
if (btn->isDefault())
if ( btn->isDefault() )
option.features |= QStyleOptionButton::DefaultButton;
if (btn->isDown())
if ( btn->isDown() )
option.state |= QStyle::State_Sunken;
if (!btn->isFlat() && !btn->isDown())
if ( !btn->isFlat() && !btn->isDown() )
option.state |= QStyle::State_Raised;
return option;
}
#endif
/*!
\param num Number of arrows
\param arrowType see Qt::ArowType in the Qt docs.
\param arrowType see Qt::ArrowType in the Qt docs.
\param parent Parent widget
*/
QwtArrowButton::QwtArrowButton(int num,
Qt::ArrowType arrowType, QWidget *parent):
QPushButton(parent)
QwtArrowButton::QwtArrowButton( int num,
Qt::ArrowType arrowType, QWidget *parent ):
QPushButton( parent )
{
d_data = new PrivateData;
d_data->num = qwtLim(num, 1, MaxNum);
d_data->num = qBound( 1, num, MaxNum );
d_data->arrowType = arrowType;
setAutoRepeat(true);
setAutoDefault(false);
switch(d_data->arrowType) {
case Qt::LeftArrow:
case Qt::RightArrow:
setSizePolicy(QSizePolicy::Expanding,
QSizePolicy::Fixed);
break;
default:
setSizePolicy(QSizePolicy::Fixed,
QSizePolicy::Expanding);
setAutoRepeat( true );
setAutoDefault( false );
switch ( d_data->arrowType )
{
case Qt::LeftArrow:
case Qt::RightArrow:
setSizePolicy( QSizePolicy::Expanding,
QSizePolicy::Fixed );
break;
default:
setSizePolicy( QSizePolicy::Fixed,
QSizePolicy::Expanding );
}
}
......@@ -102,60 +100,51 @@ int QwtArrowButton::num() const
}
/*!
\return the bounding rect for the label
\return the bounding rectangle for the label
*/
QRect QwtArrowButton::labelRect() const
{
const int m = Margin;
QRect r = rect();
r.setRect(r.x() + m, r.y() + m,
r.width() - 2 * m, r.height() - 2 * m);
if ( isDown() ) {
int ph, pv;
#if QT_VERSION < 0x040000
ph = style().pixelMetric(
QStyle::PM_ButtonShiftHorizontal, this);
pv = style().pixelMetric(
QStyle::PM_ButtonShiftVertical, this);
r.moveBy(ph, pv);
#else
QStyleOptionButton option = styleOpt(this);
ph = style()->pixelMetric(
QStyle::PM_ButtonShiftHorizontal, &option, this);
pv = style()->pixelMetric(
QStyle::PM_ButtonShiftVertical, &option, this);
r.translate(ph, pv);
#endif
r.setRect( r.x() + m, r.y() + m,
r.width() - 2 * m, r.height() - 2 * m );
if ( isDown() )
{
QStyleOptionButton option = styleOpt( this );
const int ph = style()->pixelMetric(
QStyle::PM_ButtonShiftHorizontal, &option, this );
const int pv = style()->pixelMetric(
QStyle::PM_ButtonShiftVertical, &option, this );
r.translate( ph, pv );
}
return r;
}
#if QT_VERSION >= 0x040000
/*!
Paint event handler
\param event Paint event
*/
void QwtArrowButton::paintEvent(QPaintEvent *event)
void QwtArrowButton::paintEvent( QPaintEvent *event )
{
QPushButton::paintEvent(event);
QPainter painter(this);
drawButtonLabel(&painter);
QPushButton::paintEvent( event );
QPainter painter( this );
drawButtonLabel( &painter );
}
#endif
/*!
\brief Draw the button label
\param painter Painter
\sa The Qt Manual on QPushButton
\sa The Qt Manual for QPushButton
*/
void QwtArrowButton::drawButtonLabel(QPainter *painter)
void QwtArrowButton::drawButtonLabel( QPainter *painter )
{
const bool isVertical = d_data->arrowType == Qt::UpArrow ||
d_data->arrowType == Qt::DownArrow;
d_data->arrowType == Qt::DownArrow;
const QRect r = labelRect();
QSize boundingSize = labelRect().size();
......@@ -163,32 +152,36 @@ void QwtArrowButton::drawButtonLabel(QPainter *painter)
boundingSize.transpose();
const int w =
(boundingSize.width() - (MaxNum - 1) * Spacing) / MaxNum;
( boundingSize.width() - ( MaxNum - 1 ) * Spacing ) / MaxNum;
QSize arrow = arrowSize(Qt::RightArrow,
QSize(w, boundingSize.height()));
QSize arrow = arrowSize( Qt::RightArrow,
QSize( w, boundingSize.height() ) );
if ( isVertical )
arrow.transpose();
QRect contentsSize; // aligned rect where to paint all arrows
if ( d_data->arrowType == Qt::LeftArrow || d_data->arrowType == Qt::RightArrow ) {
contentsSize.setWidth(d_data->num * arrow.width()
+ (d_data->num - 1) * Spacing);
contentsSize.setHeight(arrow.height());
} else {
contentsSize.setWidth(arrow.width());
contentsSize.setHeight(d_data->num * arrow.height()
+ (d_data->num - 1) * Spacing);
if ( d_data->arrowType == Qt::LeftArrow || d_data->arrowType == Qt::RightArrow )
{
contentsSize.setWidth( d_data->num * arrow.width()
+ ( d_data->num - 1 ) * Spacing );
contentsSize.setHeight( arrow.height() );
}
else
{
contentsSize.setWidth( arrow.width() );
contentsSize.setHeight( d_data->num * arrow.height()
+ ( d_data->num - 1 ) * Spacing );
}
QRect arrowRect(contentsSize);
arrowRect.moveCenter(r.center());
arrowRect.setSize(arrow);
QRect arrowRect( contentsSize );
arrowRect.moveCenter( r.center() );
arrowRect.setSize( arrow );
painter->save();
for (int i = 0; i < d_data->num; i++) {
drawArrow(painter, arrowRect, d_data->arrowType);
for ( int i = 0; i < d_data->num; i++ )
{
drawArrow( painter, arrowRect, d_data->arrowType );
int dx = 0;
int dy = 0;
......@@ -198,77 +191,66 @@ void QwtArrowButton::drawButtonLabel(QPainter *painter)
else
dx = arrow.width() + Spacing;
#if QT_VERSION >= 0x040000
arrowRect.translate(dx, dy);
#else
arrowRect.moveBy(dx, dy);
#endif
arrowRect.translate( dx, dy );
}
painter->restore();
if ( hasFocus() ) {
#if QT_VERSION >= 0x040000
if ( hasFocus() )
{
QStyleOptionFocusRect option;
option.init(this);
option.backgroundColor = palette().color(QPalette::Background);
style()->drawPrimitive(QStyle::PE_FrameFocusRect,
&option, painter, this);
#else
const QRect focusRect =
style().subRect(QStyle::SR_PushButtonFocusRect, this);
style().drawPrimitive(QStyle::PE_FocusRect, painter,
focusRect, colorGroup());
#endif
option.init( this );
option.backgroundColor = palette().color( QPalette::Window );
style()->drawPrimitive( QStyle::PE_FrameFocusRect,
&option, painter, this );
}
}
/*!
Draw an arrow int a bounding rect
Draw an arrow int a bounding rectangle
\param painter Painter
\param r Rectangle where to paint the arrow
\param arrowType Arrow type
*/
void QwtArrowButton::drawArrow(QPainter *painter,
const QRect &r, Qt::ArrowType arrowType) const
void QwtArrowButton::drawArrow( QPainter *painter,
const QRect &r, Qt::ArrowType arrowType ) const
{
QwtPolygon pa(3);
switch(arrowType) {
case Qt::UpArrow:
pa.setPoint(0, r.bottomLeft());
pa.setPoint(1, r.bottomRight());
pa.setPoint(2, r.center().x(), r.top());
break;
case Qt::DownArrow:
pa.setPoint(0, r.topLeft());
pa.setPoint(1, r.topRight());
pa.setPoint(2, r.center().x(), r.bottom());
break;
case Qt::RightArrow:
pa.setPoint(0, r.topLeft());
pa.setPoint(1, r.bottomLeft());
pa.setPoint(2, r.right(), r.center().y());
break;
case Qt::LeftArrow:
pa.setPoint(0, r.topRight());
pa.setPoint(1, r.bottomRight());
pa.setPoint(2, r.left(), r.center().y());
break;
default:
break;
QPolygon pa( 3 );
switch ( arrowType )
{
case Qt::UpArrow:
pa.setPoint( 0, r.bottomLeft() );
pa.setPoint( 1, r.bottomRight() );
pa.setPoint( 2, r.center().x(), r.top() );
break;
case Qt::DownArrow:
pa.setPoint( 0, r.topLeft() );
pa.setPoint( 1, r.topRight() );
pa.setPoint( 2, r.center().x(), r.bottom() );
break;
case Qt::RightArrow:
pa.setPoint( 0, r.topLeft() );
pa.setPoint( 1, r.bottomLeft() );
pa.setPoint( 2, r.right(), r.center().y() );
break;
case Qt::LeftArrow:
pa.setPoint( 0, r.topRight() );
pa.setPoint( 1, r.bottomRight() );
pa.setPoint( 2, r.left(), r.center().y() );
break;
default:
break;
}
painter->save();
#if QT_VERSION < 0x040000
painter->setPen(colorGroup().buttonText());
painter->setBrush(colorGroup().brush(QColorGroup::ButtonText));
#else
painter->setPen(palette().color(QPalette::ButtonText));
painter->setBrush(palette().brush(QPalette::ButtonText));
#endif
painter->drawPolygon(pa);
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setPen( Qt::NoPen );
painter->setBrush( palette().brush( QPalette::ButtonText ) );
painter->drawPolygon( pa );
painter->restore();
}
......@@ -277,7 +259,8 @@ void QwtArrowButton::drawArrow(QPainter *painter,
*/
QSize QwtArrowButton::sizeHint() const
{
return minimumSizeHint();
const QSize hint = minimumSizeHint();
return hint.expandedTo( QApplication::globalStrut() );
}
/*!
......@@ -285,43 +268,34 @@ QSize QwtArrowButton::sizeHint() const
*/
QSize QwtArrowButton::minimumSizeHint() const
{
const QSize asz = arrowSize(Qt::RightArrow, QSize());
const QSize asz = arrowSize( Qt::RightArrow, QSize() );
QSize sz(
2 * Margin + (MaxNum - 1) * Spacing + MaxNum * asz.width(),
2 * Margin + ( MaxNum - 1 ) * Spacing + MaxNum * asz.width(),
2 * Margin + asz.height()
);
if ( d_data->arrowType == Qt::UpArrow || d_data->arrowType == Qt::DownArrow )
sz.transpose();
#if QT_VERSION >= 0x040000
QStyleOption styleOption;
styleOption.init(this);
const QSize hsz = style()->sizeFromContents(QStyle::CT_PushButton,
&styleOption, sz, this);
#if QT_VERSION < 0x040300
if ( hsz.width() != 80 ) // avoid a bug in the Cleanlooks style
#endif
sz = hsz;
styleOption.init( this );
#else
sz = style().sizeFromContents(QStyle::CT_PushButton, this, sz);
#endif
sz = style()->sizeFromContents( QStyle::CT_PushButton,
&styleOption, sz, this );
return sz;
}
/*!
Calculate the size for a arrow that fits into a rect of a given size
Calculate the size for a arrow that fits into a rectangle of a given size
\param arrowType Arrow type
\param boundingSize Bounding size
\return Size of the arrow
*/
QSize QwtArrowButton::arrowSize(Qt::ArrowType arrowType,
const QSize &boundingSize) const
QSize QwtArrowButton::arrowSize( Qt::ArrowType arrowType,
const QSize &boundingSize ) const
{
QSize bs = boundingSize;
if ( arrowType == Qt::UpArrow || arrowType == Qt::DownArrow )
......@@ -329,17 +303,18 @@ QSize QwtArrowButton::arrowSize(Qt::ArrowType arrowType,
const int MinLen = 2;
const QSize sz = bs.expandedTo(
QSize(MinLen, 2 * MinLen - 1)); // minimum
QSize( MinLen, 2 * MinLen - 1 ) ); // minimum
int w = sz.width();
int h = 2 * w - 1;
if ( h > sz.height() ) {
if ( h > sz.height() )
{
h = sz.height();
w = (h + 1) / 2;
w = ( h + 1 ) / 2;
}
QSize arrSize(w, h);
QSize arrSize( w, h );
if ( arrowType == Qt::UpArrow || arrowType == Qt::DownArrow )
arrSize.transpose();
......@@ -349,10 +324,10 @@ QSize QwtArrowButton::arrowSize(Qt::ArrowType arrowType,
/*!
\brief autoRepeat for the space keys
*/
void QwtArrowButton::keyPressEvent(QKeyEvent *e)
void QwtArrowButton::keyPressEvent( QKeyEvent *event )
{
if ( e->isAutoRepeat() && e->key() == Qt::Key_Space )
emit clicked();
if ( event->isAutoRepeat() && event->key() == Qt::Key_Space )
Q_EMIT clicked();
QPushButton::keyPressEvent(e);
QPushButton::keyPressEvent( event );
}
libs/qwt/qwt_arrow_button.h
View file @ c96458cf
......@@ -10,8 +10,8 @@
#ifndef QWT_ARROW_BUTTON_H
#define QWT_ARROW_BUTTON_H
#include <qpushbutton.h>
#include "qwt_global.h"
#include <qpushbutton.h>
/*!
\brief Arrow Button
......@@ -23,7 +23,7 @@
class QWT_EXPORT QwtArrowButton : public QPushButton
{
public:
explicit QwtArrowButton (int num, Qt::ArrowType, QWidget *parent = NULL);
explicit QwtArrowButton ( int num, Qt::ArrowType, QWidget *parent = NULL );
virtual ~QwtArrowButton();
Qt::ArrowType arrowType() const;
......@@ -33,18 +33,16 @@ public:
virtual QSize minimumSizeHint() const;
protected:
#if QT_VERSION >= 0x040000
virtual void paintEvent(QPaintEvent *event);
#endif
virtual void paintEvent( QPaintEvent *event );
virtual void drawButtonLabel(QPainter *p);
virtual void drawArrow(QPainter *,
const QRect &, Qt::ArrowType) const;
virtual void drawButtonLabel( QPainter *p );
virtual void drawArrow( QPainter *,
const QRect &, Qt::ArrowType ) const;
virtual QRect labelRect() const;
virtual QSize arrowSize(Qt::ArrowType,
const QSize &boundingSize) const;
virtual QSize arrowSize( Qt::ArrowType,
const QSize &boundingSize ) const;
virtual void keyPressEvent(QKeyEvent *);
virtual void keyPressEvent( QKeyEvent * );
private:
class PrivateData;
......
libs/qwt/qwt_clipper.cpp
View file @ c96458cf
This diff is collapsed.
libs/qwt/qwt_clipper.h
View file @ c96458cf
......@@ -11,27 +11,30 @@
#define QWT_CLIPPER_H
#include "qwt_global.h"
#include "qwt_array.h"
#include "qwt_polygon.h"
#include "qwt_double_rect.h"
#include "qwt_double_interval.h"
#include "qwt_interval.h"
#include <qpolygon.h>
#include <qvector.h>
class QRect;
class QRectF;
/*!
\brief Some clipping algos
\brief Some clipping algorithms
*/
class QWT_EXPORT QwtClipper
{
public:
static QwtPolygon clipPolygon(const QRect &, const QwtPolygon &);
static QwtPolygonF clipPolygonF(const QwtDoubleRect &, const QwtPolygonF &);
static QPolygon clipPolygon( const QRect &,
const QPolygon &, bool closePolygon = false );
static QPolygon clipPolygon( const QRectF &,
const QPolygon &, bool closePolygon = false );
#if QT_VERSION >= 0x040000
static QwtArray<QwtDoubleInterval> clipCircle(
const QwtDoubleRect &, const QwtDoublePoint &, double radius);
#endif
static QPolygonF clipPolygonF( const QRectF &,
const QPolygonF &, bool closePolygon = false );
static QVector<QwtInterval> clipCircle(
const QRectF &, const QPointF &, double radius );
};
#endif
libs/qwt/qwt_color_map.cpp
View file @ c96458cf
This diff is collapsed.
libs/qwt/qwt_color_map.h
View file @ c96458cf
......@@ -10,21 +10,10 @@
#ifndef QWT_COLOR_MAP_H
#define QWT_COLOR_MAP_H
#include <qglobal.h>
#include "qwt_global.h"
#include "qwt_interval.h"
#include <qcolor.h>
#if QT_VERSION < 0x040000
#include <qvaluevector.h>
#else
#include <qvector.h>
#endif
#include "qwt_array.h"
#include "qwt_double_interval.h"
#if defined(QWT_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class QWT_EXPORT QwtArray<double>;
// MOC_SKIP_END
#endif
/*!
\brief QwtColorMap is used to map values into colors.
......@@ -45,67 +34,60 @@ class QWT_EXPORT QwtColorMap
{
public:
/*!
- RGB\n
The map is intended to map into QRgb values.
- Indexed\n
The map is intended to map into 8 bit values, that
are indices into the color table.
Format for color mapping
\sa rgb(), colorIndex(), colorTable()
*/
enum Format {
enum Format
{
//! The map is intended to map into RGB values.
RGB,
/*!
The map is intended to map into 8 bit values, that
are indices into the color table.
*/
Indexed
};
QwtColorMap(Format = QwtColorMap::RGB );
QwtColorMap( Format = QwtColorMap::RGB );
virtual ~QwtColorMap();
inline Format format() const;
//! Clone the color map
virtual QwtColorMap *copy() const = 0;
Format format() const;
/*!
Map a value of a given interval into a rgb value.
Map a value of a given interval into a RGB value.
\param interval Range for the values
\param value Value
\return rgb value, corresponding to value
\return RGB value, corresponding to value
*/
virtual QRgb rgb(
const QwtDoubleInterval &interval, double value) const = 0;
virtual QRgb rgb( const QwtInterval &interval,
double value ) const = 0;
/*!
Map a value of a given interval into a color index
\param interval Range for the values
\param value Value
\return color index, corresponding to value
*/
virtual unsigned char colorIndex(
const QwtDoubleInterval &interval, double value) const = 0;
const QwtInterval &interval, double value ) const = 0;
QColor color(const QwtDoubleInterval &, double value) const;
#if QT_VERSION < 0x040000
virtual QValueVector<QRgb> colorTable(const QwtDoubleInterval &) const;
#else
virtual QVector<QRgb> colorTable(const QwtDoubleInterval &) const;
#endif
QColor color( const QwtInterval &, double value ) const;
virtual QVector<QRgb> colorTable( const QwtInterval & ) const;
private:
Format d_format;
};
/*!
\brief QwtLinearColorMap builds a color map from color stops.
A color stop is a color at a specific position. The valid
range for the positions is [0.0, 1.0]. When mapping a value
into a color it is translated into this interval. If
mode() == FixedColors the color is calculated from the next lower
color stop. If mode() == ScaledColors the color is calculated
by interpolating the colors of the adjacent stops.
into a color it is translated into this interval according to mode().
*/
class QWT_EXPORT QwtLinearColorMap: public QwtColorMap
{
......@@ -114,67 +96,66 @@ public:
Mode of color map
\sa setMode(), mode()
*/
enum Mode {
enum Mode
{
//! Return the color from the next lower color stop
FixedColors,
//! Interpolating the colors of the adjacent stops.
ScaledColors
};
QwtLinearColorMap(QwtColorMap::Format = QwtColorMap::RGB);
QwtLinearColorMap( QwtColorMap::Format = QwtColorMap::RGB );
QwtLinearColorMap( const QColor &from, const QColor &to,
QwtColorMap::Format = QwtColorMap::RGB);
QwtLinearColorMap(const QwtLinearColorMap &);
QwtColorMap::Format = QwtColorMap::RGB );
virtual ~QwtLinearColorMap();
QwtLinearColorMap &operator=(const QwtLinearColorMap &);
virtual QwtColorMap *copy() const;
void setMode(Mode);
void setMode( Mode );
Mode mode() const;
void setColorInterval(const QColor &color1, const QColor &color2);
void addColorStop(double value, const QColor&);
QwtArray<double> colorStops() const;
void setColorInterval( const QColor &color1, const QColor &color2 );
void addColorStop( double value, const QColor& );
QVector<double> colorStops() const;
QColor color1() const;
QColor color2() const;
virtual QRgb rgb(const QwtDoubleInterval &, double value) const;
virtual QRgb rgb( const QwtInterval &, double value ) const;
virtual unsigned char colorIndex(
const QwtDoubleInterval &, double value) const;
const QwtInterval &, double value ) const;
class ColorStops;
private:
// Disabled copy constructor and operator=
QwtLinearColorMap( const QwtLinearColorMap & );
QwtLinearColorMap &operator=( const QwtLinearColorMap & );
class PrivateData;
PrivateData *d_data;
};
/*!
\brief QwtAlphaColorMap variies the alpha value of a color
\brief QwtAlphaColorMap varies the alpha value of a color
*/
class QWT_EXPORT QwtAlphaColorMap: public QwtColorMap
{
public:
QwtAlphaColorMap(const QColor & = QColor(Qt::gray));
QwtAlphaColorMap(const QwtAlphaColorMap &);
QwtAlphaColorMap( const QColor & = QColor( Qt::gray ) );
virtual ~QwtAlphaColorMap();
QwtAlphaColorMap &operator=(const QwtAlphaColorMap &);
virtual QwtColorMap *copy() const;
void setColor(const QColor &);
void setColor( const QColor & );
QColor color() const;
virtual QRgb rgb(const QwtDoubleInterval &, double value) const;
virtual QRgb rgb( const QwtInterval &, double value ) const;
private:
QwtAlphaColorMap( const QwtAlphaColorMap & );
QwtAlphaColorMap &operator=( const QwtAlphaColorMap & );
virtual unsigned char colorIndex(
const QwtDoubleInterval &, double value) const;
const QwtInterval &, double value ) const;
class PrivateData;
PrivateData *d_data;
......@@ -194,13 +175,16 @@ private:
color table once and find the color using colorIndex().
*/
inline QColor QwtColorMap::color(
const QwtDoubleInterval &interval, double value) const
const QwtInterval &interval, double value ) const
{
if ( d_format == RGB ) {
return QColor( rgb(interval, value) );
} else {
const unsigned int index = colorIndex(interval, value);
return colorTable(interval)[index]; // slow
if ( d_format == RGB )
{
return QColor( rgb( interval, value ) );
}
else
{
const unsigned int index = colorIndex( interval, value );
return colorTable( interval )[index]; // slow
}
}
......
libs/qwt/qwt_column_symbol.cpp 0 → 100644
View file @ c96458cf
This diff is collapsed.
libs/qwt/qwt_column_symbol.h 0 → 100644
View file @ c96458cf
This diff is collapsed.
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment