Qwt User's Guide 6.0.1

- Main Page
- Related Pages
- Classes
- Files

- File List

# qwt_interval.h

    00001 /* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
    00002  * Qwt Widget Library
    00003  * Copyright (C) 1997   Josef Wilgen
    00004  * Copyright (C) 2002   Uwe Rathmann
    00005  *
    00006  * This library is free software; you can redistribute it and/or
    00007  * modify it under the terms of the Qwt License, Version 1.0
    00008  *****************************************************************************/
    00009
    00010 #ifndef QWT_INTERVAL_H
    00011 #define QWT_INTERVAL_H
    00012
    00013 #include "qwt_global.h"
    00014 #ifndef QT_NO_DEBUG_STREAM
    00015 #include <qdebug.h>
    00016 #endif
    00017
    00024 class QWT_EXPORT QwtInterval
    00025 {
    00026 public:
    00031     enum BorderFlag
    00032     {
    00034         IncludeBorders = 0x00,
    00035
    00037         ExcludeMinimum = 0x01,
    00038
    00040         ExcludeMaximum = 0x02,
    00041
    00043         ExcludeBorders = ExcludeMinimum | ExcludeMaximum
    00044     };
    00045
    00047     typedef QFlags<BorderFlag> BorderFlags;
    00048
    00049     QwtInterval();
    00050     QwtInterval( double minValue, double maxValue,
    00051         BorderFlags = IncludeBorders );
    00052
    00053     void setInterval( double minValue, double maxValue,
    00054         BorderFlags = IncludeBorders );
    00055
    00056     QwtInterval normalized() const;
    00057     QwtInterval inverted() const;
    00058     QwtInterval limited( double minValue, double maxValue ) const;
    00059
    00060     bool operator==( const QwtInterval & ) const;
    00061     bool operator!=( const QwtInterval & ) const;
    00062
    00063     void setBorderFlags( BorderFlags );
    00064     BorderFlags borderFlags() const;
    00065
    00066     double minValue() const;
    00067     double maxValue() const;
    00068
    00069     double width() const;
    00070
    00071     void setMinValue( double );
    00072     void setMaxValue( double );
    00073
    00074     bool contains( double value ) const;
    00075
    00076     bool intersects( const QwtInterval & ) const;
    00077     QwtInterval intersect( const QwtInterval & ) const;
    00078     QwtInterval unite( const QwtInterval & ) const;
    00079
    00080     QwtInterval operator|( const QwtInterval & ) const;
    00081     QwtInterval operator&( const QwtInterval & ) const;
    00082
    00083     QwtInterval &operator|=( const QwtInterval & );
    00084     QwtInterval &operator&=( const QwtInterval & );
    00085
    00086     QwtInterval extend( double value ) const;
    00087     QwtInterval operator|( double ) const;
    00088     QwtInterval &operator|=( double );
    00089
    00090     bool isValid() const;
    00091     bool isNull() const;
    00092     void invalidate();
    00093
    00094     QwtInterval symmetrize( double value ) const;
    00095
    00096 private:
    00097     double d_minValue;
    00098     double d_maxValue;
    00099     BorderFlags d_borderFlags;
    00100 };
    00101
    00102 Q_DECLARE_TYPEINFO(QwtInterval, Q_MOVABLE_TYPE);
    00103
    00110 inline QwtInterval::QwtInterval():
    00111     d_minValue( 0.0 ),
    00112     d_maxValue( -1.0 ),
    00113     d_borderFlags( IncludeBorders )
    00114 {
    00115 }
    00116
    00126 inline QwtInterval::QwtInterval(
    00127         double minValue, double maxValue, BorderFlags borderFlags ):
    00128     d_minValue( minValue ),
    00129     d_maxValue( maxValue ),
    00130     d_borderFlags( borderFlags )
    00131 {
    00132 }
    00133
    00141 inline void QwtInterval::setInterval(
    00142     double minValue, double maxValue, BorderFlags borderFlags )
    00143 {
    00144     d_minValue = minValue;
    00145     d_maxValue = maxValue;
    00146     d_borderFlags = borderFlags;
    00147 }
    00148
    00155 inline void QwtInterval::setBorderFlags( BorderFlags borderFlags )
    00156 {
    00157     d_borderFlags = borderFlags;
    00158 }
    00159
    00164 inline QwtInterval::BorderFlags QwtInterval::borderFlags() const
    00165 {
    00166     return d_borderFlags;
    00167 }
    00168
    00174 inline void QwtInterval::setMinValue( double minValue )
    00175 {
    00176     d_minValue = minValue;
    00177 }
    00178
    00184 inline void QwtInterval::setMaxValue( double maxValue )
    00185 {
    00186     d_maxValue = maxValue;
    00187 }
    00188
    00190 inline double QwtInterval::minValue() const
    00191 {
    00192     return d_minValue;
    00193 }
    00194
    00196 inline double QwtInterval::maxValue() const
    00197 {
    00198     return d_maxValue;
    00199 }
    00200
    00208 inline double QwtInterval::width() const
    00209 {
    00210     return isValid() ? ( d_maxValue - d_minValue ) : 0.0;
    00211 }
    00212
    00217 inline QwtInterval QwtInterval::operator&(
    00218     const QwtInterval &interval ) const
    00219 {
    00220     return intersect( interval );
    00221 }
    00222
    00227 inline QwtInterval QwtInterval::operator|(
    00228     const QwtInterval &interval ) const
    00229 {
    00230     return unite( interval );
    00231 }
    00232
    00234 inline bool QwtInterval::operator==( const QwtInterval &other ) const
    00235 {
    00236     return ( d_minValue == other.d_minValue ) &&
    00237            ( d_maxValue == other.d_maxValue ) &&
    00238            ( d_borderFlags == other.d_borderFlags );
    00239 }
    00240
    00242 inline bool QwtInterval::operator!=( const QwtInterval &other ) const
    00243 {
    00244     return ( !( *this == other ) );
    00245 }
    00246
    00254 inline QwtInterval QwtInterval::operator|( double value ) const
    00255 {
    00256     return extend( value );
    00257 }
    00258
    00260 inline bool QwtInterval::isNull() const
    00261 {
    00262     return isValid() && d_minValue >= d_maxValue;
    00263 }
    00264
    00270 inline bool QwtInterval::isValid() const
    00271 {
    00272     if ( ( d_borderFlags & ExcludeBorders ) == 0 )
    00273         return d_minValue <= d_maxValue;
    00274     else
    00275         return d_minValue < d_maxValue;
    00276 }
    00277
    00284 inline void QwtInterval::invalidate()
    00285 {
    00286     d_minValue = 0.0;
    00287     d_maxValue = -1.0;
    00288 }
    00289
    00290 Q_DECLARE_OPERATORS_FOR_FLAGS( QwtInterval::BorderFlags )
    00291
    00292 #ifndef QT_NO_DEBUG_STREAM
    00293 QWT_EXPORT QDebug operator<<( QDebug, const QwtInterval & );
    00294 #endif
    00295
    00296 #endif