qpen.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qpen.h"
#include "qpen_p.h"
#include "qdatastream.h"
#include "qvariant.h"
#include "qbrush.h"
 
#include <qdebug.h>
 
QT_BEGIN_NAMESPACE
 
typedef QPenPrivate QPenData;
 
QPenPrivate::QPenPrivate(const QBrush &_brush, qreal _width, Qt::PenStyle penStyle,
                         Qt::PenCapStyle _capStyle, Qt::PenJoinStyle _joinStyle)
    : ref(1), dashOffset(0), miterLimit(2),
      cosmetic(false)
{
    width = _width;
    brush = _brush;
    style = penStyle;
    capStyle = _capStyle;
    joinStyle = _joinStyle;
}
 
static const Qt::PenCapStyle qpen_default_cap = Qt::SquareCap;
static const Qt::PenJoinStyle qpen_default_join = Qt::BevelJoin;
 
class QPenDataHolder
{
public:
    QPenData *pen;
    QPenDataHolder(const QBrush &brush, qreal width, Qt::PenStyle penStyle,
                   Qt::PenCapStyle penCapStyle, Qt::PenJoinStyle _joinStyle)
        : pen(new QPenData(brush, width, penStyle, penCapStyle, _joinStyle))
    { }
    ~QPenDataHolder()
    {
        if (!pen->ref.deref())
            delete pen;
        pen = nullptr;
    }
};
 
Q_GLOBAL_STATIC_WITH_ARGS(QPenDataHolder, defaultPenInstance,
                          (Qt::black, 1, Qt::SolidLine, qpen_default_cap, qpen_default_join))
Q_GLOBAL_STATIC_WITH_ARGS(QPenDataHolder, nullPenInstance,
                          (Qt::black, 1, Qt::NoPen, qpen_default_cap, qpen_default_join))
 
QPen::QPen()
{
    d = defaultPenInstance()->pen;
    d->ref.ref();
}
 
QPen::QPen(Qt::PenStyle style)
{
    if (style == Qt::NoPen) {
        d = nullPenInstance()->pen;
        d->ref.ref();
    } else {
        d = new QPenData(Qt::black, 1, style, qpen_default_cap, qpen_default_join);
    }
}
 
 
QPen::QPen(const QColor &color)
{
    d = new QPenData(color, 1, Qt::SolidLine, qpen_default_cap, qpen_default_join);
}
 
 
QPen::QPen(const QBrush &brush, qreal width, Qt::PenStyle s, Qt::PenCapStyle c, Qt::PenJoinStyle j)
{
    d = new QPenData(brush, width, s, c, j);
}
 
QPen::QPen(const QPen &p) noexcept
{
    d = p.d;
    if (d)
        d->ref.ref();
}
 
 
QPen::~QPen()
{
    if (d && !d->ref.deref())
        delete d;
}
 
void QPen::detach()
{
    if (d->ref.loadRelaxed() == 1)
        return;
 
    QPenData *x = new QPenData(*static_cast<QPenData *>(d));
    if (!d->ref.deref())
        delete d;
    x->ref.storeRelaxed(1);
    d = x;
}
 
 
QPen &QPen::operator=(const QPen &p) noexcept
{
    QPen(p).swap(*this);
    return *this;
}
 
QPen::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
Qt::PenStyle QPen::style() const
{
    return d->style;
}
void QPen::setStyle(Qt::PenStyle s)
{
    if (d->style == s)
        return;
    detach();
    d->style = s;
    QPenData *dd = static_cast<QPenData *>(d);
    dd->dashPattern.clear();
    dd->dashOffset = 0;
}
 
QList<qreal> QPen::dashPattern() const
{
    QPenData *dd = static_cast<QPenData *>(d);
    if (d->style == Qt::SolidLine || d->style == Qt::NoPen) {
        return QList<qreal>();
    } else if (dd->dashPattern.isEmpty()) {
        const qreal space = 2;
        const qreal dot = 1;
        const qreal dash = 4;
 
        switch (d->style) {
        case Qt::DashLine:
            dd->dashPattern.reserve(2);
            dd->dashPattern << dash << space;
            break;
        case Qt::DotLine:
            dd->dashPattern.reserve(2);
            dd->dashPattern << dot << space;
            break;
        case Qt::DashDotLine:
            dd->dashPattern.reserve(4);
            dd->dashPattern << dash << space << dot << space;
            break;
        case Qt::DashDotDotLine:
            dd->dashPattern.reserve(6);
            dd->dashPattern << dash << space << dot << space << dot << space;
            break;
        default:
            break;
        }
    }
    return dd->dashPattern;
}
 
