|  | Home · All Namespaces · All Classes · Main Classes · Grouped Classes · Modules · Functions |

# context2d.h Example File
script/context2d/context2d.h

     /****************************************************************************
     **
     ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
     ** Contact: Qt Software Information (qt-info@nokia.com)
     **
     ** This file is part of the examples of the Qt Toolkit.
     **
     ** $QT_BEGIN_LICENSE:LGPL$
     ** Commercial Usage
     ** Licensees holding valid Qt Commercial licenses may use this file in
     ** accordance with the Qt Commercial License Agreement provided with the
     ** Software or, alternatively, in accordance with the terms contained in
     ** a written agreement between you and Nokia.
     **
     ** GNU Lesser General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU Lesser
     ** General Public License version 2.1 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.LGPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU Lesser General Public License version 2.1 requirements
     ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
     **
     ** In addition, as a special exception, Nokia gives you certain
     ** additional rights. These rights are described in the Nokia Qt LGPL
     ** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
     ** package.
     **
     ** GNU General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU
     ** General Public License version 3.0 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.GPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU General Public License version 3.0 requirements will be
     ** met: http://www.gnu.org/copyleft/gpl.html.
     **
     ** If you are unsure which license is appropriate for your use, please
     ** contact the sales department at qt-sales@nokia.com.
     ** $QT_END_LICENSE$
     **
     ****************************************************************************/

     #ifndef CONTEXT2D_H
     #define CONTEXT2D_H

     #include "domimage.h"

     #include <QPainter>
     #include <QPainterPath>
     #include <QString>
     #include <QStack>
     #include <QMetaType>
     #include <QTimerEvent>

     // [3]
     class CanvasGradient
     {
     public:
         CanvasGradient(const QGradient &v)
             : value(v) {}
         CanvasGradient() {}

         QGradient value;
     };
     // [3]

     Q_DECLARE_METATYPE(CanvasGradient)
     Q_DECLARE_METATYPE(CanvasGradient*)

     class ImageData {
     };

     class QContext2DCanvas;

     class Context2D : public QObject
     {
         Q_OBJECT
         // compositing
         Q_PROPERTY(qreal globalAlpha READ globalAlpha WRITE setGlobalAlpha)
         Q_PROPERTY(QString globalCompositeOperation READ globalCompositeOperation WRITE setGlobalCompositeOperation)
         Q_PROPERTY(QVariant strokeStyle READ strokeStyle WRITE setStrokeStyle)
         Q_PROPERTY(QVariant fillStyle READ fillStyle WRITE setFillStyle)
         // line caps/joins
         Q_PROPERTY(qreal lineWidth READ lineWidth WRITE setLineWidth)
         Q_PROPERTY(QString lineCap READ lineCap WRITE setLineCap)
         Q_PROPERTY(QString lineJoin READ lineJoin WRITE setLineJoin)
         Q_PROPERTY(qreal miterLimit READ miterLimit WRITE setMiterLimit)
         // shadows
         Q_PROPERTY(qreal shadowOffsetX READ shadowOffsetX WRITE setShadowOffsetX)
         Q_PROPERTY(qreal shadowOffsetY READ shadowOffsetY WRITE setShadowOffsetY)
         Q_PROPERTY(qreal shadowBlur READ shadowBlur WRITE setShadowBlur)
         Q_PROPERTY(QString shadowColor READ shadowColor WRITE setShadowColor)

     public:
         Context2D(QObject *parent = 0);
         void setSize(int width, int height);
         void setSize(const QSize &size);
         QSize size() const;

         void clear();
         void reset();

         // compositing
         qreal globalAlpha() const; // (default 1.0)
         QString globalCompositeOperation() const; // (default over)
         QVariant strokeStyle() const; // (default black)
         QVariant fillStyle() const; // (default black)

         void setGlobalAlpha(qreal alpha);
         void setGlobalCompositeOperation(const QString &op);
         void setStrokeStyle(const QVariant &style);
         void setFillStyle(const QVariant &style);

         // line caps/joins
         qreal lineWidth() const; // (default 1)
         QString lineCap() const; // "butt", "round", "square" (default "butt")
         QString lineJoin() const; // "round", "bevel", "miter" (default "miter")
         qreal miterLimit() const; // (default 10)

         void setLineWidth(qreal w);
         void setLineCap(const QString &s);
         void setLineJoin(const QString &s);
         void setMiterLimit(qreal m);

         // shadows
         qreal shadowOffsetX() const; // (default 0)
         qreal shadowOffsetY() const; // (default 0)
         qreal shadowBlur() const; // (default 0)
         QString shadowColor() const; // (default black)

         void setShadowOffsetX(qreal x);
         void setShadowOffsetY(qreal y);
         void setShadowBlur(qreal b);
         void setShadowColor(const QString &str);

     public slots:
         void save(); // push state on state stack
         void restore(); // pop state stack and restore state

         void scale(qreal x, qreal y);
         void rotate(qreal angle);
         void translate(qreal x, qreal y);
         void transform(qreal m11, qreal m12, qreal m21, qreal m22,
                        qreal dx, qreal dy);
         void setTransform(qreal m11, qreal m12, qreal m21, qreal m22,
                           qreal dx, qreal dy);

         CanvasGradient createLinearGradient(qreal x0, qreal y0,
                                             qreal x1, qreal y1);
         CanvasGradient createRadialGradient(qreal x0, qreal y0,
                                             qreal r0, qreal x1,
                                             qreal y1, qreal r1);

         // rects
         void clearRect(qreal x, qreal y, qreal w, qreal h);
         void fillRect(qreal x, qreal y, qreal w, qreal h);
         void strokeRect(qreal x, qreal y, qreal w, qreal h);

         // path API
         void beginPath();
         void closePath();
         void moveTo(qreal x, qreal y);
         void lineTo(qreal x, qreal y);
         void quadraticCurveTo(qreal cpx, qreal cpy, qreal x, qreal y);
         void bezierCurveTo(qreal cp1x, qreal cp1y,
                            qreal cp2x, qreal cp2y, qreal x, qreal y);
         void arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius);
         void rect(qreal x, qreal y, qreal w, qreal h);
         void arc(qreal x, qreal y, qreal radius,
                  qreal startAngle, qreal endAngle,
                  bool anticlockwise);
         void fill();
         void stroke();
         void clip();
         bool isPointInPath(qreal x, qreal y) const;

         // drawing images
         void drawImage(DomImage *image, qreal dx, qreal dy);
         void drawImage(DomImage *image, qreal dx, qreal dy,
                        qreal dw, qreal dh);
         void drawImage(DomImage *image, qreal sx, qreal sy,
                        qreal sw, qreal sh, qreal dx, qreal dy,
                        qreal dw, qreal dh);

         // pixel manipulation
         ImageData getImageData(qreal sx, qreal sy, qreal sw, qreal sh);
         void putImageData(ImageData image, qreal dx, qreal dy);

     signals:
         void changed(const QImage &image);

     protected:
         void timerEvent(QTimerEvent *e);

     private:
         void beginPainting();
         const QImage &endPainting();
         void scheduleChange();

         int m_changeTimerId;
         QImage  m_image;
         QPainter m_painter;
         QPainterPath m_path;

         enum DirtyFlag {
             DirtyTransformationMatrix = 0x00001,
             DirtyClippingRegion       = 0x00002,
             DirtyStrokeStyle          = 0x00004,
             DirtyFillStyle            = 0x00008,
             DirtyGlobalAlpha          = 0x00010,
             DirtyLineWidth            = 0x00020,
             DirtyLineCap              = 0x00040,
             DirtyLineJoin             = 0x00080,
             DirtyMiterLimit           = 0x00100,
             MDirtyPen                 = DirtyStrokeStyle
                                       | DirtyLineWidth
                                       | DirtyLineCap
                                       | DirtyLineJoin
                                       | DirtyMiterLimit,
             DirtyShadowOffsetX        = 0x00200,
             DirtyShadowOffsetY        = 0x00400,
             DirtyShadowBlur           = 0x00800,
             DirtyShadowColor          = 0x01000,
             DirtyGlobalCompositeOperation = 0x2000,
             DirtyFont                 = 0x04000,
             DirtyTextAlign            = 0x08000,
             DirtyTextBaseline         = 0x10000,
             AllIsFullOfDirt           = 0xfffff
         };

         struct State {
             State() : flags(0) {}
             QMatrix matrix;
             QPainterPath clipPath;
             QBrush strokeStyle;
             QBrush fillStyle;
             qreal globalAlpha;
             qreal lineWidth;
             Qt::PenCapStyle lineCap;
             Qt::PenJoinStyle lineJoin;
             qreal miterLimit;
             qreal shadowOffsetX;
             qreal shadowOffsetY;
             qreal shadowBlur;
             QColor shadowColor;
             QPainter::CompositionMode globalCompositeOperation;
             QFont font;
             int textAlign;
             int textBaseline;
             int flags;
         };
         State m_state;
         QStack<State> m_stateStack;
     };

     #endif