From 3bc907d155034fe64efc8cb6056b48f0c6401bfb Mon Sep 17 00:00:00 2001 From: Matthew Vogt Date: Mon, 5 Mar 2012 17:01:33 +1000 Subject: Remove uses of QtGui symbols in QQmlEngine. Move the code dealing with QImage and QPixmap out of QQmlEngine and into the QtQuick library. QQmlEngine remains the owner of image provider resources, but does not use them directly. Change-Id: I52083581394d9c308db446372883eb7479ccf807 Reviewed-by: Martin Jones --- src/quick/util/qquickimageprovider.cpp | 334 +++++++++++++++++++++++++++++++++ src/quick/util/qquickimageprovider.h | 97 ++++++++++ src/quick/util/qquickpixmapcache.cpp | 59 ++++-- src/quick/util/qquickpixmapcache_p.h | 2 +- src/quick/util/util.pri | 2 + 5 files changed, 473 insertions(+), 21 deletions(-) create mode 100644 src/quick/util/qquickimageprovider.cpp create mode 100644 src/quick/util/qquickimageprovider.h (limited to 'src/quick/util') diff --git a/src/quick/util/qquickimageprovider.cpp b/src/quick/util/qquickimageprovider.cpp new file mode 100644 index 0000000000..4a1db050d6 --- /dev/null +++ b/src/quick/util/qquickimageprovider.cpp @@ -0,0 +1,334 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickimageprovider.h" + +QT_BEGIN_NAMESPACE + +class QQuickImageProviderPrivate +{ +public: + QQuickImageProvider::ImageType type; +}; + +/*! + \class QQuickTextureFactory + \since 5.0 + \brief The QQuickTextureFactory class provides an interface for loading custom textures from QML. + + The purpose of the texture factory is to provide a placeholder for a image + data that can be converted into an OpenGL texture. + + Creating a texture directly is not possible as there is rarely an OpenGL context + available in the thread that is responsible for loading the image data. + */ + +QQuickTextureFactory::QQuickTextureFactory() +{ +} + +QQuickTextureFactory::~QQuickTextureFactory() +{ +} + + + +/*! + \fn QSGTexture *QQuickTextureFactory::createTexture() const + + This function is called on the scene graph rendering thread to create a QSGTexture + instance from the factory. + + QML will internally cache the returned texture as needed. Each call to this + function should return a unique instance. + + The OpenGL context used for rendering is bound when this function is called. + */ + +/*! + \fn QSize QQuickTextureFactory::textureSize() const + + Returns the size of the texture. This function will be called from arbitrary threads + and should not rely on an OpenGL context bound. + */ + + +/*! + \class QQuickImageProvider + \since 4.7 + \brief The QQuickImageProvider class provides an interface for supporting pixmaps and threaded image requests in QML. + + QQuickImageProvider is used to provide advanced image loading features + in QML applications. It allows images in QML to be: + + \list + \o Loaded using QPixmaps rather than actual image files + \o Loaded asynchronously in a separate thread, if imageType() is \l{QQuickImageProvider::ImageType}{ImageType::Image} + \endlist + + To specify that an image should be loaded by an image provider, use the + \bold {"image:"} scheme for the URL source of the image, followed by the + identifiers of the image provider and the requested image. For example: + + \qml + Image { source: "image://myimageprovider/image.png" } + \endqml + + This specifies that the image should be loaded by the image provider named + "myimageprovider", and the image to be loaded is named "image.png". The QML engine + invokes the appropriate image provider according to the providers that have + been registered through QQmlEngine::addImageProvider(). + + Note that the identifiers are case-insensitive, but the rest of the URL will be passed on with + preserved case. For example, the below snippet would still specify that the image is loaded by the + image provider named "myimageprovider", but it would request a different image than the above snippet + ("Image.png" instead of "image.png"). + \qml + Image { source: "image://MyImageProvider/Image.png" } + \endqml + + If you want the rest of the URL to be case insensitive, you will have to take care + of that yourself inside your image provider. + + \section2 An example + + Here are two images. Their \c source values indicate they should be loaded by + an image provider named "colors", and the images to be loaded are "yellow" + and "red", respectively: + + \snippet examples/declarative/cppextensions/imageprovider/imageprovider-example.qml 0 + + When these images are loaded by QML, it looks for a matching image provider + and calls its requestImage() or requestPixmap() method (depending on its + imageType()) to load the image. The method is called with the \c id + parameter set to "yellow" for the first image, and "red" for the second. + + Here is an image provider implementation that can load the images + requested by the above QML. This implementation dynamically + generates QPixmap images that are filled with the requested color: + + \snippet examples/declarative/cppextensions/imageprovider/imageprovider.cpp 0 + \codeline + \snippet examples/declarative/cppextensions/imageprovider/imageprovider.cpp 1 + + To make this provider accessible to QML, it is registered with the QML engine + with a "colors" identifier: + + \code + int main(int argc, char *argv[]) + { + ... + + QQmlEngine engine; + engine->addImageProvider(QLatin1String("colors"), new ColorPixmapProvider); + + ... + } + \endcode + + Now the images can be successfully loaded in QML: + + \image imageprovider.png + + A complete example is available in Qt's + \l {declarative/cppextensions/imageprovider}{examples/declarative/cppextensions/imageprovider} + directory. Note the example registers the provider via a \l{QQmlExtensionPlugin}{plugin} + instead of registering it in the application \c main() function as shown above. + + + \section2 Asynchronous image loading + + Image providers that support QImage loading automatically include support + for asychronous loading of images. To enable asynchronous loading for an + image source, set the \c asynchronous property to \c true for the relevant + \l Image, \l BorderImage or \l AnimatedImage object. When this is enabled, + the image request to the provider is run in a low priority thread, + allowing image loading to be executed in the background, and reducing the + performance impact on the user interface. + + Asynchronous loading is not supported for image providers that provide + QPixmap rather than QImage values, as pixmaps can only be created in the + main thread. In this case, if \l {Image::}{asynchronous} is set to + \c true, the value is ignored and the image is loaded + synchronously. + + + \section2 Image caching + + Images returned by a QQuickImageProvider are automatically cached, + similar to any image loaded by the QML engine. When an image with a + "image://" prefix is loaded from cache, requestImage() and requestPixmap() + will not be called for the relevant image provider. If an image should always + be fetched from the image provider, and should not be cached at all, set the + \c cache property to \c false for the relevant \l Image, \l BorderImage or + \l AnimatedImage object. + + \sa QQmlEngine::addImageProvider() +*/ + +/*! + \enum QQuickImageProvider::ImageType + + Defines the type of image supported by this image provider. + + \value Image The Image Provider provides QImage images. The + requestImage() method will be called for all image requests. + \value Pixmap The Image Provider provides QPixmap images. The + requestPixmap() method will be called for all image requests. + \value Texture The Image Provider provides QSGTextureProvider based images. + The requestTexture() method will be called for all image requests. \omitvalue +*/ + +/*! + Creates an image provider that will provide images of the given \a type. +*/ +QQuickImageProvider::QQuickImageProvider(ImageType type) + : d(new QQuickImageProviderPrivate) +{ + d->type = type; +} + +/*! + Destroys the QQuickImageProvider + + \note The destructor of your derived class need to be thread safe. +*/ +QQuickImageProvider::~QQuickImageProvider() +{ + delete d; +} + +/*! + Returns the image type supported by this provider. +*/ +QQuickImageProvider::ImageType QQuickImageProvider::imageType() const +{ + return d->type; +} + +/*! + Implement this method to return the image with \a id. The default + implementation returns an empty image. + + The \a id is the requested image source, with the "image:" scheme and + provider identifier removed. For example, if the image \l{Image::}{source} + was "image://myprovider/icons/home", the given \a id would be "icons/home". + + The \a requestedSize corresponds to the \l {Image::sourceSize} requested by + an Image element. If \a requestedSize is a valid size, the image + returned should be of that size. + + In all cases, \a size must be set to the original size of the image. This + is used to set the \l {Item::}{width} and \l {Item::}{height} of the + relevant \l Image if these values have not been set explicitly. + + \note this method may be called by multiple threads, so ensure the + implementation of this method is reentrant. +*/ +QImage QQuickImageProvider::requestImage(const QString &id, QSize *size, const QSize& requestedSize) +{ + Q_UNUSED(id); + Q_UNUSED(size); + Q_UNUSED(requestedSize); + if (d->type == Image) + qWarning("ImageProvider supports Image type but has not implemented requestImage()"); + return QImage(); +} + +/*! + Implement this method to return the pixmap with \a id. The default + implementation returns an empty pixmap. + + The \a id is the requested image source, with the "image:" scheme and + provider identifier removed. For example, if the image \l{Image::}{source} + was "image://myprovider/icons/home", the given \a id would be "icons/home". + + The \a requestedSize corresponds to the \l {Image::sourceSize} requested by + an Image element. If \a requestedSize is a valid size, the image + returned should be of that size. + + In all cases, \a size must be set to the original size of the image. This + is used to set the \l {Item::}{width} and \l {Item::}{height} of the + relevant \l Image if these values have not been set explicitly. +*/ +QPixmap QQuickImageProvider::requestPixmap(const QString &id, QSize *size, const QSize& requestedSize) +{ + Q_UNUSED(id); + Q_UNUSED(size); + Q_UNUSED(requestedSize); + if (d->type == Pixmap) + qWarning("ImageProvider supports Pixmap type but has not implemented requestPixmap()"); + return QPixmap(); +} + + +/*! + Implement this method to return the texture with \a id. The default + implementation returns 0. + + The \a id is the requested image source, with the "image:" scheme and + provider identifier removed. For example, if the image \l{Image::}{source} + was "image://myprovider/icons/home", the given \a id would be "icons/home". + + The \a requestedSize corresponds to the \l {Image::sourceSize} requested by + an Image element. If \a requestedSize is a valid size, the image + returned should be of that size. + + In all cases, \a size must be set to the original size of the image. This + is used to set the \l {Item::}{width} and \l {Item::}{height} of the + relevant \l Image if these values have not been set explicitly. + + \note this method may be called by multiple threads, so ensure the + implementation of this method is reentrant. +*/ + +QQuickTextureFactory *QQuickImageProvider::requestTexture(const QString &id, QSize *size, const QSize &requestedSize) +{ + Q_UNUSED(id); + Q_UNUSED(size); + Q_UNUSED(requestedSize); + if (d->type == Texture) + qWarning("ImageProvider supports Texture type but has not implemented requestTexture()"); + return 0; +} + +QT_END_NAMESPACE + diff --git a/src/quick/util/qquickimageprovider.h b/src/quick/util/qquickimageprovider.h new file mode 100644 index 0000000000..153a4bab8e --- /dev/null +++ b/src/quick/util/qquickimageprovider.h @@ -0,0 +1,97 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKIMAGEPROVIDER_H +#define QQUICKIMAGEPROVIDER_H + +#include +#include +#include +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + + +class QQuickImageProviderPrivate; +class QSGTexture; +class QQuickCanvas; + +class Q_QUICK_EXPORT QQuickTextureFactory : public QObject +{ +public: + QQuickTextureFactory(); + virtual ~QQuickTextureFactory(); + + virtual QSGTexture *createTexture(QQuickCanvas *canvas) const = 0; + virtual QSize textureSize() const = 0; + virtual int textureByteCount() const = 0; +}; + +class Q_QUICK_EXPORT QQuickImageProvider : public QQmlImageProviderBase +{ +public: + enum ImageType { + Image, + Pixmap, + Texture, + Invalid + }; + + QQuickImageProvider(ImageType type); + virtual ~QQuickImageProvider(); + + ImageType imageType() const; + + virtual QImage requestImage(const QString &id, QSize *size, const QSize& requestedSize); + virtual QPixmap requestPixmap(const QString &id, QSize *size, const QSize& requestedSize); + virtual QQuickTextureFactory *requestTexture(const QString &id, QSize *size, const QSize &requestedSize); + +private: + QQuickImageProviderPrivate *d; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QQUICKIMAGEPROVIDER_H diff --git a/src/quick/util/qquickpixmapcache.cpp b/src/quick/util/qquickpixmapcache.cpp index aae5306aa7..350940c93c 100644 --- a/src/quick/util/qquickpixmapcache.cpp +++ b/src/quick/util/qquickpixmapcache.cpp @@ -41,7 +41,7 @@ #include "qquickpixmapcache_p.h" #include -#include +#include #include #include @@ -76,6 +76,16 @@ QT_BEGIN_NAMESPACE // The cache limit describes the maximum "junk" in the cache. static int cache_limit = 2048 * 1024; // 2048 KB cache limit for embedded in qpixmapcache.cpp +static inline QString imageProviderId(const QUrl &url) +{ + return url.host(); +} + +static inline QString imageId(const QUrl &url) +{ + return url.toString(QUrl::RemoveScheme | QUrl::RemoveAuthority).mid(1); +} + QSGTexture *QQuickDefaultTextureFactory::createTexture(QQuickCanvas *) const { QSGPlainTexture *t = new QSGPlainTexture(); @@ -514,11 +524,15 @@ void QQuickPixmapReader::processJob(QQuickPixmapReply *runningJob, const QUrl &u { // fetch if (url.scheme() == QLatin1String("image")) { - // Use QmlImageProvider + // Use QQuickImageProvider QSize readSize; - QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine); - QQmlImageProvider::ImageType imageType = ep->getImageProviderType(url); - if (imageType == QQmlImageProvider::Invalid) { + + QQuickImageProvider::ImageType imageType = QQuickImageProvider::Invalid; + QQuickImageProvider *provider = static_cast(engine->imageProvider(imageProviderId(url))); + if (provider) + imageType = provider->imageType(); + + if (imageType == QQuickImageProvider::Invalid) { QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::Loading; QString errorStr = QQuickPixmap::tr("Invalid image provider: %1").arg(url.toString()); QImage image; @@ -526,8 +540,8 @@ void QQuickPixmapReader::processJob(QQuickPixmapReply *runningJob, const QUrl &u if (!cancelled.contains(runningJob)) runningJob->postReply(errorCode, errorStr, readSize, image); mutex.unlock(); - } else if (imageType == QQmlImageProvider::Image) { - QImage image = ep->getImageFromProvider(url, &readSize, requestSize); + } else if (imageType == QQuickImageProvider::Image) { + QImage image = provider->requestImage(imageId(url), &readSize, requestSize); QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::NoError; QString errorStr; if (image.isNull()) { @@ -545,7 +559,7 @@ void QQuickPixmapReader::processJob(QQuickPixmapReply *runningJob, const QUrl &u mutex.unlock(); } else { - QQuickTextureFactory *t = ep->getTextureFromProvider(url, &readSize, requestSize); + QQuickTextureFactory *t = provider->requestTexture(imageId(url), &readSize, requestSize); QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::NoError; QString errorStr; if (!t) { @@ -945,33 +959,36 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q { if (url.scheme() == QLatin1String("image")) { QSize readSize; - QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine); - QQmlImageProvider::ImageType imageType = ep->getImageProviderType(url); + + QQuickImageProvider::ImageType imageType = QQuickImageProvider::Invalid; + QQuickImageProvider *provider = static_cast(engine->imageProvider(imageProviderId(url))); + if (provider) + imageType = provider->imageType(); switch (imageType) { - case QQmlImageProvider::Invalid: + case QQuickImageProvider::Invalid: return new QQuickPixmapData(declarativePixmap, url, requestSize, QQuickPixmap::tr("Invalid image provider: %1").arg(url.toString())); - case QQmlImageProvider::Texture: + case QQuickImageProvider::Texture: { - QQuickTextureFactory *texture = ep->getTextureFromProvider(url, &readSize, requestSize); + QQuickTextureFactory *texture = provider->requestTexture(imageId(url), &readSize, requestSize); if (texture) { *ok = true; return new QQuickPixmapData(declarativePixmap, url, texture, QImage(), readSize, requestSize); } } - case QQmlImageProvider::Image: + case QQuickImageProvider::Image: { - QImage image = ep->getImageFromProvider(url, &readSize, requestSize); + QImage image = provider->requestImage(imageId(url), &readSize, requestSize); if (!image.isNull()) { *ok = true; return new QQuickPixmapData(declarativePixmap, url, image, readSize, requestSize); } } - case QQmlImageProvider::Pixmap: + case QQuickImageProvider::Pixmap: { - QPixmap pixmap = ep->getPixmapFromProvider(url, &readSize, requestSize); + QPixmap pixmap = provider->requestPixmap(imageId(url), &readSize, requestSize); if (!pixmap.isNull()) { *ok = true; return new QQuickPixmapData(declarativePixmap, url, pixmap.toImage(), readSize, requestSize); @@ -1180,9 +1197,11 @@ void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &reques if (iter == store->m_cache.end()) { if (options & QQuickPixmap::Asynchronous) { // pixmaps can only be loaded synchronously - if (url.scheme() == QLatin1String("image") - && QQmlEnginePrivate::get(engine)->getImageProviderType(url) == QQmlImageProvider::Pixmap) { - options &= ~QQuickPixmap::Asynchronous; + if (url.scheme() == QLatin1String("image")) { + QQuickImageProvider *provider = static_cast(engine->imageProvider(imageProviderId(url))); + if (provider && provider->imageType() == QQuickImageProvider::Pixmap) { + options &= ~QQuickPixmap::Asynchronous; + } } } diff --git a/src/quick/util/qquickpixmapcache_p.h b/src/quick/util/qquickpixmapcache_p.h index 0b4c2fb473..ef17a12709 100644 --- a/src/quick/util/qquickpixmapcache_p.h +++ b/src/quick/util/qquickpixmapcache_p.h @@ -47,9 +47,9 @@ #include #include #include +#include #include -#include QT_BEGIN_HEADER diff --git a/src/quick/util/util.pri b/src/quick/util/util.pri index c3cec91404..d720ef02c9 100644 --- a/src/quick/util/util.pri +++ b/src/quick/util/util.pri @@ -25,6 +25,7 @@ SOURCES += \ $$PWD/qquickchangeset.cpp \ $$PWD/qquicklistcompositor.cpp \ $$PWD/qquickpathinterpolator.cpp \ + $$PWD/qquickimageprovider.cpp \ $$PWD/qquicksvgparser.cpp HEADERS += \ @@ -58,4 +59,5 @@ HEADERS += \ $$PWD/qquickchangeset_p.h \ $$PWD/qquicklistcompositor_p.h \ $$PWD/qquickpathinterpolator_p.h \ + $$PWD/qquickimageprovider.h \ $$PWD/qquicksvgparser_p.h -- cgit v1.2.3 From ab1e510121c8a679fdaca12ccd30e0f7ac12a26b Mon Sep 17 00:00:00 2001 From: Matthew Vogt Date: Fri, 2 Mar 2012 08:25:43 +1000 Subject: Migrate gui dependencies from QtQml to QtQuick. Ensure that users of declarative that have no need for functionality provided by the Qt Gui module do not have to link against it. Any use of QtGui functionality is delegated to providers that can be installed by another library; QtQuick adds default providers for this functionality when linked against QtQml. Task-number: QTBUG-24559 Change-Id: I5e6a58a4198732dc2f8f52f71abfa1152b871aa7 Reviewed-by: Martin Jones --- src/quick/util/qquickanimation.cpp | 43 +-- src/quick/util/qquickapplication.cpp | 124 ++++++++ src/quick/util/qquickapplication_p.h | 86 ++++++ src/quick/util/qquickglobal.cpp | 530 +++++++++++++++++++++++++++++++++++ src/quick/util/qquickvaluetypes.cpp | 468 +++++++++++++++++++++++++++++++ src/quick/util/qquickvaluetypes_p.h | 310 ++++++++++++++++++++ src/quick/util/util.pri | 9 +- 7 files changed, 1537 insertions(+), 33 deletions(-) create mode 100644 src/quick/util/qquickapplication.cpp create mode 100644 src/quick/util/qquickapplication_p.h create mode 100644 src/quick/util/qquickglobal.cpp create mode 100644 src/quick/util/qquickvaluetypes.cpp create mode 100644 src/quick/util/qquickvaluetypes_p.h (limited to 'src/quick/util') diff --git a/src/quick/util/qquickanimation.cpp b/src/quick/util/qquickanimation.cpp index 33a5d0a438..fc1e6ec89f 100644 --- a/src/quick/util/qquickanimation.cpp +++ b/src/quick/util/qquickanimation.cpp @@ -1755,38 +1755,19 @@ void QQuickPropertyAnimationPrivate::convertVariant(QVariant &variant, int type) } switch (type) { - case QVariant::Rect: { - variant.setValue(QQmlStringConverters::rectFFromString(variant.toString()).toRect()); - break; - } - case QVariant::RectF: { - variant.setValue(QQmlStringConverters::rectFFromString(variant.toString())); - break; - } - case QVariant::Point: { - variant.setValue(QQmlStringConverters::pointFFromString(variant.toString()).toPoint()); - break; - } - case QVariant::PointF: { - variant.setValue(QQmlStringConverters::pointFFromString(variant.toString())); - break; - } - case QVariant::Size: { - variant.setValue(QQmlStringConverters::sizeFFromString(variant.toString()).toSize()); - break; - } - case QVariant::SizeF: { - variant.setValue(QQmlStringConverters::sizeFFromString(variant.toString())); - break; - } - case QVariant::Color: { - variant.setValue(QQmlStringConverters::colorFromString(variant.toString())); - break; - } - case QVariant::Vector3D: { - variant.setValue(QQmlStringConverters::vector3DFromString(variant.toString())); + case QVariant::Rect: + case QVariant::RectF: + case QVariant::Point: + case QVariant::PointF: + case QVariant::Size: + case QVariant::SizeF: + case QVariant::Color: + case QVariant::Vector3D: + { + bool ok = false; + variant = QQmlStringConverters::variantFromString(variant.toString(), type, &ok); + } break; - } default: if (QQmlValueTypeFactory::isValueType((uint)type)) { variant.convert((QVariant::Type)type); diff --git a/src/quick/util/qquickapplication.cpp b/src/quick/util/qquickapplication.cpp new file mode 100644 index 0000000000..55ebb11d29 --- /dev/null +++ b/src/quick/util/qquickapplication.cpp @@ -0,0 +1,124 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQuick module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickapplication_p.h" + +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class QQuickApplicationPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QQuickApplication) +public: + QQuickApplicationPrivate() + : isActive(QGuiApplication::focusWindow() != 0), + direction(QGuiApplication::layoutDirection()) + { + } + +private: + bool isActive; + Qt::LayoutDirection direction; +}; + +/* + This object and its properties are documented as part of the Qt object, + in qqmlengine.cpp +*/ + +QQuickApplication::QQuickApplication(QObject *parent) + : QObject(*new QQuickApplicationPrivate(), parent) +{ + if (qApp) { + qApp->installEventFilter(this); + } +} + +QQuickApplication::~QQuickApplication() +{ +} + +bool QQuickApplication::active() const +{ + Q_D(const QQuickApplication); + return d->isActive; +} + +Qt::LayoutDirection QQuickApplication::layoutDirection() const +{ + Q_D(const QQuickApplication); + return d->direction; +} + +QObject *QQuickApplication::inputPanel() const +{ + static bool warned = false; + if (!warned) { + qWarning() << "Qt.application.inputPanel is deprecated, use Qt.inputMethod instead"; + warned = true; + } + return qGuiApp->inputMethod(); +} + +bool QQuickApplication::eventFilter(QObject *, QEvent *event) +{ + Q_D(QQuickApplication); + if ((event->type() == QEvent::ApplicationActivate) || + (event->type() == QEvent::ApplicationDeactivate)) { + bool wasActive = d->isActive; + d->isActive = (event->type() == QEvent::ApplicationActivate); + if (d->isActive != wasActive) { + emit activeChanged(); + } + } else if (event->type() == QEvent::LayoutDirectionChange) { + Qt::LayoutDirection newDirection = QGuiApplication::layoutDirection(); + if (d->direction != newDirection) { + d->direction = newDirection; + emit layoutDirectionChanged(); + } + } + return false; +} + +QT_END_NAMESPACE diff --git a/src/quick/util/qquickapplication_p.h b/src/quick/util/qquickapplication_p.h new file mode 100644 index 0000000000..e8a3cd58ca --- /dev/null +++ b/src/quick/util/qquickapplication_p.h @@ -0,0 +1,86 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQuick module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKAPPLICATION_P_H +#define QQUICKAPPLICATION_P_H + +#include +#include +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + + +class QQuickApplicationPrivate; +class Q_QUICK_PRIVATE_EXPORT QQuickApplication : public QObject +{ + Q_OBJECT + Q_PROPERTY(bool active READ active NOTIFY activeChanged) + Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection NOTIFY layoutDirectionChanged) + Q_PROPERTY(QObject *inputPanel READ inputPanel CONSTANT) + +public: + explicit QQuickApplication(QObject *parent = 0); + virtual ~QQuickApplication(); + bool active() const; + Qt::LayoutDirection layoutDirection() const; + QT_DEPRECATED QObject *inputPanel() const; + +Q_SIGNALS: + void activeChanged(); + void layoutDirectionChanged(); + +private: + bool eventFilter(QObject *, QEvent *event); + + Q_DISABLE_COPY(QQuickApplication) + Q_DECLARE_PRIVATE(QQuickApplication) +}; + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QQuickApplication) + +QT_END_HEADER + +#endif // QQUICKAPPLICATION_P_H diff --git a/src/quick/util/qquickglobal.cpp b/src/quick/util/qquickglobal.cpp new file mode 100644 index 0000000000..b99cb7a1d4 --- /dev/null +++ b/src/quick/util/qquickglobal.cpp @@ -0,0 +1,530 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include +#include + +#include +#include +#include + + +QT_BEGIN_NAMESPACE + +class QQuickColorProvider : public QQmlColorProvider +{ +public: + static inline QColor QColorFromString(const QString &s) + { + // Should we also handle #rrggbb here? + if (s.length() == 9 && s.startsWith(QLatin1Char('#'))) { + uchar a = fromHex(s, 1); + uchar r = fromHex(s, 3); + uchar g = fromHex(s, 5); + uchar b = fromHex(s, 7); + return QColor(r, g, b, a); + } + + return QColor(s); + } + + QVariant colorFromString(const QString &s, bool *ok) + { + QColor c(QColorFromString(s)); + if (c.isValid()) { + if (ok) *ok = true; + return QVariant(c); + } + + if (ok) *ok = false; + return QVariant(); + } + + unsigned rgbaFromString(const QString &s, bool *ok) + { + QColor c(QColorFromString(s)); + if (c.isValid()) { + if (ok) *ok = true; + return c.rgba(); + } + + if (ok) *ok = false; + return 0; + } + + QString stringFromRgba(unsigned rgba) + { + QColor c(QColor::fromRgba(rgba)); + if (c.isValid()) { + return QVariant(c).toString(); + } + + return QString(); + } + + QVariant fromRgbF(double r, double g, double b, double a) + { + return QVariant(QColor::fromRgbF(r, g, b, a)); + } + + QVariant fromHslF(double h, double s, double l, double a) + { + return QVariant(QColor::fromHslF(h, s, l, a)); + } + + QVariant lighter(const QVariant &var, qreal factor) + { + QColor color = var.value(); + color = color.lighter(int(qRound(factor*100.))); + return QVariant::fromValue(color); + } + + QVariant darker(const QVariant &var, qreal factor) + { + QColor color = var.value(); + color = color.darker(int(qRound(factor*100.))); + return QVariant::fromValue(color); + } + + QVariant tint(const QVariant &baseVar, const QVariant &tintVar) + { + QColor tintColor = tintVar.value(); + + int tintAlpha = tintColor.alpha(); + if (tintAlpha == 0xFF) { + return tintVar; + } else if (tintAlpha == 0x00) { + return baseVar; + } + + // tint the base color and return the final color + QColor baseColor = baseVar.value(); + qreal a = tintColor.alphaF(); + qreal inv_a = 1.0 - a; + + qreal r = tintColor.redF() * a + baseColor.redF() * inv_a; + qreal g = tintColor.greenF() * a + baseColor.greenF() * inv_a; + qreal b = tintColor.blueF() * a + baseColor.blueF() * inv_a; + + return QVariant::fromValue(QColor::fromRgbF(r, g, b, a + inv_a * baseColor.alphaF())); + } + +private: + static uchar fromHex(const uchar c, const uchar c2) + { + uchar rv = 0; + if (c >= '0' && c <= '9') + rv += (c - '0') * 16; + else if (c >= 'A' && c <= 'F') + rv += (c - 'A' + 10) * 16; + else if (c >= 'a' && c <= 'f') + rv += (c - 'a' + 10) * 16; + + if (c2 >= '0' && c2 <= '9') + rv += (c2 - '0'); + else if (c2 >= 'A' && c2 <= 'F') + rv += (c2 - 'A' + 10); + else if (c2 >= 'a' && c2 <= 'f') + rv += (c2 - 'a' + 10); + + return rv; + } + + static inline uchar fromHex(const QString &s, int idx) + { + uchar c = s.at(idx).toAscii(); + uchar c2 = s.at(idx + 1).toAscii(); + return fromHex(c, c2); + } +}; + + +class QQuickValueTypeProvider : public QQmlValueTypeProvider +{ +public: + static QVector3D vector3DFromString(const QString &s, bool *ok) + { + if (s.count(QLatin1Char(',')) == 2) { + int index = s.indexOf(QLatin1Char(',')); + int index2 = s.indexOf(QLatin1Char(','), index+1); + + bool xGood, yGood, zGood; + qreal xCoord = s.left(index).toDouble(&xGood); + qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood); + qreal zCoord = s.mid(index2+1).toDouble(&zGood); + + if (xGood && yGood && zGood) { + if (ok) *ok = true; + return QVector3D(xCoord, yCoord, zCoord); + } + } + + if (ok) *ok = false; + return QVector3D(); + } + + static QVector4D vector4DFromString(const QString &s, bool *ok) + { + if (s.count(QLatin1Char(',')) == 3) { + int index = s.indexOf(QLatin1Char(',')); + int index2 = s.indexOf(QLatin1Char(','), index+1); + int index3 = s.indexOf(QLatin1Char(','), index2+1); + + bool xGood, yGood, zGood, wGood; + qreal xCoord = s.left(index).toDouble(&xGood); + qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood); + qreal zCoord = s.mid(index2+1, index3-index2-1).toDouble(&zGood); + qreal wCoord = s.mid(index3+1).toDouble(&wGood); + + if (xGood && yGood && zGood && wGood) { + if (ok) *ok = true; + return QVector4D(xCoord, yCoord, zCoord, wCoord); + } + } + + if (ok) *ok = false; + return QVector4D(); + } + + bool create(int type, QQmlValueType *&v) + { + switch (type) { + case QMetaType::QColor: + v = new QQuickColorValueType; + return true; + case QMetaType::QVector2D: + v = new QQuickVector2DValueType; + return true; + case QMetaType::QVector3D: + v = new QQuickVector3DValueType; + return true; + case QMetaType::QVector4D: + v = new QQuickVector4DValueType; + return true; + case QMetaType::QQuaternion: + v = new QQuickQuaternionValueType; + return true; + case QMetaType::QMatrix4x4: + v = new QQuickMatrix4x4ValueType; + return true; + case QMetaType::QFont: + v = new QQuickFontValueType; + return true; + default: + return false; + } + } + + bool init(int type, void *data, size_t n) + { + if (type == QMetaType::QColor) { + Q_ASSERT(n >= sizeof(QColor)); + QColor *color = reinterpret_cast(data); + new (color) QColor(); + return true; + } + + return false; + } + + bool destroy(int type, void *data, size_t n) + { + if (type == QMetaType::QColor) { + Q_ASSERT(n >= sizeof(QColor)); + QColor *color = reinterpret_cast(data); + color->~QColor(); + return true; + } + + return false; + } + + bool copy(int type, const void *src, void *dst, size_t n) + { + if (type == QMetaType::QColor) { + Q_ASSERT(n >= sizeof(QColor)); + const QColor *srcColor = reinterpret_cast(src); + QColor *dstColor = reinterpret_cast(dst); + new (dstColor) QColor(*srcColor); + return true; + } + + return false; + } + + bool create(int type, int argc, const void *argv[], QVariant *v) + { + switch (type) { + case QMetaType::QVector3D: + if (argc == 1) { + const float *xyz = reinterpret_cast(argv[0]); + QVector3D v3(xyz[0], xyz[1], xyz[2]); + *v = QVariant(v3); + return true; + } + break; + case QMetaType::QVector4D: + if (argc == 1) { + const float *xyzw = reinterpret_cast(argv[0]); + QVector4D v4(xyzw[0], xyzw[1], xyzw[2], xyzw[3]); + *v = QVariant(v4); + return true; + } + break; + } + + return false; + } + + bool createFromString(int type, const QString &s, void *data, size_t n) + { + bool ok = false; + + switch (type) { + case QMetaType::QColor: + { + Q_ASSERT(n >= sizeof(QColor)); + QColor *color = reinterpret_cast(data); + new (color) QColor(QQuickColorProvider::QColorFromString(s)); + return true; + } + case QMetaType::QVector3D: + { + Q_ASSERT(n >= sizeof(QVector3D)); + QVector3D *v3 = reinterpret_cast(data); + new (v3) QVector3D(vector3DFromString(s, &ok)); + return true; + } + case QMetaType::QVector4D: + { + Q_ASSERT(n >= sizeof(QVector4D)); + QVector4D *v4 = reinterpret_cast(data); + new (v4) QVector4D(vector4DFromString(s, &ok)); + return true; + } + } + + return false; + } + + bool createStringFrom(int type, const void *data, QString *s) + { + if (type == QMetaType::QColor) { + const QColor *color = reinterpret_cast(data); + new (s) QString(QVariant(*color).toString()); + return true; + } + + return false; + } + + bool variantFromString(const QString &s, QVariant *v) + { + QColor c(QQuickColorProvider::QColorFromString(s)); + if (c.isValid()) { + *v = QVariant::fromValue(c); + return true; + } + + bool ok = false; + + QVector3D v3 = vector3DFromString(s, &ok); + if (ok) { + *v = QVariant::fromValue(v3); + return true; + } + + QVector4D v4 = vector4DFromString(s, &ok); + if (ok) { + *v = QVariant::fromValue(v4); + return true; + } + + return false; + } + + bool variantFromString(int type, const QString &s, QVariant *v) + { + bool ok = false; + + switch (type) { + case QMetaType::QColor: + { + QColor c(QQuickColorProvider::QColorFromString(s)); + *v = QVariant::fromValue(c); + return true; + } + case QMetaType::QVector3D: + *v = QVariant::fromValue(vector3DFromString(s, &ok)); + return true; + case QMetaType::QVector4D: + *v = QVariant::fromValue(vector4DFromString(s, &ok)); + return true; + } + + return false; + } + + bool store(int type, const void *src, void *dst, size_t n) + { + switch (type) { + case QMetaType::QColor: + { + Q_ASSERT(n >= sizeof(QColor)); + const QRgb *rgb = reinterpret_cast(src); + QColor *color = reinterpret_cast(dst); + new (color) QColor(QColor::fromRgba(*rgb)); + return true; + } + case QMetaType::QVector3D: + { + Q_ASSERT(n >= sizeof(QVector3D)); + const QVector3D *srcVector = reinterpret_cast(src); + QVector3D *dstVector = reinterpret_cast(dst); + new (dstVector) QVector3D(*srcVector); + return true; + } + case QMetaType::QVector4D: + { + Q_ASSERT(n >= sizeof(QVector4D)); + const QVector4D *srcVector = reinterpret_cast(src); + QVector4D *dstVector = reinterpret_cast(dst); + new (dstVector) QVector4D(*srcVector); + return true; + } + } + + return false; + } + + bool read(int srcType, const void *src, int dstType, void *dst) + { + if (dstType == QMetaType::QColor) { + QColor *dstColor = reinterpret_cast(dst); + if (srcType == QMetaType::QColor) { + const QColor *srcColor = reinterpret_cast(src); + *dstColor = *srcColor; + } else { + *dstColor = QColor(); + } + return true; + } + + return false; + } + + bool write(int type, const void *src, void *dst, size_t n) + { + if (type == QMetaType::QColor) { + Q_ASSERT(n >= sizeof(QColor)); + const QColor *srcColor = reinterpret_cast(src); + QColor *dstColor = reinterpret_cast(dst); + if (*dstColor != *srcColor) { + *dstColor = *srcColor; + return true; + } + } + + return false; + } +}; + + +class QQuickGuiProvider : public QQmlGuiProvider +{ +public: + QQuickApplication *application(QObject *parent) + { + return new QQuickApplication(parent); + } + + QInputMethod *inputMethod() + { + return qGuiApp->inputMethod(); + } + + QStringList fontFamilies() + { + QFontDatabase database; + return database.families(); + } + + bool openUrlExternally(QUrl &url) + { +#ifndef QT_NO_DESKTOPSERVICES + return QDesktopServices::openUrl(url); +#else + return false; +#endif + } +}; + + +static QQuickValueTypeProvider *getValueTypeProvider() +{ + static QQuickValueTypeProvider valueTypeProvider; + return &valueTypeProvider; +} + +static QQuickColorProvider *getColorProvider() +{ + static QQuickColorProvider colorProvider; + return &colorProvider; +} + +static QQuickGuiProvider *getGuiProvider() +{ + static QQuickGuiProvider guiProvider; + return &guiProvider; +} + +static bool initializeProviders() +{ + QQml_addValueTypeProvider(getValueTypeProvider()); + QQml_setColorProvider(getColorProvider()); + QQml_setGuiProvider(getGuiProvider()); + return true; +} + +static bool initialized = initializeProviders(); + +QT_END_NAMESPACE diff --git a/src/quick/util/qquickvaluetypes.cpp b/src/quick/util/qquickvaluetypes.cpp new file mode 100644 index 0000000000..179f840acd --- /dev/null +++ b/src/quick/util/qquickvaluetypes.cpp @@ -0,0 +1,468 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include + +#include +#include +#include + + +QT_BEGIN_NAMESPACE + +namespace QQuickValueTypes { + +void registerValueTypes() +{ + QQmlValueTypeFactory::registerValueTypes(); + + qmlRegisterValueTypeEnums("QtQuick", 2, 0, "Font"); +} + +} + +QQuickColorValueType::QQuickColorValueType(QObject *parent) + : QQmlValueTypeBase(parent) +{ +} + +QString QQuickColorValueType::toString() const +{ + // to maintain behaviour with QtQuick 1.0, we just output normal toString() value. + return QVariant(v).toString(); +} + +qreal QQuickColorValueType::r() const +{ + return v.redF(); +} + +qreal QQuickColorValueType::g() const +{ + return v.greenF(); +} + +qreal QQuickColorValueType::b() const +{ + return v.blueF(); +} + +qreal QQuickColorValueType::a() const +{ + return v.alphaF(); +} + +void QQuickColorValueType::setR(qreal r) +{ + v.setRedF(r); +} + +void QQuickColorValueType::setG(qreal g) +{ + v.setGreenF(g); +} + +void QQuickColorValueType::setB(qreal b) +{ + v.setBlueF(b); +} + +void QQuickColorValueType::setA(qreal a) +{ + v.setAlphaF(a); +} + + +QQuickVector2DValueType::QQuickVector2DValueType(QObject *parent) + : QQmlValueTypeBase(parent) +{ +} + +QString QQuickVector2DValueType::toString() const +{ + return QString(QLatin1String("QVector2D(%1, %2)")).arg(v.x()).arg(v.y()); +} + +qreal QQuickVector2DValueType::x() const +{ + return v.x(); +} + +qreal QQuickVector2DValueType::y() const +{ + return v.y(); +} + +void QQuickVector2DValueType::setX(qreal x) +{ + v.setX(x); +} + +void QQuickVector2DValueType::setY(qreal y) +{ + v.setY(y); +} + + +QQuickVector3DValueType::QQuickVector3DValueType(QObject *parent) + : QQmlValueTypeBase(parent) +{ +} + +QString QQuickVector3DValueType::toString() const +{ + return QString(QLatin1String("QVector3D(%1, %2, %3)")).arg(v.x()).arg(v.y()).arg(v.z()); +} + +qreal QQuickVector3DValueType::x() const +{ + return v.x(); +} + +qreal QQuickVector3DValueType::y() const +{ + return v.y(); +} + +qreal QQuickVector3DValueType::z() const +{ + return v.z(); +} + +void QQuickVector3DValueType::setX(qreal x) +{ + v.setX(x); +} + +void QQuickVector3DValueType::setY(qreal y) +{ + v.setY(y); +} + +void QQuickVector3DValueType::setZ(qreal z) +{ + v.setZ(z); +} + + +QQuickVector4DValueType::QQuickVector4DValueType(QObject *parent) + : QQmlValueTypeBase(parent) +{ +} + +QString QQuickVector4DValueType::toString() const +{ + return QString(QLatin1String("QVector4D(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.z()).arg(v.w()); +} + +qreal QQuickVector4DValueType::x() const +{ + return v.x(); +} + +qreal QQuickVector4DValueType::y() const +{ + return v.y(); +} + +qreal QQuickVector4DValueType::z() const +{ + return v.z(); +} + +qreal QQuickVector4DValueType::w() const +{ + return v.w(); +} + +void QQuickVector4DValueType::setX(qreal x) +{ + v.setX(x); +} + +void QQuickVector4DValueType::setY(qreal y) +{ + v.setY(y); +} + +void QQuickVector4DValueType::setZ(qreal z) +{ + v.setZ(z); +} + +void QQuickVector4DValueType::setW(qreal w) +{ + v.setW(w); +} + + +QQuickQuaternionValueType::QQuickQuaternionValueType(QObject *parent) + : QQmlValueTypeBase(parent) +{ +} + +QString QQuickQuaternionValueType::toString() const +{ + return QString(QLatin1String("QQuaternion(%1, %2, %3, %4)")).arg(v.scalar()).arg(v.x()).arg(v.y()).arg(v.z()); +} + +qreal QQuickQuaternionValueType::scalar() const +{ + return v.scalar(); +} + +qreal QQuickQuaternionValueType::x() const +{ + return v.x(); +} + +qreal QQuickQuaternionValueType::y() const +{ + return v.y(); +} + +qreal QQuickQuaternionValueType::z() const +{ + return v.z(); +} + +void QQuickQuaternionValueType::setScalar(qreal scalar) +{ + v.setScalar(scalar); +} + +void QQuickQuaternionValueType::setX(qreal x) +{ + v.setX(x); +} + +void QQuickQuaternionValueType::setY(qreal y) +{ + v.setY(y); +} + +void QQuickQuaternionValueType::setZ(qreal z) +{ + v.setZ(z); +} + + +QQuickMatrix4x4ValueType::QQuickMatrix4x4ValueType(QObject *parent) + : QQmlValueTypeBase(parent) +{ +} + +QString QQuickMatrix4x4ValueType::toString() const +{ + return QString(QLatin1String("QMatrix4x4(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %16)")) + .arg(v(0, 0)).arg(v(0, 1)).arg(v(0, 2)).arg(v(0, 3)) + .arg(v(1, 0)).arg(v(1, 1)).arg(v(1, 2)).arg(v(1, 3)) + .arg(v(2, 0)).arg(v(2, 1)).arg(v(2, 2)).arg(v(2, 3)) + .arg(v(3, 0)).arg(v(3, 1)).arg(v(3, 2)).arg(v(3, 3)); +} + + +QQuickFontValueType::QQuickFontValueType(QObject *parent) + : QQmlValueTypeBase(parent), + pixelSizeSet(false), + pointSizeSet(false) +{ +} + +void QQuickFontValueType::onLoad() +{ + pixelSizeSet = false; + pointSizeSet = false; +} + +QString QQuickFontValueType::toString() const +{ + return QString(QLatin1String("QFont(%1)")).arg(v.toString()); +} + +QString QQuickFontValueType::family() const +{ + return v.family(); +} + +void QQuickFontValueType::setFamily(const QString &family) +{ + v.setFamily(family); +} + +bool QQuickFontValueType::bold() const +{ + return v.bold(); +} + +void QQuickFontValueType::setBold(bool b) +{ + v.setBold(b); +} + +QQuickFontValueType::FontWeight QQuickFontValueType::weight() const +{ + return (QQuickFontValueType::FontWeight)v.weight(); +} + +void QQuickFontValueType::setWeight(QQuickFontValueType::FontWeight w) +{ + v.setWeight((QFont::Weight)w); +} + +bool QQuickFontValueType::italic() const +{ + return v.italic(); +} + +void QQuickFontValueType::setItalic(bool b) +{ + v.setItalic(b); +} + +bool QQuickFontValueType::underline() const +{ + return v.underline(); +} + +void QQuickFontValueType::setUnderline(bool b) +{ + v.setUnderline(b); +} + +bool QQuickFontValueType::overline() const +{ + return v.overline(); +} + +void QQuickFontValueType::setOverline(bool b) +{ + v.setOverline(b); +} + +bool QQuickFontValueType::strikeout() const +{ + return v.strikeOut(); +} + +void QQuickFontValueType::setStrikeout(bool b) +{ + v.setStrikeOut(b); +} + +qreal QQuickFontValueType::pointSize() const +{ + if (v.pointSizeF() == -1) { + if (dpi.isNull) + dpi = qt_defaultDpi(); + return v.pixelSize() * qreal(72.) / qreal(dpi); + } + return v.pointSizeF(); +} + +void QQuickFontValueType::setPointSize(qreal size) +{ + if (pixelSizeSet) { + qWarning() << "Both point size and pixel size set. Using pixel size."; + return; + } + + if (size >= 0.0) { + pointSizeSet = true; + v.setPointSizeF(size); + } else { + pointSizeSet = false; + } +} + +int QQuickFontValueType::pixelSize() const +{ + if (v.pixelSize() == -1) { + if (dpi.isNull) + dpi = qt_defaultDpi(); + return (v.pointSizeF() * dpi) / qreal(72.); + } + return v.pixelSize(); +} + +void QQuickFontValueType::setPixelSize(int size) +{ + if (size >0) { + if (pointSizeSet) + qWarning() << "Both point size and pixel size set. Using pixel size."; + v.setPixelSize(size); + pixelSizeSet = true; + } else { + pixelSizeSet = false; + } +} + +QQuickFontValueType::Capitalization QQuickFontValueType::capitalization() const +{ + return (QQuickFontValueType::Capitalization)v.capitalization(); +} + +void QQuickFontValueType::setCapitalization(QQuickFontValueType::Capitalization c) +{ + v.setCapitalization((QFont::Capitalization)c); +} + +qreal QQuickFontValueType::letterSpacing() const +{ + return v.letterSpacing(); +} + +void QQuickFontValueType::setLetterSpacing(qreal size) +{ + v.setLetterSpacing(QFont::AbsoluteSpacing, size); +} + +qreal QQuickFontValueType::wordSpacing() const +{ + return v.wordSpacing(); +} + +void QQuickFontValueType::setWordSpacing(qreal size) +{ + v.setWordSpacing(size); +} + +QT_END_NAMESPACE diff --git a/src/quick/util/qquickvaluetypes_p.h b/src/quick/util/qquickvaluetypes_p.h new file mode 100644 index 0000000000..d2767db329 --- /dev/null +++ b/src/quick/util/qquickvaluetypes_p.h @@ -0,0 +1,310 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtQml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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.1, 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKVALUETYPES_P_H +#define QQUICKVALUETYPES_P_H + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +namespace QQuickValueTypes { + +void registerValueTypes(); + +} + +class Q_AUTOTEST_EXPORT QQuickColorValueType : public QQmlValueTypeBase +{ + Q_PROPERTY(qreal r READ r WRITE setR) + Q_PROPERTY(qreal g READ g WRITE setG) + Q_PROPERTY(qreal b READ b WRITE setB) + Q_PROPERTY(qreal a READ a WRITE setA) + Q_OBJECT +public: + QQuickColorValueType(QObject *parent = 0); + + virtual QString toString() const; + + qreal r() const; + qreal g() const; + qreal b() const; + qreal a() const; + void setR(qreal); + void setG(qreal); + void setB(qreal); + void setA(qreal); +}; + +class Q_AUTOTEST_EXPORT QQuickVector2DValueType : public QQmlValueTypeBase +{ + Q_PROPERTY(qreal x READ x WRITE setX) + Q_PROPERTY(qreal y READ y WRITE setY) + Q_OBJECT +public: + QQuickVector2DValueType(QObject *parent = 0); + + virtual QString toString() const; + + qreal x() const; + qreal y() const; + void setX(qreal); + void setY(qreal); +}; + +class Q_AUTOTEST_EXPORT QQuickVector3DValueType : public QQmlValueTypeBase +{ + Q_PROPERTY(qreal x READ x WRITE setX) + Q_PROPERTY(qreal y READ y WRITE setY) + Q_PROPERTY(qreal z READ z WRITE setZ) + Q_OBJECT +public: + QQuickVector3DValueType(QObject *parent = 0); + + virtual QString toString() const; + + qreal x() const; + qreal y() const; + qreal z() const; + void setX(qreal); + void setY(qreal); + void setZ(qreal); +}; + +class Q_AUTOTEST_EXPORT QQuickVector4DValueType : public QQmlValueTypeBase +{ + Q_PROPERTY(qreal x READ x WRITE setX) + Q_PROPERTY(qreal y READ y WRITE setY) + Q_PROPERTY(qreal z READ z WRITE setZ) + Q_PROPERTY(qreal w READ w WRITE setW) + Q_OBJECT +public: + QQuickVector4DValueType(QObject *parent = 0); + + virtual QString toString() const; + + qreal x() const; + qreal y() const; + qreal z() const; + qreal w() const; + void setX(qreal); + void setY(qreal); + void setZ(qreal); + void setW(qreal); +}; + +class Q_AUTOTEST_EXPORT QQuickQuaternionValueType : public QQmlValueTypeBase +{ + Q_PROPERTY(qreal scalar READ scalar WRITE setScalar) + Q_PROPERTY(qreal x READ x WRITE setX) + Q_PROPERTY(qreal y READ y WRITE setY) + Q_PROPERTY(qreal z READ z WRITE setZ) + Q_OBJECT +public: + QQuickQuaternionValueType(QObject *parent = 0); + + virtual QString toString() const; + + qreal scalar() const; + qreal x() const; + qreal y() const; + qreal z() const; + void setScalar(qreal); + void setX(qreal); + void setY(qreal); + void setZ(qreal); +}; + +class Q_AUTOTEST_EXPORT QQuickMatrix4x4ValueType : public QQmlValueTypeBase +{ + Q_PROPERTY(qreal m11 READ m11 WRITE setM11) + Q_PROPERTY(qreal m12 READ m12 WRITE setM12) + Q_PROPERTY(qreal m13 READ m13 WRITE setM13) + Q_PROPERTY(qreal m14 READ m14 WRITE setM14) + Q_PROPERTY(qreal m21 READ m21 WRITE setM21) + Q_PROPERTY(qreal m22 READ m22 WRITE setM22) + Q_PROPERTY(qreal m23 READ m23 WRITE setM23) + Q_PROPERTY(qreal m24 READ m24 WRITE setM24) + Q_PROPERTY(qreal m31 READ m31 WRITE setM31) + Q_PROPERTY(qreal m32 READ m32 WRITE setM32) + Q_PROPERTY(qreal m33 READ m33 WRITE setM33) + Q_PROPERTY(qreal m34 READ m34 WRITE setM34) + Q_PROPERTY(qreal m41 READ m41 WRITE setM41) + Q_PROPERTY(qreal m42 READ m42 WRITE setM42) + Q_PROPERTY(qreal m43 READ m43 WRITE setM43) + Q_PROPERTY(qreal m44 READ m44 WRITE setM44) + Q_OBJECT +public: + QQuickMatrix4x4ValueType(QObject *parent = 0); + + virtual QString toString() const; + + qreal m11() const { return v(0, 0); } + qreal m12() const { return v(0, 1); } + qreal m13() const { return v(0, 2); } + qreal m14() const { return v(0, 3); } + qreal m21() const { return v(1, 0); } + qreal m22() const { return v(1, 1); } + qreal m23() const { return v(1, 2); } + qreal m24() const { return v(1, 3); } + qreal m31() const { return v(2, 0); } + qreal m32() const { return v(2, 1); } + qreal m33() const { return v(2, 2); } + qreal m34() const { return v(2, 3); } + qreal m41() const { return v(3, 0); } + qreal m42() const { return v(3, 1); } + qreal m43() const { return v(3, 2); } + qreal m44() const { return v(3, 3); } + + void setM11(qreal value) { v(0, 0) = value; } + void setM12(qreal value) { v(0, 1) = value; } + void setM13(qreal value) { v(0, 2) = value; } + void setM14(qreal value) { v(0, 3) = value; } + void setM21(qreal value) { v(1, 0) = value; } + void setM22(qreal value) { v(1, 1) = value; } + void setM23(qreal value) { v(1, 2) = value; } + void setM24(qreal value) { v(1, 3) = value; } + void setM31(qreal value) { v(2, 0) = value; } + void setM32(qreal value) { v(2, 1) = value; } + void setM33(qreal value) { v(2, 2) = value; } + void setM34(qreal value) { v(2, 3) = value; } + void setM41(qreal value) { v(3, 0) = value; } + void setM42(qreal value) { v(3, 1) = value; } + void setM43(qreal value) { v(3, 2) = value; } + void setM44(qreal value) { v(3, 3) = value; } +}; + +class Q_AUTOTEST_EXPORT QQuickFontValueType : public QQmlValueTypeBase +{ + Q_OBJECT + Q_ENUMS(FontWeight) + Q_ENUMS(Capitalization) + + Q_PROPERTY(QString family READ family WRITE setFamily) + Q_PROPERTY(bool bold READ bold WRITE setBold) + Q_PROPERTY(FontWeight weight READ weight WRITE setWeight) + Q_PROPERTY(bool italic READ italic WRITE setItalic) + Q_PROPERTY(bool underline READ underline WRITE setUnderline) + Q_PROPERTY(bool overline READ overline WRITE setOverline) + Q_PROPERTY(bool strikeout READ strikeout WRITE setStrikeout) + Q_PROPERTY(qreal pointSize READ pointSize WRITE setPointSize) + Q_PROPERTY(int pixelSize READ pixelSize WRITE setPixelSize) + Q_PROPERTY(Capitalization capitalization READ capitalization WRITE setCapitalization) + Q_PROPERTY(qreal letterSpacing READ letterSpacing WRITE setLetterSpacing) + Q_PROPERTY(qreal wordSpacing READ wordSpacing WRITE setWordSpacing) + +public: + enum FontWeight { Light = QFont::Light, + Normal = QFont::Normal, + DemiBold = QFont::DemiBold, + Bold = QFont::Bold, + Black = QFont::Black }; + enum Capitalization { MixedCase = QFont::MixedCase, + AllUppercase = QFont::AllUppercase, + AllLowercase = QFont::AllLowercase, + SmallCaps = QFont::SmallCaps, + Capitalize = QFont::Capitalize }; + + QQuickFontValueType(QObject *parent = 0); + + virtual QString toString() const; + + QString family() const; + void setFamily(const QString &); + + bool bold() const; + void setBold(bool b); + + FontWeight weight() const; + void setWeight(FontWeight); + + bool italic() const; + void setItalic(bool b); + + bool underline() const; + void setUnderline(bool b); + + bool overline() const; + void setOverline(bool b); + + bool strikeout() const; + void setStrikeout(bool b); + + qreal pointSize() const; + void setPointSize(qreal size); + + int pixelSize() const; + void setPixelSize(int size); + + Capitalization capitalization() const; + void setCapitalization(Capitalization); + + qreal letterSpacing() const; + void setLetterSpacing(qreal spacing); + + qreal wordSpacing() const; + void setWordSpacing(qreal spacing); + + void onLoad(); + +private: + bool pixelSizeSet; + bool pointSizeSet; + mutable QQmlNullableValue dpi; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QQUICKVALUETYPES_P_H diff --git a/src/quick/util/util.pri b/src/quick/util/util.pri index d720ef02c9..3d93b9f2f5 100644 --- a/src/quick/util/util.pri +++ b/src/quick/util/util.pri @@ -1,4 +1,5 @@ SOURCES += \ + $$PWD/qquickapplication.cpp\ $$PWD/qquickutilmodule.cpp\ $$PWD/qquickconnections.cpp \ $$PWD/qquickpackage.cpp \ @@ -26,9 +27,12 @@ SOURCES += \ $$PWD/qquicklistcompositor.cpp \ $$PWD/qquickpathinterpolator.cpp \ $$PWD/qquickimageprovider.cpp \ - $$PWD/qquicksvgparser.cpp + $$PWD/qquicksvgparser.cpp \ + $$PWD/qquickvaluetypes.cpp \ + $$PWD/qquickglobal.cpp HEADERS += \ + $$PWD/qquickapplication_p.h\ $$PWD/qquickutilmodule_p.h\ $$PWD/qquickconnections_p.h \ $$PWD/qquickpackage_p.h \ @@ -60,4 +64,5 @@ HEADERS += \ $$PWD/qquicklistcompositor_p.h \ $$PWD/qquickpathinterpolator_p.h \ $$PWD/qquickimageprovider.h \ - $$PWD/qquicksvgparser_p.h + $$PWD/qquicksvgparser_p.h \ + $$PWD/qquickvaluetypes_p.h -- cgit v1.2.3 From 392b078c78b265ee636e57fca01eebd69f262985 Mon Sep 17 00:00:00 2001 From: Matthew Vogt Date: Wed, 21 Mar 2012 17:55:07 +1000 Subject: Provide imageType() from QQmlImageProviderBase Clients who are only interested in the type of image data provided by an image provider should not need to cast the base pointer to a QQuickImageProvider to access this information. Also make the QQmlImageProviderBase constructor private to prevent unwanted inheritance; all implementors should use the QQuickImageProvider class. Change-Id: Ia2dd2595c2711fa7df47265c9857f45ef0f4cc41 Reviewed-by: Kent Hansen --- src/quick/util/qquickimageprovider.cpp | 13 ------------- src/quick/util/qquickimageprovider.h | 7 ------- 2 files changed, 20 deletions(-) (limited to 'src/quick/util') diff --git a/src/quick/util/qquickimageprovider.cpp b/src/quick/util/qquickimageprovider.cpp index a5d2720cea..1d838cac32 100644 --- a/src/quick/util/qquickimageprovider.cpp +++ b/src/quick/util/qquickimageprovider.cpp @@ -221,19 +221,6 @@ QImage QQuickTextureFactory::image() const \sa QQmlEngine::addImageProvider() */ -/*! - \enum QQuickImageProvider::ImageType - - Defines the type of image supported by this image provider. - - \value Image The Image Provider provides QImage images. The - requestImage() method will be called for all image requests. - \value Pixmap The Image Provider provides QPixmap images. The - requestPixmap() method will be called for all image requests. - \value Texture The Image Provider provides QSGTextureProvider based images. - The requestTexture() method will be called for all image requests. \omitvalue -*/ - /*! Creates an image provider that will provide images of the given \a type. */ diff --git a/src/quick/util/qquickimageprovider.h b/src/quick/util/qquickimageprovider.h index 2a5d146124..252d57b1d6 100644 --- a/src/quick/util/qquickimageprovider.h +++ b/src/quick/util/qquickimageprovider.h @@ -71,13 +71,6 @@ public: class Q_QUICK_EXPORT QQuickImageProvider : public QQmlImageProviderBase { public: - enum ImageType { - Image, - Pixmap, - Texture, - Invalid - }; - QQuickImageProvider(ImageType type); virtual ~QQuickImageProvider(); -- cgit v1.2.3