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

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

     /****************************************************************************
     **
     ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
     ** Contact: Qt Software Information (qt-info@nokia.com)
     **
     ** This file is part of the example classes of the Qt Toolkit.
     **
     ** 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 General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU
     ** General Public License versions 2.0 or 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 GNU General Public Licensing requirements will be met:
     ** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
     ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
     ** exception, Nokia gives you certain additional rights. These rights
     ** are described in the Nokia Qt GPL Exception version 1.3, included in
     ** the file GPL_EXCEPTION.txt in this package.
     **
     ** Qt for Windows(R) Licensees
     ** As a special exception, Nokia, as the sole copyright holder for Qt
     ** Designer, grants users of the Qt/Eclipse Integration plug-in the
     ** right for the Qt/Eclipse Integration to link to functionality
     ** provided by Qt Designer and its related libraries.
     **
     ** If you are unsure which license is appropriate for your use, please
     ** contact the sales department at qt-sales@nokia.com.
     **
     ****************************************************************************/

     #ifndef CONTEXT2D_H
     #define CONTEXT2D_H

     #include "domimage.h"

     #include <QPainter>
     #include <QString>
     #include <QStack>
     #include <QMetaType>
     #include <QExplicitlySharedDataPointer>

     #include <qscriptengine.h>

     class CanvasGradientData;

     typedef QExplicitlySharedDataPointer<CanvasGradientData> CanvasGradient;

     class CanvasGradientData: public QSharedData
     {
     public:
         CanvasGradientData(const QGradient &g)
             : gradient(g) {}

         const QGradient &qgradient() const
         {
             return gradient;
         }

         static void setup(QScriptEngine *e);

     private: // API
         static QScriptValue addColorStop(QScriptContext *, QScriptEngine *);

     public: // attributes
         QGradient gradient;
     };

     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(QColor shadowColor READ shadowColor WRITE setShadowColor)

     public:
         Context2D(QContext2DCanvas *parent);
         void setSize(int w, int h);

         void begin();
         const QImage &end();

         void clear();

         // 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)
         QColor shadowColor() const; // (default black)

         void setShadowOffsetX(qreal x);
         void setShadowOffsetY(qreal y);
         void setShadowBlur(qreal b);
         void setShadowColor(const QColor &c);

     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);
     private:
         QImage  m_cache;
         QPainter m_painter;
         QPainterPath m_path;
         struct State {
             State()
                 : creatingShape(false)
             {}

             QMatrix      matrix;
             bool         creatingShape;
         };
         State m_state;
         QStack<State> m_stateStack;
     };

     #endif