context2d.cpp Example File

script/context2d/context2d.cpp
/**************************************************************************** ** ** Copyright (C) 2017 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the examples of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:BSD$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** BSD License Usage ** Alternatively, you may use this file under the terms of the BSD license ** as follows: ** ** "Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are ** met: ** * Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in ** the documentation and/or other materials provided with the ** distribution. ** * Neither the name of The Qt Company Ltd nor the names of its ** contributors may be used to endorse or promote products derived ** from this software without specific prior written permission. ** ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ** ** $QT_END_LICENSE$ ** ****************************************************************************/
#include "context2d.h" #include <QVariant> #include <qmath.h> #define qClamp(val, min, max) qMin(qMax(val, min), max) static QList<qreal> parseNumbersList(QString::const_iterator &itr) { QList<qreal> points; QString temp; while ((*itr).isSpace()) ++itr; while ((*itr).isNumber() || (*itr) == '-' || (*itr) == '+' || (*itr) == '.') { temp = QString(); if ((*itr) == '-') temp += *itr++; else if ((*itr) == '+') temp += *itr++; while ((*itr).isDigit()) temp += *itr++; if ((*itr) == '.') temp += *itr++; while ((*itr).isDigit()) temp += *itr++; while ((*itr).isSpace()) ++itr; if ((*itr) == ',') ++itr; points.append(temp.toDouble()); //eat spaces while ((*itr).isSpace()) ++itr; } return points; } QColor colorFromString(const QString &name) { QString::const_iterator itr = name.constBegin(); QList<qreal> compo; if (name.startsWith("rgba(")) { ++itr; ++itr; ++itr; ++itr; ++itr; compo = parseNumbersList(itr); if (compo.size() != 4) { return QColor(); } //alpha seems to be always between 0-1 compo[3] *= 255; return QColor((int)compo[0], (int)compo[1], (int)compo[2], (int)compo[3]); } else if (name.startsWith("rgb(")) { ++itr; ++itr; ++itr; ++itr; compo = parseNumbersList(itr); if (compo.size() != 3) { return QColor(); } return QColor((int)qClamp(compo[0], qreal(0), qreal(255)), (int)qClamp(compo[1], qreal(0), qreal(255)), (int)qClamp(compo[2], qreal(0), qreal(255))); } else { //QRgb color; //CSSParser::parseColor(name, color); return QColor(name); } } static QPainter::CompositionMode compositeOperatorFromString(const QString &compositeOperator) { if ( compositeOperator == "source-over" ) { return QPainter::CompositionMode_SourceOver; } else if ( compositeOperator == "source-out" ) { return QPainter::CompositionMode_SourceOut; } else if ( compositeOperator == "source-in" ) { return QPainter::CompositionMode_SourceIn; } else if ( compositeOperator == "source-atop" ) { return QPainter::CompositionMode_SourceAtop; } else if ( compositeOperator == "destination-atop" ) { return QPainter::CompositionMode_DestinationAtop; } else if ( compositeOperator == "destination-in" ) { return QPainter::CompositionMode_DestinationIn; } else if ( compositeOperator == "destination-out" ) { return QPainter::CompositionMode_DestinationOut; } else if ( compositeOperator == "destination-over" ) { return QPainter::CompositionMode_DestinationOver; } else if ( compositeOperator == "darker" ) { return QPainter::CompositionMode_SourceOver; } else if ( compositeOperator == "lighter" ) { return QPainter::CompositionMode_SourceOver; } else if ( compositeOperator == "copy" ) { return QPainter::CompositionMode_Source; } else if ( compositeOperator == "xor" ) { return QPainter::CompositionMode_Xor; } return QPainter::CompositionMode_SourceOver; } static QString compositeOperatorToString(QPainter::CompositionMode op) { switch (op) { case QPainter::CompositionMode_SourceOver: return "source-over"; case QPainter::CompositionMode_DestinationOver: return "destination-over"; case QPainter::CompositionMode_Clear: return "clear"; case QPainter::CompositionMode_Source: return "source"; case QPainter::CompositionMode_Destination: return "destination"; case QPainter::CompositionMode_SourceIn: return "source-in"; case QPainter::CompositionMode_DestinationIn: return "destination-in"; case QPainter::CompositionMode_SourceOut: return "source-out"; case QPainter::CompositionMode_DestinationOut: return "destination-out"; case QPainter::CompositionMode_SourceAtop: return "source-atop"; case QPainter::CompositionMode_DestinationAtop: return "destination-atop"; case QPainter::CompositionMode_Xor: return "xor"; case QPainter::CompositionMode_Plus: return "plus"; case QPainter::CompositionMode_Multiply: return "multiply"; case QPainter::CompositionMode_Screen: return "screen"; case QPainter::CompositionMode_Overlay: return "overlay"; case QPainter::CompositionMode_Darken: return "darken"; case QPainter::CompositionMode_Lighten: return "lighten"; case QPainter::CompositionMode_ColorDodge: return "color-dodge"; case QPainter::CompositionMode_ColorBurn: return "color-burn"; case QPainter::CompositionMode_HardLight: return "hard-light"; case QPainter::CompositionMode_SoftLight: return "soft-light"; case QPainter::CompositionMode_Difference: return "difference"; case QPainter::CompositionMode_Exclusion: return "exclusion"; default: break; } return QString(); } void Context2D::save() { m_stateStack.push(m_state); } void Context2D::restore() { if (!m_stateStack.isEmpty()) { m_state = m_stateStack.pop(); m_state.flags = AllIsFullOfDirt; } } void Context2D::scale(qreal x, qreal y) { m_state.matrix.scale(x, y); m_state.flags |= DirtyTransformationMatrix; } void Context2D::rotate(qreal angle) { m_state.matrix.rotate(qRadiansToDegrees(angle)); m_state.flags |= DirtyTransformationMatrix; } void Context2D::translate(qreal x, qreal y) { m_state.matrix.translate(x, y); m_state.flags |= DirtyTransformationMatrix; } void Context2D::transform(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy) { QMatrix mat(m11, m12, m21, m22, dx, dy); m_state.matrix *= mat; m_state.flags |= DirtyTransformationMatrix; } void Context2D::setTransform(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy) { QMatrix mat(m11, m12, m21, m22, dx, dy); m_state.matrix = mat; m_state.flags |= DirtyTransformationMatrix; } QString Context2D::globalCompositeOperation() const { return compositeOperatorToString(m_state.globalCompositeOperation); } void Context2D::setGlobalCompositeOperation(const QString &op) { QPainter::CompositionMode mode = compositeOperatorFromString(op); m_state.globalCompositeOperation = mode; m_state.flags |= DirtyGlobalCompositeOperation; } QVariant Context2D::strokeStyle() const { return m_state.strokeStyle; } void Context2D::setStrokeStyle(const QVariant &style) { if (style.canConvert<CanvasGradient>()) { CanvasGradient cg = qvariant_cast<CanvasGradient>(style); m_state.strokeStyle = cg.value; } else { QColor color = colorFromString(style.toString()); m_state.strokeStyle = color; } m_state.flags |= DirtyStrokeStyle; } QVariant Context2D::fillStyle() const { return m_state.fillStyle; } void Context2D::setFillStyle(const QVariant &style) { if (style.canConvert<CanvasGradient>()) { CanvasGradient cg = qvariant_cast<CanvasGradient>(style); m_state.fillStyle = cg.value; } else { QColor color = colorFromString(style.toString()); m_state.fillStyle = color; } m_state.flags |= DirtyFillStyle; } qreal Context2D::globalAlpha() const { return m_state.globalAlpha; } void Context2D::setGlobalAlpha(qreal alpha) { m_state.globalAlpha = alpha; m_state.flags |= DirtyGlobalAlpha; } CanvasGradient Context2D::createLinearGradient(qreal x0, qreal y0, qreal x1, qreal y1) { QLinearGradient g(x0, y0, x1, y1); return CanvasGradient(g); } CanvasGradient Context2D::createRadialGradient(qreal x0, qreal y0, qreal r0, qreal x1, qreal y1, qreal r1) { QRadialGradient g(QPointF(x1, y1), r0+r1, QPointF(x0, y0)); return CanvasGradient(g); } qreal Context2D::lineWidth() const { return m_state.lineWidth; } void Context2D::setLineWidth(qreal w) { m_state.lineWidth = w; m_state.flags |= DirtyLineWidth; } QString Context2D::lineCap() const { switch (m_state.lineCap) { case Qt::FlatCap: return "butt"; case Qt::SquareCap: return "square"; case Qt::RoundCap: return "round"; default: ; } return QString(); } void Context2D::setLineCap(const QString &capString) { Qt::PenCapStyle style; if (capString == "round") style = Qt::RoundCap; else if (capString == "square") style = Qt::SquareCap; else //if (capString == "butt") style = Qt::FlatCap; m_state.lineCap = style; m_state.flags |= DirtyLineCap; } QString Context2D::lineJoin() const { switch (m_state.lineJoin) { case Qt::RoundJoin: return "round"; case Qt::BevelJoin: return "bevel"; case Qt::MiterJoin: return "miter"; default: ; } return QString(); } void Context2D::setLineJoin(const QString &joinString) { Qt::PenJoinStyle style; if (joinString == "round") style = Qt::RoundJoin; else if (joinString == "bevel") style = Qt::BevelJoin; else //if (joinString == "miter") style = Qt::MiterJoin; m_state.lineJoin = style; m_state.flags |= DirtyLineJoin; } qreal Context2D::miterLimit() const { return m_state.miterLimit; } void Context2D::setMiterLimit(qreal m) { m_state.miterLimit = m; m_state.flags |= DirtyMiterLimit; } void Context2D::setShadowOffsetX(qreal x) { m_state.shadowOffsetX = x; m_state.flags |= DirtyShadowOffsetX; } void Context2D::setShadowOffsetY(qreal y) { m_state.shadowOffsetY = y; m_state.flags |= DirtyShadowOffsetY; } void Context2D::setShadowBlur(qreal b) { m_state.shadowBlur = b; m_state.flags |= DirtyShadowBlur; } void Context2D::setShadowColor(const QString &str) { m_state.shadowColor = colorFromString(str); m_state.flags |= DirtyShadowColor; } qreal Context2D::shadowOffsetX() const { return m_state.shadowOffsetX; } qreal Context2D::shadowOffsetY() const { return m_state.shadowOffsetY; } qreal Context2D::shadowBlur() const { return m_state.shadowBlur; } QString Context2D::shadowColor() const { return m_state.shadowColor.name(); } void Context2D::clearRect(qreal x, qreal y, qreal w, qreal h) { beginPainting(); m_painter.save(); m_painter.setMatrix(m_state.matrix, false); m_painter.setCompositionMode(QPainter::CompositionMode_Source); m_painter.fillRect(QRectF(x, y, w, h), QColor(0, 0, 0, 0)); m_painter.restore(); scheduleChange(); } void Context2D::fillRect(qreal x, qreal y, qreal w, qreal h) { beginPainting(); m_painter.save(); m_painter.setMatrix(m_state.matrix, false); m_painter.fillRect(QRectF(x, y, w, h), m_painter.brush()); m_painter.restore(); scheduleChange(); } void Context2D::strokeRect(qreal x, qreal y, qreal w, qreal h) { QPainterPath path; path.addRect(x, y, w, h); beginPainting(); m_painter.save(); m_painter.setMatrix(m_state.matrix, false); m_painter.strokePath(path, m_painter.pen()); m_painter.restore(); scheduleChange(); } void Context2D::beginPath() { m_path = QPainterPath(); } void Context2D::closePath() { m_path.closeSubpath(); } void Context2D::moveTo(qreal x, qreal y) { QPointF pt = m_state.matrix.map(QPointF(x, y)); m_path.moveTo(pt); } void Context2D::lineTo(qreal x, qreal y) { QPointF pt = m_state.matrix.map(QPointF(x, y)); m_path.lineTo(pt); } void Context2D::quadraticCurveTo(qreal cpx, qreal cpy, qreal x, qreal y) { QPointF cp = m_state.matrix.map(QPointF(cpx, cpy)); QPointF xy = m_state.matrix.map(QPointF(x, y)); m_path.quadTo(cp, xy); } void Context2D::bezierCurveTo(qreal cp1x, qreal cp1y, qreal cp2x, qreal cp2y, qreal x, qreal y) { QPointF cp1 = m_state.matrix.map(QPointF(cp1x, cp1y)); QPointF cp2 = m_state.matrix.map(QPointF(cp2x, cp2y)); QPointF end = m_state.matrix.map(QPointF(x, y)); m_path.cubicTo(cp1, cp2, end); } void Context2D::arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius) { //FIXME: this is surely busted QPointF st = m_state.matrix.map(QPointF(x1, y1)); QPointF end = m_state.matrix.map(QPointF(x2, y2)); m_path.arcTo(st.x(), st.y(), end.x()-st.x(), end.y()-st.y(), radius, 90); } void Context2D::rect(qreal x, qreal y, qreal w, qreal h) { QPainterPath path; path.addRect(x, y, w, h); path = m_state.matrix.map(path); m_path.addPath(path); } void Context2D::arc(qreal xc, qreal yc, qreal radius, qreal sar, qreal ear, bool anticlockwise) { //### HACK // In Qt we don't switch the coordinate system for degrees // and still use the 0,0 as bottom left for degrees so we need // to switch sar = -sar; ear = -ear; anticlockwise = !anticlockwise; //end hack float sa = qRadiansToDegrees(sar); float ea = qRadiansToDegrees(ear); double span = 0; double xs = xc - radius; double ys = yc - radius; double width = radius*2; double height = radius*2; if (!anticlockwise && (ea < sa)) { span += 360; } else if (anticlockwise && (sa < ea)) { span -= 360; } //### this is also due to switched coordinate system // we would end up with a 0 span instead of 360 if (!(qFuzzyCompare(span + (ea - sa) + 1, 1) && qFuzzyCompare(qAbs(span), 360))) { span += ea - sa; } QPainterPath path; path.moveTo(QPointF(xc + radius * cos(sar), yc - radius * sin(sar))); path.arcTo(xs, ys, width, height, sa, span); path = m_state.matrix.map(path); m_path.addPath(path); } void Context2D::fill() { beginPainting(); m_painter.fillPath(m_path, m_painter.brush()); scheduleChange(); } void Context2D::stroke() { beginPainting(); m_painter.save(); m_painter.setMatrix(m_state.matrix, false); QPainterPath tmp = m_state.matrix.inverted().map(m_path); m_painter.strokePath(tmp, m_painter.pen()); m_painter.restore(); scheduleChange(); } void Context2D::clip() { m_state.clipPath = m_path; m_state.flags |= DirtyClippingRegion; } bool Context2D::isPointInPath(qreal x, qreal y) const { return m_path.contains(QPointF(x, y)); } ImageData Context2D::getImageData(qreal sx, qreal sy, qreal sw, qreal sh) { Q_UNUSED(sx); Q_UNUSED(sy); Q_UNUSED(sw); Q_UNUSED(sh); return ImageData(); } void Context2D::putImageData(ImageData image, qreal dx, qreal dy) { Q_UNUSED(image); Q_UNUSED(dx); Q_UNUSED(dy); } Context2D::Context2D(QObject *parent) : QObject(parent), m_changeTimerId(-1) { reset(); } const QImage &Context2D::endPainting() { if (m_painter.isActive()) m_painter.end(); return m_image; } void Context2D::beginPainting() { if (!m_painter.isActive()) { m_painter.begin(&m_image); m_painter.setRenderHint(QPainter::Antialiasing); if (!m_state.clipPath.isEmpty()) m_painter.setClipPath(m_state.clipPath); m_painter.setBrush(m_state.fillStyle); m_painter.setOpacity(m_state.globalAlpha); QPen pen; pen.setBrush(m_state.strokeStyle); if (pen.style() == Qt::NoPen) pen.setStyle(Qt::SolidLine); pen.setCapStyle(m_state.lineCap); pen.setJoinStyle(m_state.lineJoin); pen.setWidthF(m_state.lineWidth); pen.setMiterLimit(m_state.miterLimit); m_painter.setPen(pen); } else { if ((m_state.flags & DirtyClippingRegion) && !m_state.clipPath.isEmpty()) m_painter.setClipPath(m_state.clipPath); if (m_state.flags & DirtyFillStyle) m_painter.setBrush(m_state.fillStyle); if (m_state.flags & DirtyGlobalAlpha) m_painter.setOpacity(m_state.globalAlpha); if (m_state.flags & DirtyGlobalCompositeOperation) m_painter.setCompositionMode(m_state.globalCompositeOperation); if (m_state.flags & MDirtyPen) { QPen pen = m_painter.pen(); if (m_state.flags & DirtyStrokeStyle) pen.setBrush(m_state.strokeStyle); if (m_state.flags & DirtyLineWidth) pen.setWidthF(m_state.lineWidth); if (m_state.flags & DirtyLineCap) pen.setCapStyle(m_state.lineCap); if (m_state.flags & DirtyLineJoin) pen.setJoinStyle(m_state.lineJoin); if (m_state.flags & DirtyMiterLimit) pen.setMiterLimit(m_state.miterLimit); m_painter.setPen(pen); } m_state.flags = 0; } } void Context2D::clear() { endPainting(); m_image.fill(qRgba(0,0,0,0)); scheduleChange(); } void Context2D::reset() { m_stateStack.clear(); m_state.matrix = QMatrix(); m_state.clipPath = QPainterPath(); m_state.globalAlpha = 1.0; m_state.globalCompositeOperation = QPainter::CompositionMode_SourceOver; m_state.strokeStyle = Qt::black; m_state.fillStyle = Qt::black; m_state.lineWidth = 1; m_state.lineCap = Qt::FlatCap; m_state.lineJoin = Qt::MiterJoin; m_state.miterLimit = 10; m_state.shadowOffsetX = 0; m_state.shadowOffsetY = 0; m_state.shadowBlur = 0; m_state.shadowColor = qRgba(0, 0, 0, 0); m_state.flags = AllIsFullOfDirt; clear(); } void Context2D::setSize(int width, int height) { endPainting(); QImage newi(width, height, QImage::Format_ARGB32_Premultiplied); newi.fill(qRgba(0,0,0,0)); QPainter p(&newi); p.drawImage(0, 0, m_image); p.end(); m_image = newi; scheduleChange(); } void Context2D::setSize(const QSize &size) { setSize(size.width(), size.height()); } QSize Context2D::size() const { return m_image.size(); } void Context2D::drawImage(DomImage *image, qreal dx, qreal dy) { if (!image) return; if (dx < 0) { qreal sx = qAbs(dx); qreal sy = qAbs(dy); qreal sw = image->width() - sx; qreal sh = image->height() - sy; drawImage(image, sx, sy, sw, sh, 0, 0, sw, sh); } else { beginPainting(); m_painter.drawImage(QPointF(dx, dy), image->image()); scheduleChange(); } } void Context2D::drawImage(DomImage *image, qreal dx, qreal dy, qreal dw, qreal dh) { if (!image) return; beginPainting(); m_painter.drawImage(QRectF(dx, dy, dw, dh).toRect(), image->image()); scheduleChange(); } void Context2D::drawImage(DomImage *image, qreal sx, qreal sy, qreal sw, qreal sh, qreal dx, qreal dy, qreal dw, qreal dh) { if (!image) return; beginPainting(); m_painter.drawImage(QRectF(dx, dy, dw, dh), image->image(), QRectF(sx, sy, sw, sh)); scheduleChange(); } void Context2D::scheduleChange() { if (m_changeTimerId == -1) m_changeTimerId = startTimer(0); } void Context2D::timerEvent(QTimerEvent *e) { if (e->timerId() == m_changeTimerId) { killTimer(m_changeTimerId); m_changeTimerId = -1; emit changed(endPainting()); } else { QObject::timerEvent(e); } }

© 2020 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.