void QPen::setDashPattern(const QList<qreal> &pattern)
{
    if (pattern.isEmpty())
        return;
    detach();
 
    QPenData *dd = static_cast<QPenData *>(d);
    dd->dashPattern = pattern;
    d->style = Qt::CustomDashLine;
 
    if ((dd->dashPattern.size() % 2) == 1) {
        qWarning("QPen::setDashPattern: Pattern not of even length");
        dd->dashPattern << 1;
    }
}
 
 
qreal QPen::dashOffset() const
{
    QPenData *dd = static_cast<QPenData *>(d);
    return dd->dashOffset;
}
void QPen::setDashOffset(qreal offset)
{
    if (qFuzzyCompare(offset, static_cast<QPenData *>(d)->dashOffset))
        return;
    detach();
    QPenData *dd = static_cast<QPenData *>(d);
    dd->dashOffset = offset;
    if (d->style != Qt::CustomDashLine) {
        dd->dashPattern = dashPattern();
        d->style = Qt::CustomDashLine;
    }
}
 
qreal QPen::miterLimit() const
{
    const QPenData *dd = static_cast<QPenData *>(d);
    return dd->miterLimit;
}
 
void QPen::setMiterLimit(qreal limit)
{
    detach();
    QPenData *dd = static_cast<QPenData *>(d);
    dd->miterLimit = limit;
}
 
 
int QPen::width() const
{
    return qRound(d->width);
}
 
qreal QPen::widthF() const
{
    return d->width;
}
 
void QPen::setWidth(int width)
{
    if (width < 0 || width >= (1 << 15)) {
        qWarning("QPen::setWidth: Setting a pen width that is out of range");
        return;
    }
    if ((qreal)width == d->width)
        return;
    detach();
    d->width = width;
}
 
void QPen::setWidthF(qreal width)
{
    if (width < 0.f || width >= (1 << 15)) {
        qWarning("QPen::setWidthF: Setting a pen width that is out of range");
        return;
    }
    if (qAbs(d->width - width) < 0.00000001f)
        return;
    detach();
    d->width = width;
}
 
 
Qt::PenCapStyle QPen::capStyle() const
{
    return d->capStyle;
}
 
void QPen::setCapStyle(Qt::PenCapStyle c)
{
    if (d->capStyle == c)
        return;
    detach();
    d->capStyle = c;
}
 
Qt::PenJoinStyle QPen::joinStyle() const
{
    return d->joinStyle;
}
 
void QPen::setJoinStyle(Qt::PenJoinStyle j)
{
    if (d->joinStyle == j)
        return;
    detach();
    d->joinStyle = j;
}
 
QColor QPen::color() const
{
    return d->brush.color();
}
 
void QPen::setColor(const QColor &c)
{
    detach();
    d->brush = QBrush(c);
}
 
 
QBrush QPen::brush() const
{
    return d->brush;
}
 
void QPen::setBrush(const QBrush &brush)
{
    detach();
    d->brush = brush;
}
 
 
bool QPen::isSolid() const
{
    return d->brush.style() == Qt::SolidPattern;
}
 
 
bool QPen::isCosmetic() const
{
    QPenData *dd = static_cast<QPenData *>(d);
    return (dd->cosmetic == true) || d->width == 0;
}
 
 
void QPen::setCosmetic(bool cosmetic)
{
    detach();
    QPenData *dd = static_cast<QPenData *>(d);
    dd->cosmetic = cosmetic;
}
 
 
 
