qwt_double_rect.h

/* -*- 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_DOUBLE_RECT_H
#define QWT_DOUBLE_RECT_H 1

#include "qwt_global.h"
#include "qwt_array.h"

#if QT_VERSION >= 0x040000

#include <QPointF>
#include <QSizeF>
#include <QRectF>

typedef QPointF QwtDoublePoint;
typedef QSizeF QwtDoubleSize;
typedef QRectF QwtDoubleRect;

#else

#include <qpoint.h>
#include <qsize.h>
#include <qrect.h>

class QWT_EXPORT QwtDoublePoint
{
public:
    QwtDoublePoint();
    QwtDoublePoint(double x, double y);
    QwtDoublePoint(const QPoint &);

    QPoint toPoint() const;

    bool isNull()    const;

    double x() const;
    double y() const;

    double &rx();
    double &ry();

    void setX(double x);
    void setY(double y);

    bool operator==(const QwtDoublePoint &) const;
    bool operator!=(const QwtDoublePoint &) const;

    const QwtDoublePoint operator-() const;
    const QwtDoublePoint operator+(const QwtDoublePoint &) const;
    const QwtDoublePoint operator-(const QwtDoublePoint &) const;
    const QwtDoublePoint operator*(double) const;
    const QwtDoublePoint operator/(double) const;

    QwtDoublePoint &operator+=(const QwtDoublePoint &);
    QwtDoublePoint &operator-=(const QwtDoublePoint &);
    QwtDoublePoint &operator*=(double);
    QwtDoublePoint &operator/=(double);

private:
    double d_x;
    double d_y;
};

class QWT_EXPORT QwtDoubleSize
{
public:
    QwtDoubleSize();
    QwtDoubleSize(double width, double height);
    QwtDoubleSize(const QSize &);

    bool isNull() const;
    bool isEmpty() const;
    bool isValid() const;

    double width() const;
    double height() const;
    void setWidth( double w );
    void setHeight( double h );
    void transpose();

    QwtDoubleSize expandedTo(const QwtDoubleSize &) const;
    QwtDoubleSize boundedTo(const QwtDoubleSize &) const;

    bool operator==(const QwtDoubleSize &) const;
    bool operator!=(const QwtDoubleSize &) const;

    const QwtDoubleSize operator+(const QwtDoubleSize &) const;
    const QwtDoubleSize operator-(const QwtDoubleSize &) const;
    const QwtDoubleSize operator*(double) const;
    const QwtDoubleSize operator/(double) const;

    QwtDoubleSize &operator+=(const QwtDoubleSize &);
    QwtDoubleSize &operator-=(const QwtDoubleSize &);
    QwtDoubleSize &operator*=(double c);
    QwtDoubleSize &operator/=(double c);

private:
    double d_width;
    double d_height;
};

class QWT_EXPORT QwtDoubleRect  
{
public:
    QwtDoubleRect();
    QwtDoubleRect(double left, double top, double width, double height);
    QwtDoubleRect(const QwtDoublePoint&, const QwtDoubleSize &);

    bool isNull()    const;
    bool isEmpty()   const;
    bool isValid()   const;

    QwtDoubleRect normalized() const;

    double x()  const;
    double y()  const;

    double left()  const;
    double right()  const;
    double top()  const;
    double bottom()  const;

    void setX(double);
    void setY(double);

    void setLeft(double);
    void setRight(double);
    void setTop(double);
    void setBottom(double);

    QwtDoublePoint center()  const;

    void moveLeft(double x);
    void moveRight(double x);
    void moveTop(double y );
    void moveBottom(double y );
    void moveTo(double x, double y);
    void moveTo(const QwtDoublePoint &);
    void moveBy(double dx, double dy);
    void moveCenter(const QwtDoublePoint &);
    void moveCenter(double dx, double dy);

    void setRect(double x1, double x2, double width, double height);

    double width()   const;
    double height()  const;
    QwtDoubleSize size() const;

    void setWidth(double w );
    void setHeight(double h );
    void setSize(const QwtDoubleSize &);

    QwtDoubleRect  operator|(const QwtDoubleRect &r) const;
    QwtDoubleRect  operator&(const QwtDoubleRect &r) const;
    QwtDoubleRect &operator|=(const QwtDoubleRect &r);
    QwtDoubleRect &operator&=(const QwtDoubleRect &r);
    bool operator==( const QwtDoubleRect &) const;
    bool operator!=( const QwtDoubleRect &) const;

    bool contains(const QwtDoublePoint &p, bool proper = false) const;
    bool contains(double x, double y, bool proper = false) const; 
    bool contains(const QwtDoubleRect &r, bool proper=false) const;

    QwtDoubleRect unite(const QwtDoubleRect &) const;
    QwtDoubleRect intersect(const QwtDoubleRect &) const;
    bool intersects(const QwtDoubleRect &) const;

private:
    double d_left;
    double d_right;
    double d_top;
    double d_bottom;
};

inline bool QwtDoublePoint::isNull() const
{ 
    return d_x == 0.0 && d_y == 0.0; 
}

inline double QwtDoublePoint::x() const
{ 
    return d_x; 
}

inline double QwtDoublePoint::y() const
{   
    return d_y; 
}

inline double &QwtDoublePoint::rx()
{
    return d_x;
}

inline double &QwtDoublePoint::ry()
{
    return d_y;
}

inline void QwtDoublePoint::setX(double x)
{ 
    d_x = x; 
}

inline void QwtDoublePoint::setY(double y)
{ 
    d_y = y; 
}

inline QPoint QwtDoublePoint::toPoint() const
{
    return QPoint(qRound(d_x), qRound(d_y));
}

inline bool QwtDoubleSize::isNull() const
{ 
    return d_width == 0.0 && d_height == 0.0; 
}

inline bool QwtDoubleSize::isEmpty() const
{ 
    return d_width <= 0.0 || d_height <= 0.0; 
}

inline bool QwtDoubleSize::isValid() const
{ 
    return d_width >= 0.0 && d_height >= 0.0; 
}

inline double QwtDoubleSize::width() const
{ 
    return d_width; 
}

inline double QwtDoubleSize::height() const
{ 
    return d_height; 
}

inline void QwtDoubleSize::setWidth(double width)
{ 
    d_width = width; 
}

inline void QwtDoubleSize::setHeight(double height)
{ 
    d_height = height; 
}

inline bool QwtDoubleRect::isNull() const
{ 
    return d_right == d_left && d_bottom == d_top;
}

inline bool QwtDoubleRect::isEmpty() const
{ 
    return d_left >= d_right || d_top >= d_bottom; 
}

inline bool QwtDoubleRect::isValid() const
{ 
    return d_left < d_right && d_top < d_bottom; 
}

inline double QwtDoubleRect::x() const
{ 
    return d_left; 
}

inline double QwtDoubleRect::y() const
{ 
    return d_top; 
}

inline double QwtDoubleRect::left() const
{ 
    return d_left; 
}

inline double QwtDoubleRect::right() const
{ 
    return d_right; 
}

inline double QwtDoubleRect::top() const
{ 
    return d_top; 
}

inline double QwtDoubleRect::bottom() const
{ 
    return d_bottom; 
}

inline void QwtDoubleRect::setX(double x)
{ 
    d_left = x;
}

inline void QwtDoubleRect::setY(double y)
{ 
    d_top = y;
}

inline void QwtDoubleRect::setLeft(double x)
{ 
    d_left = x;
}

inline void QwtDoubleRect::setRight(double x)
{ 
    d_right = x;
}

inline void QwtDoubleRect::setTop(double y)
{ 
    d_top = y;
}

inline void QwtDoubleRect::setBottom(double y)
{ 
    d_bottom = y;
}

inline double QwtDoubleRect::width() const
{ 
    return  d_right - d_left; 
}

inline double QwtDoubleRect::height() const
{ 
    return  d_bottom - d_top; 
}

inline QwtDoubleSize QwtDoubleRect::size() const
{ 
    return QwtDoubleSize(width(), height());
}

inline void QwtDoubleRect::setWidth(double w)
{
    d_right = d_left + w;
}

inline void QwtDoubleRect::setHeight(double h)
{
    d_bottom = d_top + h;
}

inline void QwtDoubleRect::moveTo(const QwtDoublePoint &p)
{
    moveTo(p.x(), p.y());
}

#endif // QT_VERSION < 0x040000

#endif // QWT_DOUBLE_RECT_H

---