File indexing completed on 2024-04-28 04:05:02

 /*
     SPDX-FileCopyrightText: 2010 Stefan Majewsky <majewsky@gmx.net>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "colorproxy_p.h"
 
 // Qt
 #include <QPainterPath>
 
 // BEGIN QPaintDeviceColorProxy
 
 QPaintDeviceColorProxy::QPaintDeviceColorProxy(QPaintDevice *proxiedDevice, const QHash<QColor, QColor> &replacements)
     : m_proxiedDevice(proxiedDevice)
     , m_engine(new QPaintEngineColorProxy)
     , m_replacements(replacements)
 {
 }
 
 QPaintDeviceColorProxy::~QPaintDeviceColorProxy()
 {
     delete m_engine;
 }
 
 QPaintDevice *QPaintDeviceColorProxy::proxiedDevice() const
 {
     return m_proxiedDevice;
 }
 
 QPaintEngine *QPaintDeviceColorProxy::paintEngine() const
 {
     return m_engine;
 }
 
 int QPaintDeviceColorProxy::metric(QPaintDevice::PaintDeviceMetric metric) const
 {
     // return m_proxiedDevice->metric(metric);
     // This does not work because m_proxiedDevice->QPaintDevice::metric() is
     // protected, so we have to do the monkey dance instead.
 
     typedef int (QPaintDevice::*MetricFunction)(void) const;
     static const MetricFunction metricFunctions[] = {nullptr,
                                                      &QPaintDevice::width, // QPaintDevice::PdmWidth == 1
                                                      &QPaintDevice::height,
                                                      &QPaintDevice::widthMM,
                                                      &QPaintDevice::heightMM,
                                                      &QPaintDevice::colorCount,
                                                      &QPaintDevice::depth,
                                                      &QPaintDevice::logicalDpiX,
                                                      &QPaintDevice::logicalDpiY,
                                                      &QPaintDevice::physicalDpiX,
                                                      &QPaintDevice::physicalDpiY};
     return (m_proxiedDevice->*metricFunctions[metric])();
 }
 
 QBrush QPaintDeviceColorProxy::map(const QBrush &brush) const
 {
     const Qt::BrushStyle style = brush.style();
     const bool isGradient = style == Qt::LinearGradientPattern || style == Qt::RadialGradientPattern || style == Qt::ConicalGradientPattern;
     // copy the given brush and map the contained color
     if (!isGradient) {
         QBrush result(brush);
         result.setColor(map(brush.color()));
         return result;
     }
     // for gradients, map colors of gradient stops
     QGradient newGradient(*brush.gradient());
     QGradientStops stops = newGradient.stops();
     for (QGradientStop &stop : stops) {
         stop.second = map(stop.second);
     }
     newGradient.setStops(stops);
     // there is no QBrush::setGradient(), so we have to clone the instance by hand
     QBrush result(newGradient);
     result.setTransform(brush.transform());
     return result;
 }
 
 QColor QPaintDeviceColorProxy::map(const QColor &color) const
 {
     return m_replacements.value(color, color);
 }
 
 QPen QPaintDeviceColorProxy::map(const QPen &pen) const
 {
     QPen result(pen);
     result.setBrush(map(pen.brush()));
     return result;
 }
 
 // END QPaintDeviceColorProxy
 
 // BEGIN QPaintEngineColorProxy
 
 QPaintEngineColorProxy::QPaintEngineColorProxy()
     : m_proxy(nullptr)
     , m_painter(new QPainter)
 {
 }
 
 QPaintEngineColorProxy::~QPaintEngineColorProxy()
 {
     if (m_proxy) {
         end();
     }
     delete m_painter;
 }
 
 bool QPaintEngineColorProxy::begin(QPaintDevice *device)
 {
     // previous operation not ended?
     if (m_proxy) {
         return false;
     }
     // allow only proxy devices
     QPaintDeviceColorProxy *proxyDevice = dynamic_cast<QPaintDeviceColorProxy *>(device);
     if (!proxyDevice) {
         return false;
     }
     // check proxied device
     QPaintDevice *proxiedDevice = proxyDevice->proxiedDevice();
     if (!proxiedDevice) {
         return false;
     }
     // start to paint on proxied device
     m_painter = new QPainter;
     if (!m_painter->begin(proxiedDevice)) {
         return false;
     }
     // success
     m_proxy = proxyDevice;
     return true;
 }
 
 bool QPaintEngineColorProxy::end()
 {
     if (!m_proxy) {
         return false;
     }
     m_proxy = nullptr;
     return m_painter->end();
 }
 
 void QPaintEngineColorProxy::drawEllipse(const QRectF &rect)
 {
     if (m_proxy) {
         m_painter->drawEllipse(rect);
     }
 }
 
 void QPaintEngineColorProxy::drawEllipse(const QRect &rect)
 {
     if (m_proxy) {
         m_painter->drawEllipse(rect);
     }
 }
 
 void QPaintEngineColorProxy::drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags flags)
 {
     if (m_proxy) {
         m_painter->drawImage(rectangle, image, sr, flags);
     }
 }
 
 void QPaintEngineColorProxy::drawLines(const QLineF *lines, int lineCount)
 {
     if (m_proxy) {
         m_painter->drawLines(lines, lineCount);
     }
 }
 
 void QPaintEngineColorProxy::drawLines(const QLine *lines, int lineCount)
 {
     if (m_proxy) {
         m_painter->drawLines(lines, lineCount);
     }
 }
 
 void QPaintEngineColorProxy::drawPath(const QPainterPath &path)
 {
     if (m_proxy) {
         m_painter->drawPath(path);
     }
 }
 
 void QPaintEngineColorProxy::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
 {
     if (m_proxy) {
         m_painter->drawPixmap(r, pm, sr);
     }
 }
 
 void QPaintEngineColorProxy::drawPoints(const QPointF *points, int pointCount)
 {
     if (m_proxy) {
         m_painter->drawPoints(points, pointCount);
     }
 }
 
 void QPaintEngineColorProxy::drawPoints(const QPoint *points, int pointCount)
 {
     if (m_proxy) {
         m_painter->drawPoints(points, pointCount);
     }
 }
 
 void QPaintEngineColorProxy::drawPolygon(const QPointF *points, int pointCount, QPaintEngine::PolygonDrawMode mode)
 {
     if (m_proxy) {
         m_painter->drawPolygon(points, pointCount, mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
     }
 }
 
 void QPaintEngineColorProxy::drawPolygon(const QPoint *points, int pointCount, QPaintEngine::PolygonDrawMode mode)
 {
     if (m_proxy) {
         m_painter->drawPolygon(points, pointCount, mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
     }
 }
 
 void QPaintEngineColorProxy::drawRects(const QRectF *rects, int rectCount)
 {
     if (m_proxy) {
         m_painter->drawRects(rects, rectCount);
     }
 }
 
 void QPaintEngineColorProxy::drawRects(const QRect *rects, int rectCount)
 {
     if (m_proxy) {
         m_painter->drawRects(rects, rectCount);
     }
 }
 
 void QPaintEngineColorProxy::drawTextItem(const QPointF &p, const QTextItem &textItem)
 {
     if (m_proxy) {
         m_painter->drawTextItem(p, textItem);
     }
 }
 
 void QPaintEngineColorProxy::drawTiledPixmap(const QRectF &rect, const QPixmap &pixmap, const QPointF &p)
 {
     if (m_proxy) {
         m_painter->drawTiledPixmap(rect, pixmap, p);
     }
 }
 
 QPaintEngine::Type QPaintEngineColorProxy::type() const
 {
     return QPaintEngine::User;
 }
 
 void QPaintEngineColorProxy::updateState(const QPaintEngineState &state)
 {
     if (!m_proxy) {
         return;
     }
     const QPaintEngine::DirtyFlags flags = state.state();
     if (flags & QPaintEngine::DirtyBackground) {
         const QBrush brush = state.backgroundBrush();
         QBrush mappedBrush = m_proxy->map(brush);
         if (mappedBrush != brush)
             // pass changed brush back to own painter
             painter()->setBackground(mappedBrush);
         m_painter->setBackground(mappedBrush);
     }
     if (flags & QPaintEngine::DirtyBackgroundMode) {
         m_painter->setBackgroundMode(state.backgroundMode());
     }
     if (flags & QPaintEngine::DirtyBrush) {
         const QBrush brush = state.brush();
         QBrush mappedBrush = m_proxy->map(brush);
         if (mappedBrush != brush)
             // pass changed brush back to own painter
             painter()->setBrush(mappedBrush);
         m_painter->setBrush(mappedBrush);
     }
     if (flags & QPaintEngine::DirtyBrushOrigin) {
         m_painter->setBrushOrigin(state.brushOrigin());
     }
     if (flags & QPaintEngine::DirtyClipEnabled) {
         m_painter->setClipping(state.isClipEnabled());
     }
     if (flags & QPaintEngine::DirtyClipPath) {
         m_painter->setClipPath(state.clipPath(), state.clipOperation());
     }
     if (flags & QPaintEngine::DirtyClipRegion) {
         m_painter->setClipRegion(state.clipRegion(), state.clipOperation());
     }
     if (flags & QPaintEngine::DirtyCompositionMode) {
         m_painter->setCompositionMode(state.compositionMode());
     }
     if (flags & QPaintEngine::DirtyFont) {
         m_painter->setFont(state.font());
     }
     if (flags & QPaintEngine::DirtyHints) {
         m_painter->setRenderHints(state.renderHints());
     }
     if (flags & QPaintEngine::DirtyPen) {
         const QPen pen = state.pen();
         QPen mappedPen = m_proxy->map(pen);
         if (mappedPen != pen)
             // pass changed pen back to own painter
             painter()->setPen(mappedPen);
         m_painter->setPen(mappedPen);
     }
     if (flags & QPaintEngine::DirtyTransform) {
         m_painter->setTransform(state.transform());
     }
 }
 
 // END QPaintEngineColorProxy