bool QPen::operator==(const QPen &p) const
{
    QPenData *dd = static_cast<QPenData *>(d);
    QPenData *pdd = static_cast<QPenData *>(p.d);
    return (p.d == d)
        || (p.d->style == d->style
            && p.d->capStyle == d->capStyle
            && p.d->joinStyle == d->joinStyle
            && p.d->width == d->width
            && pdd->miterLimit == dd->miterLimit
            && (d->style != Qt::CustomDashLine
                || (qFuzzyCompare(pdd->dashOffset, dd->dashOffset) &&
                    pdd->dashPattern == dd->dashPattern))
            && p.d->brush == d->brush
            && pdd->cosmetic == dd->cosmetic);
}
 
 
bool QPen::isDetached()
{
    return d->ref.loadRelaxed() == 1;
}
 
 
/*****************************************************************************
  QPen stream functions
 *****************************************************************************/
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &s, const QPen &p)
{
    QPenData *dd = static_cast<QPenData *>(p.d);
    if (s.version() < 3) {
        s << (quint8)p.style();
    } else if (s.version() < QDataStream::Qt_4_3) {
        s << (quint8)(uint(p.style()) | uint(p.capStyle()) | uint(p.joinStyle()));
    } else {
        s << (quint16)(uint(p.style()) | uint(p.capStyle()) | uint(p.joinStyle()));
        s << (bool)(dd->cosmetic);
    }
 
    if (s.version() < 7) {
        s << (quint8)p.width();
        s << p.color();
    } else {
        s << double(p.widthF());
        s << p.brush();
        s << double(p.miterLimit());
        if (sizeof(qreal) == sizeof(double)) {
            s << p.dashPattern();
        } else {
            // ensure that we write doubles here instead of streaming the pattern
            // directly; otherwise, platforms that redefine qreal might generate
            // data that cannot be read on other platforms.
            QList<qreal> pattern = p.dashPattern();
            s << quint32(pattern.size());
            for (int i = 0; i < pattern.size(); ++i)
                s << double(pattern.at(i));
        }
        if (s.version() >= 9)
            s << double(p.dashOffset());
        if (s.version() >= QDataStream::Qt_5_0)
            s << bool(qFuzzyIsNull(p.widthF()));
    }
    return s;
}
 
QDataStream &operator>>(QDataStream &s, QPen &p)
{
    quint16 style;
    quint8 width8 = 0;
    double width = 0;
    QColor color;
    QBrush brush;
    double miterLimit = 2;
    QList<qreal> dashPattern;
    double dashOffset = 0;
    bool cosmetic = false;
    bool defaultWidth;
    if (s.version() < QDataStream::Qt_4_3) {
        quint8 style8;
        s >> style8;
        style = style8;
    } else {
        s >> style;
        s >> cosmetic;
    }
    if (s.version() < 7) {
        s >> width8;
        s >> color;
        brush = color;
        width = width8;
    } else {
        s >> width;
        s >> brush;
        s >> miterLimit;
        if (sizeof(qreal) == sizeof(double)) {
            s >> dashPattern;
        } else {
            quint32 numDashes;
            s >> numDashes;
            double dash;
            dashPattern.reserve(numDashes);
            for (quint32 i = 0; i < numDashes; ++i) {
                s >> dash;
                dashPattern << dash;
            }
        }
        if (s.version() >= 9)
            s >> dashOffset;
    }
 
    if (s.version() >= QDataStream::Qt_5_0) {
        s >> defaultWidth;
    }
 
    p.detach();
    QPenData *dd = static_cast<QPenData *>(p.d);
    dd->width = width;
    dd->brush = brush;
    dd->style = Qt::PenStyle(style & Qt::MPenStyle);
    dd->capStyle = Qt::PenCapStyle(style & Qt::MPenCapStyle);
    dd->joinStyle = Qt::PenJoinStyle(style & Qt::MPenJoinStyle);
    dd->dashPattern = dashPattern;
    dd->miterLimit = miterLimit;
    dd->dashOffset = dashOffset;
    dd->cosmetic = cosmetic;
 
    return s;
}
#endif //QT_NO_DATASTREAM
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QPen &p)
{
    const char *PEN_STYLES[] = {
        "NoPen",
        "SolidLine",
        "DashLine",
        "DotLine",
        "DashDotLine",
        "DashDotDotLine",
        "CustomDashLine"
    };
 
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QPen(" << p.width() << ',' << p.brush()
                  << ',' << PEN_STYLES[p.style()] << ',' << int(p.capStyle())
                  << ',' << int(p.joinStyle()) << ',' << p.dashPattern()
                  << ',' << p.dashOffset()
                  << ',' << p.miterLimit() << ')';
    return dbg;
}
#endif
 
QT_END_NAMESPACE
 
#undef QT_COMPILING_QPEN