\image declarative-textballoons_example.png
- The QSGPaintedItem class is a class derived from QSGItem for implementing
+ The QQuickPaintedItem class is a class derived from QQuickItem for implementing
custom QML Scene Graph items using the QPainter interfaces.
The example consists of an item class, a plugin class and a QML file
to use this plugin. The \c TextBalloon class represents the individual
- text balloons extending QSGPaintedItem, the \c TextBalloonPlugin class
+ text balloons extending QQuickPaintedItem, the \c TextBalloonPlugin class
represents the skeleton code for a QtQuick plugin and the
\c textballoons.qml file is used to load the plugin and display the text
balloons.
\section1 TextBalloon Class Declaration
- The \c TextBalloon class inherits from QSGPaintedItem. QSGPaintedItem
+ The \c TextBalloon class inherits from QQuickPaintedItem. QQuickPaintedItem
is the base class for all QPainter based items in the QML Scene Graph
framework.
\snippet examples/declarative/painteditem/textballoons/textballoon.h 0
- To implement a QSGPaintedItem you must implement QSGPaintedIem's pure
- virtual function \l {QSGPaintedItem::}{paint()} which implements the
+ To implement a QQuickPaintedItem you must implement QQuickPaintedIem's pure
+ virtual function \l {QQuickPaintedItem::}{paint()} which implements the
painting of the element.
\section1 TextBalloon Class Definition
\snippet examples/declarative/painteditem/textballoons/textballoon.cpp 1
We start with setting the pen and brush on the item to define the look of
- the item. After that we start drawing. Note that the \l {QSGPaintedItem::}{boundingRect()}
+ the item. After that we start drawing. Note that the \l {QQuickPaintedItem::}{boundingRect()}
item is called to draw depending on the size of the item. The rectangle
- returned by the \l {QSGPaintedItem::}{boundingRect()} function is the size
+ returned by the \l {QQuickPaintedItem::}{boundingRect()} function is the size
of the item as defined in the QML file.
\section1 textballoons.qml file
\section1 Running tests with QtQuick 1
The \c{-qtquick1} option can be passed to a test binary to run
- the tests using QDeclarativeView (QtQuick 1) rather than QSGView (QtQuick 2):
+ the tests using QDeclarativeView (QtQuick 1) rather than QQuickView (QtQuick 2):
\code
tst_example -qtquick1
classes replace their equivalents in QtQuick 1:
\list
-\o QSGView
-\o QSGCanvas
-\o QSGItem
-\o QSGPaintedItem
+\o QQuickView
+\o QQuickCanvas
+\o QQuickItem
+\o QQuickPaintedItem
\endlist
\section2 QML Engine/Language Improvements
\image declarative-textballoons_example.png
- The QSGPaintedItem class is a class derived from QSGItem for implementing
+ The QQuickPaintedItem class is a class derived from QQuickItem for implementing
custom QML Scene Graph items using the QPainter interfaces.
The example consists of an item class, a plugin class and a QML file
to use this plugin. The \c TextBalloon class represents the individual
- text balloons extending QSGPaintedItem, the \c TextBalloonPlugin class
+ text balloons extending QQuickPaintedItem, the \c TextBalloonPlugin class
represents the skeleton code for a QtQuick plugin and the
\c textballoons.qml file is used to load the plugin and display the text
balloons.
\section1 TextBalloon Class Declaration
- The \c TextBalloon class inherits from QSGPaintedItem. QSGPaintedItem
+ The \c TextBalloon class inherits from QQuickPaintedItem. QQuickPaintedItem
is the base class for all QPainter based items in the QML Scene Graph
framework.
\snippet examples/declarative/painteditem/textballoons/textballoon.h 0
- To implement a QSGPaintedItem you must implement QSGPaintedIem's pure
- virtual function \l {QSGPaintedItem::}{paint()} which implements the
+ To implement a QQuickPaintedItem you must implement QQuickPaintedIem's pure
+ virtual function \l {QQuickPaintedItem::}{paint()} which implements the
painting of the element.
\section1 TextBalloon Class Definition
\snippet examples/declarative/painteditem/textballoons/textballoon.cpp 1
We start with setting the pen and brush on the item to define the look of
- the item. After that we start drawing. Note that the \l {QSGPaintedItem::}{boundingRect()}
+ the item. After that we start drawing. Note that the \l {QQuickPaintedItem::}{boundingRect()}
item is called to draw depending on the size of the item. The rectangle
- returned by the \l {QSGPaintedItem::}{boundingRect()} function is the size
+ returned by the \l {QQuickPaintedItem::}{boundingRect()} function is the size
of the item as defined in the QML file.
\section1 textballoons.qml file
\section1 Running tests with QtQuick 1
The \c{-qtquick1} option can be passed to a test binary to run
- the tests using QDeclarativeView (QtQuick 1) rather than QSGView (QtQuick 2):
+ the tests using QDeclarativeView (QtQuick 1) rather than QQuickView (QtQuick 2):
\code
tst_example -qtquick1
#include <QDeclarativeEngine>
#include <QDeclarativeNetworkAccessManagerFactory>
-#include <QSGView>
+#include <QQuickView>
/*
}
}
- QSGView view;
+ QQuickView view;
view.engine()->setNetworkAccessManagerFactory(new MyNetworkAccessManagerFactory);
view.setSource(source);
****************************************************************************/
#include <QtGui/QGuiApplication>
-#include <qsgview.h>
+#include <qquickview.h>
#include <QtDeclarative/QDeclarativeContext>
#include <QtDeclarative/QDeclarativeEngine>
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
- QSGView canvas;
+ QQuickView canvas;
qmlRegisterType<TileData>();
MinehuntGame* game = new MinehuntGame();
- canvas.setResizeMode(QSGView::SizeRootObjectToView);
+ canvas.setResizeMode(QQuickView::SizeRootObjectToView);
canvas.engine()->rootContext()->setContextObject(game);
canvas.setSource(QString("qrc:minehunt.qml"));
QObject::connect(canvas.engine(), SIGNAL(quit()), &app, SLOT(quit()));
#include <qdeclarativeengine.h>
#include <qdeclarativecontext.h>
#include <qdeclarative.h>
-#include <qsgitem.h>
-#include <qsgview.h>
+#include <qquickitem.h>
+#include <qquickview.h>
//![0]
int main(int argc, char ** argv)
model.addAnimal(Animal("Polar bear", "Large"));
model.addAnimal(Animal("Quoll", "Small"));
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
QDeclarativeContext *ctxt = view.rootContext();
ctxt->setContextProperty("myModel", &model);
//![0]
#include <qdeclarativeengine.h>
#include <qdeclarativecontext.h>
#include <qdeclarative.h>
-#include <qsgitem.h>
-#include <qsgview.h>
+#include <qquickitem.h>
+#include <qquickview.h>
#include "dataobject.h"
dataList.append(new DataObject("Item 3", "blue"));
dataList.append(new DataObject("Item 4", "yellow"));
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
QDeclarativeContext *ctxt = view.rootContext();
ctxt->setContextProperty("myModel", QVariant::fromValue(dataList));
//![0]
#include <qdeclarativeengine.h>
#include <qdeclarativecontext.h>
#include <qdeclarative.h>
-#include <qsgitem.h>
-#include <qsgview.h>
+#include <qquickitem.h>
+#include <qquickview.h>
/*
dataList.append("Item 3");
dataList.append("Item 4");
- QSGView view;
+ QQuickView view;
QDeclarativeContext *ctxt = view.rootContext();
ctxt->setContextProperty("myModel", QVariant::fromValue(dataList));
//![0]
#include <QGuiApplication>
#include <QPainter>
#include <QtDeclarative/qdeclarative.h>
-#include <QtDeclarative/qsgview.h>
-#include <QtDeclarative/qsgpainteditem.h>
+#include <QtDeclarative/qquickview.h>
+#include <QtDeclarative/qquickpainteditem.h>
-class MyPaintItem : public QSGPaintedItem
+class MyPaintItem : public QQuickPaintedItem
{
Q_OBJECT
public:
- MyPaintItem() : QSGPaintedItem()
+ MyPaintItem() : QQuickPaintedItem()
{
setAntialiasing(true);
}
qmlRegisterType<MyPaintItem>("MyModule", 1, 0, "MyPaintItem");
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl::fromLocalFile("smile.qml"));
view.show();
view.raise();
#include "textballoon.h"
//! [0]
-TextBalloon::TextBalloon(QSGItem *parent)
- : QSGPaintedItem(parent)
+TextBalloon::TextBalloon(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
, rightAligned(false)
{
}
#include <QtDeclarative>
//! [0]
-class TextBalloon : public QSGPaintedItem
+class TextBalloon : public QQuickPaintedItem
{
Q_OBJECT
Q_PROPERTY(bool rightAligned READ isRightAligned WRITE setRightAligned NOTIFY rightAlignedChanged)
public:
- TextBalloon(QSGItem *parent = 0);
+ TextBalloon(QQuickItem *parent = 0);
void paint(QPainter *painter);
bool isRightAligned();
****************************************************************************/
//![0]
#include "piechart.h"
-#include <QSGView>
+#include <QQuickView>
#include <QGuiApplication>
int main(int argc, char *argv[])
qmlRegisterType<PieChart>("Charts", 1, 0, "PieChart");
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl::fromLocalFile("app.qml"));
view.show();
return app.exec();
#include <QPainter>
//![0]
-PieChart::PieChart(QSGItem *parent)
- : QSGPaintedItem(parent)
+PieChart::PieChart(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
}
//![0]
#define PIECHART_H
//![0]
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
#include <QColor>
-class PieChart : public QSGPaintedItem
+class PieChart : public QQuickPaintedItem
{
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QColor color READ color WRITE setColor)
public:
- PieChart(QSGItem *parent = 0);
+ PieChart(QQuickItem *parent = 0);
QString name() const;
void setName(const QString &name);
****************************************************************************/
//![0]
#include "piechart.h"
-#include <QSGView>
+#include <QQuickView>
#include <QGuiApplication>
int main(int argc, char *argv[])
qmlRegisterType<PieChart>("Charts", 1, 0, "PieChart");
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl::fromLocalFile("app.qml"));
view.show();
return app.exec();
#include "piechart.h"
#include <QPainter>
-PieChart::PieChart(QSGItem *parent)
- : QSGPaintedItem(parent)
+PieChart::PieChart(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
}
#ifndef PIECHART_H
#define PIECHART_H
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
#include <QColor>
//![0]
-class PieChart : public QSGPaintedItem
+class PieChart : public QQuickPaintedItem
{
//![0]
Q_OBJECT
public:
//![1]
- PieChart(QSGItem *parent = 0);
+ PieChart(QQuickItem *parent = 0);
QString name() const;
void setName(const QString &name);
****************************************************************************/
//![0]
#include "piechart.h"
-#include <QSGView>
+#include <QQuickView>
#include <QGuiApplication>
int main(int argc, char *argv[])
qmlRegisterType<PieChart>("Charts", 1, 0, "PieChart");
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl::fromLocalFile("app.qml"));
view.show();
return app.exec();
#include "piechart.h"
#include <QPainter>
-PieChart::PieChart(QSGItem *parent)
- : QSGPaintedItem(parent)
+PieChart::PieChart(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
}
#define PIECHART_H
#include <QColor>
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
//![0]
-class PieChart : public QSGPaintedItem
+class PieChart : public QQuickPaintedItem
{
//![0]
Q_OBJECT
public:
//![1]
- PieChart(QSGItem *parent = 0);
+ PieChart(QQuickItem *parent = 0);
QString name() const;
void setName(const QString &name);
#include "piechart.h"
#include "pieslice.h"
-#include <QSGView>
+#include <QQuickView>
#include <QGuiApplication>
//![0]
qmlRegisterType<PieSlice>("Charts", 1, 0, "PieSlice");
//![1]
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl::fromLocalFile("app.qml"));
view.show();
return app.exec();
#include "piechart.h"
#include "pieslice.h"
-PieChart::PieChart(QSGItem *parent)
- : QSGItem(parent)
+PieChart::PieChart(QQuickItem *parent)
+ : QQuickItem(parent)
{
}
#ifndef PIECHART_H
#define PIECHART_H
-#include <QtDeclarative/QSGItem>
+#include <QtDeclarative/QQuickItem>
class PieSlice;
//![0]
-class PieChart : public QSGItem
+class PieChart : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(PieSlice* pieSlice READ pieSlice WRITE setPieSlice)
public:
//![1]
- PieChart(QSGItem *parent = 0);
+ PieChart(QQuickItem *parent = 0);
QString name() const;
void setName(const QString &name);
#include <QPainter>
-PieSlice::PieSlice(QSGItem *parent)
- : QSGPaintedItem(parent)
+PieSlice::PieSlice(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
}
#ifndef PIESLICE_H
#define PIESLICE_H
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
#include <QColor>
//![0]
-class PieSlice : public QSGPaintedItem
+class PieSlice : public QQuickPaintedItem
{
Q_OBJECT
Q_PROPERTY(QColor color READ color WRITE setColor)
public:
- PieSlice(QSGItem *parent = 0);
+ PieSlice(QQuickItem *parent = 0);
QColor color() const;
void setColor(const QColor &color);
#include "piechart.h"
#include "pieslice.h"
-#include <QSGView>
+#include <QQuickView>
#include <QGuiApplication>
int main(int argc, char *argv[])
qmlRegisterType<PieChart>("Charts", 1, 0, "PieChart");
qmlRegisterType<PieSlice>("Charts", 1, 0, "PieSlice");
- QSGView view;
- view.setResizeMode(QSGView::SizeRootObjectToView);
+ QQuickView view;
+ view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl::fromLocalFile("app.qml"));
view.show();
return app.exec();
#include "piechart.h"
#include "pieslice.h"
-PieChart::PieChart(QSGItem *parent)
- : QSGItem(parent)
+PieChart::PieChart(QQuickItem *parent)
+ : QQuickItem(parent)
{
}
#ifndef PIECHART_H
#define PIECHART_H
-#include <QSGItem>
+#include <QQuickItem>
class PieSlice;
//![0]
-class PieChart : public QSGItem
+class PieChart : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QDeclarativeListProperty<PieSlice> slices READ slices)
//![1]
public:
//![1]
- PieChart(QSGItem *parent = 0);
+ PieChart(QQuickItem *parent = 0);
QString name() const;
void setName(const QString &name);
#include <QPainter>
-PieSlice::PieSlice(QSGItem *parent)
- : QSGPaintedItem(parent)
+PieSlice::PieSlice(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
}
#ifndef PIESLICE_H
#define PIESLICE_H
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
#include <QColor>
//![0]
-class PieSlice : public QSGPaintedItem
+class PieSlice : public QQuickPaintedItem
{
Q_OBJECT
Q_PROPERTY(QColor color READ color WRITE setColor)
//![0]
public:
- PieSlice(QSGItem *parent = 0);
+ PieSlice(QQuickItem *parent = 0);
QColor color() const;
void setColor(const QColor &color);
#include "piechart.h"
#include "pieslice.h"
-PieChart::PieChart(QSGItem *parent)
- : QSGItem(parent)
+PieChart::PieChart(QQuickItem *parent)
+ : QQuickItem(parent)
{
}
#ifndef PIECHART_H
#define PIECHART_H
-#include <QSGItem>
+#include <QQuickItem>
class PieSlice;
-class PieChart : public QSGItem
+class PieChart : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QDeclarativeListProperty<PieSlice> slices READ slices)
Q_PROPERTY(QString name READ name WRITE setName)
public:
- PieChart(QSGItem *parent = 0);
+ PieChart(QQuickItem *parent = 0);
QString name() const;
void setName(const QString &name);
#include <QPainter>
-PieSlice::PieSlice(QSGItem *parent)
- : QSGPaintedItem(parent)
+PieSlice::PieSlice(QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
}
#ifndef PIESLICE_H
#define PIESLICE_H
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
#include <QColor>
-class PieSlice : public QSGPaintedItem
+class PieSlice : public QQuickPaintedItem
{
Q_OBJECT
Q_PROPERTY(QColor color READ color WRITE setColor)
Q_PROPERTY(int angleSpan READ angleSpan WRITE setAngleSpan)
public:
- PieSlice(QSGItem *parent = 0);
+ PieSlice(QQuickItem *parent = 0);
QColor color() const;
void setColor(const QColor &color);
****************************************************************************/
#include "designersupport.h"
-#include <private/qsgitem_p.h>
+#include <private/qquickitem_p.h>
-#include <private/qsgshadereffectsource_p.h>
-#include <private/qsgrectangle_p.h>
+#include <private/qquickshadereffectsource_p.h>
+#include <private/qquickrectangle_p.h>
#include <private/qdeclarativeengine_p.h>
-#include <private/qsgview_p.h>
+#include <private/qquickview_p.h>
#include <private/qdeclarativestategroup_p.h>
#include <QtGui/QImage>
DesignerSupport::~DesignerSupport()
{
- QHash<QSGItem*, QSGShaderEffectTexture*>::iterator iterator;
+ QHash<QQuickItem*, QQuickShaderEffectTexture*>::iterator iterator;
for (iterator = m_itemTextureHash.begin(); iterator != m_itemTextureHash.end(); ++iterator) {
- QSGShaderEffectTexture *texture = iterator.value();
- QSGItem *item = iterator.key();
- QSGItemPrivate::get(item)->derefFromEffectItem(true);
+ QQuickShaderEffectTexture *texture = iterator.value();
+ QQuickItem *item = iterator.key();
+ QQuickItemPrivate::get(item)->derefFromEffectItem(true);
delete texture;
}
}
-void DesignerSupport::refFromEffectItem(QSGItem *referencedItem, bool hide)
+void DesignerSupport::refFromEffectItem(QQuickItem *referencedItem, bool hide)
{
if (referencedItem == 0)
return;
- QSGItemPrivate::get(referencedItem)->refFromEffectItem(hide);
- QSGCanvasPrivate::get(referencedItem->canvas())->updateDirtyNode(referencedItem);
+ QQuickItemPrivate::get(referencedItem)->refFromEffectItem(hide);
+ QQuickCanvasPrivate::get(referencedItem->canvas())->updateDirtyNode(referencedItem);
- Q_ASSERT(QSGItemPrivate::get(referencedItem)->rootNode);
+ Q_ASSERT(QQuickItemPrivate::get(referencedItem)->rootNode);
if (!m_itemTextureHash.contains(referencedItem)) {
- QSGShaderEffectTexture *texture = new QSGShaderEffectTexture(referencedItem);
+ QQuickShaderEffectTexture *texture = new QQuickShaderEffectTexture(referencedItem);
texture->setLive(true);
- texture->setItem(QSGItemPrivate::get(referencedItem)->rootNode);
+ texture->setItem(QQuickItemPrivate::get(referencedItem)->rootNode);
texture->setRect(referencedItem->boundingRect());
texture->setSize(referencedItem->boundingRect().size().toSize());
texture->setRecursive(true);
}
}
-void DesignerSupport::derefFromEffectItem(QSGItem *referencedItem, bool unhide)
+void DesignerSupport::derefFromEffectItem(QQuickItem *referencedItem, bool unhide)
{
if (referencedItem == 0)
return;
delete m_itemTextureHash.take(referencedItem);
- QSGItemPrivate::get(referencedItem)->derefFromEffectItem(unhide);
+ QQuickItemPrivate::get(referencedItem)->derefFromEffectItem(unhide);
}
-QImage DesignerSupport::renderImageForItem(QSGItem *referencedItem, const QRectF &boundingRect, const QSize &imageSize)
+QImage DesignerSupport::renderImageForItem(QQuickItem *referencedItem, const QRectF &boundingRect, const QSize &imageSize)
{
if (referencedItem == 0 || referencedItem->parentItem() == 0) {
qDebug() << __FILE__ << __LINE__ << "Warning: Item can be rendered.";
return QImage();
}
- QSGShaderEffectTexture *renderTexture = m_itemTextureHash.value(referencedItem);
+ QQuickShaderEffectTexture *renderTexture = m_itemTextureHash.value(referencedItem);
Q_ASSERT(renderTexture);
if (renderTexture == 0)
return renderImage;
}
-bool DesignerSupport::isDirty(QSGItem *referencedItem, DirtyType dirtyType)
+bool DesignerSupport::isDirty(QQuickItem *referencedItem, DirtyType dirtyType)
{
if (referencedItem == 0)
return false;
- return QSGItemPrivate::get(referencedItem)->dirtyAttributes & dirtyType;
+ return QQuickItemPrivate::get(referencedItem)->dirtyAttributes & dirtyType;
}
-void DesignerSupport::resetDirty(QSGItem *referencedItem)
+void DesignerSupport::resetDirty(QQuickItem *referencedItem)
{
if (referencedItem == 0)
return;
- QSGItemPrivate::get(referencedItem)->dirtyAttributes = 0x0;
- QSGItemPrivate::get(referencedItem)->removeFromDirtyList();
+ QQuickItemPrivate::get(referencedItem)->dirtyAttributes = 0x0;
+ QQuickItemPrivate::get(referencedItem)->removeFromDirtyList();
}
-QTransform DesignerSupport::canvasTransform(QSGItem *referencedItem)
+QTransform DesignerSupport::canvasTransform(QQuickItem *referencedItem)
{
if (referencedItem == 0)
return QTransform();
- return QSGItemPrivate::get(referencedItem)->itemToCanvasTransform();
+ return QQuickItemPrivate::get(referencedItem)->itemToCanvasTransform();
}
-QTransform DesignerSupport::parentTransform(QSGItem *referencedItem)
+QTransform DesignerSupport::parentTransform(QQuickItem *referencedItem)
{
if (referencedItem == 0)
return QTransform();
QTransform parentTransform;
- QSGItemPrivate::get(referencedItem)->itemToParentTransform(parentTransform);
+ QQuickItemPrivate::get(referencedItem)->itemToParentTransform(parentTransform);
return parentTransform;
}
-QString propertyNameForAnchorLine(const QSGAnchorLine::AnchorLine &anchorLine)
+QString propertyNameForAnchorLine(const QQuickAnchorLine::AnchorLine &anchorLine)
{
switch (anchorLine) {
- case QSGAnchorLine::Left: return QLatin1String("left");
- case QSGAnchorLine::Right: return QLatin1String("right");
- case QSGAnchorLine::Top: return QLatin1String("top");
- case QSGAnchorLine::Bottom: return QLatin1String("bottom");
- case QSGAnchorLine::HCenter: return QLatin1String("horizontalCenter");
- case QSGAnchorLine::VCenter: return QLatin1String("verticalCenter");
- case QSGAnchorLine::Baseline: return QLatin1String("baseline");
- case QSGAnchorLine::Invalid:
+ case QQuickAnchorLine::Left: return QLatin1String("left");
+ case QQuickAnchorLine::Right: return QLatin1String("right");
+ case QQuickAnchorLine::Top: return QLatin1String("top");
+ case QQuickAnchorLine::Bottom: return QLatin1String("bottom");
+ case QQuickAnchorLine::HCenter: return QLatin1String("horizontalCenter");
+ case QQuickAnchorLine::VCenter: return QLatin1String("verticalCenter");
+ case QQuickAnchorLine::Baseline: return QLatin1String("baseline");
+ case QQuickAnchorLine::Invalid:
default: return QString();
}
}
return anchorNameList.contains(name);
}
-bool DesignerSupport::isAnchoredTo(QSGItem *fromItem, QSGItem *toItem)
+bool DesignerSupport::isAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem)
{
- Q_ASSERT(dynamic_cast<QSGItemPrivate*>(QSGItemPrivate::get(fromItem)));
- QSGItemPrivate *fromItemPrivate = static_cast<QSGItemPrivate*>(QSGItemPrivate::get(fromItem));
- QSGAnchors *anchors = fromItemPrivate->anchors();
+ Q_ASSERT(dynamic_cast<QQuickItemPrivate*>(QQuickItemPrivate::get(fromItem)));
+ QQuickItemPrivate *fromItemPrivate = static_cast<QQuickItemPrivate*>(QQuickItemPrivate::get(fromItem));
+ QQuickAnchors *anchors = fromItemPrivate->anchors();
return anchors->fill() == toItem
|| anchors->centerIn() == toItem
|| anchors->bottom().item == toItem
|| anchors->baseline().item == toItem;
}
-bool DesignerSupport::areChildrenAnchoredTo(QSGItem *fromItem, QSGItem *toItem)
+bool DesignerSupport::areChildrenAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem)
{
- foreach (QSGItem *childItem, fromItem->childItems()) {
+ foreach (QQuickItem *childItem, fromItem->childItems()) {
if (childItem) {
if (isAnchoredTo(childItem, toItem))
return true;
return false;
}
-QSGAnchors *anchors(QSGItem *item)
+QQuickAnchors *anchors(QQuickItem *item)
{
- QSGItemPrivate *itemPrivate = static_cast<QSGItemPrivate*>(QSGItemPrivate::get(item));
+ QQuickItemPrivate *itemPrivate = static_cast<QQuickItemPrivate*>(QQuickItemPrivate::get(item));
return itemPrivate->anchors();
}
-QSGAnchors::Anchor anchorLineFlagForName(const QString &name)
+QQuickAnchors::Anchor anchorLineFlagForName(const QString &name)
{
if (name == QLatin1String("anchors.top"))
- return QSGAnchors::TopAnchor;
+ return QQuickAnchors::TopAnchor;
if (name == QLatin1String("anchors.left"))
- return QSGAnchors::LeftAnchor;
+ return QQuickAnchors::LeftAnchor;
if (name == QLatin1String("anchors.bottom"))
- return QSGAnchors::BottomAnchor;
+ return QQuickAnchors::BottomAnchor;
if (name == QLatin1String("anchors.right"))
- return QSGAnchors::RightAnchor;
+ return QQuickAnchors::RightAnchor;
if (name == QLatin1String("anchors.horizontalCenter"))
- return QSGAnchors::HCenterAnchor;
+ return QQuickAnchors::HCenterAnchor;
if (name == QLatin1String("anchors.verticalCenter"))
- return QSGAnchors::VCenterAnchor;
+ return QQuickAnchors::VCenterAnchor;
if (name == QLatin1String("anchors.baseline"))
- return QSGAnchors::BaselineAnchor;
+ return QQuickAnchors::BaselineAnchor;
Q_ASSERT_X(false, Q_FUNC_INFO, "wrong anchor name - this should never happen");
- return QSGAnchors::LeftAnchor;
+ return QQuickAnchors::LeftAnchor;
}
-bool DesignerSupport::hasAnchor(QSGItem *item, const QString &name)
+bool DesignerSupport::hasAnchor(QQuickItem *item, const QString &name)
{
if (!isValidAnchorName(name))
return false;
return anchors(item)->usedAnchors().testFlag(anchorLineFlagForName(name));
}
-QSGItem *DesignerSupport::anchorFillTargetItem(QSGItem *item)
+QQuickItem *DesignerSupport::anchorFillTargetItem(QQuickItem *item)
{
return anchors(item)->fill();
}
-QSGItem *DesignerSupport::anchorCenterInTargetItem(QSGItem *item)
+QQuickItem *DesignerSupport::anchorCenterInTargetItem(QQuickItem *item)
{
return anchors(item)->centerIn();
}
-QPair<QString, QObject*> DesignerSupport::anchorLineTarget(QSGItem *item, const QString &name, QDeclarativeContext *context)
+QPair<QString, QObject*> DesignerSupport::anchorLineTarget(QQuickItem *item, const QString &name, QDeclarativeContext *context)
{
QObject *targetObject = 0;
QString targetName;
if (!metaProperty.isValid())
return QPair<QString, QObject*>();
- QSGAnchorLine anchorLine = metaProperty.read().value<QSGAnchorLine>();
- if (anchorLine.anchorLine != QSGAnchorLine::Invalid) {
+ QQuickAnchorLine anchorLine = metaProperty.read().value<QQuickAnchorLine>();
+ if (anchorLine.anchorLine != QQuickAnchorLine::Invalid) {
targetObject = anchorLine.item;
targetName = propertyNameForAnchorLine(anchorLine.anchorLine);
}
return QPair<QString, QObject*>(targetName, targetObject);
}
-void DesignerSupport::resetAnchor(QSGItem *item, const QString &name)
+void DesignerSupport::resetAnchor(QQuickItem *item, const QString &name)
{
if (name == QLatin1String("anchors.fill")) {
anchors(item)->resetFill();
}
}
-QList<QObject*> DesignerSupport::statesForItem(QSGItem *item)
+QList<QObject*> DesignerSupport::statesForItem(QQuickItem *item)
{
QList<QObject*> objectList;
- QList<QDeclarativeState *> stateList = QSGItemPrivate::get(item)->_states()->states();
+ QList<QDeclarativeState *> stateList = QQuickItemPrivate::get(item)->_states()->states();
qCopy(stateList.begin(), stateList.end(), objectList.begin());
return objectList;
}
-bool DesignerSupport::isComponentComplete(QSGItem *item)
+bool DesignerSupport::isComponentComplete(QQuickItem *item)
{
- return static_cast<QSGItemPrivate*>(QSGItemPrivate::get(item))->componentComplete;
+ return static_cast<QQuickItemPrivate*>(QQuickItemPrivate::get(item))->componentComplete;
}
-int DesignerSupport::borderWidth(QSGItem *item)
+int DesignerSupport::borderWidth(QQuickItem *item)
{
- QSGRectangle *rectangle = qobject_cast<QSGRectangle*>(item);
+ QQuickRectangle *rectangle = qobject_cast<QQuickRectangle*>(item);
if (rectangle)
return rectangle->border()->width();
QDeclarativeContextPrivate::get(context)->data->refreshExpressions();
}
-void DesignerSupport::setRootItem(QSGView *view, QSGItem *item)
+void DesignerSupport::setRootItem(QQuickView *view, QQuickItem *item)
{
- QSGViewPrivate::get(view)->setRootObject(item);
+ QQuickViewPrivate::get(view)->setRootObject(item);
}
-bool DesignerSupport::isValidWidth(QSGItem *item)
+bool DesignerSupport::isValidWidth(QQuickItem *item)
{
- return QSGItemPrivate::get(item)->heightValid;
+ return QQuickItemPrivate::get(item)->heightValid;
}
-bool DesignerSupport::isValidHeight(QSGItem *item)
+bool DesignerSupport::isValidHeight(QQuickItem *item)
{
- return QSGItemPrivate::get(item)->widthValid;
+ return QQuickItemPrivate::get(item)->widthValid;
}
-void DesignerSupport::updateDirtyNode(QSGItem *item)
+void DesignerSupport::updateDirtyNode(QQuickItem *item)
{
- QSGCanvasPrivate::get(item->canvas())->updateDirtyNode(item);
+ QQuickCanvasPrivate::get(item->canvas())->updateDirtyNode(item);
}
QT_END_NAMESPACE
QT_MODULE(Declarative)
-class QSGItem;
-class QSGShaderEffectTexture;
+class QQuickItem;
+class QQuickShaderEffectTexture;
class QImage;
class QTransform;
class QDeclarativeContext;
-class QSGView;
+class QQuickView;
class Q_DECLARATIVE_EXPORT DesignerSupport
DesignerSupport();
~DesignerSupport();
- void refFromEffectItem(QSGItem *referencedItem, bool hide = true);
- void derefFromEffectItem(QSGItem *referencedItem, bool unhide = true);
+ void refFromEffectItem(QQuickItem *referencedItem, bool hide = true);
+ void derefFromEffectItem(QQuickItem *referencedItem, bool unhide = true);
- QImage renderImageForItem(QSGItem *referencedItem, const QRectF &boundingRect, const QSize &imageSize);
+ QImage renderImageForItem(QQuickItem *referencedItem, const QRectF &boundingRect, const QSize &imageSize);
- static bool isDirty(QSGItem *referencedItem, DirtyType dirtyType);
- static void resetDirty(QSGItem *referencedItem);
+ static bool isDirty(QQuickItem *referencedItem, DirtyType dirtyType);
+ static void resetDirty(QQuickItem *referencedItem);
- static QTransform canvasTransform(QSGItem *referencedItem);
- static QTransform parentTransform(QSGItem *referencedItem);
+ static QTransform canvasTransform(QQuickItem *referencedItem);
+ static QTransform parentTransform(QQuickItem *referencedItem);
- static bool isAnchoredTo(QSGItem *fromItem, QSGItem *toItem);
- static bool areChildrenAnchoredTo(QSGItem *fromItem, QSGItem *toItem);
- static bool hasAnchor(QSGItem *item, const QString &name);
- static QSGItem *anchorFillTargetItem(QSGItem *item);
- static QSGItem *anchorCenterInTargetItem(QSGItem *item);
- static QPair<QString, QObject*> anchorLineTarget(QSGItem *item, const QString &name, QDeclarativeContext *context);
- static void resetAnchor(QSGItem *item, const QString &name);
+ static bool isAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem);
+ static bool areChildrenAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem);
+ static bool hasAnchor(QQuickItem *item, const QString &name);
+ static QQuickItem *anchorFillTargetItem(QQuickItem *item);
+ static QQuickItem *anchorCenterInTargetItem(QQuickItem *item);
+ static QPair<QString, QObject*> anchorLineTarget(QQuickItem *item, const QString &name, QDeclarativeContext *context);
+ static void resetAnchor(QQuickItem *item, const QString &name);
- static QList<QObject*> statesForItem(QSGItem *item);
+ static QList<QObject*> statesForItem(QQuickItem *item);
- static bool isComponentComplete(QSGItem *item);
+ static bool isComponentComplete(QQuickItem *item);
- static int borderWidth(QSGItem *item);
+ static int borderWidth(QQuickItem *item);
static void refreshExpressions(QDeclarativeContext *context);
- static void setRootItem(QSGView *view, QSGItem *item);
+ static void setRootItem(QQuickView *view, QQuickItem *item);
- static bool isValidWidth(QSGItem *item);
- static bool isValidHeight(QSGItem *item);
+ static bool isValidWidth(QQuickItem *item);
+ static bool isValidHeight(QQuickItem *item);
- static void updateDirtyNode(QSGItem *item);
+ static void updateDirtyNode(QQuickItem *item);
private:
- QHash<QSGItem*, QSGShaderEffectTexture*> m_itemTextureHash;
+ QHash<QQuickItem*, QQuickShaderEffectTexture*> m_itemTextureHash;
};
QT_END_NAMESPACE
SOURCES += \
- $$PWD/qsgcanvasitem.cpp \
- $$PWD/qsgcontext2d.cpp \
- $$PWD/qsgcontext2dnode.cpp \
- $$PWD/qsgcontext2dtile.cpp \
- $$PWD/qsgcontext2dtexture.cpp \
- $$PWD/qsgcontext2dcommandbuffer.cpp \
+ $$PWD/qquickcanvasitem.cpp \
+ $$PWD/qquickcontext2d.cpp \
+ $$PWD/qquickcontext2dnode.cpp \
+ $$PWD/qquickcontext2dtile.cpp \
+ $$PWD/qquickcontext2dtexture.cpp \
+ $$PWD/qquickcontext2dcommandbuffer.cpp \
HEADERS += \
- $$PWD/qsgcanvasitem_p.h \
- $$PWD/qsgcontext2d_p.h \
- $$PWD/qsgcontext2dnode_p.h \
- $$PWD/qsgcontext2dtile_p.h \
- $$PWD/qsgcontext2dtexture_p.h \
- $$PWD/qsgcontext2dcommandbuffer_p.h \
+ $$PWD/qquickcanvasitem_p.h \
+ $$PWD/qquickcontext2d_p.h \
+ $$PWD/qquickcontext2dnode_p.h \
+ $$PWD/qquickcontext2dtile_p.h \
+ $$PWD/qquickcontext2dtexture_p.h \
+ $$PWD/qquickcontext2dcommandbuffer_p.h \
****************************************************************************/
#include <private/qsgadaptationlayer_p.h>
-#include "qsgcanvasitem_p.h"
-#include <private/qsgitem_p.h>
-#include "qsgcontext2d_p.h"
-#include "qsgcontext2dnode_p.h"
-#include "qsgcontext2dtexture_p.h"
+#include "qquickcanvasitem_p.h"
+#include <private/qquickitem_p.h>
+#include "qquickcontext2d_p.h"
+#include "qquickcontext2dnode_p.h"
+#include "qquickcontext2dtexture_p.h"
#include <private/qdeclarativepixmapcache_p.h>
#include <qdeclarativeinfo.h>
QT_BEGIN_NAMESPACE
-class QSGCanvasItemPrivate : public QSGItemPrivate
+class QQuickCanvasItemPrivate : public QQuickItemPrivate
{
public:
- QSGCanvasItemPrivate();
- ~QSGCanvasItemPrivate();
- QSGContext2D* context;
- QSGContext2DTexture* texture;
+ QQuickCanvasItemPrivate();
+ ~QQuickCanvasItemPrivate();
+ QQuickContext2D* context;
+ QQuickContext2DTexture* texture;
QSizeF canvasSize;
QSize tileSize;
QRectF canvasWindow;
uint hasTileSize :1;
uint hasCanvasWindow :1;
uint componentCompleted :1;
- QSGCanvasItem::RenderTarget renderTarget;
+ QQuickCanvasItem::RenderTarget renderTarget;
QHash<QUrl, QDeclarativePixmap*> images;
QUrl baseUrl;
};
-QSGCanvasItemPrivate::QSGCanvasItemPrivate()
- : QSGItemPrivate()
+QQuickCanvasItemPrivate::QQuickCanvasItemPrivate()
+ : QQuickItemPrivate()
, context(0)
, texture(0)
, canvasSize(1, 1)
, hasTileSize(false)
, hasCanvasWindow(false)
, componentCompleted(false)
- , renderTarget(QSGCanvasItem::FramebufferObject)
+ , renderTarget(QQuickCanvasItem::FramebufferObject)
{
}
-QSGCanvasItemPrivate::~QSGCanvasItemPrivate()
+QQuickCanvasItemPrivate::~QQuickCanvasItemPrivate()
{
qDeleteAll(images);
}
/*!
- \qmlclass Canvas QSGCanvasItem
+ \qmlclass Canvas QQuickCanvasItem
\inqmlmodule QtQuick 2
\since QtQuick 2.0
\brief The Canvas item provides HTML5 like canvas element which enables you to
\sa QtQuick2::Context2D
*/
-QSGCanvasItem::QSGCanvasItem(QSGItem *parent)
- : QSGItem(*(new QSGCanvasItemPrivate), parent)
+QQuickCanvasItem::QQuickCanvasItem(QQuickItem *parent)
+ : QQuickItem(*(new QQuickCanvasItemPrivate), parent)
{
setFlag(ItemHasContents);
}
-QSGCanvasItem::~QSGCanvasItem()
+QQuickCanvasItem::~QQuickCanvasItem()
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
delete d->context;
}
the Canvas render engine.
\sa QtQuick2::Canvas::tileSize QtQuick2::Canvas::canvasWindow
*/
-QSizeF QSGCanvasItem::canvasSize() const
+QSizeF QQuickCanvasItem::canvasSize() const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
return d->canvasSize;
}
-void QSGCanvasItem::setCanvasSize(const QSizeF & size)
+void QQuickCanvasItem::setCanvasSize(const QSizeF & size)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (d->canvasSize != size) {
d->hasCanvasSize = true;
d->canvasSize = size;
By default, the tile size is the same with the canvas size.
\sa QtQuick2::Canvas::canvaasSize QtQuick2::Canvas::canvasWindow
*/
-QSize QSGCanvasItem::tileSize() const
+QSize QQuickCanvasItem::tileSize() const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
return d->tileSize;
}
-void QSGCanvasItem::setTileSize(const QSize & size)
+void QQuickCanvasItem::setTileSize(const QSize & size)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (d->tileSize != size) {
d->hasTileSize = true;
d->tileSize = size;
and/or position.
\sa QtQuick2::Canvas::canvasSize QtQuick2::Canvas::tileSize
*/
-QRectF QSGCanvasItem::canvasWindow() const
+QRectF QQuickCanvasItem::canvasWindow() const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
return d->canvasWindow;
}
-void QSGCanvasItem::setCanvasWindow(const QRectF& rect)
+void QQuickCanvasItem::setCanvasWindow(const QRectF& rect)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (d->canvasWindow != rect) {
d->canvasWindow = rect;
}
-QSGContext2D* QSGCanvasItem::context() const
+QQuickContext2D* QQuickCanvasItem::context() const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
return d->context;
}
/*!
The default value is false.
\sa QtQuick2::Canvas::renderTarget
*/
-bool QSGCanvasItem::renderInThread() const
+bool QQuickCanvasItem::renderInThread() const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
return d->renderInThread;
}
/*!
The default render target is \c Canvas.Image.
\sa QtQuick2::Canvas::renderInThread
*/
-QSGCanvasItem::RenderTarget QSGCanvasItem::renderTarget() const
+QQuickCanvasItem::RenderTarget QQuickCanvasItem::renderTarget() const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
return d->renderTarget;
}
-void QSGCanvasItem::setRenderTarget(RenderTarget target)
+void QQuickCanvasItem::setRenderTarget(RenderTarget target)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (d->renderTarget != target) {
d->renderTarget = target;
}
}
-void QSGCanvasItem::_doPainting(const QRectF& region)
+void QQuickCanvasItem::_doPainting(const QRectF& region)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
emit paint(QDeclarativeV8Handle::fromHandle(d->context->v8value())
- , QSGContext2DTexture::tiledRect(region, d->tileSize));
+ , QQuickContext2DTexture::tiledRect(region, d->tileSize));
if (d->texture)
d->texture->wake();
}
The default renderInThread value is false.
*/
-void QSGCanvasItem::setRenderInThread(bool renderInThread)
+void QQuickCanvasItem::setRenderInThread(bool renderInThread)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (d->renderInThread != renderInThread) {
d->renderInThread = renderInThread;
}
}
-void QSGCanvasItem::geometryChanged(const QRectF &newGeometry,
+void QQuickCanvasItem::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
- Q_D(QSGCanvasItem);
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ Q_D(QQuickCanvasItem);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
const qreal w = newGeometry.width();
const qreal h = newGeometry.height();
update();
}
-void QSGCanvasItem::componentComplete()
+void QQuickCanvasItem::componentComplete()
{
- Q_D(QSGCanvasItem);
- QSGItem::componentComplete();
+ Q_D(QQuickCanvasItem);
+ QQuickItem::componentComplete();
if (!d->context)
createContext();
d->componentCompleted = true;
}
-void QSGCanvasItem::updatePolish()
+void QQuickCanvasItem::updatePolish()
{
- Q_D(QSGCanvasItem);
- QSGItem::updatePolish();
+ Q_D(QQuickCanvasItem);
+ QQuickItem::updatePolish();
if (d->texture) {
if (!d->renderInThread && d->dirtyRect.isValid())
_doPainting(d->dirtyRect);
}
}
-QSGNode *QSGCanvasItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickCanvasItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
- Q_D(QSGCanvasItem);
- QSGContext2DNode *node = static_cast<QSGContext2DNode *>(oldNode);
+ Q_D(QQuickCanvasItem);
+ QQuickContext2DNode *node = static_cast<QQuickContext2DNode *>(oldNode);
if (!node)
- node = new QSGContext2DNode(this);
+ node = new QQuickContext2DNode(this);
node->setTexture(d->texture);
node->setSize(d->canvasWindow.size());
return node;
}
-void QSGCanvasItem::createTexture()
+void QQuickCanvasItem::createTexture()
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (!d->texture
|| d->texture->threadRendering() != d->renderInThread
d->texture = 0;
}
- if (d->renderTarget == QSGCanvasItem::Image) {
- d->texture = new QSGContext2DImageTexture(d->renderInThread);
- } else if (d->renderTarget == QSGCanvasItem::FramebufferObject) {
- d->texture = new QSGContext2DFBOTexture();
+ if (d->renderTarget == QQuickCanvasItem::Image) {
+ d->texture = new QQuickContext2DImageTexture(d->renderInThread);
+ } else if (d->renderTarget == QQuickCanvasItem::FramebufferObject) {
+ d->texture = new QQuickContext2DFBOTexture();
}
if (d->renderInThread && !d->texture->supportThreadRendering()) {
}
}
-void QSGCanvasItem::createContext()
+void QQuickCanvasItem::createContext()
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
delete d->context;
- d->context = new QSGContext2D(this);
+ d->context = new QQuickContext2D(this);
QV8Engine *e = QDeclarativeEnginePrivate::getV8Engine(qmlEngine(this));
d->context->setV8Engine(e);
parameter isn't provided or is "2d", then the QtQuick2::Context2D object is
returned, otherwise returns an invalid value.
*/
-QDeclarativeV8Handle QSGCanvasItem::getContext(const QString &contextId)
+QDeclarativeV8Handle QQuickCanvasItem::getContext(const QString &contextId)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
if (contextId.toLower() != QLatin1String("2d"))
return QDeclarativeV8Handle::fromHandle(v8::Undefined());
\sa QtQuick2::Canvas::paint QtQuick2::Canvas::requestPaint
*/
-void QSGCanvasItem::markDirty(const QRectF& region)
+void QQuickCanvasItem::markDirty(const QRectF& region)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
d->dirtyRect |= region;
if (d->componentCompleted)
polish();
\sa canvasWindow canvasSize toDataURL
*/
-bool QSGCanvasItem::save(const QString &filename) const
+bool QQuickCanvasItem::save(const QString &filename) const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
QUrl url = d->baseUrl.resolved(QUrl::fromLocalFile(filename));
return toImage().save(url.toLocalFile());
}
-QImage QSGCanvasItem::loadedImage(const QUrl& url)
+QImage QQuickCanvasItem::loadedImage(const QUrl& url)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
QUrl fullPathUrl = d->baseUrl.resolved(url);
if (!d->images.contains(fullPathUrl)) {
loadImage(url);
\sa QtQuick2::Canvas::unloadImage QtQuick2::Canvas::imageLoaded QtQuick2::Canvas::isImageLoaded
\sa QtQuick2::Context2D::createImageData QtQuick2::Context2D::drawImage
*/
-void QSGCanvasItem::loadImage(const QUrl& url)
+void QQuickCanvasItem::loadImage(const QUrl& url)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
QUrl fullPathUrl = d->baseUrl.resolved(url);
if (!d->images.contains(fullPathUrl)) {
QDeclarativePixmap* pix = new QDeclarativePixmap();
\sa QtQuick2::Canvas::loadImage QtQuick2::Canvas::imageLoaded QtQuick2::Canvas::isImageLoaded
\sa QtQuick2::Context2D::createImageData QtQuick2::Context2D::drawImage
*/
-void QSGCanvasItem::unloadImage(const QUrl& url)
+void QQuickCanvasItem::unloadImage(const QUrl& url)
{
- Q_D(QSGCanvasItem);
+ Q_D(QQuickCanvasItem);
QUrl removeThis = d->baseUrl.resolved(url);
if (d->images.contains(removeThis)) {
delete d->images.value(removeThis);
\sa QtQuick2::Canvas::loadImage
*/
-bool QSGCanvasItem::isImageError(const QUrl& url) const
+bool QQuickCanvasItem::isImageError(const QUrl& url) const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
QUrl fullPathUrl = d->baseUrl.resolved(url);
return d->images.contains(fullPathUrl)
&& d->images.value(fullPathUrl)->isError();
\sa QtQuick2::Canvas::loadImage
*/
-bool QSGCanvasItem::isImageLoading(const QUrl& url) const
+bool QQuickCanvasItem::isImageLoading(const QUrl& url) const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
QUrl fullPathUrl = d->baseUrl.resolved(url);
return d->images.contains(fullPathUrl)
&& d->images.value(fullPathUrl)->isLoading();
\sa QtQuick2::Canvas::loadImage
*/
-bool QSGCanvasItem::isImageLoaded(const QUrl& url) const
+bool QQuickCanvasItem::isImageLoaded(const QUrl& url) const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
QUrl fullPathUrl = d->baseUrl.resolved(url);
return d->images.contains(fullPathUrl)
&& d->images.value(fullPathUrl)->isReady();
}
-QImage QSGCanvasItem::toImage(const QRectF& region) const
+QImage QQuickCanvasItem::toImage(const QRectF& region) const
{
- Q_D(const QSGCanvasItem);
+ Q_D(const QQuickCanvasItem);
if (d->texture) {
if (region.isEmpty())
return d->texture->toImage(canvasWindow());
\sa QtQuick2::Canvas::save
*/
-QString QSGCanvasItem::toDataURL(const QString& mimeType) const
+QString QQuickCanvasItem::toDataURL(const QString& mimeType) const
{
QImage image = toImage();
**
****************************************************************************/
-#ifndef QSGCANVASITEM_P_H
-#define QSGCANVASITEM_P_H
+#ifndef QQUICKCANVASITEM_P_H
+#define QQUICKCANVASITEM_P_H
-#include <qsgitem.h>
+#include <qquickitem.h>
#include <private/qv8engine_p.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class QSGContext2D;
-class QSGCanvasItemPrivate;
-class Q_DECLARATIVE_EXPORT QSGCanvasItem : public QSGItem
+class QQuickContext2D;
+class QQuickCanvasItemPrivate;
+class Q_DECLARATIVE_EXPORT QQuickCanvasItem : public QQuickItem
{
Q_OBJECT
Q_ENUMS(RenderTarget)
Convolute
};
- QSGCanvasItem(QSGItem *parent = 0);
- ~QSGCanvasItem();
+ QQuickCanvasItem(QQuickItem *parent = 0);
+ ~QQuickCanvasItem();
QSizeF canvasSize() const;
void setCanvasSize(const QSizeF &);
RenderTarget renderTarget() const;
void setRenderTarget(RenderTarget target);
- QSGContext2D* context() const;
+ QQuickContext2D* context() const;
QImage toImage(const QRectF& region = QRectF()) const;
QImage loadedImage(const QUrl& url);
private:
void createContext();
void createTexture();
- Q_DECLARE_PRIVATE(QSGCanvasItem)
- friend class QSGContext2D;
- friend class QSGContext2DTexture;
+ Q_DECLARE_PRIVATE(QQuickCanvasItem)
+ friend class QQuickContext2D;
+ friend class QQuickContext2DTexture;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGCanvasItem)
+QML_DECLARE_TYPE(QQuickCanvasItem)
QT_END_HEADER
-#endif //QSGCANVASITEM_P_H
+#endif //QQUICKCANVASITEM_P_H
**
****************************************************************************/
-#include "qsgcontext2d_p.h"
-#include "qsgcontext2dcommandbuffer_p.h"
-#include "qsgcanvasitem_p.h"
-#include <private/qsgitem_p.h>
-#include <private/qsgshadereffectsource_p.h>
+#include "qquickcontext2d_p.h"
+#include "qquickcontext2dcommandbuffer_p.h"
+#include "qquickcanvasitem_p.h"
+#include <private/qquickitem_p.h>
+#include <private/qquickshadereffectsource_p.h>
#include <QtGui/qopenglframebufferobject.h>
#include <QtCore/qdebug.h>
#include <private/qdeclarativesvgparser_p.h>
#include <private/qdeclarativepath_p.h>
-#include <private/qsgimage_p_p.h>
+#include <private/qquickimage_p_p.h>
#include <QtGui/qguiapplication.h>
#include <qdeclarativeinfo.h>
QT_BEGIN_NAMESPACE
/*!
- \qmlclass Context2D QSGContext2D
+ \qmlclass Context2D QQuickContext2D
\inqmlmodule QtQuick 2
\since QtQuick 2.0
\brief The Context2D API allows you to draw 2d graphic shapes on the \c Canvas item.
-class QSGContext2DEngineData : public QV8Engine::Deletable
+class QQuickContext2DEngineData : public QV8Engine::Deletable
{
public:
- QSGContext2DEngineData(QV8Engine *engine);
- ~QSGContext2DEngineData();
+ QQuickContext2DEngineData(QV8Engine *engine);
+ ~QQuickContext2DEngineData();
v8::Persistent<v8::Function> constructorContext;
v8::Persistent<v8::Function> constructorGradient;
v8::Persistent<v8::Function> constructorImageData;
};
-V8_DEFINE_EXTENSION(QSGContext2DEngineData, engineData)
+V8_DEFINE_EXTENSION(QQuickContext2DEngineData, engineData)
class QV8Context2DResource : public QV8ObjectResource
{
V8_RESOURCE_TYPE(Context2DType)
public:
QV8Context2DResource(QV8Engine *e) : QV8ObjectResource(e) {}
- QSGContext2D* context;
+ QQuickContext2D* context;
};
class QV8Context2DStyleResource : public QV8ObjectResource
static v8::Local<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
{
- QSGContext2DEngineData *ed = engineData(engine);
+ QQuickContext2DEngineData *ed = engineData(engine);
v8::Local<v8::Object> imageData = ed->constructorImageData->NewInstance();
QV8Context2DPixelArrayResource *r = new QV8Context2DPixelArrayResource(engine);
if (image.isNull()) {
QV8Engine *engine = V8ENGINE();
if (args.Length() == 4) {
- QSGContext2DEngineData *ed = engineData(engine);
+ QQuickContext2DEngineData *ed = engineData(engine);
v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
qreal x0 = args[0]->NumberValue();
QV8Engine *engine = V8ENGINE();
if (args.Length() == 6) {
- QSGContext2DEngineData *ed = engineData(engine);
+ QQuickContext2DEngineData *ed = engineData(engine);
v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
QV8Engine *engine = V8ENGINE();
if (args.Length() == 6) {
- QSGContext2DEngineData *ed = engineData(engine);
+ QQuickContext2DEngineData *ed = engineData(engine);
v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
QV8Engine *engine = V8ENGINE();
if (args.Length() == 2) {
- QSGContext2DEngineData *ed = engineData(engine);
+ QQuickContext2DEngineData *ed = engineData(engine);
QV8Context2DStyleResource *styleResouce = new QV8Context2DStyleResource(engine);
QColor color = engine->toVariant(args[0], qMetaTypeId<QColor>()).value<QColor>();
CHECK_CONTEXT(r)
QV8Engine *engine = V8ENGINE_ACCESSOR();
switch (r->context->state.textAlign) {
- case QSGContext2D::Start:
+ case QQuickContext2D::Start:
return engine->toString(QLatin1String("start"));
- case QSGContext2D::End:
+ case QQuickContext2D::End:
return engine->toString(QLatin1String("end"));
- case QSGContext2D::Left:
+ case QQuickContext2D::Left:
return engine->toString(QLatin1String("left"));
- case QSGContext2D::Right:
+ case QQuickContext2D::Right:
return engine->toString(QLatin1String("right"));
- case QSGContext2D::Center:
+ case QQuickContext2D::Center:
return engine->toString(QLatin1String("center"));
default:
break;
QString textAlign = engine->toString(value);
- QSGContext2D::TextAlignType ta;
+ QQuickContext2D::TextAlignType ta;
if (textAlign == QLatin1String("start"))
- ta = QSGContext2D::Start;
+ ta = QQuickContext2D::Start;
else if (textAlign == QLatin1String("end"))
- ta = QSGContext2D::End;
+ ta = QQuickContext2D::End;
else if (textAlign == QLatin1String("left"))
- ta = QSGContext2D::Left;
+ ta = QQuickContext2D::Left;
else if (textAlign == QLatin1String("right"))
- ta = QSGContext2D::Right;
+ ta = QQuickContext2D::Right;
else if (textAlign == QLatin1String("center"))
- ta = QSGContext2D::Center;
+ ta = QQuickContext2D::Center;
else
return;
QV8Engine *engine = V8ENGINE_ACCESSOR();
switch (r->context->state.textBaseline) {
- case QSGContext2D::Alphabetic:
+ case QQuickContext2D::Alphabetic:
return engine->toString(QLatin1String("alphabetic"));
- case QSGContext2D::Hanging:
+ case QQuickContext2D::Hanging:
return engine->toString(QLatin1String("hanging"));
- case QSGContext2D::Top:
+ case QQuickContext2D::Top:
return engine->toString(QLatin1String("top"));
- case QSGContext2D::Bottom:
+ case QQuickContext2D::Bottom:
return engine->toString(QLatin1String("bottom"));
- case QSGContext2D::Middle:
+ case QQuickContext2D::Middle:
return engine->toString(QLatin1String("middle"));
default:
break;
QV8Engine *engine = V8ENGINE_ACCESSOR();
QString textBaseline = engine->toString(value);
- QSGContext2D::TextBaseLineType tb;
+ QQuickContext2D::TextBaseLineType tb;
if (textBaseline == QLatin1String("alphabetic"))
- tb = QSGContext2D::Alphabetic;
+ tb = QQuickContext2D::Alphabetic;
else if (textBaseline == QLatin1String("hanging"))
- tb = QSGContext2D::Hanging;
+ tb = QQuickContext2D::Hanging;
else if (textBaseline == QLatin1String("top"))
- tb = QSGContext2D::Top;
+ tb = QQuickContext2D::Top;
else if (textBaseline == QLatin1String("bottom"))
- tb = QSGContext2D::Bottom;
+ tb = QQuickContext2D::Bottom;
else if (textBaseline == QLatin1String("middle"))
- tb = QSGContext2D::Middle;
+ tb = QQuickContext2D::Middle;
else
return;
image = r->context->createImage(url);
} else if (args[0]->IsObject()) {
- QSGImage *imageItem = qobject_cast<QSGImage*>(engine->toQObject(args[0]->ToObject()));
- QSGCanvasItem *canvas = qobject_cast<QSGCanvasItem*>(engine->toQObject(args[0]->ToObject()));
+ QQuickImage *imageItem = qobject_cast<QQuickImage*>(engine->toQObject(args[0]->ToObject()));
+ QQuickCanvasItem *canvas = qobject_cast<QQuickCanvasItem*>(engine->toQObject(args[0]->ToObject()));
QV8Context2DPixelArrayResource *pix = v8_resource_cast<QV8Context2DPixelArrayResource>(args[0]->ToObject()->GetInternalField(0)->ToObject());
if (pix) {
if (args.Length() >= 1) {
int filterFlag = args[0]->IntegerValue();
switch (filterFlag) {
- case QSGCanvasItem::Mono :
+ case QQuickCanvasItem::Mono :
{
r->image = r->image.convertToFormat(QImage::Format_Mono).convertToFormat(QImage::Format_ARGB32_Premultiplied);
}
break;
- case QSGCanvasItem::GrayScale :
+ case QQuickCanvasItem::GrayScale :
{
for (int y = 0; y < r->image.height(); ++y) {
QRgb *row = (QRgb*)r->image.scanLine(y);
}
}
break;
- case QSGCanvasItem::Threshold :
+ case QQuickCanvasItem::Threshold :
{
qreal threshold = 0.5;
if (args.Length() > 1)
}
}
break;
- case QSGCanvasItem::Brightness :
+ case QQuickCanvasItem::Brightness :
{
int adjustment = 1;
if (args.Length() > 1)
}
}
break;
- case QSGCanvasItem::Invert :
+ case QQuickCanvasItem::Invert :
{
r->image.invertPixels();
}
break;
- case QSGCanvasItem::Blur :
+ case QQuickCanvasItem::Blur :
{
int radius = 3;
bool quality = false;
qt_image_boxblur(r->image, radius, quality);
}
break;
- case QSGCanvasItem::Opaque :
+ case QQuickCanvasItem::Opaque :
{
for (int y = 0; y < r->image.height(); ++y) {
QRgb *row = (QRgb*)r->image.scanLine(y);
}
}
break;
- case QSGCanvasItem::Convolute :
+ case QQuickCanvasItem::Convolute :
{
if (args.Length() > 1 && args[1]->IsArray()) {
v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(args[1]);
}
-void QSGContext2D::beginPath()
+void QQuickContext2D::beginPath()
{
m_path = QPainterPath();
m_path.setFillRule(state.fillRule);
}
-void QSGContext2D::closePath()
+void QQuickContext2D::closePath()
{
if (m_path.isEmpty())
return;
//should be the first point of the previous subpath
}
-void QSGContext2D::moveTo( qreal x, qreal y)
+void QQuickContext2D::moveTo( qreal x, qreal y)
{
//FIXME: moveTo should not close the previous subpath
m_path.moveTo(state.matrix.map(QPointF(x, y)));
}
-void QSGContext2D::lineTo( qreal x, qreal y)
+void QQuickContext2D::lineTo( qreal x, qreal y)
{
m_path.lineTo(state.matrix.map(QPointF(x, y)));
}
-void QSGContext2D::quadraticCurveTo(qreal cpx, qreal cpy,
+void QQuickContext2D::quadraticCurveTo(qreal cpx, qreal cpy,
qreal x, qreal y)
{
m_path.quadTo(state.matrix.map(QPointF(cpx, cpy)),
state.matrix.map(QPointF(x, y)));
}
-void QSGContext2D::bezierCurveTo(qreal cp1x, qreal cp1y,
+void QQuickContext2D::bezierCurveTo(qreal cp1x, qreal cp1y,
qreal cp2x, qreal cp2y,
qreal x, qreal y)
{
state.matrix.map(QPointF(x, y)));
}
-void QSGContext2D::addArcTo(const QPointF& p1, const QPointF& p2, float radius)
+void QQuickContext2D::addArcTo(const QPointF& p1, const QPointF& p2, float radius)
{
QPointF p0(m_path.currentPosition());
arc(p.x(), p.y(), radius, sa, ea, anticlockwise, false);
}
-void QSGContext2D::arcTo(qreal x1, qreal y1,
+void QQuickContext2D::arcTo(qreal x1, qreal y1,
qreal x2, qreal y2,
qreal radius)
{
}
}
-void QSGContext2D::rect(qreal x, qreal y,
+void QQuickContext2D::rect(qreal x, qreal y,
qreal w, qreal h)
{
m_path.addPolygon(state.matrix.map(QRectF(x, y, w, h)));
}
-void QSGContext2D::roundedRect(qreal x, qreal y,
+void QQuickContext2D::roundedRect(qreal x, qreal y,
qreal w, qreal h,
qreal xr, qreal yr)
{
m_path.addPath(state.matrix.map(path));
}
-void QSGContext2D::ellipse(qreal x, qreal y,
+void QQuickContext2D::ellipse(qreal x, qreal y,
qreal w, qreal h)
{
QPainterPath path;
m_path.addPath(state.matrix.map(path));
}
-void QSGContext2D::text(const QString& str, qreal x, qreal y)
+void QQuickContext2D::text(const QString& str, qreal x, qreal y)
{
QPainterPath path;
path.addText(x, y, state.font, str);
m_path.addPath(state.matrix.map(path));
}
-void QSGContext2D::arc(qreal xc,
+void QQuickContext2D::arc(qreal xc,
qreal yc,
qreal radius,
qreal sar,
m_path.arcTo(xs, ys, width, height, sa, span);
}
-int baseLineOffset(QSGContext2D::TextBaseLineType value, const QFontMetrics &metrics)
+int baseLineOffset(QQuickContext2D::TextBaseLineType value, const QFontMetrics &metrics)
{
int offset = 0;
switch (value) {
- case QSGContext2D::Top:
+ case QQuickContext2D::Top:
break;
- case QSGContext2D::Alphabetic:
- case QSGContext2D::Middle:
- case QSGContext2D::Hanging:
+ case QQuickContext2D::Alphabetic:
+ case QQuickContext2D::Middle:
+ case QQuickContext2D::Hanging:
offset = metrics.ascent();
break;
- case QSGContext2D::Bottom:
+ case QQuickContext2D::Bottom:
offset = metrics.height();
break;
}
return offset;
}
-static int textAlignOffset(QSGContext2D::TextAlignType value, const QFontMetrics &metrics, const QString &text)
+static int textAlignOffset(QQuickContext2D::TextAlignType value, const QFontMetrics &metrics, const QString &text)
{
int offset = 0;
- if (value == QSGContext2D::Start)
- value = QGuiApplication::layoutDirection() == Qt::LeftToRight ? QSGContext2D::Left : QSGContext2D::Right;
- else if (value == QSGContext2D::End)
- value = QGuiApplication::layoutDirection() == Qt::LeftToRight ? QSGContext2D::Right: QSGContext2D::Left;
+ if (value == QQuickContext2D::Start)
+ value = QGuiApplication::layoutDirection() == Qt::LeftToRight ? QQuickContext2D::Left : QQuickContext2D::Right;
+ else if (value == QQuickContext2D::End)
+ value = QGuiApplication::layoutDirection() == Qt::LeftToRight ? QQuickContext2D::Right: QQuickContext2D::Left;
switch (value) {
- case QSGContext2D::Center:
+ case QQuickContext2D::Center:
offset = metrics.width(text)/2;
break;
- case QSGContext2D::Right:
+ case QQuickContext2D::Right:
offset = metrics.width(text);
- case QSGContext2D::Left:
+ case QQuickContext2D::Left:
default:
break;
}
}
-QImage QSGContext2D::createImage(const QUrl& url)
+QImage QQuickContext2D::createImage(const QUrl& url)
{
return m_canvas->loadedImage(url);
}
-QPainterPath QSGContext2D::createTextGlyphs(qreal x, qreal y, const QString& text)
+QPainterPath QQuickContext2D::createTextGlyphs(qreal x, qreal y, const QString& text)
{
const QFontMetrics metrics(state.font);
- int yoffset = baseLineOffset(static_cast<QSGContext2D::TextBaseLineType>(state.textBaseline), metrics);
- int xoffset = textAlignOffset(static_cast<QSGContext2D::TextAlignType>(state.textAlign), metrics, text);
+ int yoffset = baseLineOffset(static_cast<QQuickContext2D::TextBaseLineType>(state.textBaseline), metrics);
+ int xoffset = textAlignOffset(static_cast<QQuickContext2D::TextAlignType>(state.textAlign), metrics, text);
QPainterPath textPath;
}
-bool QSGContext2D::isPointInPath(qreal x, qreal y) const
+bool QQuickContext2D::isPointInPath(qreal x, qreal y) const
{
return m_path.contains(QPointF(x, y));
}
-QSGContext2D::QSGContext2D(QSGCanvasItem* item)
+QQuickContext2D::QQuickContext2D(QQuickCanvasItem* item)
: m_canvas(item)
- , m_buffer(new QSGContext2DCommandBuffer)
+ , m_buffer(new QQuickContext2DCommandBuffer)
, m_v8engine(0)
{
reset();
}
-QSGContext2D::~QSGContext2D()
+QQuickContext2D::~QQuickContext2D()
{
}
-v8::Handle<v8::Object> QSGContext2D::v8value() const
+v8::Handle<v8::Object> QQuickContext2D::v8value() const
{
return m_v8value;
}
-QSGContext2DEngineData::QSGContext2DEngineData(QV8Engine *engine)
+QQuickContext2DEngineData::QQuickContext2DEngineData(QV8Engine *engine)
{
v8::HandleScope handle_scope;
v8::Context::Scope scope(engine->context());
constructorImageData = qPersistentNew(ftImageData->GetFunction());
}
-QSGContext2DEngineData::~QSGContext2DEngineData()
+QQuickContext2DEngineData::~QQuickContext2DEngineData()
{
qPersistentDispose(constructorContext);
qPersistentDispose(constructorGradient);
qPersistentDispose(constructorPixelArray);
}
-void QSGContext2D::popState()
+void QQuickContext2D::popState()
{
if (m_stateStack.isEmpty())
return;
- QSGContext2D::State newState = m_stateStack.pop();
+ QQuickContext2D::State newState = m_stateStack.pop();
if (state.matrix != newState.matrix)
buffer()->updateMatrix(newState.matrix);
buffer()->setShadowOffsetY(newState.shadowOffsetY);
state = newState;
}
-void QSGContext2D::pushState()
+void QQuickContext2D::pushState()
{
m_stateStack.push(state);
}
-void QSGContext2D::reset()
+void QQuickContext2D::reset()
{
- QSGContext2D::State newState;
+ QQuickContext2D::State newState;
newState.matrix = QTransform();
QPainterPath defaultClipPath;
newState.shadowColor = qRgba(0, 0, 0, 0);
newState.globalCompositeOperation = QPainter::CompositionMode_SourceOver;
newState.font = QFont(QLatin1String("sans-serif"), 10);
- newState.textAlign = QSGContext2D::Start;
- newState.textBaseline = QSGContext2D::Alphabetic;
+ newState.textAlign = QQuickContext2D::Start;
+ newState.textBaseline = QQuickContext2D::Alphabetic;
m_stateStack.clear();
m_stateStack.push(newState);
m_buffer->clearRect(0, 0, m_canvas->width(), m_canvas->height());
}
-void QSGContext2D::setV8Engine(QV8Engine *engine)
+void QQuickContext2D::setV8Engine(QV8Engine *engine)
{
v8::HandleScope handle_scope;
v8::Context::Scope scope(engine->context());
if (m_v8engine == 0)
return;
- QSGContext2DEngineData *ed = engineData(engine);
+ QQuickContext2DEngineData *ed = engineData(engine);
m_v8value = qPersistentNew(ed->constructorContext->NewInstance());
QV8Context2DResource *r = new QV8Context2DResource(engine);
r->context = this;
**
****************************************************************************/
-#ifndef QSGCONTEXT2D_P_H
-#define QSGCONTEXT2D_P_H
+#ifndef QQUICKCONTEXT2D_P_H
+#define QQUICKCONTEXT2D_P_H
#include <QtDeclarative/qdeclarative.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#define QSGCONTEXT2D_DEBUG //enable this for just DEBUG purpose!
+#define QQUICKCONTEXT2D_DEBUG //enable this for just DEBUG purpose!
-#ifdef QSGCONTEXT2D_DEBUG
+#ifdef QQUICKCONTEXT2D_DEBUG
#include <QElapsedTimer>
#endif
QT_MODULE(Declarative)
-class QSGCanvasItem;
-class QSGContext2DCommandBuffer;
+class QQuickCanvasItem;
+class QQuickContext2DCommandBuffer;
class QDeclarativePixmap;
-class Q_DECLARATIVE_EXPORT QSGContext2D
+class Q_DECLARATIVE_EXPORT QQuickContext2D
{
public:
enum TextBaseLineType { Alphabetic=0, Top, Middle, Bottom, Hanging};
QColor shadowColor;
QPainter::CompositionMode globalCompositeOperation;
QFont font;
- QSGContext2D::TextAlignType textAlign;
- QSGContext2D::TextBaseLineType textBaseline;
+ QQuickContext2D::TextAlignType textAlign;
+ QQuickContext2D::TextBaseLineType textBaseline;
};
- QSGContext2D(QSGCanvasItem* item);
- ~QSGContext2D();
+ QQuickContext2D(QQuickCanvasItem* item);
+ ~QQuickContext2D();
- inline QSGCanvasItem* canvas() const {return m_canvas;}
- inline QSGContext2DCommandBuffer* buffer() const {return m_buffer;}
+ inline QQuickCanvasItem* canvas() const {return m_canvas;}
+ inline QQuickContext2DCommandBuffer* buffer() const {return m_buffer;}
v8::Handle<v8::Object> v8value() const;
void setV8Engine(QV8Engine *eng);
QImage createImage(const QUrl& url);
State state;
- QStack<QSGContext2D::State> m_stateStack;
- QSGCanvasItem* m_canvas;
- QSGContext2DCommandBuffer* m_buffer;
+ QStack<QQuickContext2D::State> m_stateStack;
+ QQuickCanvasItem* m_canvas;
+ QQuickContext2DCommandBuffer* m_buffer;
QPainterPath m_path;
v8::Local<v8::Value> m_fillStyle;
v8::Local<v8::Value> m_strokeStyle;
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGContext2D)
+QML_DECLARE_TYPE(QQuickContext2D)
QT_END_HEADER
-#endif // QSGCONTEXT2D_P_H
+#endif // QQUICKCONTEXT2D_P_H
**
****************************************************************************/
-#include "qsgcontext2dcommandbuffer_p.h"
-#include "qsgcanvasitem_p.h"
+#include "qquickcontext2dcommandbuffer_p.h"
+#include "qquickcanvasitem_p.h"
#include <qdeclarative.h>
#include <QtCore/QMutex>
}
}
-QPen QSGContext2DCommandBuffer::makePen(QSGContext2D::State state)
+QPen QQuickContext2DCommandBuffer::makePen(QQuickContext2D::State state)
{
QPen pen;
pen.setWidthF(state.lineWidth);
return pen;
}
-void QSGContext2DCommandBuffer::setPainterState(QPainter* p, QSGContext2D::State state, const QPen& pen)
+void QQuickContext2DCommandBuffer::setPainterState(QPainter* p, QQuickContext2D::State state, const QPen& pen)
{
p->setTransform(state.matrix * p->transform());
p->setCompositionMode(state.globalCompositeOperation);
}
-QSGContext2D::State QSGContext2DCommandBuffer::replay(QPainter* p, QSGContext2D::State state)
+QQuickContext2D::State QQuickContext2DCommandBuffer::replay(QPainter* p, QQuickContext2D::State state)
{
if (!p)
return state;
setPainterState(p, state, pen);
while (hasNext()) {
- QSGContext2D::PaintCommand cmd = takeNextCommand();
+ QQuickContext2D::PaintCommand cmd = takeNextCommand();
switch (cmd) {
- case QSGContext2D::UpdateMatrix:
+ case QQuickContext2D::UpdateMatrix:
{
state.matrix = takeMatrix();
p->setTransform(state.matrix * originMatrix);
break;
}
- case QSGContext2D::ClearRect:
+ case QQuickContext2D::ClearRect:
{
QPainter::CompositionMode cm = p->compositionMode();
qreal alpha = p->opacity();
p->setOpacity(alpha);
break;
}
- case QSGContext2D::FillRect:
+ case QQuickContext2D::FillRect:
{
QRectF r = takeRect();
if (HAS_SHADOW(state.shadowOffsetX, state.shadowOffsetY, state.shadowBlur, state.shadowColor))
p->fillRect(r, p->brush());
break;
}
- case QSGContext2D::ShadowColor:
+ case QQuickContext2D::ShadowColor:
{
state.shadowColor = takeColor();
break;
}
- case QSGContext2D::ShadowBlur:
+ case QQuickContext2D::ShadowBlur:
{
state.shadowBlur = takeShadowBlur();
break;
}
- case QSGContext2D::ShadowOffsetX:
+ case QQuickContext2D::ShadowOffsetX:
{
state.shadowOffsetX = takeShadowOffsetX();
break;
}
- case QSGContext2D::ShadowOffsetY:
+ case QQuickContext2D::ShadowOffsetY:
{
state.shadowOffsetY = takeShadowOffsetY();
break;
}
- case QSGContext2D::FillStyle:
+ case QQuickContext2D::FillStyle:
{
state.fillStyle = takeFillStyle();
state.fillPatternRepeatX = takeBool();
p->setBrush(state.fillStyle);
break;
}
- case QSGContext2D::StrokeStyle:
+ case QQuickContext2D::StrokeStyle:
{
state.strokeStyle = takeStrokeStyle();
state.strokePatternRepeatX = takeBool();
p->setPen(pen);
break;
}
- case QSGContext2D::LineWidth:
+ case QQuickContext2D::LineWidth:
{
state.lineWidth = takeLineWidth();
pen.setWidth(state.lineWidth);
p->setPen(pen);
break;
}
- case QSGContext2D::LineCap:
+ case QQuickContext2D::LineCap:
{
state.lineCap = takeLineCap();
pen.setCapStyle(state.lineCap);
p->setPen(pen);
break;
}
- case QSGContext2D::LineJoin:
+ case QQuickContext2D::LineJoin:
{
state.lineJoin = takeLineJoin();
pen.setJoinStyle(state.lineJoin);
p->setPen(pen);
break;
}
- case QSGContext2D::MiterLimit:
+ case QQuickContext2D::MiterLimit:
{
state.miterLimit = takeMiterLimit();
pen.setMiterLimit(state.miterLimit);
p->setPen(pen);
break;
}
- case QSGContext2D::TextAlign:
- case QSGContext2D::TextBaseline:
+ case QQuickContext2D::TextAlign:
+ case QQuickContext2D::TextBaseline:
break;
- case QSGContext2D::Fill:
+ case QQuickContext2D::Fill:
{
QPainterPath path = takePath();
path.closeSubpath();
p->fillPath(path, p->brush());
break;
}
- case QSGContext2D::Stroke:
+ case QQuickContext2D::Stroke:
{
if (HAS_SHADOW(state.shadowOffsetX, state.shadowOffsetY, state.shadowBlur, state.shadowColor))
strokeShadowPath(p,takePath(), state.shadowOffsetX, state.shadowOffsetY, state.shadowBlur, state.shadowColor);
p->strokePath(takePath(), p->pen());
break;
}
- case QSGContext2D::Clip:
+ case QQuickContext2D::Clip:
{
state.clipPath = takePath();
p->setClipping(true);
p->setClipPath(state.clipPath);
break;
}
- case QSGContext2D::GlobalAlpha:
+ case QQuickContext2D::GlobalAlpha:
{
state.globalAlpha = takeGlobalAlpha();
p->setOpacity(state.globalAlpha);
break;
}
- case QSGContext2D::GlobalCompositeOperation:
+ case QQuickContext2D::GlobalCompositeOperation:
{
state.globalCompositeOperation = takeGlobalCompositeOperation();
p->setCompositionMode(state.globalCompositeOperation);
break;
}
- case QSGContext2D::DrawImage:
+ case QQuickContext2D::DrawImage:
{
qreal sx = takeReal();
qreal sy = takeReal();
}
break;
}
- case QSGContext2D::GetImageData:
+ case QQuickContext2D::GetImageData:
{
//TODO:
break;
return state;
}
-QSGContext2DCommandBuffer::QSGContext2DCommandBuffer()
+QQuickContext2DCommandBuffer::QQuickContext2DCommandBuffer()
: cmdIdx(0)
, intIdx(0)
, boolIdx(0)
}
-QSGContext2DCommandBuffer::~QSGContext2DCommandBuffer()
+QQuickContext2DCommandBuffer::~QQuickContext2DCommandBuffer()
{
}
-void QSGContext2DCommandBuffer::clear()
+void QQuickContext2DCommandBuffer::clear()
{
commands.clear();
ints.clear();
reset();
}
-void QSGContext2DCommandBuffer::reset()
+void QQuickContext2DCommandBuffer::reset()
{
cmdIdx = 0;
intIdx = 0;
**
****************************************************************************/
-#ifndef QSGCONTEXT2DCOMMANDBUFFER_P_H
-#define QSGCONTEXT2DCOMMANDBUFFER_P_H
+#ifndef QQUICKCONTEXT2DCOMMANDBUFFER_P_H
+#define QQUICKCONTEXT2DCOMMANDBUFFER_P_H
-#include "qsgcontext2d_p.h"
+#include "qquickcontext2d_p.h"
#include <private/qdeclarativepixmapcache_p.h>
QT_MODULE(Declarative)
-class QSGCanvasItem;
+class QQuickCanvasItem;
class QMutex;
-class QSGContext2DCommandBuffer
+class QQuickContext2DCommandBuffer
{
public:
- QSGContext2DCommandBuffer();
- ~QSGContext2DCommandBuffer();
+ QQuickContext2DCommandBuffer();
+ ~QQuickContext2DCommandBuffer();
void reset();
void clear();
inline int size() {return commands.size();}
inline bool isEmpty() const {return commands.isEmpty(); }
inline bool hasNext() const {return cmdIdx < commands.size(); }
- inline QSGContext2D::PaintCommand takeNextCommand() { return commands[cmdIdx++]; }
+ inline QQuickContext2D::PaintCommand takeNextCommand() { return commands[cmdIdx++]; }
inline qreal takeGlobalAlpha() { return takeReal(); }
inline QPainter::CompositionMode takeGlobalCompositeOperation(){ return static_cast<QPainter::CompositionMode>(takeInt()); }
inline void setGlobalAlpha( qreal alpha)
{
- commands << QSGContext2D::GlobalAlpha;
+ commands << QQuickContext2D::GlobalAlpha;
reals << alpha;
}
inline void setGlobalCompositeOperation(QPainter::CompositionMode cm)
{
- commands << QSGContext2D::GlobalCompositeOperation;
+ commands << QQuickContext2D::GlobalCompositeOperation;
ints << cm;
}
inline void setStrokeStyle(const QBrush &style, bool repeatX = false, bool repeatY = false)
{
- commands << QSGContext2D::StrokeStyle;
+ commands << QQuickContext2D::StrokeStyle;
brushes << style;
bools << repeatX << repeatY;
}
inline void drawImage(const QImage& image, qreal sx, qreal sy, qreal sw, qreal sh, qreal dx, qreal dy, qreal dw, qreal dh)
{
- commands << QSGContext2D::DrawImage;
+ commands << QQuickContext2D::DrawImage;
images << image;
reals << sx << sy << sw << sh << dx << dy << dw << dh;
}
inline void updateMatrix(const QTransform& matrix)
{
- commands << QSGContext2D::UpdateMatrix;
+ commands << QQuickContext2D::UpdateMatrix;
matrixes << matrix;
}
inline void clearRect(qreal x, qreal y, qreal w, qreal h)
{
- commands << QSGContext2D::ClearRect;
+ commands << QQuickContext2D::ClearRect;
reals << x << y << w << h;
}
inline void fillRect(qreal x, qreal y, qreal w, qreal h)
{
- commands << QSGContext2D::FillRect;
+ commands << QQuickContext2D::FillRect;
reals << x << y << w << h;
}
QPainterPath p;
p.addRect(x, y, w, h);
- commands << QSGContext2D::Stroke;
+ commands << QQuickContext2D::Stroke;
pathes << p;
}
inline void fill(const QPainterPath& path)
{
- commands << QSGContext2D::Fill;
+ commands << QQuickContext2D::Fill;
pathes << path;
}
inline void stroke(const QPainterPath& path)
{
- commands << QSGContext2D::Stroke;
+ commands << QQuickContext2D::Stroke;
pathes << path;
}
inline void clip(const QPainterPath& path)
{
- commands << QSGContext2D::Clip;
+ commands << QQuickContext2D::Clip;
pathes << path;
}
inline void setFillStyle(const QBrush &style, bool repeatX = false, bool repeatY = false)
{
- commands << QSGContext2D::FillStyle;
+ commands << QQuickContext2D::FillStyle;
brushes << style;
bools << repeatX << repeatY;
}
inline void setLineWidth( qreal w)
{
- commands << QSGContext2D::LineWidth;
+ commands << QQuickContext2D::LineWidth;
reals << w;
}
inline void setLineCap(Qt::PenCapStyle cap)
{
- commands << QSGContext2D::LineCap;
+ commands << QQuickContext2D::LineCap;
ints << cap;
}
inline void setLineJoin(Qt::PenJoinStyle join)
{
- commands << QSGContext2D::LineJoin;
+ commands << QQuickContext2D::LineJoin;
ints << join;
}
inline void setMiterLimit( qreal limit)
{
- commands << QSGContext2D::MiterLimit;
+ commands << QQuickContext2D::MiterLimit;
reals << limit;
}
inline void setShadowOffsetX( qreal x)
{
- commands << QSGContext2D::ShadowOffsetX;
+ commands << QQuickContext2D::ShadowOffsetX;
reals << x;
}
inline void setShadowOffsetY( qreal y)
{
- commands << QSGContext2D::ShadowOffsetY;
+ commands << QQuickContext2D::ShadowOffsetY;
reals << y;
}
inline void setShadowBlur( qreal b)
{
- commands << QSGContext2D::ShadowBlur;
+ commands << QQuickContext2D::ShadowBlur;
reals << b;
}
inline void setShadowColor(const QColor &color)
{
- commands << QSGContext2D::ShadowColor;
+ commands << QQuickContext2D::ShadowColor;
colors << color;
}
inline QColor takeColor() { return colors[colorIdx++]; }
inline QBrush takeBrush() { return brushes[brushIdx++]; }
- QSGContext2D::State replay(QPainter* painter, QSGContext2D::State state);
+ QQuickContext2D::State replay(QPainter* painter, QQuickContext2D::State state);
private:
- QPen makePen(QSGContext2D::State state);
- void setPainterState(QPainter* painter, QSGContext2D::State state, const QPen& pen);
+ QPen makePen(QQuickContext2D::State state);
+ void setPainterState(QPainter* painter, QQuickContext2D::State state, const QPen& pen);
int cmdIdx;
int intIdx;
int boolIdx;
int brushIdx;
int pathIdx;
int imageIdx;
- QVector<QSGContext2D::PaintCommand> commands;
+ QVector<QQuickContext2D::PaintCommand> commands;
QVector<int> ints;
QVector<bool> bools;
QT_END_NAMESPACE
-#endif // QSGCONTEXT2DCOMMANDBUFFER_P_H
+#endif // QQUICKCONTEXT2DCOMMANDBUFFER_P_H
**
****************************************************************************/
-#include "qsgcontext2dnode_p.h"
+#include "qquickcontext2dnode_p.h"
#include <private/qsgcontext_p.h>
#include <QtCore/qmath.h>
QT_BEGIN_NAMESPACE
-QSGContext2DNode::QSGContext2DNode(QSGCanvasItem* item)
+QQuickContext2DNode::QQuickContext2DNode(QQuickCanvasItem* item)
: QSGGeometryNode()
, m_item(item)
, m_geometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 4)
setFlag(UsePreprocess, true);
}
-QSGContext2DNode::~QSGContext2DNode()
+QQuickContext2DNode::~QQuickContext2DNode()
{
delete m_texture;
}
-void QSGContext2DNode::setSize(const QSizeF& size)
+void QQuickContext2DNode::setSize(const QSizeF& size)
{
if (m_size != size) {
m_dirtyGeometry = true;
}
}
-void QSGContext2DNode::preprocess()
+void QQuickContext2DNode::preprocess()
{
bool doDirty = false;
QSGDynamicTexture *t = qobject_cast<QSGDynamicTexture *>(m_material.texture());
markDirty(DirtyMaterial);
}
}
-void QSGContext2DNode::setTexture(QSGContext2DTexture* texture)
+void QQuickContext2DNode::setTexture(QQuickContext2DTexture* texture)
{
if (texture != m_texture) {
m_dirtyTexture = true;
}
}
-void QSGContext2DNode::update()
+void QQuickContext2DNode::update()
{
if (m_dirtyGeometry)
updateGeometry();
m_dirtyTexture = false;
}
-void QSGContext2DNode::updateTexture()
+void QQuickContext2DNode::updateTexture()
{
m_material.setTexture(m_texture);
m_materialO.setTexture(m_texture);
markDirty(DirtyMaterial);
}
-void QSGContext2DNode::updateGeometry()
+void QQuickContext2DNode::updateGeometry()
{
QRectF source = m_texture->textureSubRect();
QSGGeometry::updateTexturedRectGeometry(&m_geometry,
**
****************************************************************************/
-#ifndef QSGCONTEXT2DNODE_P_H
-#define QSGCONTEXT2DNODE_P_H
+#ifndef QQUICKCONTEXT2DNODE_P_H
+#define QQUICKCONTEXT2DNODE_P_H
#include <qsgnode.h>
#include <qsgtexturematerial.h>
-#include "qsgcanvasitem_p.h"
-#include "qsgcontext2dtexture_p.h"
-#include "qsgcontext2d_p.h"
+#include "qquickcanvasitem_p.h"
+#include "qquickcontext2dtexture_p.h"
+#include "qquickcontext2d_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGContext2DNode : public QSGGeometryNode
+class QQuickContext2DNode : public QSGGeometryNode
{
public:
- QSGContext2DNode(QSGCanvasItem* item);
- virtual ~QSGContext2DNode();
- void setTexture(QSGContext2DTexture* texture);
+ QQuickContext2DNode(QQuickCanvasItem* item);
+ virtual ~QQuickContext2DNode();
+ void setTexture(QQuickContext2DTexture* texture);
void update();
void preprocess();
void setSize(const QSizeF& size);
void updateTexture();
void updateGeometry();
- QSGCanvasItem* m_item;
+ QQuickCanvasItem* m_item;
QSGOpaqueTextureMaterial m_material;
QSGTextureMaterial m_materialO;
QSGGeometry m_geometry;
- QSGContext2DTexture* m_texture;
+ QQuickContext2DTexture* m_texture;
QSizeF m_size;
bool m_dirtyGeometry;
QT_END_NAMESPACE
-#endif // QSGCONTEXT2DNODE_P_H
+#endif // QQUICKCONTEXT2DNODE_P_H
**
****************************************************************************/
-#include "qsgcontext2dtexture_p.h"
-#include "qsgcontext2dtile_p.h"
-#include "qsgcanvasitem_p.h"
-#include <private/qsgitem_p.h>
+#include "qquickcontext2dtexture_p.h"
+#include "qquickcontext2dtile_p.h"
+#include "qquickcanvasitem_p.h"
+#include <private/qquickitem_p.h>
#include <private/qsgtexture_p.h>
-#include "qsgcontext2dcommandbuffer_p.h"
+#include "qquickcontext2dcommandbuffer_p.h"
#include <QOpenGLPaintDevice>
#include <QOpenGLFramebufferObject>
Q_GLOBAL_STATIC(QThread, globalCanvasThreadRenderInstance)
-QSGContext2DTexture::QSGContext2DTexture()
+QQuickContext2DTexture::QQuickContext2DTexture()
: QSGDynamicTexture()
, m_context(0)
, m_canvasSize(QSize(1, 1))
{
}
-QSGContext2DTexture::~QSGContext2DTexture()
+QQuickContext2DTexture::~QQuickContext2DTexture()
{
clearTiles();
}
-QSize QSGContext2DTexture::textureSize() const
+QSize QQuickContext2DTexture::textureSize() const
{
return m_canvasWindow.size();
}
-void QSGContext2DTexture::markDirtyTexture()
+void QQuickContext2DTexture::markDirtyTexture()
{
lock();
m_dirtyTexture = true;
emit textureChanged();
}
-bool QSGContext2DTexture::setCanvasSize(const QSize &size)
+bool QQuickContext2DTexture::setCanvasSize(const QSize &size)
{
if (m_canvasSize != size) {
m_canvasSize = size;
return false;
}
-bool QSGContext2DTexture::setTileSize(const QSize &size)
+bool QQuickContext2DTexture::setTileSize(const QSize &size)
{
if (m_tileSize != size) {
m_tileSize = size;
return false;
}
-void QSGContext2DTexture::setSmooth(bool smooth)
+void QQuickContext2DTexture::setSmooth(bool smooth)
{
m_smooth = smooth;
}
-void QSGContext2DTexture::setItem(QSGCanvasItem* item)
+void QQuickContext2DTexture::setItem(QQuickCanvasItem* item)
{
if (!item) {
lock();
}
}
-bool QSGContext2DTexture::setCanvasWindow(const QRect& r)
+bool QQuickContext2DTexture::setCanvasWindow(const QRect& r)
{
if (m_canvasWindow != r) {
m_canvasWindow = r;
return false;
}
-bool QSGContext2DTexture::setDirtyRect(const QRect &r)
+bool QQuickContext2DTexture::setDirtyRect(const QRect &r)
{
bool doDirty = false;
if (m_tiledCanvas) {
- foreach (QSGContext2DTile* t, m_tiles) {
+ foreach (QQuickContext2DTile* t, m_tiles) {
bool dirty = t->rect().intersected(r).isValid();
t->markDirty(dirty);
if (dirty)
return doDirty;
}
-void QSGContext2DTexture::canvasChanged(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth)
+void QQuickContext2DTexture::canvasChanged(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth)
{
lock();
unlock();
}
-void QSGContext2DTexture::paintWithoutTiles()
+void QQuickContext2DTexture::paintWithoutTiles()
{
- QSGContext2DCommandBuffer* ccb = m_context->buffer();
+ QQuickContext2DCommandBuffer* ccb = m_context->buffer();
if (ccb->isEmpty() && m_threadRendering && !m_doGrabImage) {
lock();
endPainting();
}
-bool QSGContext2DTexture::canvasDestroyed()
+bool QQuickContext2DTexture::canvasDestroyed()
{
bool noCanvas = false;
lock();
return noCanvas;
}
-void QSGContext2DTexture::paint()
+void QQuickContext2DTexture::paint()
{
if (canvasDestroyed())
return;
if (!m_tiledCanvas) {
paintWithoutTiles();
} else {
- QSGContext2D::State oldState = m_state;
- QSGContext2DCommandBuffer* ccb = m_context->buffer();
+ QQuickContext2D::State oldState = m_state;
+ QQuickContext2DCommandBuffer* ccb = m_context->buffer();
lock();
QRect tiledRegion = createTiles(m_canvasWindow.intersected(QRect(QPoint(0, 0), m_canvasSize)));
QRect dirtyRect;
lock();
- foreach (QSGContext2DTile* tile, m_tiles) {
+ foreach (QQuickContext2DTile* tile, m_tiles) {
if (tile->dirty()) {
if (dirtyRect.isEmpty())
dirtyRect = tile->rect();
}
if (beginPainting()) {
- foreach (QSGContext2DTile* tile, m_tiles) {
+ foreach (QQuickContext2DTile* tile, m_tiles) {
bool dirtyTile = false, dirtyCanvas = false, smooth = false;
lock();
}
}
-QRect QSGContext2DTexture::tiledRect(const QRectF& window, const QSize& tileSize)
+QRect QQuickContext2DTexture::tiledRect(const QRectF& window, const QSize& tileSize)
{
if (window.isEmpty())
return QRect();
return QRect(h1 * tw, v1 * th, htiles * tw, vtiles * th);
}
-QRect QSGContext2DTexture::createTiles(const QRect& window)
+QRect QQuickContext2DTexture::createTiles(const QRect& window)
{
- QList<QSGContext2DTile*> oldTiles = m_tiles;
+ QList<QQuickContext2DTile*> oldTiles = m_tiles;
m_tiles.clear();
if (window.isEmpty()) {
int ht = xx + h1;
int vt = yy + v1;
- QSGContext2DTile* tile = 0;
+ QQuickContext2DTile* tile = 0;
QPoint pos(ht * tw, vt * th);
QRect rect(pos, m_tileSize);
return r;
}
-void QSGContext2DTexture::clearTiles()
+void QQuickContext2DTexture::clearTiles()
{
qDeleteAll(m_tiles);
m_tiles.clear();
}
-QSGContext2DFBOTexture::QSGContext2DFBOTexture()
- : QSGContext2DTexture()
+QQuickContext2DFBOTexture::QQuickContext2DFBOTexture()
+ : QQuickContext2DTexture()
, m_fbo(0)
, m_multisampledFbo(0)
, m_paint_device(0)
m_threadRendering = false;
}
-QSGContext2DFBOTexture::~QSGContext2DFBOTexture()
+QQuickContext2DFBOTexture::~QQuickContext2DFBOTexture()
{
delete m_fbo;
delete m_multisampledFbo;
delete m_paint_device;
}
-bool QSGContext2DFBOTexture::setCanvasSize(const QSize &size)
+bool QQuickContext2DFBOTexture::setCanvasSize(const QSize &size)
{
QSize s = QSize(qMax(QT_MINIMUM_FBO_SIZE, qt_next_power_of_two(size.width()))
, qMax(QT_MINIMUM_FBO_SIZE, qt_next_power_of_two(size.height())));
return false;
}
-bool QSGContext2DFBOTexture::setTileSize(const QSize &size)
+bool QQuickContext2DFBOTexture::setTileSize(const QSize &size)
{
QSize s = QSize(qMax(QT_MINIMUM_FBO_SIZE, qt_next_power_of_two(size.width()))
, qMax(QT_MINIMUM_FBO_SIZE, qt_next_power_of_two(size.height())));
return false;
}
-bool QSGContext2DFBOTexture::setCanvasWindow(const QRect& canvasWindow)
+bool QQuickContext2DFBOTexture::setCanvasWindow(const QRect& canvasWindow)
{
QSize s = QSize(qMax(QT_MINIMUM_FBO_SIZE, qt_next_power_of_two(canvasWindow.size().width()))
, qMax(QT_MINIMUM_FBO_SIZE, qt_next_power_of_two(canvasWindow.size().height())));
return doChanged;
}
-void QSGContext2DFBOTexture::bind()
+void QQuickContext2DFBOTexture::bind()
{
glBindTexture(GL_TEXTURE_2D, textureId());
updateBindOptions();
}
-QRectF QSGContext2DFBOTexture::textureSubRect() const
+QRectF QQuickContext2DFBOTexture::textureSubRect() const
{
return QRectF(0
, 0
}
-int QSGContext2DFBOTexture::textureId() const
+int QQuickContext2DFBOTexture::textureId() const
{
return m_fbo? m_fbo->texture() : 0;
}
-bool QSGContext2DFBOTexture::updateTexture()
+bool QQuickContext2DFBOTexture::updateTexture()
{
if (!m_context->buffer()->isEmpty()) {
paint();
return textureUpdated;
}
-QSGContext2DTile* QSGContext2DFBOTexture::createTile() const
+QQuickContext2DTile* QQuickContext2DFBOTexture::createTile() const
{
- return new QSGContext2DFBOTile();
+ return new QQuickContext2DFBOTile();
}
-void QSGContext2DFBOTexture::grabImage()
+void QQuickContext2DFBOTexture::grabImage()
{
if (m_fbo) {
m_grabedImage = m_fbo->toImage();
}
}
-bool QSGContext2DFBOTexture::doMultisampling() const
+bool QQuickContext2DFBOTexture::doMultisampling() const
{
static bool extensionsChecked = false;
static bool multisamplingSupported = false;
return multisamplingSupported && m_smooth;
}
-QImage QSGContext2DFBOTexture::toImage(const QRectF& region)
+QImage QQuickContext2DFBOTexture::toImage(const QRectF& region)
{
#define QML_CONTEXT2D_WAIT_MAX 5000
return grabbed;
}
-void QSGContext2DFBOTexture::compositeTile(QSGContext2DTile* tile)
+void QQuickContext2DFBOTexture::compositeTile(QQuickContext2DTile* tile)
{
- QSGContext2DFBOTile* t = static_cast<QSGContext2DFBOTile*>(tile);
+ QQuickContext2DFBOTile* t = static_cast<QQuickContext2DFBOTile*>(tile);
QRect target = t->rect().intersect(m_canvasWindow);
if (target.isValid()) {
QRect source = target;
QOpenGLFramebufferObject::blitFramebuffer(m_fbo, target, t->fbo(), source);
}
}
-QSGCanvasItem::RenderTarget QSGContext2DFBOTexture::renderTarget() const
+QQuickCanvasItem::RenderTarget QQuickContext2DFBOTexture::renderTarget() const
{
- return QSGCanvasItem::FramebufferObject;
+ return QQuickCanvasItem::FramebufferObject;
}
-QPaintDevice* QSGContext2DFBOTexture::beginPainting()
+QPaintDevice* QQuickContext2DFBOTexture::beginPainting()
{
- QSGContext2DTexture::beginPainting();
+ QQuickContext2DTexture::beginPainting();
if (m_canvasWindow.size().isEmpty() && !m_threadRendering) {
delete m_fbo;
return m_paint_device;
}
-void QSGContext2DFBOTexture::endPainting()
+void QQuickContext2DFBOTexture::endPainting()
{
- QSGContext2DTexture::endPainting();
+ QQuickContext2DTexture::endPainting();
if (m_multisampledFbo) {
QOpenGLFramebufferObject::blitFramebuffer(m_fbo, m_multisampledFbo);
m_multisampledFbo->release();
}
}
-QSGContext2DImageTexture::QSGContext2DImageTexture(bool threadRendering)
- : QSGContext2DTexture()
+QQuickContext2DImageTexture::QQuickContext2DImageTexture(bool threadRendering)
+ : QQuickContext2DTexture()
, m_texture(new QSGPlainTexture())
{
m_texture->setOwnsTexture(true);
}
}
-QSGContext2DImageTexture::~QSGContext2DImageTexture()
+QQuickContext2DImageTexture::~QQuickContext2DImageTexture()
{
delete m_texture;
}
-int QSGContext2DImageTexture::textureId() const
+int QQuickContext2DImageTexture::textureId() const
{
return m_texture->textureId();
}
-void QSGContext2DImageTexture::lock()
+void QQuickContext2DImageTexture::lock()
{
if (m_threadRendering)
m_mutex.lock();
}
-void QSGContext2DImageTexture::unlock()
+void QQuickContext2DImageTexture::unlock()
{
if (m_threadRendering)
m_mutex.unlock();
}
-void QSGContext2DImageTexture::wait()
+void QQuickContext2DImageTexture::wait()
{
if (m_threadRendering)
m_waitCondition.wait(&m_mutex);
}
-void QSGContext2DImageTexture::wake()
+void QQuickContext2DImageTexture::wake()
{
if (m_threadRendering)
m_waitCondition.wakeOne();
}
-bool QSGContext2DImageTexture::supportDirectRendering() const
+bool QQuickContext2DImageTexture::supportDirectRendering() const
{
return !m_threadRendering;
}
-QSGCanvasItem::RenderTarget QSGContext2DImageTexture::renderTarget() const
+QQuickCanvasItem::RenderTarget QQuickContext2DImageTexture::renderTarget() const
{
- return QSGCanvasItem::Image;
+ return QQuickCanvasItem::Image;
}
-void QSGContext2DImageTexture::bind()
+void QQuickContext2DImageTexture::bind()
{
m_texture->bind();
}
-bool QSGContext2DImageTexture::updateTexture()
+bool QQuickContext2DImageTexture::updateTexture()
{
lock();
bool textureUpdated = m_dirtyTexture;
return textureUpdated;
}
-QSGContext2DTile* QSGContext2DImageTexture::createTile() const
+QQuickContext2DTile* QQuickContext2DImageTexture::createTile() const
{
- return new QSGContext2DImageTile();
+ return new QQuickContext2DImageTile();
}
-void QSGContext2DImageTexture::grabImage(const QRect& r)
+void QQuickContext2DImageTexture::grabImage(const QRect& r)
{
m_doGrabImage = true;
paint();
m_grabedImage = m_image.copy(r);
}
-QImage QSGContext2DImageTexture::toImage(const QRectF& region)
+QImage QQuickContext2DImageTexture::toImage(const QRectF& region)
{
QRect r = region.isValid() ? region.toRect() : QRect(QPoint(0, 0), m_canvasWindow.size());
if (threadRendering()) {
return image;
}
-QPaintDevice* QSGContext2DImageTexture::beginPainting()
+QPaintDevice* QQuickContext2DImageTexture::beginPainting()
{
- QSGContext2DTexture::beginPainting();
+ QQuickContext2DTexture::beginPainting();
if (m_canvasWindow.size().isEmpty())
return 0;
return &m_image;
}
-void QSGContext2DImageTexture::compositeTile(QSGContext2DTile* tile)
+void QQuickContext2DImageTexture::compositeTile(QQuickContext2DTile* tile)
{
Q_ASSERT(!tile->dirty());
- QSGContext2DImageTile* t = static_cast<QSGContext2DImageTile*>(tile);
+ QQuickContext2DImageTile* t = static_cast<QQuickContext2DImageTile*>(tile);
QRect target = t->rect().intersect(m_canvasWindow);
if (target.isValid()) {
QRect source = target;
**
****************************************************************************/
-#ifndef QSGCONTEXT2DTEXTURE_P_H
-#define QSGCONTEXT2DTEXTURE_P_H
+#ifndef QQUICKCONTEXT2DTEXTURE_P_H
+#define QQUICKCONTEXT2DTEXTURE_P_H
#include <qsgtexture.h>
-#include "qsgcanvasitem_p.h"
-#include "qsgcontext2d_p.h"
+#include "qquickcanvasitem_p.h"
+#include "qquickcontext2d_p.h"
#include <QOpenGLContext>
#include <QOpenGLFramebufferObject>
QT_MODULE(Declarative)
-class QSGContext2DTile;
-class QSGContext2DCommandBuffer;
+class QQuickContext2DTile;
+class QQuickContext2DCommandBuffer;
-class QSGContext2DTexture : public QSGDynamicTexture
+class QQuickContext2DTexture : public QSGDynamicTexture
{
Q_OBJECT
public:
- QSGContext2DTexture();
- ~QSGContext2DTexture();
+ QQuickContext2DTexture();
+ ~QQuickContext2DTexture();
virtual bool hasAlphaChannel() const {return true;}
virtual bool hasMipmaps() const {return false;}
bool threadRendering() const {return m_threadRendering;}
virtual bool supportThreadRendering() const = 0;
virtual bool supportDirectRendering() const = 0;
- virtual QSGCanvasItem::RenderTarget renderTarget() const = 0;
+ virtual QQuickCanvasItem::RenderTarget renderTarget() const = 0;
virtual QImage toImage(const QRectF& region = QRectF()) = 0;
static QRect tiledRect(const QRectF& window, const QSize& tileSize);
public Q_SLOTS:
void markDirtyTexture();
- void setItem(QSGCanvasItem* item);
+ void setItem(QQuickCanvasItem* item);
void paint();
protected:
void paintWithoutTiles();
virtual QPaintDevice* beginPainting() {m_painting = true; return 0; }
virtual void endPainting() {m_painting = false;}
- virtual QSGContext2DTile* createTile() const = 0;
- virtual void compositeTile(QSGContext2DTile* tile) = 0;
+ virtual QQuickContext2DTile* createTile() const = 0;
+ virtual void compositeTile(QQuickContext2DTile* tile) = 0;
void clearTiles();
QRect createTiles(const QRect& window);
- QList<QSGContext2DTile*> m_tiles;
- QSGContext2D* m_context;
+ QList<QQuickContext2DTile*> m_tiles;
+ QQuickContext2D* m_context;
- QSGContext2D::State m_state;
+ QQuickContext2D::State m_state;
- QSGCanvasItem* m_item;
+ QQuickCanvasItem* m_item;
QSize m_canvasSize;
QSize m_tileSize;
QRect m_canvasWindow;
uint m_painting : 1;
};
-class QSGContext2DFBOTexture : public QSGContext2DTexture
+class QQuickContext2DFBOTexture : public QQuickContext2DTexture
{
Q_OBJECT
public:
- QSGContext2DFBOTexture();
- ~QSGContext2DFBOTexture();
+ QQuickContext2DFBOTexture();
+ ~QQuickContext2DFBOTexture();
virtual int textureId() const;
virtual bool updateTexture();
- virtual QSGContext2DTile* createTile() const;
+ virtual QQuickContext2DTile* createTile() const;
virtual QImage toImage(const QRectF& region = QRectF());
virtual QPaintDevice* beginPainting();
virtual void endPainting();
QRectF textureSubRect() const;
virtual bool supportThreadRendering() const {return false;}
virtual bool supportDirectRendering() const {return false;}
- virtual QSGCanvasItem::RenderTarget renderTarget() const;
- virtual void compositeTile(QSGContext2DTile* tile);
+ virtual QQuickCanvasItem::RenderTarget renderTarget() const;
+ virtual void compositeTile(QQuickContext2DTile* tile);
virtual void bind();
virtual bool setCanvasSize(const QSize &size);
virtual bool setTileSize(const QSize &size);
};
class QSGPlainTexture;
-class QSGContext2DImageTexture : public QSGContext2DTexture
+class QQuickContext2DImageTexture : public QQuickContext2DTexture
{
Q_OBJECT
public:
- QSGContext2DImageTexture(bool threadRendering = true);
- ~QSGContext2DImageTexture();
+ QQuickContext2DImageTexture(bool threadRendering = true);
+ ~QQuickContext2DImageTexture();
virtual int textureId() const;
virtual void bind();
virtual bool supportThreadRendering() const {return true;}
virtual bool supportDirectRendering() const;
- virtual QSGCanvasItem::RenderTarget renderTarget() const;
+ virtual QQuickCanvasItem::RenderTarget renderTarget() const;
virtual void lock();
virtual void unlock();
virtual void wait();
virtual void wake();
virtual bool updateTexture();
- virtual QSGContext2DTile* createTile() const;
+ virtual QQuickContext2DTile* createTile() const;
virtual QImage toImage(const QRectF& region = QRectF());
virtual QPaintDevice* beginPainting();
- virtual void compositeTile(QSGContext2DTile* tile);
+ virtual void compositeTile(QQuickContext2DTile* tile);
private Q_SLOTS:
void grabImage(const QRect& r);
QT_END_NAMESPACE
-#endif // QSGCONTEXT2DTEXTURE_P_H
+#endif // QQUICKCONTEXT2DTEXTURE_P_H
**
****************************************************************************/
-#include "qsgcontext2dtile_p.h"
+#include "qquickcontext2dtile_p.h"
#include <QOpenGLFramebufferObject>
#include <QOpenGLFramebufferObjectFormat>
#include <QOpenGLPaintDevice>
-QSGContext2DTile::QSGContext2DTile()
+QQuickContext2DTile::QQuickContext2DTile()
: m_dirty(true)
, m_rect(QRect(0, 0, 1, 1))
, m_device(0)
{
}
-QSGContext2DTile::~QSGContext2DTile()
+QQuickContext2DTile::~QQuickContext2DTile()
{
if (m_painter.isActive())
m_painter.end();
}
-QPainter* QSGContext2DTile::createPainter(bool smooth)
+QPainter* QQuickContext2DTile::createPainter(bool smooth)
{
if (m_painter.isActive())
m_painter.end();
m_painter.resetTransform();
m_painter.setCompositionMode(QPainter::CompositionMode_Source);
-#ifdef QSGCONTEXT2D_DEBUG
+#ifdef QQUICKCONTEXT2D_DEBUG
int v = 100;
int gray = (m_rect.x() / m_rect.width() + m_rect.y() / m_rect.height()) % 2;
if (gray)
return 0;
}
-QSGContext2DFBOTile::QSGContext2DFBOTile()
- : QSGContext2DTile()
+QQuickContext2DFBOTile::QQuickContext2DFBOTile()
+ : QQuickContext2DTile()
, m_fbo(0)
{
}
-QSGContext2DFBOTile::~QSGContext2DFBOTile()
+QQuickContext2DFBOTile::~QQuickContext2DFBOTile()
{
delete m_fbo;
}
-void QSGContext2DFBOTile::aboutToDraw()
+void QQuickContext2DFBOTile::aboutToDraw()
{
m_fbo->bind();
if (!m_device) {
}
}
-void QSGContext2DFBOTile::drawFinished()
+void QQuickContext2DFBOTile::drawFinished()
{
m_fbo->release();
}
-void QSGContext2DFBOTile::setRect(const QRect& r)
+void QQuickContext2DFBOTile::setRect(const QRect& r)
{
if (m_rect == r)
return;
}
-QSGContext2DImageTile::QSGContext2DImageTile()
- : QSGContext2DTile()
+QQuickContext2DImageTile::QQuickContext2DImageTile()
+ : QQuickContext2DTile()
{
}
-QSGContext2DImageTile::~QSGContext2DImageTile()
+QQuickContext2DImageTile::~QQuickContext2DImageTile()
{
}
-void QSGContext2DImageTile::setRect(const QRect& r)
+void QQuickContext2DImageTile::setRect(const QRect& r)
{
if (m_rect == r)
return;
m_image = QImage(r.size(), QImage::Format_ARGB32_Premultiplied);
}
m_device = &m_image;
-}
\ No newline at end of file
+}
**
****************************************************************************/
-#ifndef QSGCONTEXT2DTILE_P_H
-#define QSGCONTEXT2DTILE_P_H
+#ifndef QQUICKCONTEXT2DTILE_P_H
+#define QQUICKCONTEXT2DTILE_P_H
-#include "qsgcontext2d_p.h"
+#include "qquickcontext2d_p.h"
#include <QOpenGLFramebufferObject>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGContext2DTexture;
-class QSGContext2DCommandBuffer;
+class QQuickContext2DTexture;
+class QQuickContext2DCommandBuffer;
-class QSGContext2DTile
+class QQuickContext2DTile
{
public:
- QSGContext2DTile();
- ~QSGContext2DTile();
+ QQuickContext2DTile();
+ ~QQuickContext2DTile();
bool dirty() const {return m_dirty;}
void markDirty(bool dirty) {m_dirty = dirty;}
};
-class QSGContext2DFBOTile : public QSGContext2DTile
+class QQuickContext2DFBOTile : public QQuickContext2DTile
{
public:
- QSGContext2DFBOTile();
- ~QSGContext2DFBOTile();
+ QQuickContext2DFBOTile();
+ ~QQuickContext2DFBOTile();
virtual void setRect(const QRect& r);
QOpenGLFramebufferObject* fbo() const {return m_fbo;}
void drawFinished();
QOpenGLFramebufferObject *m_fbo;
};
-class QSGContext2DImageTile : public QSGContext2DTile
+class QQuickContext2DImageTile : public QQuickContext2DTile
{
public:
- QSGContext2DImageTile();
- ~QSGContext2DImageTile();
+ QQuickContext2DImageTile();
+ ~QQuickContext2DImageTile();
void setRect(const QRect& r);
const QImage& image() const {return m_image;}
private:
QT_END_NAMESPACE
-#endif // QSGCONTEXT2DTILE_P_H
+#endif // QQUICKCONTEXT2DTILE_P_H
HEADERS += \
- $$PWD/qsgevents_p_p.h \
- $$PWD/qsgitemchangelistener_p.h \
- $$PWD/qsganchors_p.h \
- $$PWD/qsganchors_p_p.h \
- $$PWD/qsgitem.h \
- $$PWD/qsgitem_p.h \
- $$PWD/qsgrectangle_p.h \
- $$PWD/qsgrectangle_p_p.h \
- $$PWD/qsgcanvas.h \
- $$PWD/qsgcanvas_p.h \
- $$PWD/qsgfocusscope_p.h \
- $$PWD/qsgitemsmodule_p.h \
- $$PWD/qsgpainteditem.h \
- $$PWD/qsgpainteditem_p.h \
- $$PWD/qsgtext_p.h \
- $$PWD/qsgtext_p_p.h \
- $$PWD/qsgtextnode_p.h \
- $$PWD/qsgtextinput_p.h \
- $$PWD/qsgtextinput_p_p.h \
- $$PWD/qsgtextedit_p.h \
- $$PWD/qsgtextedit_p_p.h \
- $$PWD/qsgimagebase_p.h \
- $$PWD/qsgimagebase_p_p.h \
- $$PWD/qsgimage_p.h \
- $$PWD/qsgimage_p_p.h \
- $$PWD/qsgborderimage_p.h \
- $$PWD/qsgborderimage_p_p.h \
- $$PWD/qsgninepatchnode_p.h \
- $$PWD/qsgscalegrid_p_p.h \
- $$PWD/qsgmousearea_p.h \
- $$PWD/qsgmousearea_p_p.h \
- $$PWD/qsgpincharea_p.h \
- $$PWD/qsgpincharea_p_p.h \
- $$PWD/qsgflickable_p.h \
- $$PWD/qsgflickable_p_p.h \
- $$PWD/qsglistview_p.h \
- $$PWD/qsgvisualadaptormodel_p.h \
- $$PWD/qsgvisualdatamodel_p.h \
- $$PWD/qsgvisualitemmodel_p.h \
- $$PWD/qsgrepeater_p.h \
- $$PWD/qsgrepeater_p_p.h \
- $$PWD/qsggridview_p.h \
- $$PWD/qsgpathview_p.h \
- $$PWD/qsgpathview_p_p.h \
- $$PWD/qsgpositioners_p.h \
- $$PWD/qsgpositioners_p_p.h \
- $$PWD/qsgloader_p.h \
- $$PWD/qsgloader_p_p.h \
- $$PWD/qsganimatedimage_p.h \
- $$PWD/qsganimatedimage_p_p.h \
- $$PWD/qsgflipable_p.h \
- $$PWD/qsgtranslate_p.h \
- $$PWD/qsgclipnode_p.h \
- $$PWD/qsgview.h \
- $$PWD/qsgview_p.h \
- $$PWD/qsganimation_p.h \
- $$PWD/qsganimation_p_p.h \
- $$PWD/qsgstateoperations_p.h \
- $$PWD/qsgimplicitsizeitem_p.h \
- $$PWD/qsgimplicitsizeitem_p_p.h \
- $$PWD/qsgspriteengine_p.h \
- $$PWD/qsgsprite_p.h \
- $$PWD/qsgspriteimage_p.h \
- $$PWD/qsgdrag_p.h \
- $$PWD/qsgdroparea_p.h \
- $$PWD/qsgitemview_p.h \
- $$PWD/qsgitemview_p_p.h
+ $$PWD/qquickevents_p_p.h \
+ $$PWD/qquickitemchangelistener_p.h \
+ $$PWD/qquickanchors_p.h \
+ $$PWD/qquickanchors_p_p.h \
+ $$PWD/qquickitem.h \
+ $$PWD/qquickitem_p.h \
+ $$PWD/qquickrectangle_p.h \
+ $$PWD/qquickrectangle_p_p.h \
+ $$PWD/qquickcanvas.h \
+ $$PWD/qquickcanvas_p.h \
+ $$PWD/qquickfocusscope_p.h \
+ $$PWD/qquickitemsmodule_p.h \
+ $$PWD/qquickpainteditem.h \
+ $$PWD/qquickpainteditem_p.h \
+ $$PWD/qquicktext_p.h \
+ $$PWD/qquicktext_p_p.h \
+ $$PWD/qquicktextnode_p.h \
+ $$PWD/qquicktextinput_p.h \
+ $$PWD/qquicktextinput_p_p.h \
+ $$PWD/qquicktextedit_p.h \
+ $$PWD/qquicktextedit_p_p.h \
+ $$PWD/qquickimagebase_p.h \
+ $$PWD/qquickimagebase_p_p.h \
+ $$PWD/qquickimage_p.h \
+ $$PWD/qquickimage_p_p.h \
+ $$PWD/qquickborderimage_p.h \
+ $$PWD/qquickborderimage_p_p.h \
+ $$PWD/qquickninepatchnode_p.h \
+ $$PWD/qquickscalegrid_p_p.h \
+ $$PWD/qquickmousearea_p.h \
+ $$PWD/qquickmousearea_p_p.h \
+ $$PWD/qquickpincharea_p.h \
+ $$PWD/qquickpincharea_p_p.h \
+ $$PWD/qquickflickable_p.h \
+ $$PWD/qquickflickable_p_p.h \
+ $$PWD/qquicklistview_p.h \
+ $$PWD/qquickvisualadaptormodel_p.h \
+ $$PWD/qquickvisualdatamodel_p.h \
+ $$PWD/qquickvisualitemmodel_p.h \
+ $$PWD/qquickrepeater_p.h \
+ $$PWD/qquickrepeater_p_p.h \
+ $$PWD/qquickgridview_p.h \
+ $$PWD/qquickpathview_p.h \
+ $$PWD/qquickpathview_p_p.h \
+ $$PWD/qquickpositioners_p.h \
+ $$PWD/qquickpositioners_p_p.h \
+ $$PWD/qquickloader_p.h \
+ $$PWD/qquickloader_p_p.h \
+ $$PWD/qquickanimatedimage_p.h \
+ $$PWD/qquickanimatedimage_p_p.h \
+ $$PWD/qquickflipable_p.h \
+ $$PWD/qquicktranslate_p.h \
+ $$PWD/qquickclipnode_p.h \
+ $$PWD/qquickview.h \
+ $$PWD/qquickview_p.h \
+ $$PWD/qquickanimation_p.h \
+ $$PWD/qquickanimation_p_p.h \
+ $$PWD/qquickstateoperations_p.h \
+ $$PWD/qquickimplicitsizeitem_p.h \
+ $$PWD/qquickimplicitsizeitem_p_p.h \
+ $$PWD/qquickspriteengine_p.h \
+ $$PWD/qquicksprite_p.h \
+ $$PWD/qquickspriteimage_p.h \
+ $$PWD/qquickdrag_p.h \
+ $$PWD/qquickdroparea_p.h \
+ $$PWD/qquickitemview_p.h \
+ $$PWD/qquickitemview_p_p.h
SOURCES += \
- $$PWD/qsgevents.cpp \
- $$PWD/qsganchors.cpp \
- $$PWD/qsgitem.cpp \
- $$PWD/qsgrectangle.cpp \
- $$PWD/qsgcanvas.cpp \
- $$PWD/qsgfocusscope.cpp \
- $$PWD/qsgitemsmodule.cpp \
- $$PWD/qsgpainteditem.cpp \
- $$PWD/qsgtext.cpp \
- $$PWD/qsgtextnode.cpp \
- $$PWD/qsgtextinput.cpp \
- $$PWD/qsgtextedit.cpp \
- $$PWD/qsgimagebase.cpp \
- $$PWD/qsgimage.cpp \
- $$PWD/qsgborderimage.cpp \
- $$PWD/qsgninepatchnode.cpp \
- $$PWD/qsgscalegrid.cpp \
- $$PWD/qsgmousearea.cpp \
- $$PWD/qsgpincharea.cpp \
- $$PWD/qsgflickable.cpp \
- $$PWD/qsglistview.cpp \
- $$PWD/qsgvisualadaptormodel.cpp \
- $$PWD/qsgvisualdatamodel.cpp \
- $$PWD/qsgvisualitemmodel.cpp \
- $$PWD/qsgrepeater.cpp \
- $$PWD/qsggridview.cpp \
- $$PWD/qsgpathview.cpp \
- $$PWD/qsgpositioners.cpp \
- $$PWD/qsgloader.cpp \
- $$PWD/qsganimatedimage.cpp \
- $$PWD/qsgflipable.cpp \
- $$PWD/qsgtranslate.cpp \
- $$PWD/qsgclipnode.cpp \
- $$PWD/qsgview.cpp \
- $$PWD/qsganimation.cpp \
- $$PWD/qsgstateoperations.cpp \
- $$PWD/qsgimplicitsizeitem.cpp \
- $$PWD/qsgspriteengine.cpp \
- $$PWD/qsgsprite.cpp \
- $$PWD/qsgspriteimage.cpp \
- $$PWD/qsgdrag.cpp \
- $$PWD/qsgdroparea.cpp \
- $$PWD/qsgitemview.cpp
+ $$PWD/qquickevents.cpp \
+ $$PWD/qquickanchors.cpp \
+ $$PWD/qquickitem.cpp \
+ $$PWD/qquickrectangle.cpp \
+ $$PWD/qquickcanvas.cpp \
+ $$PWD/qquickfocusscope.cpp \
+ $$PWD/qquickitemsmodule.cpp \
+ $$PWD/qquickpainteditem.cpp \
+ $$PWD/qquicktext.cpp \
+ $$PWD/qquicktextnode.cpp \
+ $$PWD/qquicktextinput.cpp \
+ $$PWD/qquicktextedit.cpp \
+ $$PWD/qquickimagebase.cpp \
+ $$PWD/qquickimage.cpp \
+ $$PWD/qquickborderimage.cpp \
+ $$PWD/qquickninepatchnode.cpp \
+ $$PWD/qquickscalegrid.cpp \
+ $$PWD/qquickmousearea.cpp \
+ $$PWD/qquickpincharea.cpp \
+ $$PWD/qquickflickable.cpp \
+ $$PWD/qquicklistview.cpp \
+ $$PWD/qquickvisualadaptormodel.cpp \
+ $$PWD/qquickvisualdatamodel.cpp \
+ $$PWD/qquickvisualitemmodel.cpp \
+ $$PWD/qquickrepeater.cpp \
+ $$PWD/qquickgridview.cpp \
+ $$PWD/qquickpathview.cpp \
+ $$PWD/qquickpositioners.cpp \
+ $$PWD/qquickloader.cpp \
+ $$PWD/qquickanimatedimage.cpp \
+ $$PWD/qquickflipable.cpp \
+ $$PWD/qquicktranslate.cpp \
+ $$PWD/qquickclipnode.cpp \
+ $$PWD/qquickview.cpp \
+ $$PWD/qquickanimation.cpp \
+ $$PWD/qquickstateoperations.cpp \
+ $$PWD/qquickimplicitsizeitem.cpp \
+ $$PWD/qquickspriteengine.cpp \
+ $$PWD/qquicksprite.cpp \
+ $$PWD/qquickspriteimage.cpp \
+ $$PWD/qquickdrag.cpp \
+ $$PWD/qquickdroparea.cpp \
+ $$PWD/qquickitemview.cpp
SOURCES += \
- $$PWD/qsgshadereffect.cpp \
- $$PWD/qsgshadereffectmesh.cpp \
- $$PWD/qsgshadereffectnode.cpp \
- $$PWD/qsgshadereffectsource.cpp \
+ $$PWD/qquickshadereffect.cpp \
+ $$PWD/qquickshadereffectmesh.cpp \
+ $$PWD/qquickshadereffectnode.cpp \
+ $$PWD/qquickshadereffectsource.cpp \
HEADERS += \
- $$PWD/qsgshadereffect_p.h \
- $$PWD/qsgshadereffectmesh_p.h \
- $$PWD/qsgshadereffectnode_p.h \
- $$PWD/qsgshadereffectsource_p.h \
+ $$PWD/qquickshadereffect_p.h \
+ $$PWD/qquickshadereffectmesh_p.h \
+ $$PWD/qquickshadereffectnode_p.h \
+ $$PWD/qquickshadereffectsource_p.h \
include(context2d/context2d.pri)
**
****************************************************************************/
-#include "qsganchors_p_p.h"
+#include "qquickanchors_p_p.h"
-#include "qsgitem.h"
-#include "qsgitem_p.h"
+#include "qquickitem.h"
+#include "qquickitem_p.h"
#include <qdeclarativeinfo.h>
//TODO: should we cache relationships, so we don't have to check each time (parent-child or sibling)?
//TODO: support non-parent, non-sibling (need to find lowest common ancestor)
-static qreal hcenter(QSGItem *item)
+static qreal hcenter(QQuickItem *item)
{
qreal width = item->width();
int iw = width;
return width / 2;
}
-static qreal vcenter(QSGItem *item)
+static qreal vcenter(QQuickItem *item)
{
qreal height = item->height();
int ih = height;
//### const item?
//local position
-static qreal position(QSGItem *item, QSGAnchorLine::AnchorLine anchorLine)
+static qreal position(QQuickItem *item, QQuickAnchorLine::AnchorLine anchorLine)
{
qreal ret = 0.0;
switch (anchorLine) {
- case QSGAnchorLine::Left:
+ case QQuickAnchorLine::Left:
ret = item->x();
break;
- case QSGAnchorLine::Right:
+ case QQuickAnchorLine::Right:
ret = item->x() + item->width();
break;
- case QSGAnchorLine::Top:
+ case QQuickAnchorLine::Top:
ret = item->y();
break;
- case QSGAnchorLine::Bottom:
+ case QQuickAnchorLine::Bottom:
ret = item->y() + item->height();
break;
- case QSGAnchorLine::HCenter:
+ case QQuickAnchorLine::HCenter:
ret = item->x() + hcenter(item);
break;
- case QSGAnchorLine::VCenter:
+ case QQuickAnchorLine::VCenter:
ret = item->y() + vcenter(item);
break;
- case QSGAnchorLine::Baseline:
+ case QQuickAnchorLine::Baseline:
ret = item->y() + item->baselineOffset();
break;
default:
}
//position when origin is 0,0
-static qreal adjustedPosition(QSGItem *item, QSGAnchorLine::AnchorLine anchorLine)
+static qreal adjustedPosition(QQuickItem *item, QQuickAnchorLine::AnchorLine anchorLine)
{
qreal ret = 0.0;
switch (anchorLine) {
- case QSGAnchorLine::Left:
+ case QQuickAnchorLine::Left:
ret = 0.0;
break;
- case QSGAnchorLine::Right:
+ case QQuickAnchorLine::Right:
ret = item->width();
break;
- case QSGAnchorLine::Top:
+ case QQuickAnchorLine::Top:
ret = 0.0;
break;
- case QSGAnchorLine::Bottom:
+ case QQuickAnchorLine::Bottom:
ret = item->height();
break;
- case QSGAnchorLine::HCenter:
+ case QQuickAnchorLine::HCenter:
ret = hcenter(item);
break;
- case QSGAnchorLine::VCenter:
+ case QQuickAnchorLine::VCenter:
ret = vcenter(item);
break;
- case QSGAnchorLine::Baseline:
+ case QQuickAnchorLine::Baseline:
ret = item->baselineOffset();
break;
default:
return ret;
}
-QSGAnchors::QSGAnchors(QSGItem *item, QObject *parent)
-: QObject(*new QSGAnchorsPrivate(item), parent)
+QQuickAnchors::QQuickAnchors(QQuickItem *item, QObject *parent)
+: QObject(*new QQuickAnchorsPrivate(item), parent)
{
}
-QSGAnchors::~QSGAnchors()
+QQuickAnchors::~QQuickAnchors()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->remDepend(d->fill);
d->remDepend(d->centerIn);
d->remDepend(d->left.item);
d->remDepend(d->baseline.item);
}
-void QSGAnchorsPrivate::fillChanged()
+void QQuickAnchorsPrivate::fillChanged()
{
- Q_Q(QSGAnchors);
+ Q_Q(QQuickAnchors);
if (!fill || !isItemComplete())
return;
--updatingFill;
} else {
// ### Make this certain :)
- qmlInfo(item) << QSGAnchors::tr("Possible anchor loop detected on fill.");
+ qmlInfo(item) << QQuickAnchors::tr("Possible anchor loop detected on fill.");
}
}
-void QSGAnchorsPrivate::centerInChanged()
+void QQuickAnchorsPrivate::centerInChanged()
{
- Q_Q(QSGAnchors);
+ Q_Q(QQuickAnchors);
if (!centerIn || fill || !isItemComplete())
return;
--updatingCenterIn;
} else {
// ### Make this certain :)
- qmlInfo(item) << QSGAnchors::tr("Possible anchor loop detected on centerIn.");
+ qmlInfo(item) << QQuickAnchors::tr("Possible anchor loop detected on centerIn.");
}
}
-void QSGAnchorsPrivate::clearItem(QSGItem *item)
+void QQuickAnchorsPrivate::clearItem(QQuickItem *item)
{
if (!item)
return;
centerIn = 0;
if (left.item == item) {
left.item = 0;
- usedAnchors &= ~QSGAnchors::LeftAnchor;
+ usedAnchors &= ~QQuickAnchors::LeftAnchor;
}
if (right.item == item) {
right.item = 0;
- usedAnchors &= ~QSGAnchors::RightAnchor;
+ usedAnchors &= ~QQuickAnchors::RightAnchor;
}
if (top.item == item) {
top.item = 0;
- usedAnchors &= ~QSGAnchors::TopAnchor;
+ usedAnchors &= ~QQuickAnchors::TopAnchor;
}
if (bottom.item == item) {
bottom.item = 0;
- usedAnchors &= ~QSGAnchors::BottomAnchor;
+ usedAnchors &= ~QQuickAnchors::BottomAnchor;
}
if (vCenter.item == item) {
vCenter.item = 0;
- usedAnchors &= ~QSGAnchors::VCenterAnchor;
+ usedAnchors &= ~QQuickAnchors::VCenterAnchor;
}
if (hCenter.item == item) {
hCenter.item = 0;
- usedAnchors &= ~QSGAnchors::HCenterAnchor;
+ usedAnchors &= ~QQuickAnchors::HCenterAnchor;
}
if (baseline.item == item) {
baseline.item = 0;
- usedAnchors &= ~QSGAnchors::BaselineAnchor;
+ usedAnchors &= ~QQuickAnchors::BaselineAnchor;
}
}
-void QSGAnchorsPrivate::addDepend(QSGItem *item)
+void QQuickAnchorsPrivate::addDepend(QQuickItem *item)
{
if (!item)
return;
- QSGItemPrivate *p = QSGItemPrivate::get(item);
- p->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(item);
+ p->addItemChangeListener(this, QQuickItemPrivate::Geometry);
}
-void QSGAnchorsPrivate::remDepend(QSGItem *item)
+void QQuickAnchorsPrivate::remDepend(QQuickItem *item)
{
if (!item)
return;
- QSGItemPrivate *p = QSGItemPrivate::get(item);
- p->removeItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(item);
+ p->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
}
-bool QSGAnchors::mirrored()
+bool QQuickAnchors::mirrored()
{
- Q_D(QSGAnchors);
- return QSGItemPrivate::get(d->item)->effectiveLayoutMirror;
+ Q_D(QQuickAnchors);
+ return QQuickItemPrivate::get(d->item)->effectiveLayoutMirror;
}
-bool QSGAnchorsPrivate::isItemComplete() const
+bool QQuickAnchorsPrivate::isItemComplete() const
{
return componentComplete;
}
-void QSGAnchors::classBegin()
+void QQuickAnchors::classBegin()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->componentComplete = false;
}
-void QSGAnchors::componentComplete()
+void QQuickAnchors::componentComplete()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->componentComplete = true;
}
-void QSGAnchorsPrivate::setItemHeight(qreal v)
+void QQuickAnchorsPrivate::setItemHeight(qreal v)
{
updatingMe = true;
item->setHeight(v);
updatingMe = false;
}
-void QSGAnchorsPrivate::setItemWidth(qreal v)
+void QQuickAnchorsPrivate::setItemWidth(qreal v)
{
updatingMe = true;
item->setWidth(v);
updatingMe = false;
}
-void QSGAnchorsPrivate::setItemX(qreal v)
+void QQuickAnchorsPrivate::setItemX(qreal v)
{
updatingMe = true;
item->setX(v);
updatingMe = false;
}
-void QSGAnchorsPrivate::setItemY(qreal v)
+void QQuickAnchorsPrivate::setItemY(qreal v)
{
updatingMe = true;
item->setY(v);
updatingMe = false;
}
-void QSGAnchorsPrivate::setItemPos(const QPointF &v)
+void QQuickAnchorsPrivate::setItemPos(const QPointF &v)
{
updatingMe = true;
item->setPos(v);
updatingMe = false;
}
-void QSGAnchorsPrivate::setItemSize(const QSizeF &v)
+void QQuickAnchorsPrivate::setItemSize(const QSizeF &v)
{
updatingMe = true;
item->setSize(v);
updatingMe = false;
}
-void QSGAnchorsPrivate::updateMe()
+void QQuickAnchorsPrivate::updateMe()
{
if (updatingMe) {
updatingMe = false;
updateVerticalAnchors();
}
-void QSGAnchorsPrivate::updateOnComplete()
+void QQuickAnchorsPrivate::updateOnComplete()
{
fillChanged();
centerInChanged();
updateVerticalAnchors();
}
-void QSGAnchorsPrivate::itemGeometryChanged(QSGItem *, const QRectF &newG, const QRectF &oldG)
+void QQuickAnchorsPrivate::itemGeometryChanged(QQuickItem *, const QRectF &newG, const QRectF &oldG)
{
fillChanged();
centerInChanged();
updateVerticalAnchors();
}
-QSGItem *QSGAnchors::fill() const
+QQuickItem *QQuickAnchors::fill() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->fill;
}
-void QSGAnchors::setFill(QSGItem *f)
+void QQuickAnchors::setFill(QQuickItem *f)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->fill == f)
return;
d->fillChanged();
}
-void QSGAnchors::resetFill()
+void QQuickAnchors::resetFill()
{
setFill(0);
}
-QSGItem *QSGAnchors::centerIn() const
+QQuickItem *QQuickAnchors::centerIn() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->centerIn;
}
-void QSGAnchors::setCenterIn(QSGItem* c)
+void QQuickAnchors::setCenterIn(QQuickItem* c)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->centerIn == c)
return;
d->centerInChanged();
}
-void QSGAnchors::resetCenterIn()
+void QQuickAnchors::resetCenterIn()
{
setCenterIn(0);
}
-bool QSGAnchorsPrivate::calcStretch(const QSGAnchorLine &edge1,
- const QSGAnchorLine &edge2,
+bool QQuickAnchorsPrivate::calcStretch(const QQuickAnchorLine &edge1,
+ const QQuickAnchorLine &edge2,
qreal offset1,
qreal offset2,
- QSGAnchorLine::AnchorLine line,
+ QQuickAnchorLine::AnchorLine line,
qreal &stretch)
{
bool edge1IsParent = (edge1.item == item->parentItem());
return invalid;
}
-void QSGAnchorsPrivate::updateVerticalAnchors()
+void QQuickAnchorsPrivate::updateVerticalAnchors()
{
if (fill || centerIn || !isItemComplete())
return;
if (updatingVerticalAnchor < 2) {
++updatingVerticalAnchor;
- if (usedAnchors & QSGAnchors::TopAnchor) {
+ if (usedAnchors & QQuickAnchors::TopAnchor) {
//Handle stretching
bool invalid = true;
qreal height = 0.0;
- if (usedAnchors & QSGAnchors::BottomAnchor) {
- invalid = calcStretch(top, bottom, topMargin, -bottomMargin, QSGAnchorLine::Top, height);
- } else if (usedAnchors & QSGAnchors::VCenterAnchor) {
- invalid = calcStretch(top, vCenter, topMargin, vCenterOffset, QSGAnchorLine::Top, height);
+ if (usedAnchors & QQuickAnchors::BottomAnchor) {
+ invalid = calcStretch(top, bottom, topMargin, -bottomMargin, QQuickAnchorLine::Top, height);
+ } else if (usedAnchors & QQuickAnchors::VCenterAnchor) {
+ invalid = calcStretch(top, vCenter, topMargin, vCenterOffset, QQuickAnchorLine::Top, height);
height *= 2;
}
if (!invalid)
} else if (top.item->parentItem() == item->parentItem()) {
setItemY(position(top.item, top.anchorLine) + topMargin);
}
- } else if (usedAnchors & QSGAnchors::BottomAnchor) {
+ } else if (usedAnchors & QQuickAnchors::BottomAnchor) {
//Handle stretching (top + bottom case is handled above)
- if (usedAnchors & QSGAnchors::VCenterAnchor) {
+ if (usedAnchors & QQuickAnchors::VCenterAnchor) {
qreal height = 0.0;
bool invalid = calcStretch(vCenter, bottom, vCenterOffset, -bottomMargin,
- QSGAnchorLine::Top, height);
+ QQuickAnchorLine::Top, height);
if (!invalid)
setItemHeight(height*2);
}
} else if (bottom.item->parentItem() == item->parentItem()) {
setItemY(position(bottom.item, bottom.anchorLine) - item->height() - bottomMargin);
}
- } else if (usedAnchors & QSGAnchors::VCenterAnchor) {
+ } else if (usedAnchors & QQuickAnchors::VCenterAnchor) {
//(stetching handled above)
//Handle vCenter
} else if (vCenter.item->parentItem() == item->parentItem()) {
setItemY(position(vCenter.item, vCenter.anchorLine) - vcenter(item) + vCenterOffset);
}
- } else if (usedAnchors & QSGAnchors::BaselineAnchor) {
+ } else if (usedAnchors & QQuickAnchors::BaselineAnchor) {
//Handle baseline
if (baseline.item == item->parentItem()) {
setItemY(adjustedPosition(baseline.item, baseline.anchorLine) - item->baselineOffset() + baselineOffset);
--updatingVerticalAnchor;
} else {
// ### Make this certain :)
- qmlInfo(item) << QSGAnchors::tr("Possible anchor loop detected on vertical anchor.");
+ qmlInfo(item) << QQuickAnchors::tr("Possible anchor loop detected on vertical anchor.");
}
}
-inline QSGAnchorLine::AnchorLine reverseAnchorLine(QSGAnchorLine::AnchorLine anchorLine)
+inline QQuickAnchorLine::AnchorLine reverseAnchorLine(QQuickAnchorLine::AnchorLine anchorLine)
{
- if (anchorLine == QSGAnchorLine::Left) {
- return QSGAnchorLine::Right;
- } else if (anchorLine == QSGAnchorLine::Right) {
- return QSGAnchorLine::Left;
+ if (anchorLine == QQuickAnchorLine::Left) {
+ return QQuickAnchorLine::Right;
+ } else if (anchorLine == QQuickAnchorLine::Right) {
+ return QQuickAnchorLine::Left;
} else {
return anchorLine;
}
}
-void QSGAnchorsPrivate::updateHorizontalAnchors()
+void QQuickAnchorsPrivate::updateHorizontalAnchors()
{
- Q_Q(QSGAnchors);
+ Q_Q(QQuickAnchors);
if (fill || centerIn || !isItemComplete())
return;
if (updatingHorizontalAnchor < 3) {
++updatingHorizontalAnchor;
qreal effectiveRightMargin, effectiveLeftMargin, effectiveHorizontalCenterOffset;
- QSGAnchorLine effectiveLeft, effectiveRight, effectiveHorizontalCenter;
- QSGAnchors::Anchor effectiveLeftAnchor, effectiveRightAnchor;
+ QQuickAnchorLine effectiveLeft, effectiveRight, effectiveHorizontalCenter;
+ QQuickAnchors::Anchor effectiveLeftAnchor, effectiveRightAnchor;
if (q->mirrored()) {
- effectiveLeftAnchor = QSGAnchors::RightAnchor;
- effectiveRightAnchor = QSGAnchors::LeftAnchor;
+ effectiveLeftAnchor = QQuickAnchors::RightAnchor;
+ effectiveRightAnchor = QQuickAnchors::LeftAnchor;
effectiveLeft.item = right.item;
effectiveLeft.anchorLine = reverseAnchorLine(right.anchorLine);
effectiveRight.item = left.item;
effectiveRightMargin = leftMargin;
effectiveHorizontalCenterOffset = -hCenterOffset;
} else {
- effectiveLeftAnchor = QSGAnchors::LeftAnchor;
- effectiveRightAnchor = QSGAnchors::RightAnchor;
+ effectiveLeftAnchor = QQuickAnchors::LeftAnchor;
+ effectiveRightAnchor = QQuickAnchors::RightAnchor;
effectiveLeft = left;
effectiveRight = right;
effectiveHorizontalCenter = hCenter;
bool invalid = true;
qreal width = 0.0;
if (usedAnchors & effectiveRightAnchor) {
- invalid = calcStretch(effectiveLeft, effectiveRight, effectiveLeftMargin, -effectiveRightMargin, QSGAnchorLine::Left, width);
- } else if (usedAnchors & QSGAnchors::HCenterAnchor) {
- invalid = calcStretch(effectiveLeft, effectiveHorizontalCenter, effectiveLeftMargin, effectiveHorizontalCenterOffset, QSGAnchorLine::Left, width);
+ invalid = calcStretch(effectiveLeft, effectiveRight, effectiveLeftMargin, -effectiveRightMargin, QQuickAnchorLine::Left, width);
+ } else if (usedAnchors & QQuickAnchors::HCenterAnchor) {
+ invalid = calcStretch(effectiveLeft, effectiveHorizontalCenter, effectiveLeftMargin, effectiveHorizontalCenterOffset, QQuickAnchorLine::Left, width);
width *= 2;
}
if (!invalid)
}
} else if (usedAnchors & effectiveRightAnchor) {
//Handle stretching (left + right case is handled in updateLeftAnchor)
- if (usedAnchors & QSGAnchors::HCenterAnchor) {
+ if (usedAnchors & QQuickAnchors::HCenterAnchor) {
qreal width = 0.0;
bool invalid = calcStretch(effectiveHorizontalCenter, effectiveRight, effectiveHorizontalCenterOffset, -effectiveRightMargin,
- QSGAnchorLine::Left, width);
+ QQuickAnchorLine::Left, width);
if (!invalid)
setItemWidth(width*2);
}
} else if (effectiveRight.item->parentItem() == item->parentItem()) {
setItemX(position(effectiveRight.item, effectiveRight.anchorLine) - item->width() - effectiveRightMargin);
}
- } else if (usedAnchors & QSGAnchors::HCenterAnchor) {
+ } else if (usedAnchors & QQuickAnchors::HCenterAnchor) {
//Handle hCenter
if (effectiveHorizontalCenter.item == item->parentItem()) {
setItemX(adjustedPosition(effectiveHorizontalCenter.item, effectiveHorizontalCenter.anchorLine) - hcenter(item) + effectiveHorizontalCenterOffset);
--updatingHorizontalAnchor;
} else {
// ### Make this certain :)
- qmlInfo(item) << QSGAnchors::tr("Possible anchor loop detected on horizontal anchor.");
+ qmlInfo(item) << QQuickAnchors::tr("Possible anchor loop detected on horizontal anchor.");
}
}
-QSGAnchorLine QSGAnchors::top() const
+QQuickAnchorLine QQuickAnchors::top() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->top;
}
-void QSGAnchors::setTop(const QSGAnchorLine &edge)
+void QQuickAnchors::setTop(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkVAnchorValid(edge) || d->top == edge)
return;
d->updateVerticalAnchors();
}
-void QSGAnchors::resetTop()
+void QQuickAnchors::resetTop()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~TopAnchor;
d->remDepend(d->top.item);
- d->top = QSGAnchorLine();
+ d->top = QQuickAnchorLine();
emit topChanged();
d->updateVerticalAnchors();
}
-QSGAnchorLine QSGAnchors::bottom() const
+QQuickAnchorLine QQuickAnchors::bottom() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->bottom;
}
-void QSGAnchors::setBottom(const QSGAnchorLine &edge)
+void QQuickAnchors::setBottom(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkVAnchorValid(edge) || d->bottom == edge)
return;
d->updateVerticalAnchors();
}
-void QSGAnchors::resetBottom()
+void QQuickAnchors::resetBottom()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~BottomAnchor;
d->remDepend(d->bottom.item);
- d->bottom = QSGAnchorLine();
+ d->bottom = QQuickAnchorLine();
emit bottomChanged();
d->updateVerticalAnchors();
}
-QSGAnchorLine QSGAnchors::verticalCenter() const
+QQuickAnchorLine QQuickAnchors::verticalCenter() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->vCenter;
}
-void QSGAnchors::setVerticalCenter(const QSGAnchorLine &edge)
+void QQuickAnchors::setVerticalCenter(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkVAnchorValid(edge) || d->vCenter == edge)
return;
d->updateVerticalAnchors();
}
-void QSGAnchors::resetVerticalCenter()
+void QQuickAnchors::resetVerticalCenter()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~VCenterAnchor;
d->remDepend(d->vCenter.item);
- d->vCenter = QSGAnchorLine();
+ d->vCenter = QQuickAnchorLine();
emit verticalCenterChanged();
d->updateVerticalAnchors();
}
-QSGAnchorLine QSGAnchors::baseline() const
+QQuickAnchorLine QQuickAnchors::baseline() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->baseline;
}
-void QSGAnchors::setBaseline(const QSGAnchorLine &edge)
+void QQuickAnchors::setBaseline(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkVAnchorValid(edge) || d->baseline == edge)
return;
d->updateVerticalAnchors();
}
-void QSGAnchors::resetBaseline()
+void QQuickAnchors::resetBaseline()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~BaselineAnchor;
d->remDepend(d->baseline.item);
- d->baseline = QSGAnchorLine();
+ d->baseline = QQuickAnchorLine();
emit baselineChanged();
d->updateVerticalAnchors();
}
-QSGAnchorLine QSGAnchors::left() const
+QQuickAnchorLine QQuickAnchors::left() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->left;
}
-void QSGAnchors::setLeft(const QSGAnchorLine &edge)
+void QQuickAnchors::setLeft(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkHAnchorValid(edge) || d->left == edge)
return;
d->updateHorizontalAnchors();
}
-void QSGAnchors::resetLeft()
+void QQuickAnchors::resetLeft()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~LeftAnchor;
d->remDepend(d->left.item);
- d->left = QSGAnchorLine();
+ d->left = QQuickAnchorLine();
emit leftChanged();
d->updateHorizontalAnchors();
}
-QSGAnchorLine QSGAnchors::right() const
+QQuickAnchorLine QQuickAnchors::right() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->right;
}
-void QSGAnchors::setRight(const QSGAnchorLine &edge)
+void QQuickAnchors::setRight(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkHAnchorValid(edge) || d->right == edge)
return;
d->updateHorizontalAnchors();
}
-void QSGAnchors::resetRight()
+void QQuickAnchors::resetRight()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~RightAnchor;
d->remDepend(d->right.item);
- d->right = QSGAnchorLine();
+ d->right = QQuickAnchorLine();
emit rightChanged();
d->updateHorizontalAnchors();
}
-QSGAnchorLine QSGAnchors::horizontalCenter() const
+QQuickAnchorLine QQuickAnchors::horizontalCenter() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->hCenter;
}
-void QSGAnchors::setHorizontalCenter(const QSGAnchorLine &edge)
+void QQuickAnchors::setHorizontalCenter(const QQuickAnchorLine &edge)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (!d->checkHAnchorValid(edge) || d->hCenter == edge)
return;
d->updateHorizontalAnchors();
}
-void QSGAnchors::resetHorizontalCenter()
+void QQuickAnchors::resetHorizontalCenter()
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
d->usedAnchors &= ~HCenterAnchor;
d->remDepend(d->hCenter.item);
- d->hCenter = QSGAnchorLine();
+ d->hCenter = QQuickAnchorLine();
emit horizontalCenterChanged();
d->updateHorizontalAnchors();
}
-qreal QSGAnchors::leftMargin() const
+qreal QQuickAnchors::leftMargin() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->leftMargin;
}
-void QSGAnchors::setLeftMargin(qreal offset)
+void QQuickAnchors::setLeftMargin(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->leftMargin == offset)
return;
d->leftMargin = offset;
emit leftMarginChanged();
}
-qreal QSGAnchors::rightMargin() const
+qreal QQuickAnchors::rightMargin() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->rightMargin;
}
-void QSGAnchors::setRightMargin(qreal offset)
+void QQuickAnchors::setRightMargin(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->rightMargin == offset)
return;
d->rightMargin = offset;
emit rightMarginChanged();
}
-qreal QSGAnchors::margins() const
+qreal QQuickAnchors::margins() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->margins;
}
-void QSGAnchors::setMargins(qreal offset)
+void QQuickAnchors::setMargins(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->margins == offset)
return;
//###Is it significantly faster to set them directly so we can call fillChanged only once?
}
-qreal QSGAnchors::horizontalCenterOffset() const
+qreal QQuickAnchors::horizontalCenterOffset() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->hCenterOffset;
}
-void QSGAnchors::setHorizontalCenterOffset(qreal offset)
+void QQuickAnchors::setHorizontalCenterOffset(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->hCenterOffset == offset)
return;
d->hCenterOffset = offset;
emit horizontalCenterOffsetChanged();
}
-qreal QSGAnchors::topMargin() const
+qreal QQuickAnchors::topMargin() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->topMargin;
}
-void QSGAnchors::setTopMargin(qreal offset)
+void QQuickAnchors::setTopMargin(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->topMargin == offset)
return;
d->topMargin = offset;
emit topMarginChanged();
}
-qreal QSGAnchors::bottomMargin() const
+qreal QQuickAnchors::bottomMargin() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->bottomMargin;
}
-void QSGAnchors::setBottomMargin(qreal offset)
+void QQuickAnchors::setBottomMargin(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->bottomMargin == offset)
return;
d->bottomMargin = offset;
emit bottomMarginChanged();
}
-qreal QSGAnchors::verticalCenterOffset() const
+qreal QQuickAnchors::verticalCenterOffset() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->vCenterOffset;
}
-void QSGAnchors::setVerticalCenterOffset(qreal offset)
+void QQuickAnchors::setVerticalCenterOffset(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->vCenterOffset == offset)
return;
d->vCenterOffset = offset;
emit verticalCenterOffsetChanged();
}
-qreal QSGAnchors::baselineOffset() const
+qreal QQuickAnchors::baselineOffset() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->baselineOffset;
}
-void QSGAnchors::setBaselineOffset(qreal offset)
+void QQuickAnchors::setBaselineOffset(qreal offset)
{
- Q_D(QSGAnchors);
+ Q_D(QQuickAnchors);
if (d->baselineOffset == offset)
return;
d->baselineOffset = offset;
emit baselineOffsetChanged();
}
-QSGAnchors::Anchors QSGAnchors::usedAnchors() const
+QQuickAnchors::Anchors QQuickAnchors::usedAnchors() const
{
- Q_D(const QSGAnchors);
+ Q_D(const QQuickAnchors);
return d->usedAnchors;
}
-bool QSGAnchorsPrivate::checkHValid() const
+bool QQuickAnchorsPrivate::checkHValid() const
{
- if (usedAnchors & QSGAnchors::LeftAnchor &&
- usedAnchors & QSGAnchors::RightAnchor &&
- usedAnchors & QSGAnchors::HCenterAnchor) {
- qmlInfo(item) << QSGAnchors::tr("Cannot specify left, right, and hcenter anchors.");
+ if (usedAnchors & QQuickAnchors::LeftAnchor &&
+ usedAnchors & QQuickAnchors::RightAnchor &&
+ usedAnchors & QQuickAnchors::HCenterAnchor) {
+ qmlInfo(item) << QQuickAnchors::tr("Cannot specify left, right, and hcenter anchors.");
return false;
}
return true;
}
-bool QSGAnchorsPrivate::checkHAnchorValid(QSGAnchorLine anchor) const
+bool QQuickAnchorsPrivate::checkHAnchorValid(QQuickAnchorLine anchor) const
{
if (!anchor.item) {
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor to a null item.");
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor to a null item.");
return false;
- } else if (anchor.anchorLine & QSGAnchorLine::Vertical_Mask) {
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor a horizontal edge to a vertical edge.");
+ } else if (anchor.anchorLine & QQuickAnchorLine::Vertical_Mask) {
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor a horizontal edge to a vertical edge.");
return false;
} else if (anchor.item != item->parentItem() && anchor.item->parentItem() != item->parentItem()){
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor to an item that isn't a parent or sibling.");
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor to an item that isn't a parent or sibling.");
return false;
} else if (anchor.item == item) {
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor item to self.");
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor item to self.");
return false;
}
return true;
}
-bool QSGAnchorsPrivate::checkVValid() const
+bool QQuickAnchorsPrivate::checkVValid() const
{
- if (usedAnchors & QSGAnchors::TopAnchor &&
- usedAnchors & QSGAnchors::BottomAnchor &&
- usedAnchors & QSGAnchors::VCenterAnchor) {
- qmlInfo(item) << QSGAnchors::tr("Cannot specify top, bottom, and vcenter anchors.");
+ if (usedAnchors & QQuickAnchors::TopAnchor &&
+ usedAnchors & QQuickAnchors::BottomAnchor &&
+ usedAnchors & QQuickAnchors::VCenterAnchor) {
+ qmlInfo(item) << QQuickAnchors::tr("Cannot specify top, bottom, and vcenter anchors.");
return false;
- } else if (usedAnchors & QSGAnchors::BaselineAnchor &&
- (usedAnchors & QSGAnchors::TopAnchor ||
- usedAnchors & QSGAnchors::BottomAnchor ||
- usedAnchors & QSGAnchors::VCenterAnchor)) {
- qmlInfo(item) << QSGAnchors::tr("Baseline anchor cannot be used in conjunction with top, bottom, or vcenter anchors.");
+ } else if (usedAnchors & QQuickAnchors::BaselineAnchor &&
+ (usedAnchors & QQuickAnchors::TopAnchor ||
+ usedAnchors & QQuickAnchors::BottomAnchor ||
+ usedAnchors & QQuickAnchors::VCenterAnchor)) {
+ qmlInfo(item) << QQuickAnchors::tr("Baseline anchor cannot be used in conjunction with top, bottom, or vcenter anchors.");
return false;
}
return true;
}
-bool QSGAnchorsPrivate::checkVAnchorValid(QSGAnchorLine anchor) const
+bool QQuickAnchorsPrivate::checkVAnchorValid(QQuickAnchorLine anchor) const
{
if (!anchor.item) {
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor to a null item.");
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor to a null item.");
return false;
- } else if (anchor.anchorLine & QSGAnchorLine::Horizontal_Mask) {
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor a vertical edge to a horizontal edge.");
+ } else if (anchor.anchorLine & QQuickAnchorLine::Horizontal_Mask) {
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor a vertical edge to a horizontal edge.");
return false;
} else if (anchor.item != item->parentItem() && anchor.item->parentItem() != item->parentItem()){
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor to an item that isn't a parent or sibling.");
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor to an item that isn't a parent or sibling.");
return false;
} else if (anchor.item == item){
- qmlInfo(item) << QSGAnchors::tr("Cannot anchor item to self.");
+ qmlInfo(item) << QQuickAnchors::tr("Cannot anchor item to self.");
return false;
}
QT_END_NAMESPACE
-#include <moc_qsganchors_p.cpp>
+#include <moc_qquickanchors_p.cpp>
**
****************************************************************************/
-#ifndef QSGANCHORS_P_H
-#define QSGANCHORS_P_H
+#ifndef QQUICKANCHORS_P_H
+#define QQUICKANCHORS_P_H
#include <qdeclarative.h>
QT_MODULE(Declarative)
-class QSGItem;
-class QSGAnchorsPrivate;
-class QSGAnchorLine;
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGAnchors : public QObject
+class QQuickItem;
+class QQuickAnchorsPrivate;
+class QQuickAnchorLine;
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickAnchors : public QObject
{
Q_OBJECT
- Q_PROPERTY(QSGAnchorLine left READ left WRITE setLeft RESET resetLeft NOTIFY leftChanged)
- Q_PROPERTY(QSGAnchorLine right READ right WRITE setRight RESET resetRight NOTIFY rightChanged)
- Q_PROPERTY(QSGAnchorLine horizontalCenter READ horizontalCenter WRITE setHorizontalCenter RESET resetHorizontalCenter NOTIFY horizontalCenterChanged)
- Q_PROPERTY(QSGAnchorLine top READ top WRITE setTop RESET resetTop NOTIFY topChanged)
- Q_PROPERTY(QSGAnchorLine bottom READ bottom WRITE setBottom RESET resetBottom NOTIFY bottomChanged)
- Q_PROPERTY(QSGAnchorLine verticalCenter READ verticalCenter WRITE setVerticalCenter RESET resetVerticalCenter NOTIFY verticalCenterChanged)
- Q_PROPERTY(QSGAnchorLine baseline READ baseline WRITE setBaseline RESET resetBaseline NOTIFY baselineChanged)
+ Q_PROPERTY(QQuickAnchorLine left READ left WRITE setLeft RESET resetLeft NOTIFY leftChanged)
+ Q_PROPERTY(QQuickAnchorLine right READ right WRITE setRight RESET resetRight NOTIFY rightChanged)
+ Q_PROPERTY(QQuickAnchorLine horizontalCenter READ horizontalCenter WRITE setHorizontalCenter RESET resetHorizontalCenter NOTIFY horizontalCenterChanged)
+ Q_PROPERTY(QQuickAnchorLine top READ top WRITE setTop RESET resetTop NOTIFY topChanged)
+ Q_PROPERTY(QQuickAnchorLine bottom READ bottom WRITE setBottom RESET resetBottom NOTIFY bottomChanged)
+ Q_PROPERTY(QQuickAnchorLine verticalCenter READ verticalCenter WRITE setVerticalCenter RESET resetVerticalCenter NOTIFY verticalCenterChanged)
+ Q_PROPERTY(QQuickAnchorLine baseline READ baseline WRITE setBaseline RESET resetBaseline NOTIFY baselineChanged)
Q_PROPERTY(qreal margins READ margins WRITE setMargins NOTIFY marginsChanged)
Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin NOTIFY leftMarginChanged)
Q_PROPERTY(qreal rightMargin READ rightMargin WRITE setRightMargin NOTIFY rightMarginChanged)
Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin NOTIFY bottomMarginChanged)
Q_PROPERTY(qreal verticalCenterOffset READ verticalCenterOffset WRITE setVerticalCenterOffset NOTIFY verticalCenterOffsetChanged)
Q_PROPERTY(qreal baselineOffset READ baselineOffset WRITE setBaselineOffset NOTIFY baselineOffsetChanged)
- Q_PROPERTY(QSGItem *fill READ fill WRITE setFill RESET resetFill NOTIFY fillChanged)
- Q_PROPERTY(QSGItem *centerIn READ centerIn WRITE setCenterIn RESET resetCenterIn NOTIFY centerInChanged)
+ Q_PROPERTY(QQuickItem *fill READ fill WRITE setFill RESET resetFill NOTIFY fillChanged)
+ Q_PROPERTY(QQuickItem *centerIn READ centerIn WRITE setCenterIn RESET resetCenterIn NOTIFY centerInChanged)
Q_PROPERTY(bool mirrored READ mirrored NOTIFY mirroredChanged)
public:
- QSGAnchors(QSGItem *item, QObject *parent=0);
- virtual ~QSGAnchors();
+ QQuickAnchors(QQuickItem *item, QObject *parent=0);
+ virtual ~QQuickAnchors();
enum Anchor {
LeftAnchor = 0x01,
};
Q_DECLARE_FLAGS(Anchors, Anchor)
- QSGAnchorLine left() const;
- void setLeft(const QSGAnchorLine &edge);
+ QQuickAnchorLine left() const;
+ void setLeft(const QQuickAnchorLine &edge);
void resetLeft();
- QSGAnchorLine right() const;
- void setRight(const QSGAnchorLine &edge);
+ QQuickAnchorLine right() const;
+ void setRight(const QQuickAnchorLine &edge);
void resetRight();
- QSGAnchorLine horizontalCenter() const;
- void setHorizontalCenter(const QSGAnchorLine &edge);
+ QQuickAnchorLine horizontalCenter() const;
+ void setHorizontalCenter(const QQuickAnchorLine &edge);
void resetHorizontalCenter();
- QSGAnchorLine top() const;
- void setTop(const QSGAnchorLine &edge);
+ QQuickAnchorLine top() const;
+ void setTop(const QQuickAnchorLine &edge);
void resetTop();
- QSGAnchorLine bottom() const;
- void setBottom(const QSGAnchorLine &edge);
+ QQuickAnchorLine bottom() const;
+ void setBottom(const QQuickAnchorLine &edge);
void resetBottom();
- QSGAnchorLine verticalCenter() const;
- void setVerticalCenter(const QSGAnchorLine &edge);
+ QQuickAnchorLine verticalCenter() const;
+ void setVerticalCenter(const QQuickAnchorLine &edge);
void resetVerticalCenter();
- QSGAnchorLine baseline() const;
- void setBaseline(const QSGAnchorLine &edge);
+ QQuickAnchorLine baseline() const;
+ void setBaseline(const QQuickAnchorLine &edge);
void resetBaseline();
qreal leftMargin() const;
qreal baselineOffset() const;
void setBaselineOffset(qreal);
- QSGItem *fill() const;
- void setFill(QSGItem *);
+ QQuickItem *fill() const;
+ void setFill(QQuickItem *);
void resetFill();
- QSGItem *centerIn() const;
- void setCenterIn(QSGItem *);
+ QQuickItem *centerIn() const;
+ void setCenterIn(QQuickItem *);
void resetCenterIn();
Anchors usedAnchors() const;
void mirroredChanged();
private:
- friend class QSGItemPrivate;
- Q_DISABLE_COPY(QSGAnchors)
- Q_DECLARE_PRIVATE(QSGAnchors)
+ friend class QQuickItemPrivate;
+ Q_DISABLE_COPY(QQuickAnchors)
+ Q_DECLARE_PRIVATE(QQuickAnchors)
};
-Q_DECLARE_OPERATORS_FOR_FLAGS(QSGAnchors::Anchors)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickAnchors::Anchors)
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGAnchors)
+QML_DECLARE_TYPE(QQuickAnchors)
QT_END_HEADER
-#endif // QSGANCHORS_P_H
+#endif // QQUICKANCHORS_P_H
**
****************************************************************************/
-#ifndef QSGANCHORS_P_P_H
-#define QSGANCHORS_P_P_H
+#ifndef QQUICKANCHORS_P_P_H
+#define QQUICKANCHORS_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsganchors_p.h"
-#include "qsgitemchangelistener_p.h"
+#include "qquickanchors_p.h"
+#include "qquickitemchangelistener_p.h"
#include <private/qobject_p.h>
QT_BEGIN_NAMESPACE
-class QSGAnchorLine
+class QQuickAnchorLine
{
public:
- QSGAnchorLine() : item(0), anchorLine(Invalid) {}
+ QQuickAnchorLine() : item(0), anchorLine(Invalid) {}
enum AnchorLine {
Invalid = 0x0,
Vertical_Mask = Top | Bottom | VCenter | Baseline
};
- QSGItem *item;
+ QQuickItem *item;
AnchorLine anchorLine;
};
-inline bool operator==(const QSGAnchorLine& a, const QSGAnchorLine& b)
+inline bool operator==(const QQuickAnchorLine& a, const QQuickAnchorLine& b)
{
return a.item == b.item && a.anchorLine == b.anchorLine;
}
-class QSGAnchorsPrivate : public QObjectPrivate, public QSGItemChangeListener
+class QQuickAnchorsPrivate : public QObjectPrivate, public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGAnchors)
+ Q_DECLARE_PUBLIC(QQuickAnchors)
public:
- QSGAnchorsPrivate(QSGItem *i)
+ QQuickAnchorsPrivate(QQuickItem *i)
: componentComplete(true), updatingMe(false), updatingHorizontalAnchor(0),
updatingVerticalAnchor(0), updatingFill(0), updatingCenterIn(0), item(i), usedAnchors(0), fill(0),
centerIn(0), leftMargin(0), rightMargin(0), topMargin(0), bottomMargin(0),
{
}
- void clearItem(QSGItem *);
+ void clearItem(QQuickItem *);
- void addDepend(QSGItem *);
- void remDepend(QSGItem *);
+ void addDepend(QQuickItem *);
+ void remDepend(QQuickItem *);
bool isItemComplete() const;
bool componentComplete:1;
void updateOnComplete();
void updateMe();
- // QSGItemGeometryListener interface
- void itemGeometryChanged(QSGItem *, const QRectF &, const QRectF &);
- QSGAnchorsPrivate *anchorPrivate() { return this; }
+ // QQuickItemGeometryListener interface
+ void itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &);
+ QQuickAnchorsPrivate *anchorPrivate() { return this; }
bool checkHValid() const;
bool checkVValid() const;
- bool checkHAnchorValid(QSGAnchorLine anchor) const;
- bool checkVAnchorValid(QSGAnchorLine anchor) const;
- bool calcStretch(const QSGAnchorLine &edge1, const QSGAnchorLine &edge2, qreal offset1, qreal offset2, QSGAnchorLine::AnchorLine line, qreal &stretch);
+ bool checkHAnchorValid(QQuickAnchorLine anchor) const;
+ bool checkVAnchorValid(QQuickAnchorLine anchor) const;
+ bool calcStretch(const QQuickAnchorLine &edge1, const QQuickAnchorLine &edge2, qreal offset1, qreal offset2, QQuickAnchorLine::AnchorLine line, qreal &stretch);
bool isMirrored() const;
void updateHorizontalAnchors();
void fillChanged();
void centerInChanged();
- QSGItem *item;
- QSGAnchors::Anchors usedAnchors;
+ QQuickItem *item;
+ QQuickAnchors::Anchors usedAnchors;
- QSGItem *fill;
- QSGItem *centerIn;
+ QQuickItem *fill;
+ QQuickItem *centerIn;
- QSGAnchorLine left;
- QSGAnchorLine right;
- QSGAnchorLine top;
- QSGAnchorLine bottom;
- QSGAnchorLine vCenter;
- QSGAnchorLine hCenter;
- QSGAnchorLine baseline;
+ QQuickAnchorLine left;
+ QQuickAnchorLine right;
+ QQuickAnchorLine top;
+ QQuickAnchorLine bottom;
+ QQuickAnchorLine vCenter;
+ QQuickAnchorLine hCenter;
+ QQuickAnchorLine baseline;
qreal leftMargin;
qreal rightMargin;
qreal hCenterOffset;
qreal baselineOffset;
- static inline QSGAnchorsPrivate *get(QSGAnchors *o) {
- return static_cast<QSGAnchorsPrivate *>(QObjectPrivate::get(o));
+ static inline QQuickAnchorsPrivate *get(QQuickAnchors *o) {
+ return static_cast<QQuickAnchorsPrivate *>(QObjectPrivate::get(o));
}
};
QT_END_NAMESPACE
-Q_DECLARE_METATYPE(QSGAnchorLine)
+Q_DECLARE_METATYPE(QQuickAnchorLine)
#endif
**
****************************************************************************/
-#include "qsganimatedimage_p.h"
-#include "qsganimatedimage_p_p.h"
+#include "qquickanimatedimage_p.h"
+#include "qquickanimatedimage_p_p.h"
#ifndef QT_NO_MOVIE
QT_BEGIN_NAMESPACE
/*!
- \qmlclass AnimatedImage QSGAnimatedImage
+ \qmlclass AnimatedImage QQuickAnimatedImage
\inqmlmodule QtQuick 2
\inherits Image
\ingroup basic-visual-elements
The default value is false.
*/
-QSGAnimatedImage::QSGAnimatedImage(QSGItem *parent)
- : QSGImage(*(new QSGAnimatedImagePrivate), parent)
+QQuickAnimatedImage::QQuickAnimatedImage(QQuickItem *parent)
+ : QQuickImage(*(new QQuickAnimatedImagePrivate), parent)
{
}
-QSGAnimatedImage::~QSGAnimatedImage()
+QQuickAnimatedImage::~QQuickAnimatedImage()
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
delete d->_movie;
}
the animation.
*/
-bool QSGAnimatedImage::isPaused() const
+bool QQuickAnimatedImage::isPaused() const
{
- Q_D(const QSGAnimatedImage);
+ Q_D(const QQuickAnimatedImage);
if (!d->_movie)
return false;
return d->_movie->state()==QMovie::Paused;
}
-void QSGAnimatedImage::setPaused(bool pause)
+void QQuickAnimatedImage::setPaused(bool pause)
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
if (pause == d->paused)
return;
d->paused = pause;
will start playing immediately.
*/
-bool QSGAnimatedImage::isPlaying() const
+bool QQuickAnimatedImage::isPlaying() const
{
- Q_D(const QSGAnimatedImage);
+ Q_D(const QQuickAnimatedImage);
if (!d->_movie)
return false;
return d->_movie->state()!=QMovie::NotRunning;
}
-void QSGAnimatedImage::setPlaying(bool play)
+void QQuickAnimatedImage::setPlaying(bool play)
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
if (play == d->playing)
return;
d->playing = play;
frameCount is the number of frames in the animation. For some animation formats,
frameCount is unknown and has a value of zero.
*/
-int QSGAnimatedImage::currentFrame() const
+int QQuickAnimatedImage::currentFrame() const
{
- Q_D(const QSGAnimatedImage);
+ Q_D(const QQuickAnimatedImage);
if (!d->_movie)
return d->preset_currentframe;
return d->_movie->currentFrameNumber();
}
-void QSGAnimatedImage::setCurrentFrame(int frame)
+void QQuickAnimatedImage::setCurrentFrame(int frame)
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
if (!d->_movie) {
d->preset_currentframe = frame;
return;
d->_movie->jumpToFrame(frame);
}
-int QSGAnimatedImage::frameCount() const
+int QQuickAnimatedImage::frameCount() const
{
- Q_D(const QSGAnimatedImage);
+ Q_D(const QQuickAnimatedImage);
if (!d->_movie)
return 0;
return d->_movie->frameCount();
}
-void QSGAnimatedImage::setSource(const QUrl &url)
+void QQuickAnimatedImage::setSource(const QUrl &url)
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
if (url == d->url)
return;
load();
}
-void QSGAnimatedImage::load()
+void QQuickAnimatedImage::load()
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
- QSGImageBase::Status oldStatus = d->status;
+ QQuickImageBase::Status oldStatus = d->status;
qreal oldProgress = d->progress;
if (d->url.isEmpty()) {
#define ANIMATEDIMAGE_MAXIMUM_REDIRECT_RECURSION 16
-void QSGAnimatedImage::movieRequestFinished()
+void QQuickAnimatedImage::movieRequestFinished()
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
d->redirectCount++;
if (d->redirectCount < ANIMATEDIMAGE_MAXIMUM_REDIRECT_RECURSION) {
emit statusChanged(d->status);
}
-void QSGAnimatedImage::movieUpdate()
+void QQuickAnimatedImage::movieUpdate()
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
d->setPixmap(d->_movie->currentPixmap());
emit frameChanged();
}
-void QSGAnimatedImage::playingStatusChanged()
+void QQuickAnimatedImage::playingStatusChanged()
{
- Q_D(QSGAnimatedImage);
+ Q_D(QQuickAnimatedImage);
if ((d->_movie->state() != QMovie::NotRunning) != d->playing) {
d->playing = (d->_movie->state() != QMovie::NotRunning);
emit playingChanged();
}
}
-void QSGAnimatedImage::componentComplete()
+void QQuickAnimatedImage::componentComplete()
{
- Q_D(QSGAnimatedImage);
- QSGItem::componentComplete(); // NOT QSGImage
+ Q_D(QQuickAnimatedImage);
+ QQuickItem::componentComplete(); // NOT QQuickImage
if (d->url.isValid())
load();
if (!d->reply) {
**
****************************************************************************/
-#ifndef QSGANIMATEDIMAGE_P_H
-#define QSGANIMATEDIMAGE_P_H
+#ifndef QQUICKANIMATEDIMAGE_P_H
+#define QQUICKANIMATEDIMAGE_P_H
-#include "qsgimage_p.h"
+#include "qquickimage_p.h"
#ifndef QT_NO_MOVIE
QT_MODULE(Declarative)
class QMovie;
-class QSGAnimatedImagePrivate;
+class QQuickAnimatedImagePrivate;
-class Q_AUTOTEST_EXPORT QSGAnimatedImage : public QSGImage
+class Q_AUTOTEST_EXPORT QQuickAnimatedImage : public QQuickImage
{
Q_OBJECT
Q_PROPERTY(QSize sourceSize READ sourceSize NOTIFY sourceSizeChanged)
public:
- QSGAnimatedImage(QSGItem *parent=0);
- ~QSGAnimatedImage();
+ QQuickAnimatedImage(QQuickItem *parent=0);
+ ~QQuickAnimatedImage();
bool isPlaying() const;
void setPlaying(bool play);
int frameCount() const;
- // Extends QSGImage's src property*/
+ // Extends QQuickImage's src property*/
virtual void setSource(const QUrl&);
Q_SIGNALS:
void componentComplete();
private:
- Q_DISABLE_COPY(QSGAnimatedImage)
- Q_DECLARE_PRIVATE(QSGAnimatedImage)
+ Q_DISABLE_COPY(QQuickAnimatedImage)
+ Q_DECLARE_PRIVATE(QQuickAnimatedImage)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGAnimatedImage)
+QML_DECLARE_TYPE(QQuickAnimatedImage)
QT_END_HEADER
#endif // QT_NO_MOVIE
-#endif // QSGANIMATEDIMAGE_P_H
+#endif // QQUICKANIMATEDIMAGE_P_H
**
****************************************************************************/
-#ifndef QSGANIMATEDIMAGE_P_P_H
-#define QSGANIMATEDIMAGE_P_P_H
+#ifndef QQUICKANIMATEDIMAGE_P_P_H
+#define QQUICKANIMATEDIMAGE_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgimage_p_p.h"
+#include "qquickimage_p_p.h"
#ifndef QT_NO_MOVIE
class QMovie;
class QNetworkReply;
-class QSGAnimatedImagePrivate : public QSGImagePrivate
+class QQuickAnimatedImagePrivate : public QQuickImagePrivate
{
- Q_DECLARE_PUBLIC(QSGAnimatedImage)
+ Q_DECLARE_PUBLIC(QQuickAnimatedImage)
public:
- QSGAnimatedImagePrivate()
+ QQuickAnimatedImagePrivate()
: playing(true), paused(false), preset_currentframe(0), _movie(0), reply(0), redirectCount(0)
{
}
#endif // QT_NO_MOVIE
-#endif // QSGANIMATEDIMAGE_P_P_H
+#endif // QQUICKANIMATEDIMAGE_P_P_H
**
****************************************************************************/
-#include "qsganimation_p.h"
-#include "qsganimation_p_p.h"
-#include "qsgstateoperations_p.h"
+#include "qquickanimation_p.h"
+#include "qquickanimation_p_p.h"
+#include "qquickstateoperations_p.h"
#include <private/qdeclarativeproperty_p.h>
#include <private/qdeclarativepath_p.h>
QT_BEGIN_NAMESPACE
-QSGParentAnimation::QSGParentAnimation(QObject *parent)
- : QDeclarativeAnimationGroup(*(new QSGParentAnimationPrivate), parent)
+QQuickParentAnimation::QQuickParentAnimation(QObject *parent)
+ : QDeclarativeAnimationGroup(*(new QQuickParentAnimationPrivate), parent)
{
- Q_D(QSGParentAnimation);
+ Q_D(QQuickParentAnimation);
d->topLevelGroup = new QSequentialAnimationGroup;
QDeclarative_setParent_noEvent(d->topLevelGroup, this);
d->topLevelGroup->addAnimation(d->endAction);
}
-QSGParentAnimation::~QSGParentAnimation()
+QQuickParentAnimation::~QQuickParentAnimation()
{
}
-QSGItem *QSGParentAnimation::target() const
+QQuickItem *QQuickParentAnimation::target() const
{
- Q_D(const QSGParentAnimation);
+ Q_D(const QQuickParentAnimation);
return d->target;
}
-void QSGParentAnimation::setTarget(QSGItem *target)
+void QQuickParentAnimation::setTarget(QQuickItem *target)
{
- Q_D(QSGParentAnimation);
+ Q_D(QQuickParentAnimation);
if (target == d->target)
return;
emit targetChanged();
}
-QSGItem *QSGParentAnimation::newParent() const
+QQuickItem *QQuickParentAnimation::newParent() const
{
- Q_D(const QSGParentAnimation);
+ Q_D(const QQuickParentAnimation);
return d->newParent;
}
-void QSGParentAnimation::setNewParent(QSGItem *newParent)
+void QQuickParentAnimation::setNewParent(QQuickItem *newParent)
{
- Q_D(QSGParentAnimation);
+ Q_D(QQuickParentAnimation);
if (newParent == d->newParent)
return;
emit newParentChanged();
}
-QSGItem *QSGParentAnimation::via() const
+QQuickItem *QQuickParentAnimation::via() const
{
- Q_D(const QSGParentAnimation);
+ Q_D(const QQuickParentAnimation);
return d->via;
}
-void QSGParentAnimation::setVia(QSGItem *via)
+void QQuickParentAnimation::setVia(QQuickItem *via)
{
- Q_D(QSGParentAnimation);
+ Q_D(QQuickParentAnimation);
if (via == d->via)
return;
emit viaChanged();
}
-//### mirrors same-named function in QSGItem
-QPointF QSGParentAnimationPrivate::computeTransformOrigin(QSGItem::TransformOrigin origin, qreal width, qreal height) const
+//### mirrors same-named function in QQuickItem
+QPointF QQuickParentAnimationPrivate::computeTransformOrigin(QQuickItem::TransformOrigin origin, qreal width, qreal height) const
{
switch (origin) {
default:
- case QSGItem::TopLeft:
+ case QQuickItem::TopLeft:
return QPointF(0, 0);
- case QSGItem::Top:
+ case QQuickItem::Top:
return QPointF(width / 2., 0);
- case QSGItem::TopRight:
+ case QQuickItem::TopRight:
return QPointF(width, 0);
- case QSGItem::Left:
+ case QQuickItem::Left:
return QPointF(0, height / 2.);
- case QSGItem::Center:
+ case QQuickItem::Center:
return QPointF(width / 2., height / 2.);
- case QSGItem::Right:
+ case QQuickItem::Right:
return QPointF(width, height / 2.);
- case QSGItem::BottomLeft:
+ case QQuickItem::BottomLeft:
return QPointF(0, height);
- case QSGItem::Bottom:
+ case QQuickItem::Bottom:
return QPointF(width / 2., height);
- case QSGItem::BottomRight:
+ case QQuickItem::BottomRight:
return QPointF(width, height);
}
}
-void QSGParentAnimation::transition(QDeclarativeStateActions &actions,
+void QQuickParentAnimation::transition(QDeclarativeStateActions &actions,
QDeclarativeProperties &modified,
TransitionDirection direction)
{
- Q_D(QSGParentAnimation);
+ Q_D(QQuickParentAnimation);
- struct QSGParentAnimationData : public QAbstractAnimationAction
+ struct QQuickParentAnimationData : public QAbstractAnimationAction
{
- QSGParentAnimationData() {}
- ~QSGParentAnimationData() { qDeleteAll(pc); }
+ QQuickParentAnimationData() {}
+ ~QQuickParentAnimationData() { qDeleteAll(pc); }
QDeclarativeStateActions actions;
//### reverse should probably apply on a per-action basis
bool reverse;
- QList<QSGParentChange *> pc;
+ QList<QQuickParentChange *> pc;
virtual void doAction()
{
for (int ii = 0; ii < actions.count(); ++ii) {
}
};
- QSGParentAnimationData *data = new QSGParentAnimationData;
- QSGParentAnimationData *viaData = new QSGParentAnimationData;
+ QQuickParentAnimationData *data = new QQuickParentAnimationData;
+ QQuickParentAnimationData *viaData = new QQuickParentAnimationData;
bool hasExplicit = false;
if (d->target && d->newParent) {
data->reverse = false;
QDeclarativeAction myAction;
- QSGParentChange *pc = new QSGParentChange;
+ QQuickParentChange *pc = new QQuickParentChange;
pc->setObject(d->target);
pc->setParent(d->newParent);
myAction.event = pc;
if (d->via) {
viaData->reverse = false;
QDeclarativeAction myVAction;
- QSGParentChange *vpc = new QSGParentChange;
+ QQuickParentChange *vpc = new QQuickParentChange;
vpc->setObject(d->target);
vpc->setParent(d->via);
myVAction.event = vpc;
for (int i = 0; i < actions.size(); ++i) {
QDeclarativeAction &action = actions[i];
if (action.event && action.event->typeName() == QLatin1String("ParentChange")
- && (!d->target || static_cast<QSGParentChange*>(action.event)->object() == d->target)) {
+ && (!d->target || static_cast<QQuickParentChange*>(action.event)->object() == d->target)) {
- QSGParentChange *pc = static_cast<QSGParentChange*>(action.event);
+ QQuickParentChange *pc = static_cast<QQuickParentChange*>(action.event);
QDeclarativeAction myAction = action;
data->reverse = action.reverseEvent;
//### this logic differs from PropertyAnimation
// (probably a result of modified vs. done)
if (d->newParent) {
- QSGParentChange *epc = new QSGParentChange;
- epc->setObject(static_cast<QSGParentChange*>(action.event)->object());
+ QQuickParentChange *epc = new QQuickParentChange;
+ epc->setObject(static_cast<QQuickParentChange*>(action.event)->object());
epc->setParent(d->newParent);
myAction.event = epc;
data->pc << epc;
if (d->via) {
viaData->reverse = false;
QDeclarativeAction myAction;
- QSGParentChange *vpc = new QSGParentChange;
+ QQuickParentChange *vpc = new QQuickParentChange;
vpc->setObject(pc->object());
vpc->setParent(d->via);
myAction.event = vpc;
QDeclarativeAction &yAction = pc->yIsSet() && i < actions.size()-1 ? actions[++i] : dummyAction;
QDeclarativeAction &sAction = pc->scaleIsSet() && i < actions.size()-1 ? actions[++i] : dummyAction;
QDeclarativeAction &rAction = pc->rotationIsSet() && i < actions.size()-1 ? actions[++i] : dummyAction;
- QSGItem *target = pc->object();
- QSGItem *targetParent = action.reverseEvent ? pc->originalParent() : pc->parent();
+ QQuickItem *target = pc->object();
+ QQuickItem *targetParent = action.reverseEvent ? pc->originalParent() : pc->parent();
- //### this mirrors the logic in QSGParentChange.
+ //### this mirrors the logic in QQuickParentChange.
bool ok;
const QTransform &transform = targetParent->itemTransform(d->via, &ok);
if (transform.type() >= QTransform::TxShear || !ok) {
- qmlInfo(this) << QSGParentAnimation::tr("Unable to preserve appearance under complex transform");
+ qmlInfo(this) << QQuickParentAnimation::tr("Unable to preserve appearance under complex transform");
ok = false;
}
if (transform.m11() == transform.m22())
scale = transform.m11();
else {
- qmlInfo(this) << QSGParentAnimation::tr("Unable to preserve appearance under non-uniform scale");
+ qmlInfo(this) << QQuickParentAnimation::tr("Unable to preserve appearance under non-uniform scale");
ok = false;
}
} else if (ok && isRotate) {
if (transform.m11() == transform.m22())
scale = qSqrt(transform.m11()*transform.m11() + transform.m12()*transform.m12());
else {
- qmlInfo(this) << QSGParentAnimation::tr("Unable to preserve appearance under non-uniform scale");
+ qmlInfo(this) << QQuickParentAnimation::tr("Unable to preserve appearance under non-uniform scale");
ok = false;
}
if (scale != 0)
rotation = atan2(transform.m12()/scale, transform.m11()/scale) * 180/M_PI;
else {
- qmlInfo(this) << QSGParentAnimation::tr("Unable to preserve appearance under scale of 0");
+ qmlInfo(this) << QQuickParentAnimation::tr("Unable to preserve appearance under scale of 0");
ok = false;
}
}
const QPointF &point = transform.map(QPointF(xAction.toValue.toReal(),yAction.toValue.toReal()));
qreal x = point.x();
qreal y = point.y();
- if (ok && target->transformOrigin() != QSGItem::TopLeft) {
+ if (ok && target->transformOrigin() != QQuickItem::TopLeft) {
qreal w = target->width();
qreal h = target->height();
if (pc->widthIsSet() && i < actions.size() - 1)
}
-QAbstractAnimation *QSGParentAnimation::qtAnimation()
+QAbstractAnimation *QQuickParentAnimation::qtAnimation()
{
- Q_D(QSGParentAnimation);
+ Q_D(QQuickParentAnimation);
return d->topLevelGroup;
}
-QSGAnchorAnimation::QSGAnchorAnimation(QObject *parent)
-: QDeclarativeAbstractAnimation(*(new QSGAnchorAnimationPrivate), parent)
+QQuickAnchorAnimation::QQuickAnchorAnimation(QObject *parent)
+: QDeclarativeAbstractAnimation(*(new QQuickAnchorAnimationPrivate), parent)
{
- Q_D(QSGAnchorAnimation);
+ Q_D(QQuickAnchorAnimation);
d->va = new QDeclarativeBulkValueAnimator;
QDeclarative_setParent_noEvent(d->va, this);
}
-QSGAnchorAnimation::~QSGAnchorAnimation()
+QQuickAnchorAnimation::~QQuickAnchorAnimation()
{
}
-QAbstractAnimation *QSGAnchorAnimation::qtAnimation()
+QAbstractAnimation *QQuickAnchorAnimation::qtAnimation()
{
- Q_D(QSGAnchorAnimation);
+ Q_D(QQuickAnchorAnimation);
return d->va;
}
-QDeclarativeListProperty<QSGItem> QSGAnchorAnimation::targets()
+QDeclarativeListProperty<QQuickItem> QQuickAnchorAnimation::targets()
{
- Q_D(QSGAnchorAnimation);
- return QDeclarativeListProperty<QSGItem>(this, d->targets);
+ Q_D(QQuickAnchorAnimation);
+ return QDeclarativeListProperty<QQuickItem>(this, d->targets);
}
-int QSGAnchorAnimation::duration() const
+int QQuickAnchorAnimation::duration() const
{
- Q_D(const QSGAnchorAnimation);
+ Q_D(const QQuickAnchorAnimation);
return d->va->duration();
}
-void QSGAnchorAnimation::setDuration(int duration)
+void QQuickAnchorAnimation::setDuration(int duration)
{
if (duration < 0) {
qmlInfo(this) << tr("Cannot set a duration of < 0");
return;
}
- Q_D(QSGAnchorAnimation);
+ Q_D(QQuickAnchorAnimation);
if (d->va->duration() == duration)
return;
d->va->setDuration(duration);
emit durationChanged(duration);
}
-QEasingCurve QSGAnchorAnimation::easing() const
+QEasingCurve QQuickAnchorAnimation::easing() const
{
- Q_D(const QSGAnchorAnimation);
+ Q_D(const QQuickAnchorAnimation);
return d->va->easingCurve();
}
-void QSGAnchorAnimation::setEasing(const QEasingCurve &e)
+void QQuickAnchorAnimation::setEasing(const QEasingCurve &e)
{
- Q_D(QSGAnchorAnimation);
+ Q_D(QQuickAnchorAnimation);
if (d->va->easingCurve() == e)
return;
emit easingChanged(e);
}
-void QSGAnchorAnimation::transition(QDeclarativeStateActions &actions,
+void QQuickAnchorAnimation::transition(QDeclarativeStateActions &actions,
QDeclarativeProperties &modified,
TransitionDirection direction)
{
Q_UNUSED(modified);
- Q_D(QSGAnchorAnimation);
+ Q_D(QQuickAnchorAnimation);
QDeclarativeAnimationPropertyUpdater *data = new QDeclarativeAnimationPropertyUpdater;
data->interpolatorType = QMetaType::QReal;
data->interpolator = d->interpolator;
for (int ii = 0; ii < actions.count(); ++ii) {
QDeclarativeAction &action = actions[ii];
if (action.event && action.event->typeName() == QLatin1String("AnchorChanges")
- && (d->targets.isEmpty() || d->targets.contains(static_cast<QSGAnchorChanges*>(action.event)->object()))) {
- data->actions << static_cast<QSGAnchorChanges*>(action.event)->additionalActions();
+ && (d->targets.isEmpty() || d->targets.contains(static_cast<QQuickAnchorChanges*>(action.event)->object()))) {
+ data->actions << static_cast<QQuickAnchorChanges*>(action.event)->additionalActions();
}
}
}
}
-QSGPathAnimation::QSGPathAnimation(QObject *parent)
-: QDeclarativeAbstractAnimation(*(new QSGPathAnimationPrivate), parent)
+QQuickPathAnimation::QQuickPathAnimation(QObject *parent)
+: QDeclarativeAbstractAnimation(*(new QQuickPathAnimationPrivate), parent)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
d->pa = new QDeclarativeBulkValueAnimator;
QDeclarative_setParent_noEvent(d->pa, this);
}
-QSGPathAnimation::~QSGPathAnimation()
+QQuickPathAnimation::~QQuickPathAnimation()
{
}
-int QSGPathAnimation::duration() const
+int QQuickPathAnimation::duration() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->pa->duration();
}
-void QSGPathAnimation::setDuration(int duration)
+void QQuickPathAnimation::setDuration(int duration)
{
if (duration < 0) {
qmlInfo(this) << tr("Cannot set a duration of < 0");
return;
}
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->pa->duration() == duration)
return;
d->pa->setDuration(duration);
emit durationChanged(duration);
}
-QEasingCurve QSGPathAnimation::easing() const
+QEasingCurve QQuickPathAnimation::easing() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->pa->easingCurve();
}
-void QSGPathAnimation::setEasing(const QEasingCurve &e)
+void QQuickPathAnimation::setEasing(const QEasingCurve &e)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->pa->easingCurve() == e)
return;
emit easingChanged(e);
}
-QDeclarativePath *QSGPathAnimation::path() const
+QDeclarativePath *QQuickPathAnimation::path() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->path;
}
-void QSGPathAnimation::setPath(QDeclarativePath *path)
+void QQuickPathAnimation::setPath(QDeclarativePath *path)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->path == path)
return;
emit pathChanged();
}
-QSGItem *QSGPathAnimation::target() const
+QQuickItem *QQuickPathAnimation::target() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->target;
}
-void QSGPathAnimation::setTarget(QSGItem *target)
+void QQuickPathAnimation::setTarget(QQuickItem *target)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->target == target)
return;
emit targetChanged();
}
-QSGPathAnimation::Orientation QSGPathAnimation::orientation() const
+QQuickPathAnimation::Orientation QQuickPathAnimation::orientation() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->orientation;
}
-void QSGPathAnimation::setOrientation(Orientation orientation)
+void QQuickPathAnimation::setOrientation(Orientation orientation)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->orientation == orientation)
return;
emit orientationChanged(d->orientation);
}
-QPointF QSGPathAnimation::anchorPoint() const
+QPointF QQuickPathAnimation::anchorPoint() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->anchorPoint;
}
-void QSGPathAnimation::setAnchorPoint(const QPointF &point)
+void QQuickPathAnimation::setAnchorPoint(const QPointF &point)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->anchorPoint == point)
return;
emit anchorPointChanged(point);
}
-qreal QSGPathAnimation::orientationEntryInterval() const
+qreal QQuickPathAnimation::orientationEntryInterval() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->entryInterval;
}
-void QSGPathAnimation::setOrientationEntryInterval(qreal interval)
+void QQuickPathAnimation::setOrientationEntryInterval(qreal interval)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->entryInterval == interval)
return;
d->entryInterval = interval;
emit orientationEntryIntervalChanged(interval);
}
-qreal QSGPathAnimation::orientationExitInterval() const
+qreal QQuickPathAnimation::orientationExitInterval() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->exitInterval;
}
-void QSGPathAnimation::setOrientationExitInterval(qreal interval)
+void QQuickPathAnimation::setOrientationExitInterval(qreal interval)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (d->exitInterval == interval)
return;
d->exitInterval = interval;
emit orientationExitIntervalChanged(interval);
}
-qreal QSGPathAnimation::endRotation() const
+qreal QQuickPathAnimation::endRotation() const
{
- Q_D(const QSGPathAnimation);
+ Q_D(const QQuickPathAnimation);
return d->endRotation.isNull ? qreal(0) : d->endRotation.value;
}
-void QSGPathAnimation::setEndRotation(qreal rotation)
+void QQuickPathAnimation::setEndRotation(qreal rotation)
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
if (!d->endRotation.isNull && d->endRotation == rotation)
return;
}
-QAbstractAnimation *QSGPathAnimation::qtAnimation()
+QAbstractAnimation *QQuickPathAnimation::qtAnimation()
{
- Q_D(QSGPathAnimation);
+ Q_D(QQuickPathAnimation);
return d->pa;
}
-void QSGPathAnimation::transition(QDeclarativeStateActions &actions,
+void QQuickPathAnimation::transition(QDeclarativeStateActions &actions,
QDeclarativeProperties &modified,
TransitionDirection direction)
{
- Q_D(QSGPathAnimation);
- QSGPathAnimationUpdater *data = new QSGPathAnimationUpdater;
+ Q_D(QQuickPathAnimation);
+ QQuickPathAnimationUpdater *data = new QQuickPathAnimationUpdater;
data->orientation = d->orientation;
data->anchorPoint = d->anchorPoint;
yet been deleted, and has the same target, etc, which may be a bit fragile.
*/
if (d->pa->getAnimValue()) {
- QSGPathAnimationUpdater *prevData = static_cast<QSGPathAnimationUpdater*>(d->pa->getAnimValue());
+ QQuickPathAnimationUpdater *prevData = static_cast<QQuickPathAnimationUpdater*>(d->pa->getAnimValue());
// get the original start angle that was used (so we can exactly reverse).
data->startRotation = prevData->startRotation;
}
}
-void QSGPathAnimationUpdater::setValue(qreal v)
+void QQuickPathAnimationUpdater::setValue(qreal v)
{
if (interruptStart.isValid()) {
if (reverse)
}
qreal angle;
- bool fixed = orientation == QSGPathAnimation::Fixed;
+ bool fixed = orientation == QQuickPathAnimation::Fixed;
QPointF currentPos = !painterPath.isEmpty() ? path->sequentialPointAt(painterPath, pathLength, attributePoints, prevBez, v, fixed ? 0 : &angle) : path->sequentialPointAt(v, fixed ? 0 : &angle);
//adjust position according to anchor point
//adjust angle according to orientation
if (!fixed) {
switch (orientation) {
- case QSGPathAnimation::RightFirst:
+ case QQuickPathAnimation::RightFirst:
angle = -angle;
break;
- case QSGPathAnimation::TopFirst:
+ case QQuickPathAnimation::TopFirst:
angle = -angle + 90;
break;
- case QSGPathAnimation::LeftFirst:
+ case QQuickPathAnimation::LeftFirst:
angle = -angle + 180;
break;
- case QSGPathAnimation::BottomFirst:
+ case QQuickPathAnimation::BottomFirst:
angle = -angle + 270;
break;
default:
**
****************************************************************************/
-#ifndef QSGANIMATION_H
-#define QSGANIMATION_H
+#ifndef QQUICKANIMATION_H
+#define QQUICKANIMATION_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <private/qdeclarativeanimation_p.h>
QT_MODULE(Declarative)
-class QSGParentAnimationPrivate;
-class QSGParentAnimation : public QDeclarativeAnimationGroup
+class QQuickParentAnimationPrivate;
+class QQuickParentAnimation : public QDeclarativeAnimationGroup
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGParentAnimation)
+ Q_DECLARE_PRIVATE(QQuickParentAnimation)
- Q_PROPERTY(QSGItem *target READ target WRITE setTarget NOTIFY targetChanged)
- Q_PROPERTY(QSGItem *newParent READ newParent WRITE setNewParent NOTIFY newParentChanged)
- Q_PROPERTY(QSGItem *via READ via WRITE setVia NOTIFY viaChanged)
+ Q_PROPERTY(QQuickItem *target READ target WRITE setTarget NOTIFY targetChanged)
+ Q_PROPERTY(QQuickItem *newParent READ newParent WRITE setNewParent NOTIFY newParentChanged)
+ Q_PROPERTY(QQuickItem *via READ via WRITE setVia NOTIFY viaChanged)
public:
- QSGParentAnimation(QObject *parent=0);
- virtual ~QSGParentAnimation();
+ QQuickParentAnimation(QObject *parent=0);
+ virtual ~QQuickParentAnimation();
- QSGItem *target() const;
- void setTarget(QSGItem *);
+ QQuickItem *target() const;
+ void setTarget(QQuickItem *);
- QSGItem *newParent() const;
- void setNewParent(QSGItem *);
+ QQuickItem *newParent() const;
+ void setNewParent(QQuickItem *);
- QSGItem *via() const;
- void setVia(QSGItem *);
+ QQuickItem *via() const;
+ void setVia(QQuickItem *);
Q_SIGNALS:
void targetChanged();
virtual QAbstractAnimation *qtAnimation();
};
-class QSGAnchorAnimationPrivate;
-class QSGAnchorAnimation : public QDeclarativeAbstractAnimation
+class QQuickAnchorAnimationPrivate;
+class QQuickAnchorAnimation : public QDeclarativeAbstractAnimation
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGAnchorAnimation)
- Q_PROPERTY(QDeclarativeListProperty<QSGItem> targets READ targets)
+ Q_DECLARE_PRIVATE(QQuickAnchorAnimation)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickItem> targets READ targets)
Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
Q_PROPERTY(QEasingCurve easing READ easing WRITE setEasing NOTIFY easingChanged)
public:
- QSGAnchorAnimation(QObject *parent=0);
- virtual ~QSGAnchorAnimation();
+ QQuickAnchorAnimation(QObject *parent=0);
+ virtual ~QQuickAnchorAnimation();
- QDeclarativeListProperty<QSGItem> targets();
+ QDeclarativeListProperty<QQuickItem> targets();
int duration() const;
void setDuration(int);
virtual QAbstractAnimation *qtAnimation();
};
-class QSGItem;
+class QQuickItem;
class QDeclarativePath;
-class QSGPathAnimationPrivate;
-class Q_AUTOTEST_EXPORT QSGPathAnimation : public QDeclarativeAbstractAnimation
+class QQuickPathAnimationPrivate;
+class Q_AUTOTEST_EXPORT QQuickPathAnimation : public QDeclarativeAbstractAnimation
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGPathAnimation)
+ Q_DECLARE_PRIVATE(QQuickPathAnimation)
Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
Q_PROPERTY(QEasingCurve easing READ easing WRITE setEasing NOTIFY easingChanged)
Q_PROPERTY(QDeclarativePath *path READ path WRITE setPath NOTIFY pathChanged)
- Q_PROPERTY(QSGItem *target READ target WRITE setTarget NOTIFY targetChanged)
+ Q_PROPERTY(QQuickItem *target READ target WRITE setTarget NOTIFY targetChanged)
Q_PROPERTY(Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged)
Q_PROPERTY(QPointF anchorPoint READ anchorPoint WRITE setAnchorPoint NOTIFY anchorPointChanged)
Q_PROPERTY(qreal orientationEntryInterval READ orientationEntryInterval WRITE setOrientationEntryInterval NOTIFY orientationEntryIntervalChanged)
Q_PROPERTY(qreal endRotation READ endRotation WRITE setEndRotation NOTIFY endRotationChanged)
public:
- QSGPathAnimation(QObject *parent=0);
- virtual ~QSGPathAnimation();
+ QQuickPathAnimation(QObject *parent=0);
+ virtual ~QQuickPathAnimation();
enum Orientation {
Fixed,
QDeclarativePath *path() const;
void setPath(QDeclarativePath *);
- QSGItem *target() const;
- void setTarget(QSGItem *);
+ QQuickItem *target() const;
+ void setTarget(QQuickItem *);
Orientation orientation() const;
void setOrientation(Orientation orientation);
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGParentAnimation)
-QML_DECLARE_TYPE(QSGAnchorAnimation)
-QML_DECLARE_TYPE(QSGPathAnimation)
+QML_DECLARE_TYPE(QQuickParentAnimation)
+QML_DECLARE_TYPE(QQuickAnchorAnimation)
+QML_DECLARE_TYPE(QQuickPathAnimation)
QT_END_HEADER
-#endif // QSGANIMATION_H
+#endif // QQUICKANIMATION_H
**
****************************************************************************/
-#ifndef QSGANIMATION_P_H
-#define QSGANIMATION_P_H
+#ifndef QQUICKANIMATION_P_H
+#define QQUICKANIMATION_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsganimation_p.h"
+#include "qquickanimation_p.h"
#include <private/qdeclarativepath_p.h>
#include <private/qdeclarativeanimation_p_p.h>
QT_BEGIN_NAMESPACE
-class QSGParentAnimationPrivate : public QDeclarativeAnimationGroupPrivate
+class QQuickParentAnimationPrivate : public QDeclarativeAnimationGroupPrivate
{
- Q_DECLARE_PUBLIC(QSGParentAnimation)
+ Q_DECLARE_PUBLIC(QQuickParentAnimation)
public:
- QSGParentAnimationPrivate()
+ QQuickParentAnimationPrivate()
: QDeclarativeAnimationGroupPrivate(), target(0), newParent(0),
via(0), topLevelGroup(0), startAction(0), endAction(0) {}
- QSGItem *target;
- QSGItem *newParent;
- QSGItem *via;
+ QQuickItem *target;
+ QQuickItem *newParent;
+ QQuickItem *via;
QSequentialAnimationGroup *topLevelGroup;
QActionAnimation *startAction;
QActionAnimation *endAction;
- QPointF computeTransformOrigin(QSGItem::TransformOrigin origin, qreal width, qreal height) const;
+ QPointF computeTransformOrigin(QQuickItem::TransformOrigin origin, qreal width, qreal height) const;
};
-class QSGAnchorAnimationPrivate : public QDeclarativeAbstractAnimationPrivate
+class QQuickAnchorAnimationPrivate : public QDeclarativeAbstractAnimationPrivate
{
- Q_DECLARE_PUBLIC(QSGAnchorAnimation)
+ Q_DECLARE_PUBLIC(QQuickAnchorAnimation)
public:
- QSGAnchorAnimationPrivate() : rangeIsSet(false), va(0),
+ QQuickAnchorAnimationPrivate() : rangeIsSet(false), va(0),
interpolator(QVariantAnimationPrivate::getInterpolator(QMetaType::QReal)) {}
bool rangeIsSet;
QDeclarativeBulkValueAnimator *va;
QVariantAnimation::Interpolator interpolator;
- QList<QSGItem*> targets;
+ QList<QQuickItem*> targets;
};
-class QSGPathAnimationUpdater : public QDeclarativeBulkValueUpdater
+class QQuickPathAnimationUpdater : public QDeclarativeBulkValueUpdater
{
public:
- QSGPathAnimationUpdater() : path(0), target(0), reverse(false),
+ QQuickPathAnimationUpdater() : path(0), target(0), reverse(false),
fromSourced(false), fromDefined(false), toDefined(false),
- toX(0), toY(0), currentV(0), orientation(QSGPathAnimation::Fixed),
+ toX(0), toY(0), currentV(0), orientation(QQuickPathAnimation::Fixed),
entryInterval(0), exitInterval(0) {}
- ~QSGPathAnimationUpdater() {}
+ ~QQuickPathAnimationUpdater() {}
void setValue(qreal v);
qreal pathLength;
QList<QDeclarativePath::AttributePoint> attributePoints;
- QSGItem *target;
+ QQuickItem *target;
bool reverse;
bool fromSourced;
bool fromDefined;
qreal currentV;
QDeclarativeNullableValue<qreal> interruptStart;
//TODO: bundle below into common struct
- QSGPathAnimation::Orientation orientation;
+ QQuickPathAnimation::Orientation orientation;
QPointF anchorPoint;
qreal entryInterval;
qreal exitInterval;
QDeclarativeNullableValue<qreal> startRotation;
};
-class QSGPathAnimationPrivate : public QDeclarativeAbstractAnimationPrivate
+class QQuickPathAnimationPrivate : public QDeclarativeAbstractAnimationPrivate
{
- Q_DECLARE_PUBLIC(QSGPathAnimation)
+ Q_DECLARE_PUBLIC(QQuickPathAnimation)
public:
- QSGPathAnimationPrivate() : path(0), target(0),
- rangeIsSet(false), orientation(QSGPathAnimation::Fixed), entryInterval(0), exitInterval(0), pa(0) {}
+ QQuickPathAnimationPrivate() : path(0), target(0),
+ rangeIsSet(false), orientation(QQuickPathAnimation::Fixed), entryInterval(0), exitInterval(0), pa(0) {}
QDeclarativePath *path;
- QSGItem *target;
+ QQuickItem *target;
bool rangeIsSet;
- QSGPathAnimation::Orientation orientation;
+ QQuickPathAnimation::Orientation orientation;
QPointF anchorPoint;
qreal entryInterval;
qreal exitInterval;
QT_END_NAMESPACE
-#endif // QSGANIMATION_P_H
+#endif // QQUICKANIMATION_P_H
**
****************************************************************************/
-#include "qsgborderimage_p.h"
-#include "qsgborderimage_p_p.h"
-#include "qsgninepatchnode_p.h"
+#include "qquickborderimage_p.h"
+#include "qquickborderimage_p_p.h"
+#include "qquickninepatchnode_p.h"
#include <QtDeclarative/qdeclarativeinfo.h>
#include <QtCore/qfile.h>
/*!
- \qmlclass BorderImage QSGBorderImage
+ \qmlclass BorderImage QQuickBorderImage
\inqmlmodule QtQuick 2
\brief The BorderImage element provides an image that can be used as a border.
\inherits Item
local filesystem. Images loaded via a network resource (e.g. HTTP)
are always loaded asynchonously.
*/
-QSGBorderImage::QSGBorderImage(QSGItem *parent)
-: QSGImageBase(*(new QSGBorderImagePrivate), parent)
+QQuickBorderImage::QQuickBorderImage(QQuickItem *parent)
+: QQuickImageBase(*(new QQuickBorderImagePrivate), parent)
{
}
-QSGBorderImage::~QSGBorderImage()
+QQuickBorderImage::~QQuickBorderImage()
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
if (d->sciReply)
d->sciReply->deleteLater();
}
\sa Image::sourceSize
*/
-void QSGBorderImage::setSource(const QUrl &url)
+void QQuickBorderImage::setSource(const QUrl &url)
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
//equality is fairly expensive, so we bypass for simple, common case
if ((d->url.isEmpty() == url.isEmpty()) && url == d->url)
return;
load();
}
-void QSGBorderImage::load()
+void QQuickBorderImage::load()
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
if (d->progress != 0.0) {
d->progress = 0.0;
emit progressChanged(d->progress);
if (!lf.isEmpty()) {
QFile file(lf);
file.open(QIODevice::ReadOnly);
- setGridScaledImage(QSGGridScaledImage(&file));
+ setGridScaledImage(QQuickGridScaledImage(&file));
} else {
QNetworkRequest req(d->url);
d->sciReply = qmlEngine(this)->networkAccessManager()->get(req);
\l {BorderImage::source}{.sci file}.
*/
-QSGScaleGrid *QSGBorderImage::border()
+QQuickScaleGrid *QQuickBorderImage::border()
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
return d->getScaleGrid();
}
The default tile mode for each property is BorderImage.Stretch.
*/
-QSGBorderImage::TileMode QSGBorderImage::horizontalTileMode() const
+QQuickBorderImage::TileMode QQuickBorderImage::horizontalTileMode() const
{
- Q_D(const QSGBorderImage);
+ Q_D(const QQuickBorderImage);
return d->horizontalTileMode;
}
-void QSGBorderImage::setHorizontalTileMode(TileMode t)
+void QQuickBorderImage::setHorizontalTileMode(TileMode t)
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
if (t != d->horizontalTileMode) {
d->horizontalTileMode = t;
emit horizontalTileModeChanged();
}
}
-QSGBorderImage::TileMode QSGBorderImage::verticalTileMode() const
+QQuickBorderImage::TileMode QQuickBorderImage::verticalTileMode() const
{
- Q_D(const QSGBorderImage);
+ Q_D(const QQuickBorderImage);
return d->verticalTileMode;
}
-void QSGBorderImage::setVerticalTileMode(TileMode t)
+void QQuickBorderImage::setVerticalTileMode(TileMode t)
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
if (t != d->verticalTileMode) {
d->verticalTileMode = t;
emit verticalTileModeChanged();
}
}
-void QSGBorderImage::setGridScaledImage(const QSGGridScaledImage& sci)
+void QQuickBorderImage::setGridScaledImage(const QQuickGridScaledImage& sci)
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
if (!sci.isValid()) {
d->status = Error;
emit statusChanged(d->status);
} else {
- QSGScaleGrid *sg = border();
+ QQuickScaleGrid *sg = border();
sg->setTop(sci.gridTop());
sg->setBottom(sci.gridBottom());
sg->setLeft(sci.gridLeft());
static int thisRequestFinished = -1;
if (thisRequestProgress == -1) {
thisRequestProgress =
- QSGBorderImage::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)");
+ QQuickBorderImage::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)");
thisRequestFinished =
- QSGBorderImage::staticMetaObject.indexOfSlot("requestFinished()");
+ QQuickBorderImage::staticMetaObject.indexOfSlot("requestFinished()");
}
d->pix.connectFinished(this, thisRequestFinished);
}
}
-void QSGBorderImage::requestFinished()
+void QQuickBorderImage::requestFinished()
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
QSize impsize = d->pix.implicitSize();
if (d->pix.isError()) {
#define BORDERIMAGE_MAX_REDIRECT 16
-void QSGBorderImage::sciRequestFinished()
+void QQuickBorderImage::sciRequestFinished()
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
d->redirectCount++;
if (d->redirectCount < BORDERIMAGE_MAX_REDIRECT) {
d->sciReply = 0;
emit statusChanged(d->status);
} else {
- QSGGridScaledImage sci(d->sciReply);
+ QQuickGridScaledImage sci(d->sciReply);
d->sciReply->deleteLater();
d->sciReply = 0;
setGridScaledImage(sci);
}
}
-void QSGBorderImage::doUpdate()
+void QQuickBorderImage::doUpdate()
{
update();
}
-QSGNode *QSGBorderImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickBorderImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
QSGTexture *texture = d->pix.texture(d->sceneGraphContext());
return 0;
}
- QSGNinePatchNode *node = static_cast<QSGNinePatchNode *>(oldNode);
+ QQuickNinePatchNode *node = static_cast<QQuickNinePatchNode *>(oldNode);
if (!node) {
- node = new QSGNinePatchNode();
+ node = new QQuickNinePatchNode();
}
node->setTexture(texture);
// Don't implicitly create the scalegrid in the rendering thread...
if (d->border) {
- const QSGScaleGrid *border = d->getScaleGrid();
+ const QQuickScaleGrid *border = d->getScaleGrid();
node->setInnerRect(QRectF(border->left(),
border->top(),
qMax(1, d->pix.width() - border->right() - border->left()),
return node;
}
-void QSGBorderImage::pixmapChange()
+void QQuickBorderImage::pixmapChange()
{
- Q_D(QSGBorderImage);
+ Q_D(QQuickBorderImage);
d->pixmapChanged = true;
}
**
****************************************************************************/
-#ifndef QSGBORDERIMAGE_P_H
-#define QSGBORDERIMAGE_P_H
+#ifndef QQUICKBORDERIMAGE_P_H
+#define QQUICKBORDERIMAGE_P_H
-#include "qsgimagebase_p.h"
+#include "qquickimagebase_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class QSGScaleGrid;
-class QSGGridScaledImage;
-class QSGBorderImagePrivate;
-class Q_AUTOTEST_EXPORT QSGBorderImage : public QSGImageBase
+class QQuickScaleGrid;
+class QQuickGridScaledImage;
+class QQuickBorderImagePrivate;
+class Q_AUTOTEST_EXPORT QQuickBorderImage : public QQuickImageBase
{
Q_OBJECT
Q_ENUMS(TileMode)
- Q_PROPERTY(QSGScaleGrid *border READ border CONSTANT)
+ Q_PROPERTY(QQuickScaleGrid *border READ border CONSTANT)
Q_PROPERTY(TileMode horizontalTileMode READ horizontalTileMode WRITE setHorizontalTileMode NOTIFY horizontalTileModeChanged)
Q_PROPERTY(TileMode verticalTileMode READ verticalTileMode WRITE setVerticalTileMode NOTIFY verticalTileModeChanged)
// read-only for BorderImage
Q_PROPERTY(QSize sourceSize READ sourceSize NOTIFY sourceSizeChanged)
public:
- QSGBorderImage(QSGItem *parent=0);
- ~QSGBorderImage();
+ QQuickBorderImage(QQuickItem *parent=0);
+ ~QQuickBorderImage();
- QSGScaleGrid *border();
+ QQuickScaleGrid *border();
enum TileMode { Stretch = Qt::StretchTile, Repeat = Qt::RepeatTile, Round = Qt::RoundTile };
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
private:
- void setGridScaledImage(const QSGGridScaledImage& sci);
+ void setGridScaledImage(const QQuickGridScaledImage& sci);
private Q_SLOTS:
void doUpdate();
void sciRequestFinished();
private:
- Q_DISABLE_COPY(QSGBorderImage)
- Q_DECLARE_PRIVATE(QSGBorderImage)
+ Q_DISABLE_COPY(QQuickBorderImage)
+ Q_DECLARE_PRIVATE(QQuickBorderImage)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGBorderImage)
+QML_DECLARE_TYPE(QQuickBorderImage)
QT_END_HEADER
-#endif // QSGBORDERIMAGE_P_H
+#endif // QQUICKBORDERIMAGE_P_H
**
****************************************************************************/
-#ifndef QSGBORDERIMAGE_P_P_H
-#define QSGBORDERIMAGE_P_P_H
+#ifndef QQUICKBORDERIMAGE_P_P_H
+#define QQUICKBORDERIMAGE_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgimagebase_p_p.h"
-#include "qsgscalegrid_p_p.h"
+#include "qquickimagebase_p_p.h"
+#include "qquickscalegrid_p_p.h"
QT_BEGIN_NAMESPACE
class QNetworkReply;
-class QSGBorderImagePrivate : public QSGImageBasePrivate
+class QQuickBorderImagePrivate : public QQuickImageBasePrivate
{
- Q_DECLARE_PUBLIC(QSGBorderImage)
+ Q_DECLARE_PUBLIC(QQuickBorderImage)
public:
- QSGBorderImagePrivate()
+ QQuickBorderImagePrivate()
: border(0), sciReply(0),
- horizontalTileMode(QSGBorderImage::Stretch),
- verticalTileMode(QSGBorderImage::Stretch),
+ horizontalTileMode(QQuickBorderImage::Stretch),
+ verticalTileMode(QQuickBorderImage::Stretch),
redirectCount(0), pixmapChanged(false)
{
}
- ~QSGBorderImagePrivate()
+ ~QQuickBorderImagePrivate()
{
}
- QSGScaleGrid *getScaleGrid()
+ QQuickScaleGrid *getScaleGrid()
{
- Q_Q(QSGBorderImage);
+ Q_Q(QQuickBorderImage);
if (!border) {
- border = new QSGScaleGrid(q);
+ border = new QQuickScaleGrid(q);
FAST_CONNECT(border, SIGNAL(borderChanged()), q, SLOT(doUpdate()))
}
return border;
}
- QSGScaleGrid *border;
+ QQuickScaleGrid *border;
QUrl sciurl;
QNetworkReply *sciReply;
- QSGBorderImage::TileMode horizontalTileMode;
- QSGBorderImage::TileMode verticalTileMode;
+ QQuickBorderImage::TileMode horizontalTileMode;
+ QQuickBorderImage::TileMode verticalTileMode;
int redirectCount;
bool pixmapChanged : 1;
QT_END_NAMESPACE
-#endif // QSGBORDERIMAGE_P_P_H
+#endif // QQUICKBORDERIMAGE_P_P_H
**
****************************************************************************/
-#include "qsgcanvas.h"
-#include "qsgcanvas_p.h"
+#include "qquickcanvas.h"
+#include "qquickcanvas_p.h"
-#include "qsgitem.h"
-#include "qsgitem_p.h"
+#include "qquickitem.h"
+#include "qquickitem_p.h"
#include <private/qsgrenderer_p.h>
#include <private/qsgflashnode_p.h>
QT_BEGIN_NAMESPACE
-#define QSG_CANVAS_TIMING
-#ifdef QSG_CANVAS_TIMING
-static bool qsg_canvas_timing = !qgetenv("QML_CANVAS_TIMING").isEmpty();
+#define QQUICK_CANVAS_TIMING
+#ifdef QQUICK_CANVAS_TIMING
+static bool qquick_canvas_timing = !qgetenv("QML_CANVAS_TIMING").isEmpty();
static QTime threadTimer;
static int syncTime;
static int renderTime;
extern Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha);
-void QSGCanvasPrivate::updateFocusItemTransform()
+void QQuickCanvasPrivate::updateFocusItemTransform()
{
- Q_Q(QSGCanvas);
- QSGItem *focus = q->activeFocusItem();
+ Q_Q(QQuickCanvas);
+ QQuickItem *focus = q->activeFocusItem();
if (focus && qApp->inputPanel()->inputItem() == focus)
- qApp->inputPanel()->setInputItemTransform(QSGItemPrivate::get(focus)->itemToCanvasTransform());
+ qApp->inputPanel()->setInputItemTransform(QQuickItemPrivate::get(focus)->itemToCanvasTransform());
}
-class QSGCanvasIncubationController : public QObject, public QDeclarativeIncubationController
+class QQuickCanvasIncubationController : public QObject, public QDeclarativeIncubationController
{
public:
- QSGCanvasIncubationController(QSGCanvasPrivate *canvas)
+ QQuickCanvasIncubationController(QQuickCanvasPrivate *canvas)
: m_canvas(canvas), m_eventSent(false) {}
protected:
}
private:
- QSGCanvasPrivate *m_canvas;
+ QQuickCanvasPrivate *m_canvas;
bool m_eventSent;
};
-class QSGCanvasPlainRenderLoop : public QObject, public QSGCanvasRenderLoop
+class QQuickCanvasPlainRenderLoop : public QObject, public QQuickCanvasRenderLoop
{
public:
- QSGCanvasPlainRenderLoop()
+ QQuickCanvasPlainRenderLoop()
: updatePending(false)
, animationRunning(false)
{
- qWarning("QSGCanvas: using non-threaded render loop. Be very sure to not access scene graph "
- "objects outside the QSGItem::updatePaintNode() call. Failing to do so will cause "
+ qWarning("QQuickCanvas: using non-threaded render loop. Be very sure to not access scene graph "
+ "objects outside the QQuickItem::updatePaintNode() call. Failing to do so will cause "
"your code to crash on other platforms!");
}
int readbackTime;
#endif
-QSGItem::UpdatePaintNodeData::UpdatePaintNodeData()
+QQuickItem::UpdatePaintNodeData::UpdatePaintNodeData()
: transformNode(0)
{
}
-QSGRootItem::QSGRootItem()
+QQuickRootItem::QQuickRootItem()
{
}
-void QSGCanvas::exposeEvent(QExposeEvent *)
+void QQuickCanvas::exposeEvent(QExposeEvent *)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
d->thread->paint();
}
-void QSGCanvas::resizeEvent(QResizeEvent *)
+void QQuickCanvas::resizeEvent(QResizeEvent *)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
d->thread->resize(size());
}
-void QSGCanvas::animationStarted()
+void QQuickCanvas::animationStarted()
{
d_func()->thread->animationStarted();
}
-void QSGCanvas::animationStopped()
+void QQuickCanvas::animationStopped()
{
d_func()->thread->animationStopped();
}
-void QSGCanvas::showEvent(QShowEvent *)
+void QQuickCanvas::showEvent(QShowEvent *)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->vsyncAnimations) {
if (!d->animationDriver) {
d->animationDriver = d->context->createAnimationDriver(this);
}
}
-void QSGCanvas::hideEvent(QHideEvent *)
+void QQuickCanvas::hideEvent(QHideEvent *)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
d->thread->stopRendering();
}
/*!
Sets weither this canvas should use vsync driven animations.
- This option can only be set on one single QSGCanvas, and that it's
+ This option can only be set on one single QQuickCanvas, and that it's
vsync signal will then be used to drive all animations in the
process.
- This feature is primarily useful for single QSGCanvas, QML-only
+ This feature is primarily useful for single QQuickCanvas, QML-only
applications.
- \warning Enabling vsync on multiple QSGCanvas instances has
+ \warning Enabling vsync on multiple QQuickCanvas instances has
undefined behavior.
*/
-void QSGCanvas::setVSyncAnimations(bool enabled)
+void QQuickCanvas::setVSyncAnimations(bool enabled)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (visible()) {
- qWarning("QSGCanvas::setVSyncAnimations: Cannot be changed when widget is shown");
+ qWarning("QQuickCanvas::setVSyncAnimations: Cannot be changed when widget is shown");
return;
}
d->vsyncAnimations = enabled;
Returns true if this canvas should use vsync driven animations;
otherwise returns false.
*/
-bool QSGCanvas::vsyncAnimations() const
+bool QQuickCanvas::vsyncAnimations() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
return d->vsyncAnimations;
}
-void QSGCanvasPrivate::initializeSceneGraph()
+void QQuickCanvasPrivate::initializeSceneGraph()
{
if (!context)
context = QSGContext::createDefaultContext();
QOpenGLContext *glctx = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
context->initialize(glctx);
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
QObject::connect(context->renderer(), SIGNAL(sceneGraphChanged()), q, SLOT(maybeUpdate()),
Qt::DirectConnection);
- if (!QSGItemPrivate::get(rootItem)->itemNode()->parent()) {
- context->rootNode()->appendChildNode(QSGItemPrivate::get(rootItem)->itemNode());
+ if (!QQuickItemPrivate::get(rootItem)->itemNode()->parent()) {
+ context->rootNode()->appendChildNode(QQuickItemPrivate::get(rootItem)->itemNode());
}
emit q_func()->sceneGraphInitialized();
}
-void QSGCanvasPrivate::polishItems()
+void QQuickCanvasPrivate::polishItems()
{
while (!itemsToPolish.isEmpty()) {
- QSet<QSGItem *>::Iterator iter = itemsToPolish.begin();
- QSGItem *item = *iter;
+ QSet<QQuickItem *>::Iterator iter = itemsToPolish.begin();
+ QQuickItem *item = *iter;
itemsToPolish.erase(iter);
- QSGItemPrivate::get(item)->polishScheduled = false;
+ QQuickItemPrivate::get(item)->polishScheduled = false;
item->updatePolish();
}
updateFocusItemTransform();
}
-void QSGCanvasPrivate::syncSceneGraph()
+void QQuickCanvasPrivate::syncSceneGraph()
{
updateDirtyNodes();
}
-void QSGCanvasPrivate::renderSceneGraph(const QSize &size)
+void QQuickCanvasPrivate::renderSceneGraph(const QSize &size)
{
context->renderer()->setDeviceRect(QRect(QPoint(0, 0), size));
context->renderer()->setViewportRect(QRect(QPoint(0, 0), renderTarget ? renderTarget->size() : size));
// ### Do we need this?
-void QSGCanvas::sceneGraphChanged()
+void QQuickCanvas::sceneGraphChanged()
{
-// Q_D(QSGCanvas);
+// Q_D(QQuickCanvas);
// d->needsRepaint = true;
}
-QSGCanvasPrivate::QSGCanvasPrivate()
+QQuickCanvasPrivate::QQuickCanvasPrivate()
: rootItem(0)
, activeFocusItem(0)
, mouseGrabberItem(0)
{
}
-QSGCanvasPrivate::~QSGCanvasPrivate()
+QQuickCanvasPrivate::~QQuickCanvasPrivate()
{
}
-void QSGCanvasPrivate::init(QSGCanvas *c)
+void QQuickCanvasPrivate::init(QQuickCanvas *c)
{
QUnifiedTimer::instance(true)->setConsistentTiming(qmlFixedAnimationStep());
q_ptr = c;
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
- rootItem = new QSGRootItem;
- QSGItemPrivate *rootItemPrivate = QSGItemPrivate::get(rootItem);
+ rootItem = new QQuickRootItem;
+ QQuickItemPrivate *rootItemPrivate = QQuickItemPrivate::get(rootItem);
rootItemPrivate->canvas = q;
- rootItemPrivate->flags |= QSGItem::ItemIsFocusScope;
+ rootItemPrivate->flags |= QQuickItem::ItemIsFocusScope;
// QML always has focus. It is important that this call happens after the rootItem
// has a canvas..
bool threaded = !qmlNoThreadedRenderer();
if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL)) {
- qWarning("QSGCanvas: platform does not support threaded rendering!");
+ qWarning("QQuickCanvas: platform does not support threaded rendering!");
threaded = false;
}
if (threaded)
- thread = new QSGCanvasRenderThread();
+ thread = new QQuickCanvasRenderThread();
else
- thread = new QSGCanvasPlainRenderLoop();
+ thread = new QQuickCanvasPlainRenderLoop();
thread->renderer = q;
thread->d = this;
q->setFormat(context->defaultSurfaceFormat());
}
-void QSGCanvasPrivate::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform)
+void QQuickCanvasPrivate::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform)
{
for (int i=0; i<touchPoints.count(); i++) {
QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
Translates the data in \a touchEvent to this canvas. This method leaves the item local positions in
\a touchEvent untouched (these are filled in later).
*/
-void QSGCanvasPrivate::translateTouchEvent(QTouchEvent *touchEvent)
+void QQuickCanvasPrivate::translateTouchEvent(QTouchEvent *touchEvent)
{
-// Q_Q(QSGCanvas);
+// Q_Q(QQuickCanvas);
// touchEvent->setWidget(q); // ### refactor...
touchEvent->setTouchPoints(touchPoints);
}
-void QSGCanvasPrivate::setFocusInScope(QSGItem *scope, QSGItem *item, FocusOptions options)
+void QQuickCanvasPrivate::setFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions options)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
Q_ASSERT(item);
Q_ASSERT(scope || item == rootItem);
#ifdef FOCUS_DEBUG
- qWarning() << "QSGCanvasPrivate::setFocusInScope():";
+ qWarning() << "QQuickCanvasPrivate::setFocusInScope():";
qWarning() << " scope:" << (QObject *)scope;
if (scope)
- qWarning() << " scopeSubFocusItem:" << (QObject *)QSGItemPrivate::get(scope)->subFocusItem;
+ qWarning() << " scopeSubFocusItem:" << (QObject *)QQuickItemPrivate::get(scope)->subFocusItem;
qWarning() << " item:" << (QObject *)item;
qWarning() << " activeFocusItem:" << (QObject *)activeFocusItem;
#endif
- QSGItemPrivate *scopePrivate = scope ? QSGItemPrivate::get(scope) : 0;
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ QQuickItemPrivate *scopePrivate = scope ? QQuickItemPrivate::get(scope) : 0;
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- QSGItem *oldActiveFocusItem = 0;
- QSGItem *newActiveFocusItem = 0;
+ QQuickItem *oldActiveFocusItem = 0;
+ QQuickItem *newActiveFocusItem = 0;
- QVarLengthArray<QSGItem *, 20> changed;
+ QVarLengthArray<QQuickItem *, 20> changed;
// Does this change the active focus?
if (item == rootItem || scopePrivate->activeFocus) {
QFocusEvent event(QEvent::FocusOut, Qt::OtherFocusReason);
q->sendEvent(oldActiveFocusItem, &event);
- QSGItem *afi = oldActiveFocusItem;
+ QQuickItem *afi = oldActiveFocusItem;
while (afi != scope) {
- if (QSGItemPrivate::get(afi)->activeFocus) {
- QSGItemPrivate::get(afi)->activeFocus = false;
+ if (QQuickItemPrivate::get(afi)->activeFocus) {
+ QQuickItemPrivate::get(afi)->activeFocus = false;
changed << afi;
}
afi = afi->parentItem();
}
if (item != rootItem) {
- QSGItem *oldSubFocusItem = scopePrivate->subFocusItem;
+ QQuickItem *oldSubFocusItem = scopePrivate->subFocusItem;
// Correct focus chain in scope
if (oldSubFocusItem) {
- QSGItem *sfi = scopePrivate->subFocusItem->parentItem();
+ QQuickItem *sfi = scopePrivate->subFocusItem->parentItem();
while (sfi != scope) {
- QSGItemPrivate::get(sfi)->subFocusItem = 0;
+ QQuickItemPrivate::get(sfi)->subFocusItem = 0;
sfi = sfi->parentItem();
}
}
{
scopePrivate->subFocusItem = item;
- QSGItem *sfi = scopePrivate->subFocusItem->parentItem();
+ QQuickItem *sfi = scopePrivate->subFocusItem->parentItem();
while (sfi != scope) {
- QSGItemPrivate::get(sfi)->subFocusItem = item;
+ QQuickItemPrivate::get(sfi)->subFocusItem = item;
sfi = sfi->parentItem();
}
}
if (oldSubFocusItem) {
- QSGItemPrivate::get(oldSubFocusItem)->focus = false;
+ QQuickItemPrivate::get(oldSubFocusItem)->focus = false;
changed << oldSubFocusItem;
}
}
if (newActiveFocusItem) { // ### refactor: && q->hasFocus()) {
activeFocusItem = newActiveFocusItem;
- QSGItemPrivate::get(newActiveFocusItem)->activeFocus = true;
+ QQuickItemPrivate::get(newActiveFocusItem)->activeFocus = true;
changed << newActiveFocusItem;
- QSGItem *afi = newActiveFocusItem->parentItem();
+ QQuickItem *afi = newActiveFocusItem->parentItem();
while (afi && afi != scope) {
if (afi->isFocusScope()) {
- QSGItemPrivate::get(afi)->activeFocus = true;
+ QQuickItemPrivate::get(afi)->activeFocus = true;
changed << afi;
}
afi = afi->parentItem();
notifyFocusChangesRecur(changed.data(), changed.count() - 1);
}
-void QSGCanvasPrivate::clearFocusInScope(QSGItem *scope, QSGItem *item, FocusOptions options)
+void QQuickCanvasPrivate::clearFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions options)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
Q_UNUSED(item);
Q_ASSERT(item);
Q_ASSERT(scope || item == rootItem);
#ifdef FOCUS_DEBUG
- qWarning() << "QSGCanvasPrivate::clearFocusInScope():";
+ qWarning() << "QQuickCanvasPrivate::clearFocusInScope():";
qWarning() << " scope:" << (QObject *)scope;
qWarning() << " item:" << (QObject *)item;
qWarning() << " activeFocusItem:" << (QObject *)activeFocusItem;
#endif
- QSGItemPrivate *scopePrivate = scope ? QSGItemPrivate::get(scope) : 0;
+ QQuickItemPrivate *scopePrivate = scope ? QQuickItemPrivate::get(scope) : 0;
- QSGItem *oldActiveFocusItem = 0;
- QSGItem *newActiveFocusItem = 0;
+ QQuickItem *oldActiveFocusItem = 0;
+ QQuickItem *newActiveFocusItem = 0;
- QVarLengthArray<QSGItem *, 20> changed;
+ QVarLengthArray<QQuickItem *, 20> changed;
Q_ASSERT(item == rootItem || item == scopePrivate->subFocusItem);
QFocusEvent event(QEvent::FocusOut, Qt::OtherFocusReason);
q->sendEvent(oldActiveFocusItem, &event);
- QSGItem *afi = oldActiveFocusItem;
+ QQuickItem *afi = oldActiveFocusItem;
while (afi != scope) {
- if (QSGItemPrivate::get(afi)->activeFocus) {
- QSGItemPrivate::get(afi)->activeFocus = false;
+ if (QQuickItemPrivate::get(afi)->activeFocus) {
+ QQuickItemPrivate::get(afi)->activeFocus = false;
changed << afi;
}
afi = afi->parentItem();
}
if (item != rootItem) {
- QSGItem *oldSubFocusItem = scopePrivate->subFocusItem;
+ QQuickItem *oldSubFocusItem = scopePrivate->subFocusItem;
// Correct focus chain in scope
if (oldSubFocusItem) {
- QSGItem *sfi = scopePrivate->subFocusItem->parentItem();
+ QQuickItem *sfi = scopePrivate->subFocusItem->parentItem();
while (sfi != scope) {
- QSGItemPrivate::get(sfi)->subFocusItem = 0;
+ QQuickItemPrivate::get(sfi)->subFocusItem = 0;
sfi = sfi->parentItem();
}
}
scopePrivate->subFocusItem = 0;
if (oldSubFocusItem && !(options & DontChangeFocusProperty)) {
- QSGItemPrivate::get(oldSubFocusItem)->focus = false;
+ QQuickItemPrivate::get(oldSubFocusItem)->focus = false;
changed << oldSubFocusItem;
}
} else if (!(options & DontChangeFocusProperty)) {
- QSGItemPrivate::get(item)->focus = false;
+ QQuickItemPrivate::get(item)->focus = false;
changed << item;
}
notifyFocusChangesRecur(changed.data(), changed.count() - 1);
}
-void QSGCanvasPrivate::notifyFocusChangesRecur(QSGItem **items, int remaining)
+void QQuickCanvasPrivate::notifyFocusChangesRecur(QQuickItem **items, int remaining)
{
- QDeclarativeGuard<QSGItem> item(*items);
+ QDeclarativeGuard<QQuickItem> item(*items);
if (remaining)
notifyFocusChangesRecur(items + 1, remaining - 1);
if (item) {
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->notifiedFocus != itemPrivate->focus) {
itemPrivate->notifiedFocus = itemPrivate->focus;
if (item && itemPrivate->notifiedActiveFocus != itemPrivate->activeFocus) {
itemPrivate->notifiedActiveFocus = itemPrivate->activeFocus;
- itemPrivate->itemChange(QSGItem::ItemActiveFocusHasChanged, itemPrivate->activeFocus);
+ itemPrivate->itemChange(QQuickItem::ItemActiveFocusHasChanged, itemPrivate->activeFocus);
emit item->activeFocusChanged(itemPrivate->activeFocus);
}
}
}
-void QSGCanvasPrivate::updateInputMethodData()
+void QQuickCanvasPrivate::updateInputMethodData()
{
- QSGItem *inputItem = 0;
- if (activeFocusItem && activeFocusItem->flags() & QSGItem::ItemAcceptsInputMethod)
+ QQuickItem *inputItem = 0;
+ if (activeFocusItem && activeFocusItem->flags() & QQuickItem::ItemAcceptsInputMethod)
inputItem = activeFocusItem;
qApp->inputPanel()->setInputItem(inputItem);
}
-QVariant QSGCanvas::inputMethodQuery(Qt::InputMethodQuery query) const
+QVariant QQuickCanvas::inputMethodQuery(Qt::InputMethodQuery query) const
{
- Q_D(const QSGCanvas);
- if (!d->activeFocusItem || !(QSGItemPrivate::get(d->activeFocusItem)->flags & QSGItem::ItemAcceptsInputMethod))
+ Q_D(const QQuickCanvas);
+ if (!d->activeFocusItem || !(QQuickItemPrivate::get(d->activeFocusItem)->flags & QQuickItem::ItemAcceptsInputMethod))
return QVariant();
QVariant value = d->activeFocusItem->inputMethodQuery(query);
//map geometry types
QVariant::Type type = value.type();
if (type == QVariant::RectF || type == QVariant::Rect) {
- const QTransform transform = QSGItemPrivate::get(d->activeFocusItem)->itemToCanvasTransform();
+ const QTransform transform = QQuickItemPrivate::get(d->activeFocusItem)->itemToCanvasTransform();
value = transform.mapRect(value.toRectF());
} else if (type == QVariant::PointF || type == QVariant::Point) {
- const QTransform transform = QSGItemPrivate::get(d->activeFocusItem)->itemToCanvasTransform();
+ const QTransform transform = QQuickItemPrivate::get(d->activeFocusItem)->itemToCanvasTransform();
value = transform.map(value.toPointF());
}
return value;
}
-void QSGCanvasPrivate::dirtyItem(QSGItem *)
+void QQuickCanvasPrivate::dirtyItem(QQuickItem *)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
q->maybeUpdate();
}
-void QSGCanvasPrivate::cleanup(QSGNode *n)
+void QQuickCanvasPrivate::cleanup(QSGNode *n)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
Q_ASSERT(!cleanupNodeList.contains(n));
cleanupNodeList.append(n);
}
-QSGCanvas::QSGCanvas(QWindow *parent)
- : QWindow(*(new QSGCanvasPrivate), parent)
+QQuickCanvas::QQuickCanvas(QWindow *parent)
+ : QWindow(*(new QQuickCanvasPrivate), parent)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
d->init(this);
}
-QSGCanvas::QSGCanvas(QSGCanvasPrivate &dd, QWindow *parent)
+QQuickCanvas::QQuickCanvas(QQuickCanvasPrivate &dd, QWindow *parent)
: QWindow(dd, parent)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
d->init(this);
}
-QSGCanvas::~QSGCanvas()
+QQuickCanvas::~QQuickCanvas()
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->thread->isRunning()) {
d->thread->stopRendering();
d->thread = 0;
}
- // ### should we change ~QSGItem to handle this better?
+ // ### should we change ~QQuickItem to handle this better?
// manually cleanup for the root item (item destructor only handles these when an item is parented)
- QSGItemPrivate *rootItemPrivate = QSGItemPrivate::get(d->rootItem);
+ QQuickItemPrivate *rootItemPrivate = QQuickItemPrivate::get(d->rootItem);
rootItemPrivate->removeFromDirtyList();
delete d->incubationController; d->incubationController = 0;
d->cleanupNodes();
}
-QSGItem *QSGCanvas::rootItem() const
+QQuickItem *QQuickCanvas::rootItem() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
return d->rootItem;
}
-QSGItem *QSGCanvas::activeFocusItem() const
+QQuickItem *QQuickCanvas::activeFocusItem() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
return d->activeFocusItem;
}
-QSGItem *QSGCanvas::mouseGrabberItem() const
+QQuickItem *QQuickCanvas::mouseGrabberItem() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
return d->mouseGrabberItem;
}
-bool QSGCanvasPrivate::clearHover()
+bool QQuickCanvasPrivate::clearHover()
{
if (hoverItems.isEmpty())
return false;
QPointF pos = QCursor::pos(); // ### refactor: q->mapFromGlobal(QCursor::pos());
bool accepted = false;
- foreach (QSGItem* item, hoverItems)
+ foreach (QQuickItem* item, hoverItems)
accepted = sendHoverEvent(QEvent::HoverLeave, item, pos, pos, QGuiApplication::keyboardModifiers(), true) || accepted;
hoverItems.clear();
return accepted;
}
-bool QSGCanvas::event(QEvent *e)
+bool QQuickCanvas::event(QEvent *e)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
switch (e->type()) {
return QWindow::event(e);
}
-void QSGCanvas::keyPressEvent(QKeyEvent *e)
+void QQuickCanvas::keyPressEvent(QKeyEvent *e)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->activeFocusItem)
sendEvent(d->activeFocusItem, e);
}
-void QSGCanvas::keyReleaseEvent(QKeyEvent *e)
+void QQuickCanvas::keyReleaseEvent(QKeyEvent *e)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->activeFocusItem)
sendEvent(d->activeFocusItem, e);
}
-void QSGCanvas::inputMethodEvent(QInputMethodEvent *e)
+void QQuickCanvas::inputMethodEvent(QInputMethodEvent *e)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->activeFocusItem)
sendEvent(d->activeFocusItem, e);
}
-bool QSGCanvasPrivate::deliverInitialMousePressEvent(QSGItem *item, QMouseEvent *event)
+bool QQuickCanvasPrivate::deliverInitialMousePressEvent(QQuickItem *item, QMouseEvent *event)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->opacity == 0.0)
return false;
- if (itemPrivate->flags & QSGItem::ItemClipsChildrenToShape) {
+ if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
QPointF p = item->mapFromScene(event->windowPos());
if (!QRectF(0, 0, item->width(), item->height()).contains(p))
return false;
}
- QList<QSGItem *> children = itemPrivate->paintOrderChildItems();
+ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
for (int ii = children.count() - 1; ii >= 0; --ii) {
- QSGItem *child = children.at(ii);
+ QQuickItem *child = children.at(ii);
if (!child->isVisible() || !child->isEnabled())
continue;
if (deliverInitialMousePressEvent(child, event))
return false;
}
-bool QSGCanvasPrivate::deliverMouseEvent(QMouseEvent *event)
+bool QQuickCanvasPrivate::deliverMouseEvent(QMouseEvent *event)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
lastMousePosition = event->windowPos();
}
if (mouseGrabberItem) {
- QSGItemPrivate *mgPrivate = QSGItemPrivate::get(mouseGrabberItem);
+ QQuickItemPrivate *mgPrivate = QQuickItemPrivate::get(mouseGrabberItem);
const QTransform &transform = mgPrivate->canvasToItemTransform();
QMouseEvent me(event->type(), transform.map(event->windowPos()), event->windowPos(), event->screenPos(),
event->button(), event->buttons(), event->modifiers());
return false;
}
-void QSGCanvas::mousePressEvent(QMouseEvent *event)
+void QQuickCanvas::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
#ifdef MOUSE_DEBUG
- qWarning() << "QSGCanvas::mousePressEvent()" << event->pos() << event->button() << event->buttons();
+ qWarning() << "QQuickCanvas::mousePressEvent()" << event->pos() << event->button() << event->buttons();
#endif
d->deliverMouseEvent(event);
}
-void QSGCanvas::mouseReleaseEvent(QMouseEvent *event)
+void QQuickCanvas::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
#ifdef MOUSE_DEBUG
- qWarning() << "QSGCanvas::mouseReleaseEvent()" << event->pos() << event->button() << event->buttons();
+ qWarning() << "QQuickCanvas::mouseReleaseEvent()" << event->pos() << event->button() << event->buttons();
#endif
if (!d->mouseGrabberItem) {
d->mouseGrabberItem = 0;
}
-void QSGCanvas::mouseDoubleClickEvent(QMouseEvent *event)
+void QQuickCanvas::mouseDoubleClickEvent(QMouseEvent *event)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
#ifdef MOUSE_DEBUG
- qWarning() << "QSGCanvas::mouseDoubleClickEvent()" << event->pos() << event->button() << event->buttons();
+ qWarning() << "QQuickCanvas::mouseDoubleClickEvent()" << event->pos() << event->button() << event->buttons();
#endif
if (!d->mouseGrabberItem && (event->button() & event->buttons()) == event->buttons()) {
d->deliverMouseEvent(event);
}
-bool QSGCanvasPrivate::sendHoverEvent(QEvent::Type type, QSGItem *item,
+bool QQuickCanvasPrivate::sendHoverEvent(QEvent::Type type, QQuickItem *item,
const QPointF &scenePos, const QPointF &lastScenePos,
Qt::KeyboardModifiers modifiers, bool accepted)
{
- Q_Q(QSGCanvas);
- const QTransform transform = QSGItemPrivate::get(item)->canvasToItemTransform();
+ Q_Q(QQuickCanvas);
+ const QTransform transform = QQuickItemPrivate::get(item)->canvasToItemTransform();
//create copy of event
QHoverEvent hoverEvent(type, transform.map(scenePos), transform.map(lastScenePos), modifiers);
return hoverEvent.isAccepted();
}
-void QSGCanvas::mouseMoveEvent(QMouseEvent *event)
+void QQuickCanvas::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
#ifdef MOUSE_DEBUG
- qWarning() << "QSGCanvas::mouseMoveEvent()" << event->pos() << event->button() << event->buttons();
+ qWarning() << "QQuickCanvas::mouseMoveEvent()" << event->pos() << event->button() << event->buttons();
#endif
if (!d->mouseGrabberItem) {
d->deliverMouseEvent(event);
}
-bool QSGCanvasPrivate::deliverHoverEvent(QSGItem *item, const QPointF &scenePos, const QPointF &lastScenePos,
+bool QQuickCanvasPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &scenePos, const QPointF &lastScenePos,
Qt::KeyboardModifiers modifiers, bool &accepted)
{
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->opacity == 0.0)
return false;
- if (itemPrivate->flags & QSGItem::ItemClipsChildrenToShape) {
+ if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
QPointF p = item->mapFromScene(scenePos);
if (!QRectF(0, 0, item->width(), item->height()).contains(p))
return false;
}
- QList<QSGItem *> children = itemPrivate->paintOrderChildItems();
+ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
for (int ii = children.count() - 1; ii >= 0; --ii) {
- QSGItem *child = children.at(ii);
+ QQuickItem *child = children.at(ii);
if (!child->isVisible() || !child->isEnabled())
continue;
if (deliverHoverEvent(child, scenePos, lastScenePos, modifiers, accepted))
//move
accepted = sendHoverEvent(QEvent::HoverMove, item, scenePos, lastScenePos, modifiers, accepted);
} else {
- QList<QSGItem *> itemsToHover;
- QSGItem* parent = item;
+ QList<QQuickItem *> itemsToHover;
+ QQuickItem* parent = item;
itemsToHover << item;
while ((parent = parent->parentItem()))
itemsToHover << parent;
startIdx = itemsToHover.count() - 1;
for (int i = startIdx; i >= 0; i--) {
- QSGItem *itemToHover = itemsToHover[i];
- if (QSGItemPrivate::get(itemToHover)->hoverEnabled) {
+ QQuickItem *itemToHover = itemsToHover[i];
+ if (QQuickItemPrivate::get(itemToHover)->hoverEnabled) {
hoverItems.prepend(itemToHover);
sendHoverEvent(QEvent::HoverEnter, itemToHover, scenePos, lastScenePos, modifiers, accepted);
}
return false;
}
-bool QSGCanvasPrivate::deliverWheelEvent(QSGItem *item, QWheelEvent *event)
+bool QQuickCanvasPrivate::deliverWheelEvent(QQuickItem *item, QWheelEvent *event)
{
- Q_Q(QSGCanvas);
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ Q_Q(QQuickCanvas);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->opacity == 0.0)
return false;
- if (itemPrivate->flags & QSGItem::ItemClipsChildrenToShape) {
+ if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
QPointF p = item->mapFromScene(event->posF());
if (!QRectF(0, 0, item->width(), item->height()).contains(p))
return false;
}
- QList<QSGItem *> children = itemPrivate->paintOrderChildItems();
+ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
for (int ii = children.count() - 1; ii >= 0; --ii) {
- QSGItem *child = children.at(ii);
+ QQuickItem *child = children.at(ii);
if (!child->isVisible() || !child->isEnabled())
continue;
if (deliverWheelEvent(child, event))
}
#ifndef QT_NO_WHEELEVENT
-void QSGCanvas::wheelEvent(QWheelEvent *event)
+void QQuickCanvas::wheelEvent(QWheelEvent *event)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
#ifdef MOUSE_DEBUG
- qWarning() << "QSGCanvas::wheelEvent()" << event->pos() << event->delta() << event->orientation();
+ qWarning() << "QQuickCanvas::wheelEvent()" << event->pos() << event->delta() << event->orientation();
#endif
event->ignore();
d->deliverWheelEvent(d->rootItem, event);
}
#endif // QT_NO_WHEELEVENT
-bool QSGCanvasPrivate::deliverTouchEvent(QTouchEvent *event)
+bool QQuickCanvasPrivate::deliverTouchEvent(QTouchEvent *event)
{
#ifdef TOUCH_DEBUG
if (event->type() == QEvent::TouchBegin)
qWarning("touchEndEvent");
#endif
- QHash<QSGItem *, QList<QTouchEvent::TouchPoint> > updatedPoints;
+ QHash<QQuickItem *, QList<QTouchEvent::TouchPoint> > updatedPoints;
if (event->type() == QTouchEvent::TouchBegin) { // all points are new touch points
QSet<int> acceptedNewPoints;
const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
QList<QTouchEvent::TouchPoint> newPoints;
- QSGItem *item = 0;
+ QQuickItem *item = 0;
for (int i=0; i<touchPoints.count(); i++) {
const QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
switch (touchPoint.state()) {
return event->isAccepted();
}
-bool QSGCanvasPrivate::deliverTouchPoints(QSGItem *item, QTouchEvent *event, const QList<QTouchEvent::TouchPoint> &newPoints, QSet<int> *acceptedNewPoints, QHash<QSGItem *, QList<QTouchEvent::TouchPoint> > *updatedPoints)
+bool QQuickCanvasPrivate::deliverTouchPoints(QQuickItem *item, QTouchEvent *event, const QList<QTouchEvent::TouchPoint> &newPoints, QSet<int> *acceptedNewPoints, QHash<QQuickItem *, QList<QTouchEvent::TouchPoint> > *updatedPoints)
{
- Q_Q(QSGCanvas);
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ Q_Q(QQuickCanvas);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->opacity == 0.0)
return false;
- if (itemPrivate->flags & QSGItem::ItemClipsChildrenToShape) {
+ if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
QRectF bounds(0, 0, item->width(), item->height());
for (int i=0; i<newPoints.count(); i++) {
QPointF p = item->mapFromScene(newPoints[i].scenePos());
}
}
- QList<QSGItem *> children = itemPrivate->paintOrderChildItems();
+ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
for (int ii = children.count() - 1; ii >= 0; --ii) {
- QSGItem *child = children.at(ii);
+ QQuickItem *child = children.at(ii);
if (!child->isEnabled())
continue;
if (deliverTouchPoints(child, event, newPoints, acceptedNewPoints, updatedPoints))
return false;
}
-void QSGCanvasPrivate::deliverDragEvent(QSGDragGrabber *grabber, QEvent *event)
+void QQuickCanvasPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QEvent *event)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
grabber->resetTarget();
- QSGDragGrabber::iterator grabItem = grabber->begin();
+ QQuickDragGrabber::iterator grabItem = grabber->begin();
if (grabItem != grabber->end()) {
Q_ASSERT(event->type() != QEvent::DragEnter);
if (event->type() == QEvent::Drop) {
e->mimeData(),
e->mouseButtons(),
e->keyboardModifiers());
- QSGDropEventEx::copyActions(&translatedEvent, *e);
+ QQuickDropEventEx::copyActions(&translatedEvent, *e);
q->sendEvent(**grabItem, &translatedEvent);
e->setAccepted(translatedEvent.isAccepted());
e->setDropAction(translatedEvent.dropAction());
moveEvent->mimeData(),
moveEvent->mouseButtons(),
moveEvent->keyboardModifiers());
- QSGDropEventEx::copyActions(&translatedEvent, *moveEvent);
+ QQuickDropEventEx::copyActions(&translatedEvent, *moveEvent);
q->sendEvent(**grabItem, &translatedEvent);
++grabItem;
} else {
e->mimeData(),
e->mouseButtons(),
e->keyboardModifiers());
- QSGDropEventEx::copyActions(&enterEvent, *e);
+ QQuickDropEventEx::copyActions(&enterEvent, *e);
event->setAccepted(deliverDragEvent(grabber, rootItem, &enterEvent));
}
}
-bool QSGCanvasPrivate::deliverDragEvent(QSGDragGrabber *grabber, QSGItem *item, QDragMoveEvent *event)
+bool QQuickCanvasPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QQuickItem *item, QDragMoveEvent *event)
{
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
bool accepted = false;
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->opacity == 0.0 || !item->isVisible() || !item->isEnabled())
return false;
QPointF p = item->mapFromScene(event->pos());
if (QRectF(0, 0, item->width(), item->height()).contains(p)) {
- if (event->type() == QEvent::DragMove || itemPrivate->flags & QSGItem::ItemAcceptsDrops) {
+ if (event->type() == QEvent::DragMove || itemPrivate->flags & QQuickItem::ItemAcceptsDrops) {
QDragMoveEvent translatedEvent(
p.toPoint(),
event->possibleActions(),
event->mouseButtons(),
event->keyboardModifiers(),
event->type());
- QSGDropEventEx::copyActions(&translatedEvent, *event);
+ QQuickDropEventEx::copyActions(&translatedEvent, *event);
q->sendEvent(item, &translatedEvent);
if (event->type() == QEvent::DragEnter) {
if (translatedEvent.isAccepted()) {
accepted = true;
}
}
- } else if (itemPrivate->flags & QSGItem::ItemClipsChildrenToShape) {
+ } else if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
return false;
}
event->mimeData(),
event->mouseButtons(),
event->keyboardModifiers());
- QSGDropEventEx::copyActions(&enterEvent, *event);
- QList<QSGItem *> children = itemPrivate->paintOrderChildItems();
+ QQuickDropEventEx::copyActions(&enterEvent, *event);
+ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
for (int ii = children.count() - 1; ii >= 0; --ii) {
if (deliverDragEvent(grabber, children.at(ii), &enterEvent))
return true;
return accepted;
}
-bool QSGCanvasPrivate::sendFilteredMouseEvent(QSGItem *target, QSGItem *item, QMouseEvent *event)
+bool QQuickCanvasPrivate::sendFilteredMouseEvent(QQuickItem *target, QQuickItem *item, QMouseEvent *event)
{
if (!target)
return false;
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(target);
if (targetPrivate->filtersChildMouseEvents)
if (target->childMouseEventFilter(item, event))
return true;
return false;
}
-bool QSGCanvas::sendEvent(QSGItem *item, QEvent *e)
+bool QQuickCanvas::sendEvent(QQuickItem *item, QEvent *e)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (!item) {
- qWarning("QSGCanvas::sendEvent: Cannot send event to a null item");
+ qWarning("QQuickCanvas::sendEvent: Cannot send event to a null item");
return false;
}
case QEvent::KeyPress:
case QEvent::KeyRelease:
e->accept();
- QSGItemPrivate::get(item)->deliverKeyEvent(static_cast<QKeyEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverKeyEvent(static_cast<QKeyEvent *>(e));
while (!e->isAccepted() && (item = item->parentItem())) {
e->accept();
- QSGItemPrivate::get(item)->deliverKeyEvent(static_cast<QKeyEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverKeyEvent(static_cast<QKeyEvent *>(e));
}
break;
case QEvent::InputMethod:
e->accept();
- QSGItemPrivate::get(item)->deliverInputMethodEvent(static_cast<QInputMethodEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverInputMethodEvent(static_cast<QInputMethodEvent *>(e));
while (!e->isAccepted() && (item = item->parentItem())) {
e->accept();
- QSGItemPrivate::get(item)->deliverInputMethodEvent(static_cast<QInputMethodEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverInputMethodEvent(static_cast<QInputMethodEvent *>(e));
}
break;
case QEvent::FocusIn:
case QEvent::FocusOut:
- QSGItemPrivate::get(item)->deliverFocusEvent(static_cast<QFocusEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverFocusEvent(static_cast<QFocusEvent *>(e));
break;
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
QMouseEvent *se = static_cast<QMouseEvent *>(e);
if (!d->sendFilteredMouseEvent(item->parentItem(), item, se)) {
se->accept();
- QSGItemPrivate::get(item)->deliverMouseEvent(se);
+ QQuickItemPrivate::get(item)->deliverMouseEvent(se);
}
}
break;
case QEvent::Wheel:
- QSGItemPrivate::get(item)->deliverWheelEvent(static_cast<QWheelEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverWheelEvent(static_cast<QWheelEvent *>(e));
break;
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove:
- QSGItemPrivate::get(item)->deliverHoverEvent(static_cast<QHoverEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverHoverEvent(static_cast<QHoverEvent *>(e));
break;
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
- QSGItemPrivate::get(item)->deliverTouchEvent(static_cast<QTouchEvent *>(e));
+ QQuickItemPrivate::get(item)->deliverTouchEvent(static_cast<QTouchEvent *>(e));
break;
case QEvent::DragEnter:
case QEvent::DragMove:
case QEvent::DragLeave:
case QEvent::Drop:
- QSGItemPrivate::get(item)->deliverDragEvent(e);
+ QQuickItemPrivate::get(item)->deliverDragEvent(e);
break;
default:
break;
return false;
}
-void QSGCanvasPrivate::cleanupNodes()
+void QQuickCanvasPrivate::cleanupNodes()
{
for (int ii = 0; ii < cleanupNodeList.count(); ++ii)
delete cleanupNodeList.at(ii);
cleanupNodeList.clear();
}
-void QSGCanvasPrivate::updateDirtyNodes()
+void QQuickCanvasPrivate::updateDirtyNodes()
{
#ifdef DIRTY_DEBUG
- qWarning() << "QSGCanvasPrivate::updateDirtyNodes():";
+ qWarning() << "QQuickCanvasPrivate::updateDirtyNodes():";
#endif
cleanupNodes();
- QSGItem *updateList = dirtyItemList;
+ QQuickItem *updateList = dirtyItemList;
dirtyItemList = 0;
- if (updateList) QSGItemPrivate::get(updateList)->prevDirtyItem = &updateList;
+ if (updateList) QQuickItemPrivate::get(updateList)->prevDirtyItem = &updateList;
while (updateList) {
- QSGItem *item = updateList;
- QSGItemPrivate *itemPriv = QSGItemPrivate::get(item);
+ QQuickItem *item = updateList;
+ QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(item);
itemPriv->removeFromDirtyList();
#ifdef DIRTY_DEBUG
}
}
-void QSGCanvasPrivate::updateDirtyNode(QSGItem *item)
+void QQuickCanvasPrivate::updateDirtyNode(QQuickItem *item)
{
#ifdef QML_RUNTIME_TESTING
bool didFlash = false;
#endif
- QSGItemPrivate *itemPriv = QSGItemPrivate::get(item);
+ QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(item);
quint32 dirty = itemPriv->dirtyAttributes;
itemPriv->dirtyAttributes = 0;
- if ((dirty & QSGItemPrivate::TransformUpdateMask) ||
- (dirty & QSGItemPrivate::Size && itemPriv->origin != QSGItem::TopLeft &&
+ if ((dirty & QQuickItemPrivate::TransformUpdateMask) ||
+ (dirty & QQuickItemPrivate::Size && itemPriv->origin != QQuickItem::TopLeft &&
(itemPriv->scale != 1. || itemPriv->rotation != 0.))) {
QMatrix4x4 matrix;
itemPriv->itemNode()->setMatrix(matrix);
}
- bool clipEffectivelyChanged = dirty & QSGItemPrivate::Clip &&
+ bool clipEffectivelyChanged = dirty & QQuickItemPrivate::Clip &&
((item->clip() == false) != (itemPriv->clipNode == 0));
- bool effectRefEffectivelyChanged = dirty & QSGItemPrivate::EffectReference &&
+ bool effectRefEffectivelyChanged = dirty & QQuickItemPrivate::EffectReference &&
((itemPriv->effectRefCount == 0) != (itemPriv->rootNode == 0));
if (clipEffectivelyChanged) {
if (item->clip()) {
Q_ASSERT(itemPriv->clipNode == 0);
- itemPriv->clipNode = new QSGDefaultClipNode(item->boundingRect());
+ itemPriv->clipNode = new QQuickDefaultClipNode(item->boundingRect());
itemPriv->clipNode->update();
if (child)
}
}
- if (dirty & QSGItemPrivate::ChildrenUpdateMask)
+ if (dirty & QQuickItemPrivate::ChildrenUpdateMask)
itemPriv->childContainerNode()->removeAllChildNodes();
if (effectRefEffectivelyChanged) {
}
}
- if (dirty & QSGItemPrivate::ChildrenUpdateMask) {
+ if (dirty & QQuickItemPrivate::ChildrenUpdateMask) {
QSGNode *groupNode = itemPriv->groupNode;
if (groupNode)
groupNode->removeAllChildNodes();
- QList<QSGItem *> orderedChildren = itemPriv->paintOrderChildItems();
+ QList<QQuickItem *> orderedChildren = itemPriv->paintOrderChildItems();
int ii = 0;
for (; ii < orderedChildren.count() && orderedChildren.at(ii)->z() < 0; ++ii) {
- QSGItemPrivate *childPrivate = QSGItemPrivate::get(orderedChildren.at(ii));
+ QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(orderedChildren.at(ii));
if (!childPrivate->explicitVisible && !childPrivate->effectRefCount)
continue;
if (childPrivate->itemNode()->parent())
itemPriv->childContainerNode()->appendChildNode(itemPriv->paintNode);
for (; ii < orderedChildren.count(); ++ii) {
- QSGItemPrivate *childPrivate = QSGItemPrivate::get(orderedChildren.at(ii));
+ QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(orderedChildren.at(ii));
if (!childPrivate->explicitVisible && !childPrivate->effectRefCount)
continue;
if (childPrivate->itemNode()->parent())
}
}
- if ((dirty & QSGItemPrivate::Size) && itemPriv->clipNode) {
+ if ((dirty & QQuickItemPrivate::Size) && itemPriv->clipNode) {
itemPriv->clipNode->setRect(item->boundingRect());
itemPriv->clipNode->update();
}
- if (dirty & (QSGItemPrivate::OpacityValue | QSGItemPrivate::Visible | QSGItemPrivate::HideReference)) {
+ if (dirty & (QQuickItemPrivate::OpacityValue | QQuickItemPrivate::Visible | QQuickItemPrivate::HideReference)) {
qreal opacity = itemPriv->explicitVisible && itemPriv->hideRefCount == 0
? itemPriv->opacity : qreal(0);
itemPriv->opacityNode->setOpacity(opacity);
}
- if (dirty & QSGItemPrivate::ContentUpdateMask) {
+ if (dirty & QQuickItemPrivate::ContentUpdateMask) {
- if (itemPriv->flags & QSGItem::ItemHasContents) {
+ if (itemPriv->flags & QQuickItem::ItemHasContents) {
updatePaintNodeData.transformNode = itemPriv->itemNode();
itemPriv->paintNode = item->updatePaintNode(itemPriv->paintNode, &updatePaintNodeData);
itemPriv->childContainerNode()->appendChildNode(flash);
didFlash = true;
}
- Q_Q(QSGCanvas);
+ Q_Q(QQuickCanvas);
if (didFlash) {
q->maybeUpdate();
}
}
-void QSGCanvas::maybeUpdate()
+void QQuickCanvas::maybeUpdate()
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->thread && d->thread->isRunning())
d->thread->maybeUpdate();
notification about this.
*/
-QSGEngine *QSGCanvas::sceneGraphEngine() const
+QSGEngine *QQuickCanvas::sceneGraphEngine() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
if (d->context && d->context->isReady())
return d->context->engine();
return 0;
the rendering.
*/
-void QSGCanvas::setRenderTarget(QOpenGLFramebufferObject *fbo)
+void QQuickCanvas::setRenderTarget(QOpenGLFramebufferObject *fbo)
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
if (d->context && d->context && QThread::currentThread() != d->context->thread()) {
- qWarning("QSGCanvas::setRenderThread: Cannot set render target from outside the rendering thread");
+ qWarning("QQuickCanvas::setRenderThread: Cannot set render target from outside the rendering thread");
return;
}
The default is to render to the surface of the canvas, in which
case the render target is 0.
*/
-QOpenGLFramebufferObject *QSGCanvas::renderTarget() const
+QOpenGLFramebufferObject *QQuickCanvas::renderTarget() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
return d->renderTarget;
}
\warning This function can only be called from the GUI thread.
*/
-QImage QSGCanvas::grabFrameBuffer()
+QImage QQuickCanvas::grabFrameBuffer()
{
- Q_D(QSGCanvas);
+ Q_D(QQuickCanvas);
return d->thread ? d->thread->grab() : QImage();
}
/*!
Returns an incubation controller that splices incubation between frames
- for this canvas. QSGView automatically installs this controller for you.
+ for this canvas. QQuickView automatically installs this controller for you.
The controller is owned by the canvas and will be destroyed when the canvas
is deleted.
*/
-QDeclarativeIncubationController *QSGCanvas::incubationController() const
+QDeclarativeIncubationController *QQuickCanvas::incubationController() const
{
- Q_D(const QSGCanvas);
+ Q_D(const QQuickCanvas);
if (!d->incubationController)
- d->incubationController = new QSGCanvasIncubationController(const_cast<QSGCanvasPrivate *>(d));
+ d->incubationController = new QQuickCanvasIncubationController(const_cast<QQuickCanvasPrivate *>(d));
return d->incubationController;
}
-void QSGCanvasRenderLoop::createGLContext()
+void QQuickCanvasRenderLoop::createGLContext()
{
gl = new QOpenGLContext();
gl->setFormat(renderer->requestedFormat());
gl->create();
}
-void QSGCanvasRenderThread::run()
+void QQuickCanvasRenderThread::run()
{
#ifdef THREAD_DEBUG
qDebug("QML Rendering Thread Started");
#ifdef THREAD_DEBUG
printf(" RenderThread: Doing locked sync\n");
#endif
-#ifdef QSG_CANVAS_TIMING
- if (qsg_canvas_timing)
+#ifdef QQUICK_CANVAS_TIMING
+ if (qquick_canvas_timing)
threadTimer.start();
#endif
inSync = true;
#ifdef THREAD_DEBUG
printf(" RenderThread: sync done\n");
#endif
-#ifdef QSG_CANVAS_TIMING
- if (qsg_canvas_timing)
+#ifdef QQUICK_CANVAS_TIMING
+ if (qquick_canvas_timing)
syncTime = threadTimer.elapsed();
#endif
#endif
renderSceneGraph(windowSize);
-#ifdef QSG_CANVAS_TIMING
- if (qsg_canvas_timing)
+#ifdef QQUICK_CANVAS_TIMING
+ if (qquick_canvas_timing)
renderTime = threadTimer.elapsed() - syncTime;
#endif
#ifdef THREAD_DEBUG
printf(" RenderThread: swap complete...\n");
#endif
-#ifdef QSG_CANVAS_TIMING
- if (qsg_canvas_timing) {
+#ifdef QQUICK_CANVAS_TIMING
+ if (qquick_canvas_timing) {
swapTime = threadTimer.elapsed() - renderTime;
qDebug() << "- Breakdown of frame time: sync:" << syncTime
<< "ms render:" << renderTime << "ms swap:" << swapTime
-bool QSGCanvasRenderThread::event(QEvent *e)
+bool QQuickCanvasRenderThread::event(QEvent *e)
{
Q_ASSERT(QThread::currentThread() == qApp->thread());
-void QSGCanvasRenderThread::exhaustSyncEvent()
+void QQuickCanvasRenderThread::exhaustSyncEvent()
{
if (isGuiBlockPending) {
sync(true);
-void QSGCanvasRenderThread::sync(bool guiAlreadyLocked)
+void QQuickCanvasRenderThread::sync(bool guiAlreadyLocked)
{
#ifdef THREAD_DEBUG
printf("GUI: sync - %s\n", guiAlreadyLocked ? "outside event" : "inside event");
ourselves.
*/
-void QSGCanvasRenderThread::lockInGui()
+void QQuickCanvasRenderThread::lockInGui()
{
// We must avoid recursive locking in the GUI thread, hence we
// only lock when we are the first one to try to block.
-void QSGCanvasRenderThread::unlockInGui()
+void QQuickCanvasRenderThread::unlockInGui()
{
#ifdef THREAD_DEBUG
printf("GUI: releasing lock... %d\n", isGuiBlocked);
-void QSGCanvasRenderThread::animationStarted()
+void QQuickCanvasRenderThread::animationStarted()
{
#ifdef THREAD_DEBUG
printf("GUI: animationStarted()\n");
-void QSGCanvasRenderThread::animationStopped()
+void QQuickCanvasRenderThread::animationStopped()
{
#ifdef THREAD_DEBUG
printf("GUI: animationStopped()...\n");
}
-void QSGCanvasRenderThread::paint()
+void QQuickCanvasRenderThread::paint()
{
#ifdef THREAD_DEBUG
printf("GUI: paint called..\n");
-void QSGCanvasRenderThread::resize(const QSize &size)
+void QQuickCanvasRenderThread::resize(const QSize &size)
{
#ifdef THREAD_DEBUG
printf("GUI: Resize Event: %dx%d\n", size.width(), size.height());
-void QSGCanvasRenderThread::startRendering()
+void QQuickCanvasRenderThread::startRendering()
{
#ifdef THREAD_DEBUG
printf("GUI: Starting Render Thread\n");
-void QSGCanvasRenderThread::stopRendering()
+void QQuickCanvasRenderThread::stopRendering()
{
#ifdef THREAD_DEBUG
printf("GUI: stopping render thread\n");
-QImage QSGCanvasRenderThread::grab()
+QImage QQuickCanvasRenderThread::grab()
{
if (!isRunning())
return QImage();
if (QThread::currentThread() != qApp->thread()) {
- qWarning("QSGCanvas::grabFrameBuffer: can only be called from the GUI thread");
+ qWarning("QQuickCanvas::grabFrameBuffer: can only be called from the GUI thread");
return QImage();
}
-void QSGCanvasRenderThread::maybeUpdate()
+void QQuickCanvasRenderThread::maybeUpdate()
{
Q_ASSERT_X(QThread::currentThread() == QCoreApplication::instance()->thread() || inSync,
- "QSGCanvas::update",
- "Function can only be called from GUI thread or during QSGItem::updatePaintNode()");
+ "QQuickCanvas::update",
+ "Function can only be called from GUI thread or during QQuickItem::updatePaintNode()");
if (inSync) {
isExternalUpdatePending = true;
}
-#include "moc_qsgcanvas.cpp"
+#include "moc_qquickcanvas.cpp"
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGCANVAS_H
-#define QSGCANVAS_H
+#ifndef QQUICKCANVAS_H
+#define QQUICKCANVAS_H
#include <QtCore/qmetatype.h>
#include <QtGui/qopengl.h>
QT_MODULE(Declarative)
-class QSGItem;
+class QQuickItem;
class QSGEngine;
-class QSGCanvasPrivate;
+class QQuickCanvasPrivate;
class QOpenGLFramebufferObject;
class QDeclarativeIncubationController;
-class Q_DECLARATIVE_EXPORT QSGCanvas : public QWindow
+class Q_DECLARATIVE_EXPORT QQuickCanvas : public QWindow
{
Q_OBJECT
-Q_DECLARE_PRIVATE(QSGCanvas)
+Q_DECLARE_PRIVATE(QQuickCanvas)
public:
- QSGCanvas(QWindow *parent = 0);
+ QQuickCanvas(QWindow *parent = 0);
- virtual ~QSGCanvas();
+ virtual ~QQuickCanvas();
- QSGItem *rootItem() const;
- QSGItem *activeFocusItem() const;
+ QQuickItem *rootItem() const;
+ QQuickItem *activeFocusItem() const;
- QSGItem *mouseGrabberItem() const;
+ QQuickItem *mouseGrabberItem() const;
- bool sendEvent(QSGItem *, QEvent *);
+ bool sendEvent(QQuickItem *, QEvent *);
QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
void sceneGraphInitialized();
protected:
- QSGCanvas(QSGCanvasPrivate &dd, QWindow *parent = 0);
+ QQuickCanvas(QQuickCanvasPrivate &dd, QWindow *parent = 0);
virtual void exposeEvent(QExposeEvent *);
virtual void resizeEvent(QResizeEvent *);
void animationStopped();
private:
- friend class QSGItem;
- friend class QSGCanvasRenderLoop;
- Q_DISABLE_COPY(QSGCanvas)
+ friend class QQuickItem;
+ friend class QQuickCanvasRenderLoop;
+ Q_DISABLE_COPY(QQuickCanvas)
};
QT_END_NAMESPACE
-Q_DECLARE_METATYPE(QSGCanvas *)
+Q_DECLARE_METATYPE(QQuickCanvas *)
QT_END_HEADER
-#endif // QSGCANVAS_H
+#endif // QQUICKCANVAS_H
**
****************************************************************************/
-#ifndef QSGCANVAS_P_H
-#define QSGCANVAS_P_H
+#ifndef QQUICKCANVAS_P_H
+#define QQUICKCANVAS_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgitem.h"
-#include "qsgcanvas.h"
+#include "qquickitem.h"
+#include "qquickcanvas.h"
#include <private/qdeclarativeguard_p.h>
#include <private/qsgcontext_p.h>
-#include <private/qsgdrag_p.h>
+#include <private/qquickdrag_p.h>
#include <QtCore/qthread.h>
#include <QtCore/qmutex.h>
QT_BEGIN_NAMESPACE
//Make it easy to identify and customize the root item if needed
-class QSGRootItem : public QSGItem
+class QQuickRootItem : public QQuickItem
{
Q_OBJECT
public:
- QSGRootItem();
+ QQuickRootItem();
};
-class QSGCanvasPrivate;
+class QQuickCanvasPrivate;
class QTouchEvent;
-class QSGCanvasRenderLoop;
-class QSGCanvasIncubationController;
+class QQuickCanvasRenderLoop;
+class QQuickCanvasIncubationController;
-class QSGCanvasPrivate : public QWindowPrivate
+class QQuickCanvasPrivate : public QWindowPrivate
{
public:
- Q_DECLARE_PUBLIC(QSGCanvas)
+ Q_DECLARE_PUBLIC(QQuickCanvas)
- static inline QSGCanvasPrivate *get(QSGCanvas *c) { return c->d_func(); }
+ static inline QQuickCanvasPrivate *get(QQuickCanvas *c) { return c->d_func(); }
- QSGCanvasPrivate();
- virtual ~QSGCanvasPrivate();
+ QQuickCanvasPrivate();
+ virtual ~QQuickCanvasPrivate();
- void init(QSGCanvas *);
+ void init(QQuickCanvas *);
- QSGRootItem *rootItem;
+ QQuickRootItem *rootItem;
- QSGItem *activeFocusItem;
- QSGItem *mouseGrabberItem;
- QSGDragGrabber dragGrabber;
+ QQuickItem *activeFocusItem;
+ QQuickItem *mouseGrabberItem;
+ QQuickDragGrabber dragGrabber;
// Mouse positions are saved in widget coordinates
QPointF lastMousePosition;
void translateTouchEvent(QTouchEvent *touchEvent);
static void transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform);
- bool deliverInitialMousePressEvent(QSGItem *, QMouseEvent *);
+ bool deliverInitialMousePressEvent(QQuickItem *, QMouseEvent *);
bool deliverMouseEvent(QMouseEvent *);
- bool sendFilteredMouseEvent(QSGItem *, QSGItem *, QMouseEvent *);
- bool deliverWheelEvent(QSGItem *, QWheelEvent *);
- bool deliverTouchPoints(QSGItem *, QTouchEvent *, const QList<QTouchEvent::TouchPoint> &, QSet<int> *,
- QHash<QSGItem *, QList<QTouchEvent::TouchPoint> > *);
+ bool sendFilteredMouseEvent(QQuickItem *, QQuickItem *, QMouseEvent *);
+ bool deliverWheelEvent(QQuickItem *, QWheelEvent *);
+ bool deliverTouchPoints(QQuickItem *, QTouchEvent *, const QList<QTouchEvent::TouchPoint> &, QSet<int> *,
+ QHash<QQuickItem *, QList<QTouchEvent::TouchPoint> > *);
bool deliverTouchEvent(QTouchEvent *);
- bool deliverHoverEvent(QSGItem *, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, bool &accepted);
- bool sendHoverEvent(QEvent::Type, QSGItem *, const QPointF &scenePos, const QPointF &lastScenePos,
+ bool deliverHoverEvent(QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, bool &accepted);
+ bool sendHoverEvent(QEvent::Type, QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos,
Qt::KeyboardModifiers modifiers, bool accepted);
bool clearHover();
- void deliverDragEvent(QSGDragGrabber *, QEvent *);
- bool deliverDragEvent(QSGDragGrabber *, QSGItem *, QDragMoveEvent *);
+ void deliverDragEvent(QQuickDragGrabber *, QEvent *);
+ bool deliverDragEvent(QQuickDragGrabber *, QQuickItem *, QDragMoveEvent *);
- QList<QSGItem*> hoverItems;
+ QList<QQuickItem*> hoverItems;
enum FocusOption {
DontChangeFocusProperty = 0x01,
};
Q_DECLARE_FLAGS(FocusOptions, FocusOption)
- void setFocusInScope(QSGItem *scope, QSGItem *item, FocusOptions = 0);
- void clearFocusInScope(QSGItem *scope, QSGItem *item, FocusOptions = 0);
- void notifyFocusChangesRecur(QSGItem **item, int remaining);
+ void setFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions = 0);
+ void clearFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions = 0);
+ void notifyFocusChangesRecur(QQuickItem **item, int remaining);
void updateInputMethodData();
void updateFocusItemTransform();
- void dirtyItem(QSGItem *);
+ void dirtyItem(QQuickItem *);
void cleanup(QSGNode *);
void initializeSceneGraph();
void syncSceneGraph();
void renderSceneGraph(const QSize &size);
- QSGItem::UpdatePaintNodeData updatePaintNodeData;
+ QQuickItem::UpdatePaintNodeData updatePaintNodeData;
- QSGItem *dirtyItemList;
+ QQuickItem *dirtyItemList;
QList<QSGNode *> cleanupNodeList;
- QSet<QSGItem *> itemsToPolish;
+ QSet<QQuickItem *> itemsToPolish;
void updateDirtyNodes();
void cleanupNodes();
- bool updateEffectiveOpacity(QSGItem *);
- void updateEffectiveOpacityRoot(QSGItem *, qreal);
- void updateDirtyNode(QSGItem *);
+ bool updateEffectiveOpacity(QQuickItem *);
+ void updateEffectiveOpacityRoot(QQuickItem *, qreal);
+ void updateDirtyNode(QQuickItem *);
QSGContext *context;
uint vsyncAnimations : 1;
- QSGCanvasRenderLoop *thread;
+ QQuickCanvasRenderLoop *thread;
QSize widgetSize;
QSize viewportSize;
QOpenGLFramebufferObject *renderTarget;
- QHash<int, QSGItem *> itemForTouchPointId;
+ QHash<int, QQuickItem *> itemForTouchPointId;
- mutable QSGCanvasIncubationController *incubationController;
+ mutable QQuickCanvasIncubationController *incubationController;
};
-class QSGCanvasRenderLoop
+class QQuickCanvasRenderLoop
{
public:
- QSGCanvasRenderLoop()
+ QQuickCanvasRenderLoop()
: d(0)
, renderer(0)
, gl(0)
{
}
- virtual ~QSGCanvasRenderLoop()
+ virtual ~QQuickCanvasRenderLoop()
{
delete gl;
}
- friend class QSGCanvasPrivate;
+ friend class QQuickCanvasPrivate;
virtual void paint() = 0;
virtual void resize(const QSize &size) = 0;
}
private:
- QSGCanvasPrivate *d;
- QSGCanvas *renderer;
+ QQuickCanvasPrivate *d;
+ QQuickCanvas *renderer;
QOpenGLContext *gl;
};
-class QSGCanvasRenderThread : public QThread, public QSGCanvasRenderLoop
+class QQuickCanvasRenderThread : public QThread, public QQuickCanvasRenderLoop
{
Q_OBJECT
public:
- QSGCanvasRenderThread()
+ QQuickCanvasRenderThread()
: mutex(QMutex::NonRecursive)
, allowMainThreadProcessingFlag(true)
, animationRunning(false)
void run();
};
-Q_DECLARE_OPERATORS_FOR_FLAGS(QSGCanvasPrivate::FocusOptions)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickCanvasPrivate::FocusOptions)
QT_END_NAMESPACE
-#endif // QSGCANVAS_P_H
+#endif // QQUICKCANVAS_P_H
****************************************************************************/
-#include "qsgclipnode_p.h"
+#include "qquickclipnode_p.h"
#include <QtGui/qvector2d.h>
#include <QtCore/qmath.h>
-QSGDefaultClipNode::QSGDefaultClipNode(const QRectF &rect)
+QQuickDefaultClipNode::QQuickDefaultClipNode(const QRectF &rect)
: m_rect(rect)
, m_radius(0)
, m_dirty_geometry(true)
setIsRectangular(true);
}
-void QSGDefaultClipNode::setRect(const QRectF &rect)
+void QQuickDefaultClipNode::setRect(const QRectF &rect)
{
m_rect = rect;
m_dirty_geometry = true;
}
-void QSGDefaultClipNode::setRadius(qreal radius)
+void QQuickDefaultClipNode::setRadius(qreal radius)
{
m_radius = radius;
m_dirty_geometry = true;
setIsRectangular(radius == 0);
}
-void QSGDefaultClipNode::update()
+void QQuickDefaultClipNode::update()
{
if (m_dirty_geometry) {
updateGeometry();
}
}
-void QSGDefaultClipNode::updateGeometry()
+void QQuickDefaultClipNode::updateGeometry()
{
QSGGeometry *g = geometry();
**
****************************************************************************/
-#ifndef QSGCLIPNODE_P_H
-#define QSGCLIPNODE_P_H
+#ifndef QQUICKCLIPNODE_P_H
+#define QQUICKCLIPNODE_P_H
#include <qsgnode.h>
-class QSGDefaultClipNode : public QSGClipNode
+class QQuickDefaultClipNode : public QSGClipNode
{
public:
- QSGDefaultClipNode(const QRectF &);
+ QQuickDefaultClipNode(const QRectF &);
void setRect(const QRectF &);
QRectF rect() const { return m_rect; }
QSGGeometry m_geometry;
};
-#endif // QSGCLIPNODE_P_H
+#endif // QQUICKCLIPNODE_P_H
**
****************************************************************************/
-#include "qsgdrag_p.h"
+#include "qquickdrag_p.h"
-#include <private/qsgitem_p.h>
-#include <private/qsgevents_p_p.h>
-#include <private/qsgitemchangelistener_p.h>
+#include <private/qquickitem_p.h>
+#include <private/qquickevents_p_p.h>
+#include <private/qquickitemchangelistener_p.h>
#include <private/qv8engine_p.h>
#include <QtGui/qevent.h>
QT_BEGIN_NAMESPACE
-class QSGDragAttachedPrivate : public QObjectPrivate, public QSGItemChangeListener
+class QQuickDragAttachedPrivate : public QObjectPrivate, public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGDragAttached)
+ Q_DECLARE_PUBLIC(QQuickDragAttached)
public:
- static QSGDragAttachedPrivate *get(QSGDragAttached *attached) {
- return static_cast<QSGDragAttachedPrivate *>(QObjectPrivate::get(attached)); }
+ static QQuickDragAttachedPrivate *get(QQuickDragAttached *attached) {
+ return static_cast<QQuickDragAttachedPrivate *>(QObjectPrivate::get(attached)); }
- QSGDragAttachedPrivate()
+ QQuickDragAttachedPrivate()
: attachedItem(0)
, mimeData(0)
, proposedAction(Qt::MoveAction)
{
}
- void itemGeometryChanged(QSGItem *, const QRectF &, const QRectF &);
+ void itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &);
void start() { start(supportedActions); }
void start(Qt::DropActions supportedActions);
- void setTarget(QSGItem *item);
+ void setTarget(QQuickItem *item);
- QSGDragGrabber dragGrabber;
+ QQuickDragGrabber dragGrabber;
QDeclarativeGuard<QObject> source;
QDeclarativeGuard<QObject> target;
- QSGItem *attachedItem;
- QSGDragMimeData *mimeData;
+ QQuickItem *attachedItem;
+ QQuickDragMimeData *mimeData;
Qt::DropAction proposedAction;
Qt::DropActions supportedActions;
bool active : 1;
};
/*!
- \qmlclass Drag QSGDrag
+ \qmlclass Drag QQuickDrag
\inqmlmodule QtQuick 2
\brief The Drag attached property provides drag and drop events for moved Items.
*/
-void QSGDragAttachedPrivate::itemGeometryChanged(QSGItem *, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickDragAttachedPrivate::itemGeometryChanged(QQuickItem *, const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_Q(QSGDragAttached);
+ Q_Q(QQuickDragAttached);
if (newGeometry.topLeft() == oldGeometry.topLeft() || !active)
return;
- if (QSGCanvas *canvas = attachedItem->canvas()) {
+ if (QQuickCanvas *canvas = attachedItem->canvas()) {
QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint();
QDragMoveEvent event(scenePos, mimeData->m_supportedActions, mimeData, Qt::NoButton, Qt::NoModifier);
- QSGDropEventEx::setProposedAction(&event, proposedAction);
- QSGCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, &event);
+ QQuickDropEventEx::setProposedAction(&event, proposedAction);
+ QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, &event);
if (target != dragGrabber.target()) {
target = dragGrabber.target();
emit q->targetChanged();
}
}
-QSGDragAttached::QSGDragAttached(QObject *parent)
- : QObject(*new QSGDragAttachedPrivate, parent)
+QQuickDragAttached::QQuickDragAttached(QObject *parent)
+ : QObject(*new QQuickDragAttachedPrivate, parent)
{
- Q_D(QSGDragAttached);
- d->attachedItem = qobject_cast<QSGItem *>(parent);
+ Q_D(QQuickDragAttached);
+ d->attachedItem = qobject_cast<QQuickItem *>(parent);
d->source = d->attachedItem;
}
-QSGDragAttached::~QSGDragAttached()
+QQuickDragAttached::~QQuickDragAttached()
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
delete d->mimeData;
}
event with item's new position to the scene.
*/
-bool QSGDragAttached::isActive() const
+bool QQuickDragAttached::isActive() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->active;
}
-void QSGDragAttached::setActive(bool active)
+void QQuickDragAttached::setActive(bool active)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->active != active) {
if (active)
d->start(d->supportedActions);
Changes to source while a Drag is active don't take effect until a new drag is started.
*/
-QObject *QSGDragAttached::source() const
+QObject *QQuickDragAttached::source() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->source;
}
-void QSGDragAttached::setSource(QObject *item)
+void QQuickDragAttached::setSource(QObject *item)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->source != item) {
d->source = item;
emit sourceChanged();
}
}
-void QSGDragAttached::resetSource()
+void QQuickDragAttached::resetSource()
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->source != d->attachedItem) {
d->source = d->attachedItem;
emit sourceChanged();
the drag was cancelled the target will then be null.
*/
-QObject *QSGDragAttached::target() const
+QObject *QQuickDragAttached::target() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->target;
}
Changes to hotSpot will take effect when the next event is sent.
*/
-QPointF QSGDragAttached::hotSpot() const
+QPointF QQuickDragAttached::hotSpot() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->hotSpot;
}
-void QSGDragAttached::setHotSpot(const QPointF &hotSpot)
+void QQuickDragAttached::setHotSpot(const QPointF &hotSpot)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->hotSpot != hotSpot) {
d->hotSpot = hotSpot;
emit hotSpotChanged();
Changes to keys while a Drag is active don't take effect until a new drag is started.
*/
-QStringList QSGDragAttached::keys() const
+QStringList QQuickDragAttached::keys() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->keys;
}
-void QSGDragAttached::setKeys(const QStringList &keys)
+void QQuickDragAttached::setKeys(const QStringList &keys)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->keys != keys) {
d->keys = keys;
emit keysChanged();
until a new drag is started.
*/
-Qt::DropActions QSGDragAttached::supportedActions() const
+Qt::DropActions QQuickDragAttached::supportedActions() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->supportedActions;
}
-void QSGDragAttached::setSupportedActions(Qt::DropActions actions)
+void QQuickDragAttached::setSupportedActions(Qt::DropActions actions)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->supportedActions != actions) {
d->supportedActions = actions;
emit supportedActionsChanged();
Changes to proposedAction will take effect when the next event is sent.
*/
-Qt::DropAction QSGDragAttached::proposedAction() const
+Qt::DropAction QQuickDragAttached::proposedAction() const
{
- Q_D(const QSGDragAttached);
+ Q_D(const QQuickDragAttached);
return d->proposedAction;
}
-void QSGDragAttached::setProposedAction(Qt::DropAction action)
+void QQuickDragAttached::setProposedAction(Qt::DropAction action)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->proposedAction != action) {
d->proposedAction = action;
emit proposedActionChanged();
}
}
-void QSGDragAttachedPrivate::start(Qt::DropActions supportedActions)
+void QQuickDragAttachedPrivate::start(Qt::DropActions supportedActions)
{
- Q_Q(QSGDragAttached);
+ Q_Q(QQuickDragAttached);
Q_ASSERT(!active);
- if (QSGCanvas *canvas = attachedItem ? attachedItem->canvas() : 0) {
+ if (QQuickCanvas *canvas = attachedItem ? attachedItem->canvas() : 0) {
if (!mimeData)
- mimeData = new QSGDragMimeData;
+ mimeData = new QQuickDragMimeData;
if (!listening) {
- QSGItemPrivate::get(attachedItem)->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate::get(attachedItem)->addItemChangeListener(this, QQuickItemPrivate::Geometry);
listening = true;
}
QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint();
QDragEnterEvent event(scenePos, supportedActions, mimeData, Qt::NoButton, Qt::NoModifier);
- QSGDropEventEx::setProposedAction(&event, proposedAction);
- QSGCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, &event);
+ QQuickDropEventEx::setProposedAction(&event, proposedAction);
+ QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, &event);
emit q->activeChanged();
if (target != dragGrabber.target()) {
property for the started sequence.
*/
-void QSGDragAttached::start(QDeclarativeV8Function *args)
+void QQuickDragAttached::start(QDeclarativeV8Function *args)
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (d->active)
cancel();
*/
-int QSGDragAttached::drop()
+int QQuickDragAttached::drop()
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
Qt::DropAction acceptedAction = Qt::IgnoreAction;
if (!d->active)
QObject *target = 0;
- if (QSGCanvas *canvas = d->attachedItem->canvas()) {
+ if (QQuickCanvas *canvas = d->attachedItem->canvas()) {
QPoint scenePos = d->attachedItem->mapToScene(d->hotSpot).toPoint();
QDropEvent event(
scenePos, d->mimeData->m_supportedActions, d->mimeData, Qt::NoButton, Qt::NoModifier);
- QSGDropEventEx::setProposedAction(&event, d->proposedAction);
- QSGCanvasPrivate::get(canvas)->deliverDragEvent(&d->dragGrabber, &event);
+ QQuickDropEventEx::setProposedAction(&event, d->proposedAction);
+ QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&d->dragGrabber, &event);
if (event.isAccepted()) {
acceptedAction = event.dropAction();
Ends a drag sequence.
*/
-void QSGDragAttached::cancel()
+void QQuickDragAttached::cancel()
{
- Q_D(QSGDragAttached);
+ Q_D(QQuickDragAttached);
if (!d->active)
return;
- if (QSGCanvas *canvas = d->attachedItem->canvas()) {
+ if (QQuickCanvas *canvas = d->attachedItem->canvas()) {
QDragLeaveEvent event;
- QSGCanvasPrivate::get(canvas)->deliverDragEvent(&d->dragGrabber, &event);
+ QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&d->dragGrabber, &event);
}
d->active = false;
**
****************************************************************************/
-#ifndef QSGDRAG_P_H
-#define QSGDRAG_P_H
+#ifndef QQUICKDRAG_P_H
+#define QQUICKDRAG_P_H
-#include <qsgitem.h>
+#include <qquickitem.h>
#include <private/qv8engine_p.h>
QT_MODULE(Declarative)
-class QSGItem;
-class QSGDrag;
-class QSGDragPrivate;
+class QQuickItem;
+class QQuickDrag;
+class QQuickDragPrivate;
-class QSGDragGrabber
+class QQuickDragGrabber
{
- class Item : public QDeclarativeGuard<QSGItem>
+ class Item : public QDeclarativeGuard<QQuickItem>
{
public:
- Item(QSGItem *item) : QDeclarativeGuard<QSGItem>(item) {}
+ Item(QQuickItem *item) : QDeclarativeGuard<QQuickItem>(item) {}
QIntrusiveListNode node;
protected:
- void objectDestroyed(QSGItem *) { delete this; }
+ void objectDestroyed(QQuickItem *) { delete this; }
};
typedef QIntrusiveList<Item, &Item::node> ItemList;
public:
- QSGDragGrabber() : m_target(0) {}
- ~QSGDragGrabber() { while (!m_items.isEmpty()) delete m_items.first(); }
+ QQuickDragGrabber() : m_target(0) {}
+ ~QQuickDragGrabber() { while (!m_items.isEmpty()) delete m_items.first(); }
QObject *target() const
iterator begin() { return m_items.begin(); }
iterator end() { return m_items.end(); }
- void grab(QSGItem *item) { m_items.insert(new Item(item)); }
+ void grab(QQuickItem *item) { m_items.insert(new Item(item)); }
iterator release(iterator at) { Item *item = *at; at = at.erase(); delete item; return at; }
private:
QObject *m_target;
};
-class QSGDropEventEx : public QDropEvent
+class QQuickDropEventEx : public QDropEvent
{
public:
void setProposedAction(Qt::DropAction action) { default_action = action; drop_action = action; }
static void setProposedAction(QDropEvent *event, Qt::DropAction action) {
- static_cast<QSGDropEventEx *>(event)->setProposedAction(action);
+ static_cast<QQuickDropEventEx *>(event)->setProposedAction(action);
}
void copyActions(const QDropEvent &from) {
default_action = from.proposedAction(); drop_action = from.dropAction(); }
static void copyActions(QDropEvent *to, const QDropEvent &from) {
- static_cast<QSGDropEventEx *>(to)->copyActions(from);
+ static_cast<QQuickDropEventEx *>(to)->copyActions(from);
}
};
-class QSGDragMimeData : public QMimeData
+class QQuickDragMimeData : public QMimeData
{
Q_OBJECT
public:
- QSGDragMimeData()
+ QQuickDragMimeData()
: m_source(0)
{
}
Qt::DropActions m_supportedActions;
QStringList m_keys;
- friend class QSGDragAttached;
- friend class QSGDragAttachedPrivate;
+ friend class QQuickDragAttached;
+ friend class QQuickDragAttachedPrivate;
};
class QDeclarativeV8Function;
-class QSGDragAttachedPrivate;
-class QSGDragAttached : public QObject
+class QQuickDragAttachedPrivate;
+class QQuickDragAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged)
Q_PROPERTY(Qt::DropActions supportedActions READ supportedActions WRITE setSupportedActions NOTIFY supportedActionsChanged)
Q_PROPERTY(Qt::DropAction proposedAction READ proposedAction WRITE setProposedAction NOTIFY proposedActionChanged)
public:
- QSGDragAttached(QObject *parent);
- ~QSGDragAttached();
+ QQuickDragAttached(QObject *parent);
+ ~QQuickDragAttached();
bool isActive() const;
void setActive(bool active);
void proposedActionChanged();
private:
- Q_DECLARE_PRIVATE(QSGDragAttached)
+ Q_DECLARE_PRIVATE(QQuickDragAttached)
};
**
****************************************************************************/
-#include "qsgdroparea_p.h"
-#include "qsgdrag_p.h"
-#include "qsgitem_p.h"
-#include "qsgcanvas.h"
+#include "qquickdroparea_p.h"
+#include "qquickdrag_p.h"
+#include "qquickitem_p.h"
+#include "qquickcanvas.h"
#include <private/qdeclarativeengine_p.h>
-QSGDropAreaDrag::QSGDropAreaDrag(QSGDropAreaPrivate *d, QObject *parent)
+QQuickDropAreaDrag::QQuickDropAreaDrag(QQuickDropAreaPrivate *d, QObject *parent)
: QObject(parent)
, d(d)
{
}
-QSGDropAreaDrag::~QSGDropAreaDrag()
+QQuickDropAreaDrag::~QQuickDropAreaDrag()
{
}
-class QSGDropAreaPrivate : public QSGItemPrivate
+class QQuickDropAreaPrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGDropArea)
+ Q_DECLARE_PUBLIC(QQuickDropArea)
public:
- QSGDropAreaPrivate();
- ~QSGDropAreaPrivate();
+ QQuickDropAreaPrivate();
+ ~QQuickDropAreaPrivate();
bool hasMatchingKey(const QStringList &keys) const;
QStringList keys;
QRegExp keyRegExp;
QPointF dragPosition;
- QSGDropAreaDrag *drag;
+ QQuickDropAreaDrag *drag;
QDeclarativeGuard<QObject> source;
QDeclarativeGuard<QMimeData> mimeData;
};
-QSGDropAreaPrivate::QSGDropAreaPrivate()
+QQuickDropAreaPrivate::QQuickDropAreaPrivate()
: drag(0)
{
}
-QSGDropAreaPrivate::~QSGDropAreaPrivate()
+QQuickDropAreaPrivate::~QQuickDropAreaPrivate()
{
delete drag;
}
/*!
- \qmlclass DropArea QSGDropArea
+ \qmlclass DropArea QQuickDropArea
\inqmlmodule QtQuick 2
\brief The DropArea item provides drag and drop handling.
instantiated for each active drag over a drag target.
*/
-QSGDropArea::QSGDropArea(QSGItem *parent)
- : QSGItem(*new QSGDropAreaPrivate, parent)
+QQuickDropArea::QQuickDropArea(QQuickItem *parent)
+ : QQuickItem(*new QQuickDropAreaPrivate, parent)
{
setFlags(ItemAcceptsDrops);
}
-QSGDropArea::~QSGDropArea()
+QQuickDropArea::~QQuickDropArea()
{
}
dragged items.
*/
-bool QSGDropArea::containsDrag() const
+bool QQuickDropArea::containsDrag() const
{
- Q_D(const QSGDropArea);
+ Q_D(const QQuickDropArea);
return d->mimeData;
}
\sa QtQuick2::Drag::keys
*/
-QStringList QSGDropArea::keys() const
+QStringList QQuickDropArea::keys() const
{
- Q_D(const QSGDropArea);
+ Q_D(const QQuickDropArea);
return d->keys;
}
-void QSGDropArea::setKeys(const QStringList &keys)
+void QQuickDropArea::setKeys(const QStringList &keys)
{
- Q_D(QSGDropArea);
+ Q_D(QQuickDropArea);
if (d->keys != keys) {
d->keys = keys;
}
}
-QSGDropAreaDrag *QSGDropArea::drag()
+QQuickDropAreaDrag *QQuickDropArea::drag()
{
- Q_D(QSGDropArea);
+ Q_D(QQuickDropArea);
if (!d->drag)
- d->drag = new QSGDropAreaDrag(d);
+ d->drag = new QQuickDropAreaDrag(d);
return d->drag;
}
This property holds the source of a drag.
*/
-QObject *QSGDropAreaDrag::source() const
+QObject *QQuickDropAreaDrag::source() const
{
return d->source;
}
These properties hold the coordinates of the last drag event.
*/
-qreal QSGDropAreaDrag::x() const
+qreal QQuickDropAreaDrag::x() const
{
return d->dragPosition.x();
}
-qreal QSGDropAreaDrag::y() const
+qreal QQuickDropAreaDrag::y() const
{
return d->dragPosition.y();
}
This handler is called when the position of a drag has changed.
*/
-void QSGDropArea::dragMoveEvent(QDragMoveEvent *event)
+void QQuickDropArea::dragMoveEvent(QDragMoveEvent *event)
{
- Q_D(QSGDropArea);
+ Q_D(QQuickDropArea);
if (!d->mimeData)
return;
emit d->drag->positionChanged();
event->accept();
- QSGDropEvent dragTargetEvent(d, event);
+ QQuickDropEvent dragTargetEvent(d, event);
emit positionChanged(&dragTargetEvent);
}
-bool QSGDropAreaPrivate::hasMatchingKey(const QStringList &keys) const
+bool QQuickDropAreaPrivate::hasMatchingKey(const QStringList &keys) const
{
if (keyRegExp.isEmpty())
return true;
return false;
}
-QStringList QSGDropAreaPrivate::getKeys(const QMimeData *mimeData) const
+QStringList QQuickDropAreaPrivate::getKeys(const QMimeData *mimeData) const
{
- if (const QSGDragMimeData *dragMime = qobject_cast<const QSGDragMimeData *>(mimeData))
+ if (const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(mimeData))
return dragMime->keys();
return mimeData->formats();
}
This handler is called when a \a drag enters the bounds of a DropArea.
*/
-void QSGDropArea::dragEnterEvent(QDragEnterEvent *event)
+void QQuickDropArea::dragEnterEvent(QDragEnterEvent *event)
{
- Q_D(QSGDropArea);
+ Q_D(QQuickDropArea);
const QMimeData *mimeData = event->mimeData();
if (!d->effectiveEnable || d->mimeData || !mimeData || !d->hasMatchingKey(d->getKeys(mimeData)))
return;
d->dragPosition = event->pos();
event->accept();
- QSGDropEvent dragTargetEvent(d, event);
+ QQuickDropEvent dragTargetEvent(d, event);
emit entered(&dragTargetEvent);
if (event->isAccepted()) {
d->mimeData = const_cast<QMimeData *>(mimeData);
- if (QSGDragMimeData *dragMime = qobject_cast<QSGDragMimeData *>(d->mimeData))
+ if (QQuickDragMimeData *dragMime = qobject_cast<QQuickDragMimeData *>(d->mimeData))
d->source = dragMime->source();
else
d->source = event->source();
This handler is called when a drag exits the bounds of a DropArea.
*/
-void QSGDropArea::dragLeaveEvent(QDragLeaveEvent *)
+void QQuickDropArea::dragLeaveEvent(QDragLeaveEvent *)
{
- Q_D(QSGDropArea);
+ Q_D(QQuickDropArea);
if (!d->mimeData)
return;
a DropArea.
*/
-void QSGDropArea::dropEvent(QDropEvent *event)
+void QQuickDropArea::dropEvent(QDropEvent *event)
{
- Q_D(QSGDropArea);
+ Q_D(QQuickDropArea);
if (!d->mimeData)
return;
- QSGDropEvent dragTargetEvent(d, event);
+ QQuickDropEvent dragTargetEvent(d, event);
emit dropped(&dragTargetEvent);
d->mimeData = 0;
}
/*!
- \qmlclass DragEvent QSGDragEvent
+ \qmlclass DragEvent QQuickDragEvent
\inqmlmodule QtQuick 2
\brief The DragEvent object provides information about a drag event.
This property holds the source of a drag event.
*/
-QObject *QSGDropEvent::source()
+QObject *QQuickDropEvent::source()
{
- if (const QSGDragMimeData *dragMime = qobject_cast<const QSGDragMimeData *>(event->mimeData()))
+ if (const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(event->mimeData()))
return dragMime->source();
else
return event->source();
drag event.
*/
-QStringList QSGDropEvent::keys() const
+QStringList QQuickDropEvent::keys() const
{
return d->getKeys(event->mimeData());
}
If an \a action is specified it will overwrite the value of the \l action property.
*/
-void QSGDropEvent::accept(QDeclarativeV8Function *args)
+void QQuickDropEvent::accept(QDeclarativeV8Function *args)
{
Qt::DropAction action = event->dropAction();
**
****************************************************************************/
-#ifndef QSGDROPAREA_P_H
-#define QSGDROPAREA_P_H
+#ifndef QQUICKDROPAREA_P_H
+#define QQUICKDROPAREA_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <private/qdeclarativeguard_p.h>
#include <private/qv8engine_p.h>
QT_MODULE(Declarative)
-class QSGDropAreaPrivate;
-class QSGDropEvent : public QObject
+class QQuickDropAreaPrivate;
+class QQuickDropEvent : public QObject
{
Q_OBJECT
Q_PROPERTY(qreal x READ x)
Q_PROPERTY(Qt::DropAction action READ action WRITE setAction RESET resetAction)
Q_PROPERTY(bool accepted READ accepted WRITE setAccepted)
public:
- QSGDropEvent(QSGDropAreaPrivate *d, QDropEvent *event) : d(d), event(event) {}
+ QQuickDropEvent(QQuickDropAreaPrivate *d, QDropEvent *event) : d(d), event(event) {}
qreal x() const { return event->pos().x(); }
qreal y() const { return event->pos().y(); }
Q_INVOKABLE void accept(QDeclarativeV8Function *);
private:
- QSGDropAreaPrivate *d;
+ QQuickDropAreaPrivate *d;
QDropEvent *event;
};
-class QSGDropAreaDrag : public QObject
+class QQuickDropAreaDrag : public QObject
{
Q_OBJECT
Q_PROPERTY(qreal x READ x NOTIFY positionChanged)
Q_PROPERTY(qreal y READ y NOTIFY positionChanged)
Q_PROPERTY(QObject *source READ source NOTIFY sourceChanged)
public:
- QSGDropAreaDrag(QSGDropAreaPrivate *d, QObject *parent = 0);
- ~QSGDropAreaDrag();
+ QQuickDropAreaDrag(QQuickDropAreaPrivate *d, QObject *parent = 0);
+ ~QQuickDropAreaDrag();
qreal x() const;
qreal y() const;
void sourceChanged();
private:
- QSGDropAreaPrivate *d;
+ QQuickDropAreaPrivate *d;
- friend class QSGDropArea;
- friend class QSGDropAreaPrivate;
+ friend class QQuickDropArea;
+ friend class QQuickDropAreaPrivate;
};
-class QSGDropAreaPrivate;
-class Q_AUTOTEST_EXPORT QSGDropArea : public QSGItem
+class QQuickDropAreaPrivate;
+class Q_AUTOTEST_EXPORT QQuickDropArea : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(bool containsDrag READ containsDrag NOTIFY containsDragChanged)
Q_PROPERTY(QStringList keys READ keys WRITE setKeys NOTIFY keysChanged)
- Q_PROPERTY(QSGDropAreaDrag *drag READ drag CONSTANT)
+ Q_PROPERTY(QQuickDropAreaDrag *drag READ drag CONSTANT)
public:
- QSGDropArea(QSGItem *parent=0);
- ~QSGDropArea();
+ QQuickDropArea(QQuickItem *parent=0);
+ ~QQuickDropArea();
bool containsDrag() const;
void setContainsDrag(bool drag);
QStringList keys() const;
void setKeys(const QStringList &keys);
- QSGDropAreaDrag *drag();
+ QQuickDropAreaDrag *drag();
Q_SIGNALS:
void containsDragChanged();
void keysChanged();
void sourceChanged();
- void entered(QSGDropEvent *drag);
+ void entered(QQuickDropEvent *drag);
void exited();
- void positionChanged(QSGDropEvent *drag);
- void dropped(QSGDropEvent *drop);
+ void positionChanged(QQuickDropEvent *drag);
+ void dropped(QQuickDropEvent *drop);
protected:
void dragMoveEvent(QDragMoveEvent *event);
void dropEvent(QDropEvent *event);
private:
- Q_DISABLE_COPY(QSGDropArea)
- Q_DECLARE_PRIVATE(QSGDropArea)
+ Q_DISABLE_COPY(QQuickDropArea)
+ Q_DECLARE_PRIVATE(QQuickDropArea)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGDropEvent)
-QML_DECLARE_TYPE(QSGDropArea)
+QML_DECLARE_TYPE(QQuickDropEvent)
+QML_DECLARE_TYPE(QQuickDropArea)
QT_END_HEADER
-#endif // QSGDRAGTARGET_P_H
+#endif // QQUICKDROPAREA_P_H
**
****************************************************************************/
-#include "qsgevents_p_p.h"
+#include "qquickevents_p_p.h"
QT_BEGIN_NAMESPACE
/*!
- \qmlclass KeyEvent QSGKeyEvent
+ \qmlclass KeyEvent QQuickKeyEvent
\inqmlmodule QtQuick 2
\ingroup qml-event-elements
/*!
- \qmlclass MouseEvent QSGMouseEvent
+ \qmlclass MouseEvent QQuickMouseEvent
\inqmlmodule QtQuick 2
\ingroup qml-event-elements
/*!
\internal
- \class QSGMouseEvent
+ \class QQuickMouseEvent
*/
/*!
**
****************************************************************************/
-#ifndef QSGEVENTS_P_P_H
-#define QSGEVENTS_P_P_H
+#ifndef QQUICKEVENTS_P_P_H
+#define QQUICKEVENTS_P_P_H
//
// W A R N I N G
QT_BEGIN_NAMESPACE
-class QSGKeyEvent : public QObject
+class QQuickKeyEvent : public QObject
{
Q_OBJECT
Q_PROPERTY(int key READ key)
Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
public:
- QSGKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text=QString(), bool autorep=false, ushort count=1)
+ QQuickKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text=QString(), bool autorep=false, ushort count=1)
: event(type, key, modifiers, text, autorep, count) { event.setAccepted(false); }
- QSGKeyEvent(const QKeyEvent &ke)
+ QQuickKeyEvent(const QKeyEvent &ke)
: event(ke) { event.setAccepted(false); }
int key() const { return event.key(); }
};
// used in QtLocation
-class Q_DECLARATIVE_EXPORT QSGMouseEvent : public QObject
+class Q_DECLARATIVE_EXPORT QQuickMouseEvent : public QObject
{
Q_OBJECT
Q_PROPERTY(int x READ x)
Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
public:
- QSGMouseEvent(int x, int y, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers
+ QQuickMouseEvent(int x, int y, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers
, bool isClick=false, bool wasHeld=false)
: _x(x), _y(y), _button(button), _buttons(buttons), _modifiers(modifiers)
, _wasHeld(wasHeld), _isClick(isClick), _accepted(true) {}
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGKeyEvent)
-QML_DECLARE_TYPE(QSGMouseEvent)
+QML_DECLARE_TYPE(QQuickKeyEvent)
+QML_DECLARE_TYPE(QQuickMouseEvent)
-#endif // QSGEVENTS_P_P_H
+#endif // QQUICKEVENTS_P_P_H
**
****************************************************************************/
-#include "qsgflickable_p.h"
-#include "qsgflickable_p_p.h"
-#include "qsgcanvas.h"
-#include "qsgcanvas_p.h"
+#include "qquickflickable_p.h"
+#include "qquickflickable_p_p.h"
+#include "qquickcanvas.h"
+#include "qquickcanvas_p.h"
#include <QtDeclarative/qdeclarativeinfo.h>
#include <QtGui/qevent.h>
// will ensure the Flickable retains the grab on consecutive flicks.
static const int RetainGrabVelocity = 15;
-QSGFlickableVisibleArea::QSGFlickableVisibleArea(QSGFlickable *parent)
+QQuickFlickableVisibleArea::QQuickFlickableVisibleArea(QQuickFlickable *parent)
: QObject(parent), flickable(parent), m_xPosition(0.), m_widthRatio(0.)
, m_yPosition(0.), m_heightRatio(0.)
{
}
-qreal QSGFlickableVisibleArea::widthRatio() const
+qreal QQuickFlickableVisibleArea::widthRatio() const
{
return m_widthRatio;
}
-qreal QSGFlickableVisibleArea::xPosition() const
+qreal QQuickFlickableVisibleArea::xPosition() const
{
return m_xPosition;
}
-qreal QSGFlickableVisibleArea::heightRatio() const
+qreal QQuickFlickableVisibleArea::heightRatio() const
{
return m_heightRatio;
}
-qreal QSGFlickableVisibleArea::yPosition() const
+qreal QQuickFlickableVisibleArea::yPosition() const
{
return m_yPosition;
}
-void QSGFlickableVisibleArea::updateVisible()
+void QQuickFlickableVisibleArea::updateVisible()
{
- QSGFlickablePrivate *p = QSGFlickablePrivate::get(flickable);
+ QQuickFlickablePrivate *p = QQuickFlickablePrivate::get(flickable);
bool changeX = false;
bool changeY = false;
}
-QSGFlickablePrivate::QSGFlickablePrivate()
- : contentItem(new QSGItem)
- , hData(this, &QSGFlickablePrivate::setViewportX)
- , vData(this, &QSGFlickablePrivate::setViewportY)
+QQuickFlickablePrivate::QQuickFlickablePrivate()
+ : contentItem(new QQuickItem)
+ , hData(this, &QQuickFlickablePrivate::setViewportX)
+ , vData(this, &QQuickFlickablePrivate::setViewportY)
, hMoved(false), vMoved(false)
, stealMouse(false), pressed(false), interactive(true), calcVelocity(false)
, pixelAligned(false)
, maxVelocity(QML_FLICK_DEFAULTMAXVELOCITY), reportedVelocitySmoothing(100)
, delayedPressEvent(0), delayedPressTarget(0), pressDelay(0), fixupDuration(400)
, fixupMode(Normal), vTime(0), visibleArea(0)
- , flickableDirection(QSGFlickable::AutoFlickDirection)
- , boundsBehavior(QSGFlickable::DragAndOvershootBounds)
+ , flickableDirection(QQuickFlickable::AutoFlickDirection)
+ , boundsBehavior(QQuickFlickable::DragAndOvershootBounds)
{
}
-void QSGFlickablePrivate::init()
+void QQuickFlickablePrivate::init()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
QDeclarative_setParent_noEvent(contentItem, q);
contentItem->setParentItem(q);
FAST_CONNECT(&timeline, SIGNAL(updated()), q, SLOT(ticked()))
FAST_CONNECT(&timeline, SIGNAL(completed()), q, SLOT(movementEnding()))
q->setAcceptedMouseButtons(Qt::LeftButton);
q->setFiltersChildMouseEvents(true);
- QSGItemPrivate *viewportPrivate = QSGItemPrivate::get(contentItem);
- viewportPrivate->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *viewportPrivate = QQuickItemPrivate::get(contentItem);
+ viewportPrivate->addItemChangeListener(this, QQuickItemPrivate::Geometry);
lastPosTime.invalidate();
}
Returns the amount to overshoot by given a velocity.
Will be roughly in range 0 - size/4
*/
-qreal QSGFlickablePrivate::overShootDistance(qreal size)
+qreal QQuickFlickablePrivate::overShootDistance(qreal size)
{
if (maxVelocity <= 0)
return 0.0;
return qMin(qreal(QML_FLICK_OVERSHOOT), size/3);
}
-void QSGFlickablePrivate::AxisData::addVelocitySample(qreal v, qreal maxVelocity)
+void QQuickFlickablePrivate::AxisData::addVelocitySample(qreal v, qreal maxVelocity)
{
if (v > maxVelocity)
v = maxVelocity;
velocityBuffer.remove(0);
}
-void QSGFlickablePrivate::AxisData::updateVelocity()
+void QQuickFlickablePrivate::AxisData::updateVelocity()
{
velocity = 0;
if (velocityBuffer.count() > QML_FLICK_DISCARDSAMPLES) {
}
}
-void QSGFlickablePrivate::itemGeometryChanged(QSGItem *item, const QRectF &newGeom, const QRectF &oldGeom)
+void QQuickFlickablePrivate::itemGeometryChanged(QQuickItem *item, const QRectF &newGeom, const QRectF &oldGeom)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
if (item == contentItem) {
if (newGeom.x() != oldGeom.x())
emit q->contentXChanged();
}
}
-void QSGFlickablePrivate::flickX(qreal velocity)
+void QQuickFlickablePrivate::flickX(qreal velocity)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
flick(hData, q->minXExtent(), q->maxXExtent(), q->width(), fixupX_callback, velocity);
}
-void QSGFlickablePrivate::flickY(qreal velocity)
+void QQuickFlickablePrivate::flickY(qreal velocity)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
flick(vData, q->minYExtent(), q->maxYExtent(), q->height(), fixupY_callback, velocity);
}
-void QSGFlickablePrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal,
+void QQuickFlickablePrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal,
QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
qreal maxDistance = -1;
data.fixingUp = false;
// -ve velocity means list is moving up
v = maxVelocity;
}
timeline.reset(data.move);
- if (boundsBehavior == QSGFlickable::DragAndOvershootBounds)
+ if (boundsBehavior == QQuickFlickable::DragAndOvershootBounds)
timeline.accel(data.move, v, deceleration);
else
timeline.accel(data.move, v, deceleration, maxDistance);
}
}
-void QSGFlickablePrivate::fixupY_callback(void *data)
+void QQuickFlickablePrivate::fixupY_callback(void *data)
{
- ((QSGFlickablePrivate *)data)->fixupY();
+ ((QQuickFlickablePrivate *)data)->fixupY();
}
-void QSGFlickablePrivate::fixupX_callback(void *data)
+void QQuickFlickablePrivate::fixupX_callback(void *data)
{
- ((QSGFlickablePrivate *)data)->fixupX();
+ ((QQuickFlickablePrivate *)data)->fixupX();
}
-void QSGFlickablePrivate::fixupX()
+void QQuickFlickablePrivate::fixupX()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
fixup(hData, q->minXExtent(), q->maxXExtent());
}
-void QSGFlickablePrivate::fixupY()
+void QQuickFlickablePrivate::fixupY()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
fixup(vData, q->minYExtent(), q->maxYExtent());
}
-void QSGFlickablePrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
+void QQuickFlickablePrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
{
if (data.move.value() > minExtent || maxExtent > minExtent) {
timeline.reset(data.move);
vTime = timeline.time();
}
-void QSGFlickablePrivate::updateBeginningEnd()
+void QQuickFlickablePrivate::updateBeginningEnd()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
bool atBoundaryChange = false;
// Vertical
*/
/*!
- \qmlclass Flickable QSGFlickable
+ \qmlclass Flickable QQuickFlickable
\inqmlmodule QtQuick 2
\ingroup qml-basic-interaction-elements
\sa {declarative/ui-components/scrollbar}{scrollbar example}
*/
-QSGFlickable::QSGFlickable(QSGItem *parent)
- : QSGItem(*(new QSGFlickablePrivate), parent)
+QQuickFlickable::QQuickFlickable(QQuickItem *parent)
+ : QQuickItem(*(new QQuickFlickablePrivate), parent)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
d->init();
}
-QSGFlickable::QSGFlickable(QSGFlickablePrivate &dd, QSGItem *parent)
- : QSGItem(dd, parent)
+QQuickFlickable::QQuickFlickable(QQuickFlickablePrivate &dd, QQuickItem *parent)
+ : QQuickItem(dd, parent)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
d->init();
}
-QSGFlickable::~QSGFlickable()
+QQuickFlickable::~QQuickFlickable()
{
}
corner of the Flickable. For example, if you flick an image up 100 pixels,
\c contentY will be 100.
*/
-qreal QSGFlickable::contentX() const
+qreal QQuickFlickable::contentX() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return -d->contentItem->x();
}
-void QSGFlickable::setContentX(qreal pos)
+void QQuickFlickable::setContentX(qreal pos)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
d->hData.explicitValue = true;
d->timeline.reset(d->hData.move);
d->vTime = d->timeline.time();
}
}
-qreal QSGFlickable::contentY() const
+qreal QQuickFlickable::contentY() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return -d->contentItem->y();
}
-void QSGFlickable::setContentY(qreal pos)
+void QQuickFlickable::setContentY(qreal pos)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
d->vData.explicitValue = true;
d->timeline.reset(d->vData.move);
d->vTime = d->timeline.time();
to freeze a flickable map while scrolling through a pop-up dialog that
is a child of the Flickable.
*/
-bool QSGFlickable::isInteractive() const
+bool QQuickFlickable::isInteractive() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->interactive;
}
-void QSGFlickable::setInteractive(bool interactive)
+void QQuickFlickable::setInteractive(bool interactive)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (interactive != d->interactive) {
d->interactive = interactive;
if (!interactive && (d->hData.flicking || d->vData.flicking)) {
The reported velocity is smoothed to avoid erratic output.
*/
-qreal QSGFlickable::horizontalVelocity() const
+qreal QQuickFlickable::horizontalVelocity() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.smoothVelocity.value();
}
-qreal QSGFlickable::verticalVelocity() const
+qreal QQuickFlickable::verticalVelocity() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.smoothVelocity.value();
}
These properties are true if the flickable view is positioned at the beginning,
or end respecively.
*/
-bool QSGFlickable::isAtXEnd() const
+bool QQuickFlickable::isAtXEnd() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.atEnd;
}
-bool QSGFlickable::isAtXBeginning() const
+bool QQuickFlickable::isAtXBeginning() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.atBeginning;
}
-bool QSGFlickable::isAtYEnd() const
+bool QQuickFlickable::isAtYEnd() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.atEnd;
}
-bool QSGFlickable::isAtYBeginning() const
+bool QQuickFlickable::isAtYBeginning() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.atBeginning;
}
-void QSGFlickable::ticked()
+void QQuickFlickable::ticked()
{
viewportMoved();
}
}
\endcode
*/
-QSGItem *QSGFlickable::contentItem()
+QQuickItem *QQuickFlickable::contentItem()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
return d->contentItem;
}
-QSGFlickableVisibleArea *QSGFlickable::visibleArea()
+QQuickFlickableVisibleArea *QQuickFlickable::visibleArea()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (!d->visibleArea)
- d->visibleArea = new QSGFlickableVisibleArea(this);
+ d->visibleArea = new QQuickFlickableVisibleArea(this);
return d->visibleArea;
}
\o Flickable.HorizontalAndVerticalFlick - allows flicking in both directions.
\endlist
*/
-QSGFlickable::FlickableDirection QSGFlickable::flickableDirection() const
+QQuickFlickable::FlickableDirection QQuickFlickable::flickableDirection() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->flickableDirection;
}
-void QSGFlickable::setFlickableDirection(FlickableDirection direction)
+void QQuickFlickable::setFlickableDirection(FlickableDirection direction)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (direction != d->flickableDirection) {
d->flickableDirection = direction;
emit flickableDirectionChanged();
}
}
-bool QSGFlickable::pixelAligned() const
+bool QQuickFlickable::pixelAligned() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->pixelAligned;
}
-void QSGFlickable::setPixelAligned(bool align)
+void QQuickFlickable::setPixelAligned(bool align)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (align != d->pixelAligned) {
d->pixelAligned = align;
emit pixelAlignedChanged();
}
}
-void QSGFlickablePrivate::handleMousePressEvent(QMouseEvent *event)
+void QQuickFlickablePrivate::handleMousePressEvent(QMouseEvent *event)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
if (interactive && timeline.isActive()
&& (qAbs(hData.smoothVelocity.value()) > RetainGrabVelocity
|| qAbs(vData.smoothVelocity.value()) > RetainGrabVelocity)) {
vData.dragMaxBound = q->maxYExtent();
fixupMode = Normal;
lastPos = QPoint();
- QSGItemPrivate::start(lastPosTime);
+ QQuickItemPrivate::start(lastPosTime);
pressPos = event->localPos();
hData.pressPos = hData.move.value();
vData.pressPos = vData.move.value();
hData.flicking = false;
vData.flicking = false;
- QSGItemPrivate::start(pressTime);
- QSGItemPrivate::start(velocityTime);
+ QQuickItemPrivate::start(pressTime);
+ QQuickItemPrivate::start(velocityTime);
}
-void QSGFlickablePrivate::handleMouseMoveEvent(QMouseEvent *event)
+void QQuickFlickablePrivate::handleMouseMoveEvent(QMouseEvent *event)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
if (!interactive || !lastPosTime.isValid())
return;
bool rejectY = false;
if (q->yflick()) {
int dy = int(event->localPos().y() - pressPos.y());
- if (qAbs(dy) > qApp->styleHints()->startDragDistance() || QSGItemPrivate::elapsed(pressTime) > 200) {
+ if (qAbs(dy) > qApp->styleHints()->startDragDistance() || QQuickItemPrivate::elapsed(pressTime) > 200) {
if (!vMoved)
vData.dragStartOffset = dy;
qreal newY = dy + vData.pressPos - vData.dragStartOffset;
newY = minY + (newY - minY) / 2;
if (newY < maxY && maxY - minY <= 0)
newY = maxY + (newY - maxY) / 2;
- if (boundsBehavior == QSGFlickable::StopAtBounds && (newY > minY || newY < maxY)) {
+ if (boundsBehavior == QQuickFlickable::StopAtBounds && (newY > minY || newY < maxY)) {
rejectY = true;
if (newY < maxY) {
newY = maxY;
if (q->xflick()) {
int dx = int(event->localPos().x() - pressPos.x());
- if (qAbs(dx) > qApp->styleHints()->startDragDistance() || QSGItemPrivate::elapsed(pressTime) > 200) {
+ if (qAbs(dx) > qApp->styleHints()->startDragDistance() || QQuickItemPrivate::elapsed(pressTime) > 200) {
if (!hMoved)
hData.dragStartOffset = dx;
qreal newX = dx + hData.pressPos - hData.dragStartOffset;
newX = minX + (newX - minX) / 2;
if (newX < maxX && maxX - minX <= 0)
newX = maxX + (newX - maxX) / 2;
- if (boundsBehavior == QSGFlickable::StopAtBounds && (newX > minX || newX < maxX)) {
+ if (boundsBehavior == QQuickFlickable::StopAtBounds && (newX > minX || newX < maxX)) {
rejectX = true;
if (newX < maxX) {
newX = maxX;
}
if (!lastPos.isNull()) {
- qreal elapsed = qreal(QSGItemPrivate::elapsed(lastPosTime)) / 1000.;
+ qreal elapsed = qreal(QQuickItemPrivate::elapsed(lastPosTime)) / 1000.;
if (elapsed <= 0)
return;
- QSGItemPrivate::restart(lastPosTime);
+ QQuickItemPrivate::restart(lastPosTime);
qreal dy = event->localPos().y()-lastPos.y();
if (q->yflick() && !rejectY)
vData.addVelocitySample(dy/elapsed, maxVelocity);
lastPos = event->localPos();
}
-void QSGFlickablePrivate::handleMouseReleaseEvent(QMouseEvent *event)
+void QQuickFlickablePrivate::handleMouseReleaseEvent(QMouseEvent *event)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
stealMouse = false;
q->setKeepMouseGrab(false);
pressed = false;
// if we drag then pause before release we should not cause a flick.
- qint64 elapsed = QSGItemPrivate::elapsed(lastPosTime);
+ qint64 elapsed = QQuickItemPrivate::elapsed(lastPosTime);
vData.updateVelocity();
hData.updateVelocity();
q->movementEnding();
}
-void QSGFlickable::mousePressEvent(QMouseEvent *event)
+void QQuickFlickable::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->interactive) {
if (!d->pressed)
d->handleMousePressEvent(event);
event->accept();
} else {
- QSGItem::mousePressEvent(event);
+ QQuickItem::mousePressEvent(event);
}
}
-void QSGFlickable::mouseMoveEvent(QMouseEvent *event)
+void QQuickFlickable::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->interactive) {
d->handleMouseMoveEvent(event);
event->accept();
} else {
- QSGItem::mouseMoveEvent(event);
+ QQuickItem::mouseMoveEvent(event);
}
}
-void QSGFlickable::mouseReleaseEvent(QMouseEvent *event)
+void QQuickFlickable::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->interactive) {
d->clearDelayedPress();
d->handleMouseReleaseEvent(event);
event->accept();
ungrabMouse();
} else {
- QSGItem::mouseReleaseEvent(event);
+ QQuickItem::mouseReleaseEvent(event);
}
}
-void QSGFlickable::wheelEvent(QWheelEvent *event)
+void QQuickFlickable::wheelEvent(QWheelEvent *event)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (!d->interactive) {
- QSGItem::wheelEvent(event);
+ QQuickItem::wheelEvent(event);
} else if (yflick() && event->orientation() == Qt::Vertical) {
bool valid = false;
if (event->delta() > 0 && contentY() > -minYExtent()) {
event->accept();
}
} else {
- QSGItem::wheelEvent(event);
+ QQuickItem::wheelEvent(event);
}
}
-bool QSGFlickablePrivate::isOutermostPressDelay() const
+bool QQuickFlickablePrivate::isOutermostPressDelay() const
{
- Q_Q(const QSGFlickable);
- QSGItem *item = q->parentItem();
+ Q_Q(const QQuickFlickable);
+ QQuickItem *item = q->parentItem();
while (item) {
- QSGFlickable *flick = qobject_cast<QSGFlickable*>(item);
+ QQuickFlickable *flick = qobject_cast<QQuickFlickable*>(item);
if (flick && flick->pressDelay() > 0 && flick->isInteractive())
return false;
item = item->parentItem();
return true;
}
-void QSGFlickablePrivate::captureDelayedPress(QMouseEvent *event)
+void QQuickFlickablePrivate::captureDelayedPress(QMouseEvent *event)
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
if (!q->canvas() || pressDelay <= 0)
return;
if (!isOutermostPressDelay())
delayedPressTimer.start(pressDelay, q);
}
-void QSGFlickablePrivate::clearDelayedPress()
+void QQuickFlickablePrivate::clearDelayedPress()
{
if (delayedPressEvent) {
delayedPressTimer.stop();
}
//XXX pixelAligned ignores the global position of the Flickable, i.e. assumes Flickable itself is pixel aligned.
-void QSGFlickablePrivate::setViewportX(qreal x)
+void QQuickFlickablePrivate::setViewportX(qreal x)
{
contentItem->setX(pixelAligned ? qRound(x) : x);
}
-void QSGFlickablePrivate::setViewportY(qreal y)
+void QQuickFlickablePrivate::setViewportY(qreal y)
{
contentItem->setY(pixelAligned ? qRound(y) : y);
}
-void QSGFlickable::timerEvent(QTimerEvent *event)
+void QQuickFlickable::timerEvent(QTimerEvent *event)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (event->timerId() == d->delayedPressTimer.timerId()) {
d->delayedPressTimer.stop();
if (d->delayedPressEvent) {
- QSGItem *grabber = canvas() ? canvas()->mouseGrabberItem() : 0;
+ QQuickItem *grabber = canvas() ? canvas()->mouseGrabberItem() : 0;
if (!grabber || grabber != this) {
// We replay the mouse press but the grabber we had might not be interessted by the event (e.g. overlay)
// so we reset the grabber
if (canvas()->mouseGrabberItem() == d->delayedPressTarget)
d->delayedPressTarget->ungrabMouse();
// Use the event handler that will take care of finding the proper item to propagate the event
- QSGCanvasPrivate::get(canvas())->deliverMouseEvent(d->delayedPressEvent);
+ QQuickCanvasPrivate::get(canvas())->deliverMouseEvent(d->delayedPressEvent);
}
delete d->delayedPressEvent;
d->delayedPressEvent = 0;
}
}
-qreal QSGFlickable::minYExtent() const
+qreal QQuickFlickable::minYExtent() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.startMargin;
}
-qreal QSGFlickable::minXExtent() const
+qreal QQuickFlickable::minXExtent() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.startMargin;
}
/* returns -ve */
-qreal QSGFlickable::maxXExtent() const
+qreal QQuickFlickable::maxXExtent() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return width() - vWidth() - d->hData.endMargin;
}
/* returns -ve */
-qreal QSGFlickable::maxYExtent() const
+qreal QQuickFlickable::maxYExtent() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return height() - vHeight() - d->vData.endMargin;
}
-void QSGFlickable::componentComplete()
+void QQuickFlickable::componentComplete()
{
- Q_D(QSGFlickable);
- QSGItem::componentComplete();
+ Q_D(QQuickFlickable);
+ QQuickItem::componentComplete();
if (!d->hData.explicitValue && d->hData.startMargin != 0.)
setContentX(-minXExtent());
if (!d->vData.explicitValue && d->vData.startMargin != 0.)
setContentY(-minYExtent());
}
-void QSGFlickable::viewportMoved()
+void QQuickFlickable::viewportMoved()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
qreal prevX = d->lastFlickablePosition.x();
qreal prevY = d->lastFlickablePosition.y();
if (d->pressed || d->calcVelocity) {
- int elapsed = QSGItemPrivate::restart(d->velocityTime);
+ int elapsed = QQuickItemPrivate::restart(d->velocityTime);
if (elapsed > 0) {
qreal horizontalVelocity = (prevX - d->hData.move.value()) * 1000 / elapsed;
if (qAbs(horizontalVelocity) > 0) {
d->updateBeginningEnd();
}
-void QSGFlickable::geometryChanged(const QRectF &newGeometry,
+void QQuickFlickable::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
- Q_D(QSGFlickable);
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ Q_D(QQuickFlickable);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
bool changed = false;
if (newGeometry.width() != oldGeometry.width()) {
}
// Make sure that we're entirely in view.
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupX();
}
}
}
// Make sure that we're entirely in view.
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupY();
}
}
d->updateBeginningEnd();
}
-void QSGFlickable::cancelFlick()
+void QQuickFlickable::cancelFlick()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
d->timeline.reset(d->hData.move);
d->timeline.reset(d->vData.move);
movementEnding();
}
-void QSGFlickablePrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
+void QQuickFlickablePrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
{
- QSGItem *i = qobject_cast<QSGItem *>(o);
+ QQuickItem *i = qobject_cast<QQuickItem *>(o);
if (i) {
- i->setParentItem(static_cast<QSGFlickablePrivate*>(prop->data)->contentItem);
+ i->setParentItem(static_cast<QQuickFlickablePrivate*>(prop->data)->contentItem);
} else {
o->setParent(prop->object); // XXX todo - do we want this?
}
}
-int QSGFlickablePrivate::data_count(QDeclarativeListProperty<QObject> *)
+int QQuickFlickablePrivate::data_count(QDeclarativeListProperty<QObject> *)
{
// XXX todo
return 0;
}
-QObject *QSGFlickablePrivate::data_at(QDeclarativeListProperty<QObject> *, int)
+QObject *QQuickFlickablePrivate::data_at(QDeclarativeListProperty<QObject> *, int)
{
// XXX todo
return 0;
}
-void QSGFlickablePrivate::data_clear(QDeclarativeListProperty<QObject> *)
+void QQuickFlickablePrivate::data_clear(QDeclarativeListProperty<QObject> *)
{
// XXX todo
}
-QDeclarativeListProperty<QObject> QSGFlickable::flickableData()
+QDeclarativeListProperty<QObject> QQuickFlickable::flickableData()
{
- Q_D(QSGFlickable);
- return QDeclarativeListProperty<QObject>(this, (void *)d, QSGFlickablePrivate::data_append,
- QSGFlickablePrivate::data_count,
- QSGFlickablePrivate::data_at,
- QSGFlickablePrivate::data_clear);
+ Q_D(QQuickFlickable);
+ return QDeclarativeListProperty<QObject>(this, (void *)d, QQuickFlickablePrivate::data_append,
+ QQuickFlickablePrivate::data_count,
+ QQuickFlickablePrivate::data_at,
+ QQuickFlickablePrivate::data_clear);
}
-QDeclarativeListProperty<QSGItem> QSGFlickable::flickableChildren()
+QDeclarativeListProperty<QQuickItem> QQuickFlickable::flickableChildren()
{
- Q_D(QSGFlickable);
- return QSGItemPrivate::get(d->contentItem)->children();
+ Q_D(QQuickFlickable);
+ return QQuickItemPrivate::get(d->contentItem)->children();
}
/*!
boundary when flicked.
\endlist
*/
-QSGFlickable::BoundsBehavior QSGFlickable::boundsBehavior() const
+QQuickFlickable::BoundsBehavior QQuickFlickable::boundsBehavior() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->boundsBehavior;
}
-void QSGFlickable::setBoundsBehavior(BoundsBehavior b)
+void QQuickFlickable::setBoundsBehavior(BoundsBehavior b)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (b == d->boundsBehavior)
return;
d->boundsBehavior = b;
using the \l {Item::childrenRect.width}{childrenRect.width}
and \l {Item::childrenRect.height}{childrenRect.height} properties.
*/
-qreal QSGFlickable::contentWidth() const
+qreal QQuickFlickable::contentWidth() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.viewSize;
}
-void QSGFlickable::setContentWidth(qreal w)
+void QQuickFlickable::setContentWidth(qreal w)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->hData.viewSize == w)
return;
d->hData.viewSize = w;
d->hData.markExtentsDirty();
// Make sure that we're entirely in view.
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupX();
} else if (!d->pressed && d->hData.fixingUp) {
- d->fixupMode = QSGFlickablePrivate::ExtentChanged;
+ d->fixupMode = QQuickFlickablePrivate::ExtentChanged;
d->fixupX();
}
emit contentWidthChanged();
d->updateBeginningEnd();
}
-qreal QSGFlickable::contentHeight() const
+qreal QQuickFlickable::contentHeight() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.viewSize;
}
-void QSGFlickable::setContentHeight(qreal h)
+void QQuickFlickable::setContentHeight(qreal h)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->vData.viewSize == h)
return;
d->vData.viewSize = h;
d->vData.markExtentsDirty();
// Make sure that we're entirely in view.
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupY();
} else if (!d->pressed && d->vData.fixingUp) {
- d->fixupMode = QSGFlickablePrivate::ExtentChanged;
+ d->fixupMode = QQuickFlickablePrivate::ExtentChanged;
d->fixupY();
}
emit contentHeightChanged();
*/
-qreal QSGFlickable::topMargin() const
+qreal QQuickFlickable::topMargin() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.startMargin;
}
-void QSGFlickable::setTopMargin(qreal m)
+void QQuickFlickable::setTopMargin(qreal m)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->vData.startMargin == m)
return;
d->vData.startMargin = m;
d->vData.markExtentsDirty();
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupY();
}
emit topMarginChanged();
d->updateBeginningEnd();
}
-qreal QSGFlickable::bottomMargin() const
+qreal QQuickFlickable::bottomMargin() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.endMargin;
}
-void QSGFlickable::setBottomMargin(qreal m)
+void QQuickFlickable::setBottomMargin(qreal m)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->vData.endMargin == m)
return;
d->vData.endMargin = m;
d->vData.markExtentsDirty();
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupY();
}
emit bottomMarginChanged();
d->updateBeginningEnd();
}
-qreal QSGFlickable::leftMargin() const
+qreal QQuickFlickable::leftMargin() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.startMargin;
}
-void QSGFlickable::setLeftMargin(qreal m)
+void QQuickFlickable::setLeftMargin(qreal m)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->hData.startMargin == m)
return;
d->hData.startMargin = m;
d->hData.markExtentsDirty();
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupX();
}
emit leftMarginChanged();
d->updateBeginningEnd();
}
-qreal QSGFlickable::rightMargin() const
+qreal QQuickFlickable::rightMargin() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.endMargin;
}
-void QSGFlickable::setRightMargin(qreal m)
+void QQuickFlickable::setRightMargin(qreal m)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->hData.endMargin == m)
return;
d->hData.endMargin = m;
d->hData.markExtentsDirty();
if (!d->pressed && !d->hData.moving && !d->vData.moving) {
- d->fixupMode = QSGFlickablePrivate::Immediate;
+ d->fixupMode = QQuickFlickablePrivate::Immediate;
d->fixupX();
}
emit rightMarginChanged();
or item insertion/removal outside the visible region.
*/
-qreal QSGFlickable::yOrigin() const
+qreal QQuickFlickable::yOrigin() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return -minYExtent() + d->vData.startMargin;
}
-qreal QSGFlickable::xOrigin() const
+qreal QQuickFlickable::xOrigin() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return -minXExtent() + d->hData.startMargin;
}
the bounds of the Flickable. Calling \l returnToBounds() will
move the content back within legal bounds.
*/
-void QSGFlickable::resizeContent(qreal w, qreal h, QPointF center)
+void QQuickFlickable::resizeContent(qreal w, qreal h, QPointF center)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (w != d->hData.viewSize) {
qreal oldSize = d->hData.viewSize;
d->hData.viewSize = w;
This may be called to ensure that the content is within legal bounds
after manually positioning the content.
*/
-void QSGFlickable::returnToBounds()
+void QQuickFlickable::returnToBounds()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
d->fixupX();
d->fixupY();
}
-qreal QSGFlickable::vWidth() const
+qreal QQuickFlickable::vWidth() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
if (d->hData.viewSize < 0)
return width();
else
return d->hData.viewSize;
}
-qreal QSGFlickable::vHeight() const
+qreal QQuickFlickable::vHeight() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
if (d->vData.viewSize < 0)
return height();
else
return d->vData.viewSize;
}
-bool QSGFlickable::xflick() const
+bool QQuickFlickable::xflick() const
{
- Q_D(const QSGFlickable);
- if (d->flickableDirection == QSGFlickable::AutoFlickDirection)
+ Q_D(const QQuickFlickable);
+ if (d->flickableDirection == QQuickFlickable::AutoFlickDirection)
return vWidth() != width();
- return d->flickableDirection & QSGFlickable::HorizontalFlick;
+ return d->flickableDirection & QQuickFlickable::HorizontalFlick;
}
-bool QSGFlickable::yflick() const
+bool QQuickFlickable::yflick() const
{
- Q_D(const QSGFlickable);
- if (d->flickableDirection == QSGFlickable::AutoFlickDirection)
+ Q_D(const QQuickFlickable);
+ if (d->flickableDirection == QQuickFlickable::AutoFlickDirection)
return vHeight() != height();
- return d->flickableDirection & QSGFlickable::VerticalFlick;
+ return d->flickableDirection & QQuickFlickable::VerticalFlick;
}
-void QSGFlickable::mouseUngrabEvent()
+void QQuickFlickable::mouseUngrabEvent()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->pressed) {
// if our mouse grab has been removed (probably by another Flickable),
// fix our state
}
}
-bool QSGFlickable::sendMouseEvent(QMouseEvent *event)
+bool QQuickFlickable::sendMouseEvent(QMouseEvent *event)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
QRectF myRect = mapRectToScene(QRectF(0, 0, width(), height()));
- QSGCanvas *c = canvas();
- QSGItem *grabber = c ? c->mouseGrabberItem() : 0;
+ QQuickCanvas *c = canvas();
+ QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool disabledItem = grabber && !grabber->isEnabled();
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || myRect.contains(event->windowPos())) && (!grabber || !grabber->keepMouseGrab() || disabledItem)) {
if (c->mouseGrabberItem() == d->delayedPressTarget)
d->delayedPressTarget->ungrabMouse();
//Use the event handler that will take care of finding the proper item to propagate the event
- QSGCanvasPrivate::get(canvas())->deliverMouseEvent(d->delayedPressEvent);
+ QQuickCanvasPrivate::get(canvas())->deliverMouseEvent(d->delayedPressEvent);
d->clearDelayedPress();
// We send the release
canvas()->sendEvent(c->mouseGrabberItem(), event);
default:
break;
}
- grabber = qobject_cast<QSGItem*>(c->mouseGrabberItem());
+ grabber = qobject_cast<QQuickItem*>(c->mouseGrabberItem());
if ((grabber && stealThisEvent && !grabber->keepMouseGrab() && grabber != this) || disabledItem) {
d->clearDelayedPress();
grabMouse();
}
-bool QSGFlickable::childMouseEventFilter(QSGItem *i, QEvent *e)
+bool QQuickFlickable::childMouseEventFilter(QQuickItem *i, QEvent *e)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (!isVisible() || !d->interactive || !isEnabled())
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
switch (e->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
break;
}
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
}
/*!
The default value is platform dependent.
*/
-qreal QSGFlickable::maximumFlickVelocity() const
+qreal QQuickFlickable::maximumFlickVelocity() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->maxVelocity;
}
-void QSGFlickable::setMaximumFlickVelocity(qreal v)
+void QQuickFlickable::setMaximumFlickVelocity(qreal v)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (v == d->maxVelocity)
return;
d->maxVelocity = v;
The default value is platform dependent.
*/
-qreal QSGFlickable::flickDeceleration() const
+qreal QQuickFlickable::flickDeceleration() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->deceleration;
}
-void QSGFlickable::setFlickDeceleration(qreal deceleration)
+void QQuickFlickable::setFlickDeceleration(qreal deceleration)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (deceleration == d->deceleration)
return;
d->deceleration = deceleration;
emit flickDecelerationChanged();
}
-bool QSGFlickable::isFlicking() const
+bool QQuickFlickable::isFlicking() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.flicking || d->vData.flicking;
}
These properties describe whether the view is currently moving horizontally,
vertically or in either direction, due to the user flicking the view.
*/
-bool QSGFlickable::isFlickingHorizontally() const
+bool QQuickFlickable::isFlickingHorizontally() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.flicking;
}
-bool QSGFlickable::isFlickingVertically() const
+bool QQuickFlickable::isFlickingVertically() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.flicking;
}
These properties describe whether the view is currently moving horizontally,
vertically or in either direction, due to the user dragging the view.
*/
-bool QSGFlickable::isDragging() const
+bool QQuickFlickable::isDragging() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.dragging || d->vData.dragging;
}
-bool QSGFlickable::isDraggingHorizontally() const
+bool QQuickFlickable::isDraggingHorizontally() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.dragging;
}
-bool QSGFlickable::isDraggingVertically() const
+bool QQuickFlickable::isDraggingVertically() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.dragging;
}
-void QSGFlickablePrivate::draggingStarting()
+void QQuickFlickablePrivate::draggingStarting()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
bool wasDragging = hData.dragging || vData.dragging;
if (hMoved && !hData.dragging) {
hData.dragging = true;
}
}
-void QSGFlickablePrivate::draggingEnding()
+void QQuickFlickablePrivate::draggingEnding()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
bool wasDragging = hData.dragging || vData.dragging;
if (hData.dragging) {
hData.dragging = false;
Note that for nested Flickables with pressDelay set, the pressDelay of
inner Flickables is overridden by the outermost Flickable.
*/
-int QSGFlickable::pressDelay() const
+int QQuickFlickable::pressDelay() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->pressDelay;
}
-void QSGFlickable::setPressDelay(int delay)
+void QQuickFlickable::setPressDelay(int delay)
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->pressDelay == delay)
return;
d->pressDelay = delay;
flicking the view.
*/
-bool QSGFlickable::isMoving() const
+bool QQuickFlickable::isMoving() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.moving || d->vData.moving;
}
-bool QSGFlickable::isMovingHorizontally() const
+bool QQuickFlickable::isMovingHorizontally() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->hData.moving;
}
-bool QSGFlickable::isMovingVertically() const
+bool QQuickFlickable::isMovingVertically() const
{
- Q_D(const QSGFlickable);
+ Q_D(const QQuickFlickable);
return d->vData.moving;
}
-void QSGFlickable::movementStarting()
+void QQuickFlickable::movementStarting()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->hMoved && !d->hData.moving) {
d->hData.moving = true;
emit movingChanged();
}
}
-void QSGFlickable::movementEnding()
+void QQuickFlickable::movementEnding()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
movementXEnding();
movementYEnding();
d->hData.smoothVelocity.setValue(0);
d->vData.smoothVelocity.setValue(0);
}
-void QSGFlickable::movementXEnding()
+void QQuickFlickable::movementXEnding()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->hData.flicking) {
d->hData.flicking = false;
emit flickingChanged();
d->hData.fixingUp = false;
}
-void QSGFlickable::movementYEnding()
+void QQuickFlickable::movementYEnding()
{
- Q_D(QSGFlickable);
+ Q_D(QQuickFlickable);
if (d->vData.flicking) {
d->vData.flicking = false;
emit flickingChanged();
d->vData.fixingUp = false;
}
-void QSGFlickablePrivate::updateVelocity()
+void QQuickFlickablePrivate::updateVelocity()
{
- Q_Q(QSGFlickable);
+ Q_Q(QQuickFlickable);
emit q->horizontalVelocityChanged();
emit q->verticalVelocityChanged();
}
**
****************************************************************************/
-#ifndef QSGFLICKABLE_P_H
-#define QSGFLICKABLE_P_H
+#ifndef QQUICKFLICKABLE_P_H
+#define QQUICKFLICKABLE_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGFlickablePrivate;
-class QSGFlickableVisibleArea;
-class Q_AUTOTEST_EXPORT QSGFlickable : public QSGItem
+class QQuickFlickablePrivate;
+class QQuickFlickableVisibleArea;
+class Q_AUTOTEST_EXPORT QQuickFlickable : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight NOTIFY contentHeightChanged)
Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged)
Q_PROPERTY(qreal contentY READ contentY WRITE setContentY NOTIFY contentYChanged)
- Q_PROPERTY(QSGItem *contentItem READ contentItem CONSTANT)
+ Q_PROPERTY(QQuickItem *contentItem READ contentItem CONSTANT)
Q_PROPERTY(qreal topMargin READ topMargin WRITE setTopMargin NOTIFY topMarginChanged)
Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin NOTIFY bottomMarginChanged)
Q_PROPERTY(bool atXBeginning READ isAtXBeginning NOTIFY isAtBoundaryChanged)
Q_PROPERTY(bool atYBeginning READ isAtYBeginning NOTIFY isAtBoundaryChanged)
- Q_PROPERTY(QSGFlickableVisibleArea *visibleArea READ visibleArea CONSTANT)
+ Q_PROPERTY(QQuickFlickableVisibleArea *visibleArea READ visibleArea CONSTANT)
Q_PROPERTY(bool pixelAligned READ pixelAligned WRITE setPixelAligned NOTIFY pixelAlignedChanged)
Q_PROPERTY(QDeclarativeListProperty<QObject> flickableData READ flickableData)
- Q_PROPERTY(QDeclarativeListProperty<QSGItem> flickableChildren READ flickableChildren)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickItem> flickableChildren READ flickableChildren)
Q_CLASSINFO("DefaultProperty", "flickableData")
Q_ENUMS(FlickableDirection)
Q_ENUMS(BoundsBehavior)
public:
- QSGFlickable(QSGItem *parent=0);
- ~QSGFlickable();
+ QQuickFlickable(QQuickItem *parent=0);
+ ~QQuickFlickable();
QDeclarativeListProperty<QObject> flickableData();
- QDeclarativeListProperty<QSGItem> flickableChildren();
+ QDeclarativeListProperty<QQuickItem> flickableChildren();
enum BoundsBehavior { StopAtBounds, DragOverBounds, DragAndOvershootBounds };
BoundsBehavior boundsBehavior() const;
bool isAtYEnd() const;
bool isAtYBeginning() const;
- QSGItem *contentItem();
+ QQuickItem *contentItem();
enum FlickableDirection { AutoFlickDirection=0x00, HorizontalFlick=0x01, VerticalFlick=0x02, HorizontalAndVerticalFlick=0x03 };
FlickableDirection flickableDirection() const;
void pixelAlignedChanged();
protected:
- virtual bool childMouseEventFilter(QSGItem *, QEvent *);
+ virtual bool childMouseEventFilter(QQuickItem *, QEvent *);
virtual void mousePressEvent(QMouseEvent *event);
virtual void mouseMoveEvent(QMouseEvent *event);
virtual void mouseReleaseEvent(QMouseEvent *event);
virtual void wheelEvent(QWheelEvent *event);
virtual void timerEvent(QTimerEvent *event);
- QSGFlickableVisibleArea *visibleArea();
+ QQuickFlickableVisibleArea *visibleArea();
protected Q_SLOTS:
virtual void ticked();
void cancelFlick();
protected:
- QSGFlickable(QSGFlickablePrivate &dd, QSGItem *parent);
+ QQuickFlickable(QQuickFlickablePrivate &dd, QQuickItem *parent);
private:
- Q_DISABLE_COPY(QSGFlickable)
- Q_DECLARE_PRIVATE(QSGFlickable)
- friend class QSGFlickableVisibleArea;
+ Q_DISABLE_COPY(QQuickFlickable)
+ Q_DECLARE_PRIVATE(QQuickFlickable)
+ friend class QQuickFlickableVisibleArea;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGFlickable)
+QML_DECLARE_TYPE(QQuickFlickable)
QT_END_HEADER
-#endif // QSGFLICKABLE_P_H
+#endif // QQUICKFLICKABLE_P_H
**
****************************************************************************/
-#ifndef QSGFLICKABLE_P_P_H
-#define QSGFLICKABLE_P_P_H
+#ifndef QQUICKFLICKABLE_P_P_H
+#define QQUICKFLICKABLE_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgflickable_p.h"
-#include "qsgitem_p.h"
-#include "qsgitemchangelistener_p.h"
+#include "qquickflickable_p.h"
+#include "qquickitem_p.h"
+#include "qquickitemchangelistener_p.h"
#include <QtDeclarative/qdeclarative.h>
#include <QtCore/qdatetime.h>
// Really slow flicks can be annoying.
const qreal MinimumFlickVelocity = 75.0;
-class QSGFlickableVisibleArea;
-class QSGFlickablePrivate : public QSGItemPrivate, public QSGItemChangeListener
+class QQuickFlickableVisibleArea;
+class QQuickFlickablePrivate : public QQuickItemPrivate, public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGFlickable)
+ Q_DECLARE_PUBLIC(QQuickFlickable)
public:
- static inline QSGFlickablePrivate *get(QSGFlickable *o) { return o->d_func(); }
+ static inline QQuickFlickablePrivate *get(QQuickFlickable *o) { return o->d_func(); }
- QSGFlickablePrivate();
+ QQuickFlickablePrivate();
void init();
struct Velocity : public QDeclarativeTimeLineValue
{
- Velocity(QSGFlickablePrivate *p)
+ Velocity(QQuickFlickablePrivate *p)
: parent(p) {}
virtual void setValue(qreal v) {
if (v != value()) {
parent->updateVelocity();
}
}
- QSGFlickablePrivate *parent;
+ QQuickFlickablePrivate *parent;
};
struct AxisData {
- AxisData(QSGFlickablePrivate *fp, void (QSGFlickablePrivate::*func)(qreal))
+ AxisData(QQuickFlickablePrivate *fp, void (QQuickFlickablePrivate::*func)(qreal))
: move(fp, func), viewSize(-1), startMargin(0), endMargin(0)
, smoothVelocity(fp), atEnd(false), atBeginning(true)
, fixingUp(false), inOvershoot(false), moving(false), flicking(false)
void addVelocitySample(qreal v, qreal maxVelocity);
void updateVelocity();
- QDeclarativeTimeLineValueProxy<QSGFlickablePrivate> move;
+ QDeclarativeTimeLineValueProxy<QQuickFlickablePrivate> move;
qreal viewSize;
qreal pressPos;
qreal dragStartOffset;
qreal flickTarget;
qreal startMargin;
qreal endMargin;
- QSGFlickablePrivate::Velocity smoothVelocity;
+ QQuickFlickablePrivate::Velocity smoothVelocity;
QPODVector<qreal,10> velocityBuffer;
bool atEnd : 1;
bool atBeginning : 1;
qreal overShootDistance(qreal size);
- void itemGeometryChanged(QSGItem *, const QRectF &, const QRectF &);
+ void itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &);
void draggingStarting();
void draggingEnding();
public:
- QSGItem *contentItem;
+ QQuickItem *contentItem;
AxisData hData;
AxisData vData;
QPointF lastFlickablePosition;
qreal reportedVelocitySmoothing;
QMouseEvent *delayedPressEvent;
- QSGItem *delayedPressTarget;
+ QQuickItem *delayedPressTarget;
QBasicTimer delayedPressTimer;
int pressDelay;
int fixupDuration;
void updateVelocity();
int vTime;
QDeclarativeTimeLine velocityTimeline;
- QSGFlickableVisibleArea *visibleArea;
- QSGFlickable::FlickableDirection flickableDirection;
- QSGFlickable::BoundsBehavior boundsBehavior;
+ QQuickFlickableVisibleArea *visibleArea;
+ QQuickFlickable::FlickableDirection flickableDirection;
+ QQuickFlickable::BoundsBehavior boundsBehavior;
void handleMousePressEvent(QMouseEvent *);
void handleMouseMoveEvent(QMouseEvent *);
static void data_clear(QDeclarativeListProperty<QObject> *);
};
-class QSGFlickableVisibleArea : public QObject
+class QQuickFlickableVisibleArea : public QObject
{
Q_OBJECT
Q_PROPERTY(qreal heightRatio READ heightRatio NOTIFY heightRatioChanged)
public:
- QSGFlickableVisibleArea(QSGFlickable *parent=0);
+ QQuickFlickableVisibleArea(QQuickFlickable *parent=0);
qreal xPosition() const;
qreal widthRatio() const;
void heightRatioChanged(qreal heightRatio);
private:
- QSGFlickable *flickable;
+ QQuickFlickable *flickable;
qreal m_xPosition;
qreal m_widthRatio;
qreal m_yPosition;
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGFlickableVisibleArea)
+QML_DECLARE_TYPE(QQuickFlickableVisibleArea)
-#endif // QSGFLICKABLE_P_P_H
+#endif // QQUICKFLICKABLE_P_P_H
**
****************************************************************************/
-#include "qsgflipable_p.h"
-#include "qsgitem_p.h"
+#include "qquickflipable_p.h"
+#include "qquickitem_p.h"
#include <private/qdeclarativeguard_p.h>
// XXX todo - i think this needs work and a bit of a re-think
-class QSGLocalTransform : public QSGTransform
+class QQuickLocalTransform : public QQuickTransform
{
Q_OBJECT
public:
- QSGLocalTransform(QObject *parent) : QSGTransform(parent) {}
+ QQuickLocalTransform(QObject *parent) : QQuickTransform(parent) {}
void setTransform(const QTransform &t) {
transform = t;
QTransform transform;
};
-class QSGFlipablePrivate : public QSGItemPrivate
+class QQuickFlipablePrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGFlipable)
+ Q_DECLARE_PUBLIC(QQuickFlipable)
public:
- QSGFlipablePrivate() : current(QSGFlipable::Front), front(0), back(0), sideDirty(false) {}
+ QQuickFlipablePrivate() : current(QQuickFlipable::Front), front(0), back(0), sideDirty(false) {}
virtual void transformChanged();
void updateSide();
void setBackTransform();
- QSGFlipable::Side current;
- QDeclarativeGuard<QSGLocalTransform> backTransform;
- QDeclarativeGuard<QSGItem> front;
- QDeclarativeGuard<QSGItem> back;
+ QQuickFlipable::Side current;
+ QDeclarativeGuard<QQuickLocalTransform> backTransform;
+ QDeclarativeGuard<QQuickItem> front;
+ QDeclarativeGuard<QQuickItem> back;
bool sideDirty;
bool wantBackXFlipped;
};
/*!
- \qmlclass Flipable QSGFlipable
+ \qmlclass Flipable QQuickFlipable
\inqmlmodule QtQuick 2
\ingroup qml-basic-interaction-elements
\brief The Flipable item provides a surface that can be flipped.
\sa {declarative/ui-components/flipable}{Flipable example}
*/
-QSGFlipable::QSGFlipable(QSGItem *parent)
-: QSGItem(*(new QSGFlipablePrivate), parent)
+QQuickFlipable::QQuickFlipable(QQuickItem *parent)
+: QQuickItem(*(new QQuickFlipablePrivate), parent)
{
}
-QSGFlipable::~QSGFlipable()
+QQuickFlipable::~QQuickFlipable()
{
}
The front and back sides of the flipable.
*/
-QSGItem *QSGFlipable::front()
+QQuickItem *QQuickFlipable::front()
{
- Q_D(const QSGFlipable);
+ Q_D(const QQuickFlipable);
return d->front;
}
-void QSGFlipable::setFront(QSGItem *front)
+void QQuickFlipable::setFront(QQuickItem *front)
{
- Q_D(QSGFlipable);
+ Q_D(QQuickFlipable);
if (d->front) {
qmlInfo(this) << tr("front is a write-once property");
return;
emit frontChanged();
}
-QSGItem *QSGFlipable::back()
+QQuickItem *QQuickFlipable::back()
{
- Q_D(const QSGFlipable);
+ Q_D(const QQuickFlipable);
return d->back;
}
-void QSGFlipable::setBack(QSGItem *back)
+void QQuickFlipable::setBack(QQuickItem *back)
{
- Q_D(QSGFlipable);
+ Q_D(QQuickFlipable);
if (d->back) {
qmlInfo(this) << tr("back is a write-once property");
return;
d->back = back;
d->back->setParentItem(this);
- d->backTransform = new QSGLocalTransform(d->back);
+ d->backTransform = new QQuickLocalTransform(d->back);
d->backTransform->prependToItem(d->back);
if (Front == d->current)
emit backChanged();
}
-void QSGFlipable::retransformBack()
+void QQuickFlipable::retransformBack()
{
- Q_D(QSGFlipable);
- if (d->current == QSGFlipable::Back && d->back)
+ Q_D(QQuickFlipable);
+ if (d->current == QQuickFlipable::Back && d->back)
d->setBackTransform();
}
The side of the Flipable currently visible. Possible values are \c
Flipable.Front and \c Flipable.Back.
*/
-QSGFlipable::Side QSGFlipable::side() const
+QQuickFlipable::Side QQuickFlipable::side() const
{
- Q_D(const QSGFlipable);
+ Q_D(const QQuickFlipable);
- const_cast<QSGFlipablePrivate *>(d)->updateSide();
+ const_cast<QQuickFlipablePrivate *>(d)->updateSide();
return d->current;
}
-void QSGFlipablePrivate::transformChanged()
+void QQuickFlipablePrivate::transformChanged()
{
- Q_Q(QSGFlipable);
+ Q_Q(QQuickFlipable);
if (!sideDirty) {
sideDirty = true;
q->polish();
}
- QSGItemPrivate::transformChanged();
+ QQuickItemPrivate::transformChanged();
}
-void QSGFlipable::updatePolish()
+void QQuickFlipable::updatePolish()
{
- Q_D(QSGFlipable);
+ Q_D(QQuickFlipable);
d->updateSide();
}
// determination on the currently visible side of the flipable
// has to be done on the complete scene transform to give
// correct results.
-void QSGFlipablePrivate::updateSide()
+void QQuickFlipablePrivate::updateSide()
{
- Q_Q(QSGFlipable);
+ Q_Q(QQuickFlipable);
if (!sideDirty)
return;
wantBackYFlipped = scenep1.x() >= scenep2.x();
wantBackXFlipped = scenep2.y() >= scenep3.y();
- QSGFlipable::Side newSide;
+ QQuickFlipable::Side newSide;
if (cross > 0) {
- newSide = QSGFlipable::Back;
+ newSide = QQuickFlipable::Back;
} else {
- newSide = QSGFlipable::Front;
+ newSide = QQuickFlipable::Front;
}
if (newSide != current) {
current = newSide;
- if (current == QSGFlipable::Back && back)
+ if (current == QQuickFlipable::Back && back)
setBackTransform();
if (front)
- front->setOpacity((current==QSGFlipable::Front)?1.:0.);
+ front->setOpacity((current==QQuickFlipable::Front)?1.:0.);
if (back)
- back->setOpacity((current==QSGFlipable::Back)?1.:0.);
+ back->setOpacity((current==QQuickFlipable::Back)?1.:0.);
emit q->sideChanged();
}
}
/* Depends on the width/height of the back item, and so needs reevaulating
if those change.
*/
-void QSGFlipablePrivate::setBackTransform()
+void QQuickFlipablePrivate::setBackTransform()
{
QTransform mat;
mat.translate(back->width()/2,back->height()/2);
QT_END_NAMESPACE
-#include "qsgflipable.moc"
+#include "qquickflipable.moc"
**
****************************************************************************/
-#ifndef QSGFLIPABLE_P_H
-#define QSGFLIPABLE_P_H
+#ifndef QQUICKFLIPABLE_P_H
+#define QQUICKFLIPABLE_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <QtGui/qtransform.h>
#include <QtGui/qvector3d.h>
QT_MODULE(Declarative)
-class QSGFlipablePrivate;
-class Q_AUTOTEST_EXPORT QSGFlipable : public QSGItem
+class QQuickFlipablePrivate;
+class Q_AUTOTEST_EXPORT QQuickFlipable : public QQuickItem
{
Q_OBJECT
Q_ENUMS(Side)
- Q_PROPERTY(QSGItem *front READ front WRITE setFront NOTIFY frontChanged)
- Q_PROPERTY(QSGItem *back READ back WRITE setBack NOTIFY backChanged)
+ Q_PROPERTY(QQuickItem *front READ front WRITE setFront NOTIFY frontChanged)
+ Q_PROPERTY(QQuickItem *back READ back WRITE setBack NOTIFY backChanged)
Q_PROPERTY(Side side READ side NOTIFY sideChanged)
//### flipAxis
//### flipRotation
public:
- QSGFlipable(QSGItem *parent=0);
- ~QSGFlipable();
+ QQuickFlipable(QQuickItem *parent=0);
+ ~QQuickFlipable();
- QSGItem *front();
- void setFront(QSGItem *);
+ QQuickItem *front();
+ void setFront(QQuickItem *);
- QSGItem *back();
- void setBack(QSGItem *);
+ QQuickItem *back();
+ void setBack(QQuickItem *);
enum Side { Front, Back };
Side side() const;
void retransformBack();
private:
- Q_DISABLE_COPY(QSGFlipable)
- Q_DECLARE_PRIVATE(QSGFlipable)
+ Q_DISABLE_COPY(QQuickFlipable)
+ Q_DECLARE_PRIVATE(QQuickFlipable)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGFlipable)
+QML_DECLARE_TYPE(QQuickFlipable)
QT_END_HEADER
-#endif // QSGFLIPABLE_P_H
+#endif // QQUICKFLIPABLE_P_H
**
****************************************************************************/
-#include "qsgfocusscope_p.h"
+#include "qquickfocusscope_p.h"
QT_BEGIN_NAMESPACE
/*!
- \qmlclass FocusScope QSGFocusScope
+ \qmlclass FocusScope QQuickFocusScope
\inqmlmodule QtQuick 2
\ingroup qml-basic-interaction-elements
\sa {declarative/keyinteraction/focus}{Keyboard focus example}
*/
-QSGFocusScope::QSGFocusScope(QSGItem *parent)
-: QSGItem(parent)
+QQuickFocusScope::QQuickFocusScope(QQuickItem *parent)
+: QQuickItem(parent)
{
setFlag(ItemIsFocusScope);
}
-QSGFocusScope::~QSGFocusScope()
+QQuickFocusScope::~QQuickFocusScope()
{
}
**
****************************************************************************/
-#ifndef QSGFOCUSSCOPE_P_H
-#define QSGFOCUSSCOPE_P_H
+#ifndef QQUICKFOCUSSCOPE_P_H
+#define QQUICKFOCUSSCOPE_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class Q_AUTOTEST_EXPORT QSGFocusScope : public QSGItem
+class Q_AUTOTEST_EXPORT QQuickFocusScope : public QQuickItem
{
Q_OBJECT
public:
- QSGFocusScope(QSGItem *parent=0);
- virtual ~QSGFocusScope();
+ QQuickFocusScope(QQuickItem *parent=0);
+ virtual ~QQuickFocusScope();
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGFocusScope)
+QML_DECLARE_TYPE(QQuickFocusScope)
QT_END_HEADER
-#endif // QSGFOCUSSCOPE_P_H
+#endif // QQUICKFOCUSSCOPE_P_H
**
****************************************************************************/
-#include "qsggridview_p.h"
-#include "qsgvisualitemmodel_p.h"
-#include "qsgflickable_p_p.h"
-#include "qsgitemview_p_p.h"
+#include "qquickgridview_p.h"
+#include "qquickvisualitemmodel_p.h"
+#include "qquickflickable_p_p.h"
+#include "qquickitemview_p_p.h"
#include <private/qdeclarativesmoothedanimation_p_p.h>
#include <private/qlistmodelinterface_p.h>
class FxGridItemSG : public FxViewItem
{
public:
- FxGridItemSG(QSGItem *i, QSGGridView *v, bool own) : FxViewItem(i, own), view(v) {
- attached = static_cast<QSGGridViewAttached*>(qmlAttachedPropertiesObject<QSGGridView>(item));
+ FxGridItemSG(QQuickItem *i, QQuickGridView *v, bool own) : FxViewItem(i, own), view(v) {
+ attached = static_cast<QQuickGridViewAttached*>(qmlAttachedPropertiesObject<QQuickGridView>(item));
if (attached)
- static_cast<QSGGridViewAttached*>(attached)->setView(view);
+ static_cast<QQuickGridViewAttached*>(attached)->setView(view);
}
~FxGridItemSG() {}
}
qreal size() const {
- return view->flow() == QSGGridView::LeftToRight ? view->cellHeight() : view->cellWidth();
+ return view->flow() == QQuickGridView::LeftToRight ? view->cellHeight() : view->cellWidth();
}
qreal sectionSize() const {
}
qreal rowPos() const {
- if (view->flow() == QSGGridView::LeftToRight)
+ if (view->flow() == QQuickGridView::LeftToRight)
return item->y();
else
return (view->effectiveLayoutDirection() == Qt::RightToLeft ? -view->cellWidth()-item->x() : item->x());
}
qreal colPos() const {
- if (view->flow() == QSGGridView::LeftToRight) {
+ if (view->flow() == QQuickGridView::LeftToRight) {
if (view->effectiveLayoutDirection() == Qt::RightToLeft) {
qreal colSize = view->cellWidth();
int columns = view->width()/colSize;
}
}
qreal endRowPos() const {
- if (view->flow() == QSGGridView::LeftToRight) {
+ if (view->flow() == QQuickGridView::LeftToRight) {
return item->y() + view->cellHeight();
} else {
if (view->effectiveLayoutDirection() == Qt::RightToLeft)
}
void setPosition(qreal col, qreal row) {
if (view->effectiveLayoutDirection() == Qt::RightToLeft) {
- if (view->flow() == QSGGridView::LeftToRight) {
+ if (view->flow() == QQuickGridView::LeftToRight) {
int columns = view->width()/view->cellWidth();
item->setPos(QPointF((view->cellWidth() * (columns-1) - col), row));
} else {
item->setPos(QPointF(-view->cellWidth()-row, col));
}
} else {
- if (view->flow() == QSGGridView::LeftToRight)
+ if (view->flow() == QQuickGridView::LeftToRight)
item->setPos(QPointF(col, row));
else
item->setPos(QPointF(row, col));
y >= item->y() && y < item->y() + view->cellHeight());
}
- QSGGridView *view;
+ QQuickGridView *view;
};
//----------------------------------------------------------------------------
-class QSGGridViewPrivate : public QSGItemViewPrivate
+class QQuickGridViewPrivate : public QQuickItemViewPrivate
{
- Q_DECLARE_PUBLIC(QSGGridView)
+ Q_DECLARE_PUBLIC(QQuickGridView)
public:
virtual Qt::Orientation layoutOrientation() const;
virtual bool removeNonVisibleItems(qreal bufferFrom, qreal bufferTo);
virtual void visibleItemsChanged();
- virtual FxViewItem *newViewItem(int index, QSGItem *item);
- virtual void repositionPackageItemAt(QSGItem *item, int index);
+ virtual FxViewItem *newViewItem(int index, QQuickItem *item);
+ virtual void repositionPackageItemAt(QQuickItem *item, int index);
virtual void resetItemPosition(FxViewItem *item, FxViewItem *toItem);
virtual void resetFirstItemPosition();
virtual void moveItemBy(FxViewItem *item, qreal forwards, qreal backwards);
virtual void initializeCurrentItem();
virtual void updateViewport();
- virtual void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+ virtual void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
virtual void fixupPosition();
virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);
- virtual void flick(QSGItemViewPrivate::AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+ virtual void flick(QQuickItemViewPrivate::AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity);
- QSGGridView::Flow flow;
+ QQuickGridView::Flow flow;
qreal cellWidth;
qreal cellHeight;
int columns;
- QSGGridView::SnapMode snapMode;
+ QQuickGridView::SnapMode snapMode;
QSmoothedAnimation *highlightXAnimator;
QSmoothedAnimation *highlightYAnimator;
- QSGGridViewPrivate()
- : flow(QSGGridView::LeftToRight)
+ QQuickGridViewPrivate()
+ : flow(QQuickGridView::LeftToRight)
, cellWidth(100), cellHeight(100), columns(1)
- , snapMode(QSGGridView::NoSnap)
+ , snapMode(QQuickGridView::NoSnap)
, highlightXAnimator(0), highlightYAnimator(0)
{}
};
-Qt::Orientation QSGGridViewPrivate::layoutOrientation() const
+Qt::Orientation QQuickGridViewPrivate::layoutOrientation() const
{
- return flow == QSGGridView::LeftToRight ? Qt::Vertical : Qt::Horizontal;
+ return flow == QQuickGridView::LeftToRight ? Qt::Vertical : Qt::Horizontal;
}
-bool QSGGridViewPrivate::isContentFlowReversed() const
+bool QQuickGridViewPrivate::isContentFlowReversed() const
{
return isRightToLeftTopToBottom();
}
-bool QSGGridViewPrivate::isRightToLeftTopToBottom() const
+bool QQuickGridViewPrivate::isRightToLeftTopToBottom() const
{
- Q_Q(const QSGGridView);
- return flow == QSGGridView::TopToBottom && q->effectiveLayoutDirection() == Qt::RightToLeft;
+ Q_Q(const QQuickGridView);
+ return flow == QQuickGridView::TopToBottom && q->effectiveLayoutDirection() == Qt::RightToLeft;
}
-void QSGGridViewPrivate::changedVisibleIndex(int newIndex)
+void QQuickGridViewPrivate::changedVisibleIndex(int newIndex)
{
visibleIndex = newIndex / columns * columns;
}
-void QSGGridViewPrivate::setPosition(qreal pos)
+void QQuickGridViewPrivate::setPosition(qreal pos)
{
- Q_Q(QSGGridView);
- if (flow == QSGGridView::LeftToRight) {
- q->QSGFlickable::setContentY(pos);
- q->QSGFlickable::setContentX(0);
+ Q_Q(QQuickGridView);
+ if (flow == QQuickGridView::LeftToRight) {
+ q->QQuickFlickable::setContentY(pos);
+ q->QQuickFlickable::setContentX(0);
} else {
if (q->effectiveLayoutDirection() == Qt::LeftToRight)
- q->QSGFlickable::setContentX(pos);
+ q->QQuickFlickable::setContentX(pos);
else
- q->QSGFlickable::setContentX(-pos-size());
- q->QSGFlickable::setContentY(0);
+ q->QQuickFlickable::setContentX(-pos-size());
+ q->QQuickFlickable::setContentY(0);
}
}
-qreal QSGGridViewPrivate::originPosition() const
+qreal QQuickGridViewPrivate::originPosition() const
{
qreal pos = 0;
if (!visibleItems.isEmpty())
return pos;
}
-qreal QSGGridViewPrivate::lastPosition() const
+qreal QQuickGridViewPrivate::lastPosition() const
{
qreal pos = 0;
if (model && model->count()) {
return pos;
}
-qreal QSGGridViewPrivate::positionAt(int index) const
+qreal QQuickGridViewPrivate::positionAt(int index) const
{
return rowPosAt(index);
}
-qreal QSGGridViewPrivate::endPositionAt(int index) const
+qreal QQuickGridViewPrivate::endPositionAt(int index) const
{
return rowPosAt(index) + rowSize();
}
-qreal QSGGridViewPrivate::rowSize() const {
- return flow == QSGGridView::LeftToRight ? cellHeight : cellWidth;
+qreal QQuickGridViewPrivate::rowSize() const {
+ return flow == QQuickGridView::LeftToRight ? cellHeight : cellWidth;
}
-qreal QSGGridViewPrivate::colSize() const {
- return flow == QSGGridView::LeftToRight ? cellWidth : cellHeight;
+qreal QQuickGridViewPrivate::colSize() const {
+ return flow == QQuickGridView::LeftToRight ? cellWidth : cellHeight;
}
-qreal QSGGridViewPrivate::colPosAt(int modelIndex) const
+qreal QQuickGridViewPrivate::colPosAt(int modelIndex) const
{
if (FxViewItem *item = visibleItem(modelIndex))
return static_cast<FxGridItemSG*>(item)->colPos();
return (modelIndex % columns) * colSize();
}
-qreal QSGGridViewPrivate::rowPosAt(int modelIndex) const
+qreal QQuickGridViewPrivate::rowPosAt(int modelIndex) const
{
if (FxViewItem *item = visibleItem(modelIndex))
return static_cast<FxGridItemSG*>(item)->rowPos();
}
-qreal QSGGridViewPrivate::snapPosAt(qreal pos) const
+qreal QQuickGridViewPrivate::snapPosAt(qreal pos) const
{
- Q_Q(const QSGGridView);
+ Q_Q(const QQuickGridView);
qreal snapPos = 0;
if (!visibleItems.isEmpty()) {
qreal highlightStart = highlightRangeStart;
maxExtent = q->minXExtent();
minExtent = q->maxXExtent();
} else {
- maxExtent = flow == QSGGridView::LeftToRight ? -q->maxYExtent() : -q->maxXExtent();
- minExtent = flow == QSGGridView::LeftToRight ? -q->minYExtent() : -q->minXExtent();
+ maxExtent = flow == QQuickGridView::LeftToRight ? -q->maxYExtent() : -q->maxXExtent();
+ minExtent = flow == QQuickGridView::LeftToRight ? -q->minYExtent() : -q->minXExtent();
}
if (snapPos > maxExtent)
snapPos = maxExtent;
return snapPos;
}
-FxViewItem *QSGGridViewPrivate::snapItemAt(qreal pos) const
+FxViewItem *QQuickGridViewPrivate::snapItemAt(qreal pos) const
{
for (int i = 0; i < visibleItems.count(); ++i) {
FxViewItem *item = visibleItems.at(i);
return 0;
}
-int QSGGridViewPrivate::snapIndex() const
+int QQuickGridViewPrivate::snapIndex() const
{
int index = currentIndex;
for (int i = 0; i < visibleItems.count(); ++i) {
return index;
}
-FxViewItem *QSGGridViewPrivate::newViewItem(int modelIndex, QSGItem *item)
+FxViewItem *QQuickGridViewPrivate::newViewItem(int modelIndex, QQuickItem *item)
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
Q_UNUSED(modelIndex);
return new FxGridItemSG(item, q, false);
}
-bool QSGGridViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool doBuffer)
+bool QQuickGridViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool doBuffer)
{
int colPos = colPosAt(visibleIndex);
int rowPos = rowPosAt(visibleIndex);
return changed;
}
-bool QSGGridViewPrivate::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
+bool QQuickGridViewPrivate::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
{
FxGridItemSG *item = 0;
bool changed = false;
return changed;
}
-void QSGGridViewPrivate::visibleItemsChanged()
+void QQuickGridViewPrivate::visibleItemsChanged()
{
updateHeader();
updateFooter();
updateViewport();
}
-void QSGGridViewPrivate::updateViewport()
+void QQuickGridViewPrivate::updateViewport()
{
- Q_Q(QSGGridView);
- columns = (int)qMax((flow == QSGGridView::LeftToRight ? q->width() : q->height()) / colSize(), qreal(1.));
- QSGItemViewPrivate::updateViewport();
+ Q_Q(QQuickGridView);
+ columns = (int)qMax((flow == QQuickGridView::LeftToRight ? q->width() : q->height()) / colSize(), qreal(1.));
+ QQuickItemViewPrivate::updateViewport();
}
-void QSGGridViewPrivate::layoutVisibleItems()
+void QQuickGridViewPrivate::layoutVisibleItems()
{
if (visibleItems.count()) {
FxGridItemSG *firstItem = static_cast<FxGridItemSG*>(visibleItems.first());
}
}
-void QSGGridViewPrivate::repositionPackageItemAt(QSGItem *item, int index)
+void QQuickGridViewPrivate::repositionPackageItemAt(QQuickItem *item, int index)
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
qreal pos = position();
- if (flow == QSGGridView::LeftToRight) {
+ if (flow == QQuickGridView::LeftToRight) {
if (item->y() + item->height() > pos && item->y() < pos + q->height())
item->setPos(QPointF(colPosAt(index), rowPosAt(index)));
} else {
}
}
-void QSGGridViewPrivate::resetItemPosition(FxViewItem *item, FxViewItem *toItem)
+void QQuickGridViewPrivate::resetItemPosition(FxViewItem *item, FxViewItem *toItem)
{
if (item == toItem)
return;
static_cast<FxGridItemSG*>(item)->setPosition(toGridItem->colPos(), toGridItem->rowPos());
}
-void QSGGridViewPrivate::resetFirstItemPosition()
+void QQuickGridViewPrivate::resetFirstItemPosition()
{
FxGridItemSG *item = static_cast<FxGridItemSG*>(visibleItems.first());
item->setPosition(0, 0);
}
-void QSGGridViewPrivate::moveItemBy(FxViewItem *item, qreal forwards, qreal backwards)
+void QQuickGridViewPrivate::moveItemBy(FxViewItem *item, qreal forwards, qreal backwards)
{
int moveCount = (forwards / rowSize()) - (backwards / rowSize());
gridItem->setPosition(gridItem->colPos(), gridItem->rowPos() + ((moveCount / columns) * rowSize()));
}
-void QSGGridViewPrivate::createHighlight()
+void QQuickGridViewPrivate::createHighlight()
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
bool changed = false;
if (highlight) {
if (trackedItem == highlight)
}
if (currentItem) {
- QSGItem *item = createHighlightItem();
+ QQuickItem *item = createHighlightItem();
if (item) {
FxGridItemSG *newHighlight = new FxGridItemSG(item, q, true);
if (autoHighlight)
emit q->highlightItemChanged();
}
-void QSGGridViewPrivate::updateHighlight()
+void QQuickGridViewPrivate::updateHighlight()
{
applyPendingChanges();
if ((!currentItem && highlight) || (currentItem && !highlight))
createHighlight();
- bool strictHighlight = haveHighlightRange && highlightRange == QSGGridView::StrictlyEnforceRange;
+ bool strictHighlight = haveHighlightRange && highlightRange == QQuickGridView::StrictlyEnforceRange;
if (currentItem && autoHighlight && highlight && (!strictHighlight || !pressed)) {
// auto-update highlight
highlightXAnimator->to = currentItem->item->x();
updateTrackedItem();
}
-void QSGGridViewPrivate::resetHighlightPosition()
+void QQuickGridViewPrivate::resetHighlightPosition()
{
if (highlight && currentItem) {
FxGridItemSG *cItem = static_cast<FxGridItemSG*>(currentItem);
}
}
-qreal QSGGridViewPrivate::headerSize() const
+qreal QQuickGridViewPrivate::headerSize() const
{
if (!header)
return 0.0;
- return flow == QSGGridView::LeftToRight ? header->item->height() : header->item->width();
+ return flow == QQuickGridView::LeftToRight ? header->item->height() : header->item->width();
}
-qreal QSGGridViewPrivate::footerSize() const
+qreal QQuickGridViewPrivate::footerSize() const
{
if (!footer)
return 0.0;
- return flow == QSGGridView::LeftToRight? footer->item->height() : footer->item->width();
+ return flow == QQuickGridView::LeftToRight? footer->item->height() : footer->item->width();
}
-bool QSGGridViewPrivate::showHeaderForIndex(int index) const
+bool QQuickGridViewPrivate::showHeaderForIndex(int index) const
{
return index / columns == 0;
}
-bool QSGGridViewPrivate::showFooterForIndex(int index) const
+bool QQuickGridViewPrivate::showFooterForIndex(int index) const
{
return index / columns == (model->count()-1) / columns;
}
-void QSGGridViewPrivate::updateFooter()
+void QQuickGridViewPrivate::updateFooter()
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
bool created = false;
if (!footer) {
- QSGItem *item = createComponentItem(footerComponent, true);
+ QQuickItem *item = createComponentItem(footerComponent, true);
if (!item)
return;
item->setZ(1);
qreal colOffset = 0;
qreal rowOffset = 0;
if (q->effectiveLayoutDirection() == Qt::RightToLeft) {
- if (flow == QSGGridView::TopToBottom)
+ if (flow == QQuickGridView::TopToBottom)
rowOffset = gridItem->item->width() - cellWidth;
else
colOffset = gridItem->item->width() - cellWidth;
emit q->footerItemChanged();
}
-void QSGGridViewPrivate::updateHeader()
+void QQuickGridViewPrivate::updateHeader()
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
bool created = false;
if (!header) {
- QSGItem *item = createComponentItem(headerComponent, true);
+ QQuickItem *item = createComponentItem(headerComponent, true);
if (!item)
return;
item->setZ(1);
qreal colOffset = 0;
qreal rowOffset = -headerSize();
if (q->effectiveLayoutDirection() == Qt::RightToLeft) {
- if (flow == QSGGridView::TopToBottom)
+ if (flow == QQuickGridView::TopToBottom)
rowOffset += gridItem->item->width()-cellWidth;
else
colOffset = gridItem->item->width()-cellWidth;
emit q->headerItemChanged();
}
-void QSGGridViewPrivate::initializeCurrentItem()
+void QQuickGridViewPrivate::initializeCurrentItem()
{
if (currentItem && currentIndex >= 0) {
FxGridItemSG *gridItem = static_cast<FxGridItemSG*>(currentItem);
}
}
-void QSGGridViewPrivate::itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickGridViewPrivate::itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_Q(QSGGridView);
- QSGItemViewPrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
+ Q_Q(QQuickGridView);
+ QQuickItemViewPrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
if (!q->isComponentComplete())
return;
if (item == q) {
}
}
-void QSGGridViewPrivate::fixupPosition()
+void QQuickGridViewPrivate::fixupPosition()
{
moveReason = Other;
- if (flow == QSGGridView::LeftToRight)
+ if (flow == QQuickGridView::LeftToRight)
fixupY();
else
fixupX();
}
-void QSGGridViewPrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
+void QQuickGridViewPrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
{
- if ((flow == QSGGridView::TopToBottom && &data == &vData)
- || (flow == QSGGridView::LeftToRight && &data == &hData))
+ if ((flow == QQuickGridView::TopToBottom && &data == &vData)
+ || (flow == QQuickGridView::LeftToRight && &data == &hData))
return;
fixupMode = moveReason == Mouse ? fixupMode : Immediate;
qreal viewPos = isRightToLeftTopToBottom() ? -position()-size() : position();
- bool strictHighlightRange = haveHighlightRange && highlightRange == QSGGridView::StrictlyEnforceRange;
- if (snapMode != QSGGridView::NoSnap) {
+ bool strictHighlightRange = haveHighlightRange && highlightRange == QQuickGridView::StrictlyEnforceRange;
+ if (snapMode != QQuickGridView::NoSnap) {
qreal tempPosition = isRightToLeftTopToBottom() ? -position()-size() : position();
- if (snapMode == QSGGridView::SnapOneRow && moveReason == Mouse) {
+ if (snapMode == QQuickGridView::SnapOneRow && moveReason == Mouse) {
// if we've been dragged < rowSize()/2 then bias towards the next row
qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
qreal bias = 0;
else
pos = qMax(qMin(bottomItem->position() - highlightRangeEnd, -maxExtent), -minExtent);
} else {
- QSGItemViewPrivate::fixup(data, minExtent, maxExtent);
+ QQuickItemViewPrivate::fixup(data, minExtent, maxExtent);
return;
}
}
vTime = timeline.time();
}
- } else if (haveHighlightRange && highlightRange == QSGGridView::StrictlyEnforceRange) {
+ } else if (haveHighlightRange && highlightRange == QQuickGridView::StrictlyEnforceRange) {
if (currentItem) {
updateHighlight();
qreal pos = static_cast<FxGridItemSG*>(currentItem)->rowPos();
vTime = timeline.time();
}
} else {
- QSGItemViewPrivate::fixup(data, minExtent, maxExtent);
+ QQuickItemViewPrivate::fixup(data, minExtent, maxExtent);
}
data.inOvershoot = false;
fixupMode = Normal;
}
-void QSGGridViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+void QQuickGridViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
data.fixingUp = false;
moveReason = Mouse;
- if ((!haveHighlightRange || highlightRange != QSGGridView::StrictlyEnforceRange)
- && snapMode == QSGGridView::NoSnap) {
- QSGItemViewPrivate::flick(data, minExtent, maxExtent, vSize, fixupCallback, velocity);
+ if ((!haveHighlightRange || highlightRange != QQuickGridView::StrictlyEnforceRange)
+ && snapMode == QQuickGridView::NoSnap) {
+ QQuickItemViewPrivate::flick(data, minExtent, maxExtent, vSize, fixupCallback, velocity);
return;
}
qreal maxDistance = 0;
// -ve velocity means list is moving up/left
if (velocity > 0) {
if (data.move.value() < minExtent) {
- if (snapMode == QSGGridView::SnapOneRow) {
+ if (snapMode == QQuickGridView::SnapOneRow) {
// if we've been dragged < averageSize/2 then bias towards the next item
qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
qreal bias = dist < rowSize()/2 ? rowSize()/2 : 0;
maxDistance = qAbs(minExtent - data.move.value());
}
}
- if (snapMode == QSGGridView::NoSnap && highlightRange != QSGGridView::StrictlyEnforceRange)
+ if (snapMode == QQuickGridView::NoSnap && highlightRange != QQuickGridView::StrictlyEnforceRange)
data.flickTarget = minExtent;
} else {
if (data.move.value() > maxExtent) {
- if (snapMode == QSGGridView::SnapOneRow) {
+ if (snapMode == QQuickGridView::SnapOneRow) {
// if we've been dragged < averageSize/2 then bias towards the next item
qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
qreal bias = -dist < rowSize()/2 ? rowSize()/2 : 0;
maxDistance = qAbs(maxExtent - data.move.value());
}
}
- if (snapMode == QSGGridView::NoSnap && highlightRange != QSGGridView::StrictlyEnforceRange)
+ if (snapMode == QQuickGridView::NoSnap && highlightRange != QQuickGridView::StrictlyEnforceRange)
data.flickTarget = maxExtent;
}
- bool overShoot = boundsBehavior == QSGFlickable::DragAndOvershootBounds;
+ bool overShoot = boundsBehavior == QQuickFlickable::DragAndOvershootBounds;
if (maxDistance > 0 || overShoot) {
// This mode requires the grid to stop exactly on a row boundary.
qreal v = velocity;
qreal accel = deceleration;
qreal v2 = v * v;
qreal overshootDist = 0.0;
- if ((maxDistance > 0.0 && v2 / (2.0f * maxDistance) < accel) || snapMode == QSGGridView::SnapOneRow) {
+ if ((maxDistance > 0.0 && v2 / (2.0f * maxDistance) < accel) || snapMode == QQuickGridView::SnapOneRow) {
// + rowSize()/4 to encourage moving at least one item in the flick direction
qreal dist = v2 / (accel * 2.0) + rowSize()/4;
dist = qMin(dist, maxDistance);
if (v > 0)
dist = -dist;
- if (snapMode != QSGGridView::SnapOneRow) {
+ if (snapMode != QQuickGridView::SnapOneRow) {
qreal distTemp = isRightToLeftTopToBottom() ? -dist : dist;
data.flickTarget = -snapPosAt(-dataValue + distTemp);
}
//----------------------------------------------------------------------------
/*!
- \qmlclass GridView QSGGridView
+ \qmlclass GridView QQuickGridView
\inqmlmodule QtQuick 2
\ingroup qml-view-elements
\sa {declarative/modelviews/gridview}{GridView example}
*/
-QSGGridView::QSGGridView(QSGItem *parent)
- : QSGItemView(*(new QSGGridViewPrivate), parent)
+QQuickGridView::QQuickGridView(QQuickItem *parent)
+ : QQuickItemView(*(new QQuickGridViewPrivate), parent)
{
}
-QSGGridView::~QSGGridView()
+QQuickGridView::~QQuickGridView()
{
}
-void QSGGridView::setHighlightFollowsCurrentItem(bool autoHighlight)
+void QQuickGridView::setHighlightFollowsCurrentItem(bool autoHighlight)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (d->autoHighlight != autoHighlight) {
if (!autoHighlight && d->highlightXAnimator) {
d->highlightXAnimator->stop();
d->highlightYAnimator->stop();
}
- QSGItemView::setHighlightFollowsCurrentItem(autoHighlight);
+ QQuickItemView::setHighlightFollowsCurrentItem(autoHighlight);
}
}
delegates; the fewer elements in a delegate, the faster a view may be
scrolled.
*/
-void QSGGridView::setHighlightMoveDuration(int duration)
+void QQuickGridView::setHighlightMoveDuration(int duration)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (d->highlightMoveDuration != duration) {
if (d->highlightYAnimator) {
d->highlightXAnimator->userDuration = duration;
d->highlightYAnimator->userDuration = duration;
}
- QSGItemView::setHighlightMoveDuration(duration);
+ QQuickItemView::setHighlightMoveDuration(duration);
}
}
\o GridView.TopToBottom - Items are laid out from top to bottom, and the view scrolls horizontally
\endlist
*/
-QSGGridView::Flow QSGGridView::flow() const
+QQuickGridView::Flow QQuickGridView::flow() const
{
- Q_D(const QSGGridView);
+ Q_D(const QQuickGridView);
return d->flow;
}
-void QSGGridView::setFlow(Flow flow)
+void QQuickGridView::setFlow(Flow flow)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (d->flow != flow) {
d->flow = flow;
if (d->flow == LeftToRight) {
The default cell size is 100x100.
*/
-qreal QSGGridView::cellWidth() const
+qreal QQuickGridView::cellWidth() const
{
- Q_D(const QSGGridView);
+ Q_D(const QQuickGridView);
return d->cellWidth;
}
-void QSGGridView::setCellWidth(qreal cellWidth)
+void QQuickGridView::setCellWidth(qreal cellWidth)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (cellWidth != d->cellWidth && cellWidth > 0) {
d->cellWidth = qMax(qreal(1), cellWidth);
d->updateViewport();
}
}
-qreal QSGGridView::cellHeight() const
+qreal QQuickGridView::cellHeight() const
{
- Q_D(const QSGGridView);
+ Q_D(const QQuickGridView);
return d->cellHeight;
}
-void QSGGridView::setCellHeight(qreal cellHeight)
+void QQuickGridView::setCellHeight(qreal cellHeight)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (cellHeight != d->cellHeight && cellHeight > 0) {
d->cellHeight = qMax(qreal(1), cellHeight);
d->updateViewport();
\endlist
*/
-QSGGridView::SnapMode QSGGridView::snapMode() const
+QQuickGridView::SnapMode QQuickGridView::snapMode() const
{
- Q_D(const QSGGridView);
+ Q_D(const QQuickGridView);
return d->snapMode;
}
-void QSGGridView::setSnapMode(SnapMode mode)
+void QQuickGridView::setSnapMode(SnapMode mode)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (d->snapMode != mode) {
d->snapMode = mode;
emit snapModeChanged();
\sa footer
*/
-void QSGGridView::viewportMoved()
+void QQuickGridView::viewportMoved()
{
- Q_D(QSGGridView);
- QSGItemView::viewportMoved();
+ Q_D(QQuickGridView);
+ QQuickItemView::viewportMoved();
if (!d->itemCount)
return;
if (d->inViewportMoved)
if (d->hData.flicking || d->vData.flicking) {
if (yflick()) {
if (d->vData.velocity > 0)
- d->bufferMode = QSGGridViewPrivate::BufferBefore;
+ d->bufferMode = QQuickGridViewPrivate::BufferBefore;
else if (d->vData.velocity < 0)
- d->bufferMode = QSGGridViewPrivate::BufferAfter;
+ d->bufferMode = QQuickGridViewPrivate::BufferAfter;
}
if (xflick()) {
if (d->hData.velocity > 0)
- d->bufferMode = QSGGridViewPrivate::BufferBefore;
+ d->bufferMode = QQuickGridViewPrivate::BufferBefore;
else if (d->hData.velocity < 0)
- d->bufferMode = QSGGridViewPrivate::BufferAfter;
+ d->bufferMode = QQuickGridViewPrivate::BufferAfter;
}
}
d->refill();
if (d->hData.flicking || d->vData.flicking || d->hData.moving || d->vData.moving)
- d->moveReason = QSGGridViewPrivate::Mouse;
- if (d->moveReason != QSGGridViewPrivate::SetIndex) {
+ d->moveReason = QQuickGridViewPrivate::Mouse;
+ if (d->moveReason != QQuickGridViewPrivate::SetIndex) {
if (d->haveHighlightRange && d->highlightRange == StrictlyEnforceRange && d->highlight) {
// reposition highlight
qreal pos = d->highlight->position();
d->inViewportMoved = false;
}
-void QSGGridView::keyPressEvent(QKeyEvent *event)
+void QQuickGridView::keyPressEvent(QKeyEvent *event)
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
if (d->model && d->model->count() && d->interactive) {
- d->moveReason = QSGGridViewPrivate::SetIndex;
+ d->moveReason = QQuickGridViewPrivate::SetIndex;
int oldCurrent = currentIndex();
switch (event->key()) {
case Qt::Key_Up:
}
}
event->ignore();
- QSGItemView::keyPressEvent(event);
+ QQuickItemView::keyPressEvent(event);
}
/*!
\qmlmethod QtQuick2::GridView::moveCurrentIndexUp()
*/
-void QSGGridView::moveCurrentIndexUp()
+void QQuickGridView::moveCurrentIndexUp()
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
const int count = d->model ? d->model->count() : 0;
if (!count)
return;
- if (d->flow == QSGGridView::LeftToRight) {
+ if (d->flow == QQuickGridView::LeftToRight) {
if (currentIndex() >= d->columns || d->wrap) {
int index = currentIndex() - d->columns;
setCurrentIndex((index >= 0 && index < count) ? index : count-1);
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGGridView::moveCurrentIndexDown()
+void QQuickGridView::moveCurrentIndexDown()
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
const int count = d->model ? d->model->count() : 0;
if (!count)
return;
- if (d->flow == QSGGridView::LeftToRight) {
+ if (d->flow == QQuickGridView::LeftToRight) {
if (currentIndex() < count - d->columns || d->wrap) {
int index = currentIndex()+d->columns;
setCurrentIndex((index >= 0 && index < count) ? index : 0);
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGGridView::moveCurrentIndexLeft()
+void QQuickGridView::moveCurrentIndexLeft()
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
const int count = d->model ? d->model->count() : 0;
if (!count)
return;
if (effectiveLayoutDirection() == Qt::LeftToRight) {
- if (d->flow == QSGGridView::LeftToRight) {
+ if (d->flow == QQuickGridView::LeftToRight) {
if (currentIndex() > 0 || d->wrap) {
int index = currentIndex() - 1;
setCurrentIndex((index >= 0 && index < count) ? index : count-1);
}
}
} else {
- if (d->flow == QSGGridView::LeftToRight) {
+ if (d->flow == QQuickGridView::LeftToRight) {
if (currentIndex() < count - 1 || d->wrap) {
int index = currentIndex() + 1;
setCurrentIndex((index >= 0 && index < count) ? index : 0);
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGGridView::moveCurrentIndexRight()
+void QQuickGridView::moveCurrentIndexRight()
{
- Q_D(QSGGridView);
+ Q_D(QQuickGridView);
const int count = d->model ? d->model->count() : 0;
if (!count)
return;
if (effectiveLayoutDirection() == Qt::LeftToRight) {
- if (d->flow == QSGGridView::LeftToRight) {
+ if (d->flow == QQuickGridView::LeftToRight) {
if (currentIndex() < count - 1 || d->wrap) {
int index = currentIndex() + 1;
setCurrentIndex((index >= 0 && index < count) ? index : 0);
}
}
} else {
- if (d->flow == QSGGridView::LeftToRight) {
+ if (d->flow == QQuickGridView::LeftToRight) {
if (currentIndex() > 0 || d->wrap) {
int index = currentIndex() - 1;
setCurrentIndex((index >= 0 && index < count) ? index : count-1);
}
}
-bool QSGGridViewPrivate::applyInsertionChange(const QDeclarativeChangeSet::Insert &change, FxViewItem *firstVisible, InsertionsResult *insertResult)
+bool QQuickGridViewPrivate::applyInsertionChange(const QDeclarativeChangeSet::Insert &change, FxViewItem *firstVisible, InsertionsResult *insertResult)
{
- Q_Q(QSGGridView);
+ Q_Q(QQuickGridView);
int modelIndex = change.index;
int count = change.count;
\bold Note: methods should only be called after the Component has completed.
*/
-QSGGridViewAttached *QSGGridView::qmlAttachedProperties(QObject *obj)
+QQuickGridViewAttached *QQuickGridView::qmlAttachedProperties(QObject *obj)
{
- return new QSGGridViewAttached(obj);
+ return new QQuickGridViewAttached(obj);
}
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGGRIDVIEW_P_H
-#define QSGGRIDVIEW_P_H
+#ifndef QQUICKGRIDVIEW_P_H
+#define QQUICKGRIDVIEW_P_H
-#include "qsgitemview_p.h"
+#include "qquickitemview_p.h"
#include <private/qdeclarativeguard_p.h>
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class QSGVisualModel;
-class QSGGridViewAttached;
-class QSGGridViewPrivate;
-class Q_AUTOTEST_EXPORT QSGGridView : public QSGItemView
+class QQuickVisualModel;
+class QQuickGridViewAttached;
+class QQuickGridViewPrivate;
+class Q_AUTOTEST_EXPORT QQuickGridView : public QQuickItemView
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGGridView)
+ Q_DECLARE_PRIVATE(QQuickGridView)
Q_PROPERTY(Flow flow READ flow WRITE setFlow NOTIFY flowChanged)
Q_PROPERTY(qreal cellWidth READ cellWidth WRITE setCellWidth NOTIFY cellWidthChanged)
Q_CLASSINFO("DefaultProperty", "data")
public:
- QSGGridView(QSGItem *parent=0);
- ~QSGGridView();
+ QQuickGridView(QQuickItem *parent=0);
+ ~QQuickGridView();
virtual void setHighlightFollowsCurrentItem(bool);
virtual void setHighlightMoveDuration(int);
SnapMode snapMode() const;
void setSnapMode(SnapMode mode);
- static QSGGridViewAttached *qmlAttachedProperties(QObject *);
+ static QQuickGridViewAttached *qmlAttachedProperties(QObject *);
public Q_SLOTS:
void moveCurrentIndexUp();
virtual void keyPressEvent(QKeyEvent *);
};
-class QSGGridViewAttached : public QSGItemViewAttached
+class QQuickGridViewAttached : public QQuickItemViewAttached
{
Q_OBJECT
public:
- QSGGridViewAttached(QObject *parent)
- : QSGItemViewAttached(parent), m_view(0) {}
- ~QSGGridViewAttached() {}
+ QQuickGridViewAttached(QObject *parent)
+ : QQuickItemViewAttached(parent), m_view(0) {}
+ ~QQuickGridViewAttached() {}
- Q_PROPERTY(QSGGridView *view READ view NOTIFY viewChanged)
- QSGGridView *view() { return m_view; }
- void setView(QSGGridView *view) {
+ Q_PROPERTY(QQuickGridView *view READ view NOTIFY viewChanged)
+ QQuickGridView *view() { return m_view; }
+ void setView(QQuickGridView *view) {
if (view != m_view) {
m_view = view;
emit viewChanged();
void viewChanged();
public:
- QDeclarativeGuard<QSGGridView> m_view;
+ QDeclarativeGuard<QQuickGridView> m_view;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGGridView)
-QML_DECLARE_TYPEINFO(QSGGridView, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickGridView)
+QML_DECLARE_TYPEINFO(QQuickGridView, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
-#endif // QSGGRIDVIEW_P_H
+#endif // QQUICKGRIDVIEW_P_H
**
****************************************************************************/
-#include "qsgimage_p.h"
-#include "qsgimage_p_p.h"
+#include "qquickimage_p.h"
+#include "qquickimage_p_p.h"
#include <private/qsgtextureprovider_p.h>
QT_BEGIN_NAMESPACE
-class QSGImageTextureProvider : public QSGTextureProvider
+class QQuickImageTextureProvider : public QSGTextureProvider
{
Q_OBJECT
public:
- QSGImageTextureProvider()
+ QQuickImageTextureProvider()
: m_texture(0)
, m_smooth(false)
{
QSGTexture *texture() const {
if (m_texture->isAtlasTexture())
- const_cast<QSGImageTextureProvider *>(this)->m_texture = m_texture->removedFromAtlas();
+ const_cast<QQuickImageTextureProvider *>(this)->m_texture = m_texture->removedFromAtlas();
if (m_texture) {
m_texture->setFiltering(m_smooth ? QSGTexture::Linear : QSGTexture::Nearest);
return m_texture;
}
- friend class QSGImage;
+ friend class QQuickImage;
QSGTexture *m_texture;
bool m_smooth;
};
-#include "qsgimage.moc"
+#include "qquickimage.moc"
-QSGImagePrivate::QSGImagePrivate()
- : fillMode(QSGImage::Stretch)
+QQuickImagePrivate::QQuickImagePrivate()
+ : fillMode(QQuickImage::Stretch)
, paintedWidth(0)
, paintedHeight(0)
, pixmapChanged(false)
- , hAlign(QSGImage::AlignHCenter)
- , vAlign(QSGImage::AlignVCenter)
+ , hAlign(QQuickImage::AlignHCenter)
+ , vAlign(QQuickImage::AlignVCenter)
, provider(0)
{
}
/*!
- \qmlclass Image QSGImage
+ \qmlclass Image QQuickImage
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The Image element displays an image in a declarative user interface
\sa {declarative/imageelements/image}{Image example}, QDeclarativeImageProvider
*/
-QSGImage::QSGImage(QSGItem *parent)
- : QSGImageBase(*(new QSGImagePrivate), parent)
+QQuickImage::QQuickImage(QQuickItem *parent)
+ : QQuickImageBase(*(new QQuickImagePrivate), parent)
{
}
-QSGImage::QSGImage(QSGImagePrivate &dd, QSGItem *parent)
- : QSGImageBase(dd, parent)
+QQuickImage::QQuickImage(QQuickImagePrivate &dd, QQuickItem *parent)
+ : QQuickImageBase(dd, parent)
{
}
-QSGImage::~QSGImage()
+QQuickImage::~QQuickImage()
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
if (d->provider)
d->provider->deleteLater();
}
-void QSGImagePrivate::setPixmap(const QPixmap &pixmap)
+void QQuickImagePrivate::setPixmap(const QPixmap &pixmap)
{
- Q_Q(QSGImage);
+ Q_Q(QQuickImage);
pix.setPixmap(pixmap);
q->pixmapChange();
- status = pix.isNull() ? QSGImageBase::Null : QSGImageBase::Ready;
+ status = pix.isNull() ? QQuickImageBase::Null : QQuickImageBase::Ready;
q->update();
}
\sa {declarative/imageelements/image}{Image example}
*/
-QSGImage::FillMode QSGImage::fillMode() const
+QQuickImage::FillMode QQuickImage::fillMode() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
return d->fillMode;
}
-void QSGImage::setFillMode(FillMode mode)
+void QQuickImage::setFillMode(FillMode mode)
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
if (d->fillMode == mode)
return;
d->fillMode = mode;
\c paintedWidth or \c paintedHeight can be smaller or larger than
\c width and \c height of the Image element.
*/
-qreal QSGImage::paintedWidth() const
+qreal QQuickImage::paintedWidth() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
return d->paintedWidth;
}
-qreal QSGImage::paintedHeight() const
+qreal QQuickImage::paintedHeight() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
return d->paintedHeight;
}
The valid values for \c verticalAlignment are \c Image.AlignTop, \c Image.AlignBottom
and \c Image.AlignVCenter.
*/
-void QSGImage::updatePaintedGeometry()
+void QQuickImage::updatePaintedGeometry()
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
if (d->fillMode == PreserveAspectFit) {
if (!d->pix.width() || !d->pix.height()) {
emit paintedGeometryChanged();
}
-void QSGImage::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickImage::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- QSGImageBase::geometryChanged(newGeometry, oldGeometry);
+ QQuickImageBase::geometryChanged(newGeometry, oldGeometry);
updatePaintedGeometry();
}
-QRectF QSGImage::boundingRect() const
+QRectF QQuickImage::boundingRect() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
return QRectF(0, 0, qMax(width(), d->paintedWidth), qMax(height(), d->paintedHeight));
}
-QSGTextureProvider *QSGImage::textureProvider() const
+QSGTextureProvider *QQuickImage::textureProvider() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
if (!d->provider) {
// Make sure it gets thread affinity on the rendering thread so deletion works properly..
Q_ASSERT_X(d->canvas
&& d->sceneGraphContext()
&& QThread::currentThread() == d->sceneGraphContext()->thread(),
- "QSGImage::textureProvider",
+ "QQuickImage::textureProvider",
"Cannot be used outside the GUI thread");
- QSGImagePrivate *dd = const_cast<QSGImagePrivate *>(d);
- dd->provider = new QSGImageTextureProvider;
+ QQuickImagePrivate *dd = const_cast<QQuickImagePrivate *>(d);
+ dd->provider = new QQuickImageTextureProvider;
dd->provider->m_texture = d->pix.texture(d->sceneGraphContext());
}
return d->provider;
}
-QSGNode *QSGImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
QSGTexture *texture = d->pix.texture(d->sceneGraphContext());
qreal pixHeight = (d->fillMode == PreserveAspectFit) ? d->paintedHeight : d->pix.height();
int xOffset = 0;
- if (d->hAlign == QSGImage::AlignHCenter)
+ if (d->hAlign == QQuickImage::AlignHCenter)
xOffset = qCeil((width() - pixWidth) / 2.);
- else if (d->hAlign == QSGImage::AlignRight)
+ else if (d->hAlign == QQuickImage::AlignRight)
xOffset = qCeil(width() - pixWidth);
int yOffset = 0;
- if (d->vAlign == QSGImage::AlignVCenter)
+ if (d->vAlign == QQuickImage::AlignVCenter)
yOffset = qCeil((height() - pixHeight) / 2.);
- else if (d->vAlign == QSGImage::AlignBottom)
+ else if (d->vAlign == QQuickImage::AlignBottom)
yOffset = qCeil(height() - pixHeight);
switch (d->fillMode) {
if (wscale > hscale) {
int src = (hscale / wscale) * qreal(d->pix.height());
int y = 0;
- if (d->vAlign == QSGImage::AlignVCenter)
+ if (d->vAlign == QQuickImage::AlignVCenter)
y = qCeil((d->pix.height() - src) / 2.);
- else if (d->vAlign == QSGImage::AlignBottom)
+ else if (d->vAlign == QQuickImage::AlignBottom)
y = qCeil(d->pix.height() - src);
sourceRect = QRectF(0, y, d->pix.width(), src);
} else {
int src = (wscale / hscale) * qreal(d->pix.width());
int x = 0;
- if (d->hAlign == QSGImage::AlignHCenter)
+ if (d->hAlign == QQuickImage::AlignHCenter)
x = qCeil((d->pix.width() - src) / 2.);
- else if (d->hAlign == QSGImage::AlignRight)
+ else if (d->hAlign == QQuickImage::AlignRight)
x = qCeil(d->pix.width() - src);
sourceRect = QRectF(x, 0, src, d->pix.height());
}
return node;
}
-void QSGImage::pixmapChange()
+void QQuickImage::pixmapChange()
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
// PreserveAspectFit calculates the implicit size differently so we
// don't call our superclass pixmapChange(), since that would
// result in the implicit size being set incorrectly, then updated
// in updatePaintedGeometry()
if (d->fillMode != PreserveAspectFit)
- QSGImageBase::pixmapChange();
+ QQuickImageBase::pixmapChange();
updatePaintedGeometry();
d->pixmapChanged = true;
update();
}
-QSGImage::VAlignment QSGImage::verticalAlignment() const
+QQuickImage::VAlignment QQuickImage::verticalAlignment() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
return d->vAlign;
}
-void QSGImage::setVerticalAlignment(VAlignment align)
+void QQuickImage::setVerticalAlignment(VAlignment align)
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
if (d->vAlign == align)
return;
emit verticalAlignmentChanged(align);
}
-QSGImage::HAlignment QSGImage::horizontalAlignment() const
+QQuickImage::HAlignment QQuickImage::horizontalAlignment() const
{
- Q_D(const QSGImage);
+ Q_D(const QQuickImage);
return d->hAlign;
}
-void QSGImage::setHorizontalAlignment(HAlignment align)
+void QQuickImage::setHorizontalAlignment(HAlignment align)
{
- Q_D(QSGImage);
+ Q_D(QQuickImage);
if (d->hAlign == align)
return;
**
****************************************************************************/
-#ifndef QSGIMAGE_P_H
-#define QSGIMAGE_P_H
+#ifndef QQUICKIMAGE_P_H
+#define QQUICKIMAGE_P_H
-#include "qsgimagebase_p.h"
+#include "qquickimagebase_p.h"
#include <private/qsgtextureprovider_p.h>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGImagePrivate;
-class Q_AUTOTEST_EXPORT QSGImage : public QSGImageBase
+class QQuickImagePrivate;
+class Q_AUTOTEST_EXPORT QQuickImage : public QQuickImageBase
{
Q_OBJECT
Q_ENUMS(FillMode)
Q_PROPERTY(VAlignment verticalAlignment READ verticalAlignment WRITE setVerticalAlignment NOTIFY verticalAlignmentChanged)
public:
- QSGImage(QSGItem *parent=0);
- ~QSGImage();
+ QQuickImage(QQuickItem *parent=0);
+ ~QQuickImage();
enum HAlignment { AlignLeft = Qt::AlignLeft,
AlignRight = Qt::AlignRight,
void verticalAlignmentChanged(VAlignment alignment);
protected:
- QSGImage(QSGImagePrivate &dd, QSGItem *parent);
+ QQuickImage(QQuickImagePrivate &dd, QQuickItem *parent);
void pixmapChange();
void updatePaintedGeometry();
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
private:
- Q_DISABLE_COPY(QSGImage)
- Q_DECLARE_PRIVATE(QSGImage)
+ Q_DISABLE_COPY(QQuickImage)
+ Q_DECLARE_PRIVATE(QQuickImage)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGImage)
+QML_DECLARE_TYPE(QQuickImage)
QT_END_HEADER
-#endif // QSGIMAGE_P_H
+#endif // QQUICKIMAGE_P_H
**
****************************************************************************/
-#ifndef QSGIMAGE_P_P_H
-#define QSGIMAGE_P_P_H
+#ifndef QQUICKIMAGE_P_P_H
+#define QQUICKIMAGE_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgimagebase_p_p.h"
-#include "qsgimage_p.h"
+#include "qquickimagebase_p_p.h"
+#include "qquickimage_p.h"
QT_BEGIN_NAMESPACE
-class QSGImageTextureProvider;
+class QQuickImageTextureProvider;
-class QSGImagePrivate : public QSGImageBasePrivate
+class QQuickImagePrivate : public QQuickImageBasePrivate
{
- Q_DECLARE_PUBLIC(QSGImage)
+ Q_DECLARE_PUBLIC(QQuickImage)
public:
- QSGImagePrivate();
+ QQuickImagePrivate();
- QSGImage::FillMode fillMode;
+ QQuickImage::FillMode fillMode;
qreal paintedWidth;
qreal paintedHeight;
void setPixmap(const QPixmap &pix);
bool pixmapChanged : 1;
- QSGImage::HAlignment hAlign;
- QSGImage::VAlignment vAlign;
+ QQuickImage::HAlignment hAlign;
+ QQuickImage::VAlignment vAlign;
- QSGImageTextureProvider *provider;
+ QQuickImageTextureProvider *provider;
};
QT_END_NAMESPACE
-#endif // QSGIMAGE_P_P_H
+#endif // QQUICKIMAGE_P_P_H
**
****************************************************************************/
-#include "qsgimagebase_p.h"
-#include "qsgimagebase_p_p.h"
+#include "qquickimagebase_p.h"
+#include "qquickimagebase_p_p.h"
#include <QtDeclarative/qdeclarativeinfo.h>
QT_BEGIN_NAMESPACE
-QSGImageBase::QSGImageBase(QSGItem *parent)
-: QSGImplicitSizeItem(*(new QSGImageBasePrivate), parent)
+QQuickImageBase::QQuickImageBase(QQuickItem *parent)
+: QQuickImplicitSizeItem(*(new QQuickImageBasePrivate), parent)
{
setFlag(ItemHasContents);
}
-QSGImageBase::QSGImageBase(QSGImageBasePrivate &dd, QSGItem *parent)
-: QSGImplicitSizeItem(dd, parent)
+QQuickImageBase::QQuickImageBase(QQuickImageBasePrivate &dd, QQuickItem *parent)
+: QQuickImplicitSizeItem(dd, parent)
{
setFlag(ItemHasContents);
}
-QSGImageBase::~QSGImageBase()
+QQuickImageBase::~QQuickImageBase()
{
}
-QSGImageBase::Status QSGImageBase::status() const
+QQuickImageBase::Status QQuickImageBase::status() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->status;
}
-qreal QSGImageBase::progress() const
+qreal QQuickImageBase::progress() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->progress;
}
-bool QSGImageBase::asynchronous() const
+bool QQuickImageBase::asynchronous() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->async;
}
-void QSGImageBase::setAsynchronous(bool async)
+void QQuickImageBase::setAsynchronous(bool async)
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (d->async != async) {
d->async = async;
emit asynchronousChanged();
}
}
-QUrl QSGImageBase::source() const
+QUrl QQuickImageBase::source() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->url;
}
-void QSGImageBase::setSource(const QUrl &url)
+void QQuickImageBase::setSource(const QUrl &url)
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
//equality is fairly expensive, so we bypass for simple, common case
if ((d->url.isEmpty() == url.isEmpty()) && url == d->url)
return;
load();
}
-void QSGImageBase::setSourceSize(const QSize& size)
+void QQuickImageBase::setSourceSize(const QSize& size)
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (d->sourcesize == size)
return;
load();
}
-QSize QSGImageBase::sourceSize() const
+QSize QQuickImageBase::sourceSize() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
int width = d->sourcesize.width();
int height = d->sourcesize.height();
return QSize(width != -1 ? width : d->pix.width(), height != -1 ? height : d->pix.height());
}
-void QSGImageBase::resetSourceSize()
+void QQuickImageBase::resetSourceSize()
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (!d->explicitSourceSize)
return;
d->explicitSourceSize = false;
load();
}
-bool QSGImageBase::cache() const
+bool QQuickImageBase::cache() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->cache;
}
-void QSGImageBase::setCache(bool cache)
+void QQuickImageBase::setCache(bool cache)
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (d->cache == cache)
return;
load();
}
-QPixmap QSGImageBase::pixmap() const
+QPixmap QQuickImageBase::pixmap() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->pix.pixmap();
}
-void QSGImageBase::setMirror(bool mirror)
+void QQuickImageBase::setMirror(bool mirror)
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (mirror == d->mirror)
return;
emit mirrorChanged();
}
-bool QSGImageBase::mirror() const
+bool QQuickImageBase::mirror() const
{
- Q_D(const QSGImageBase);
+ Q_D(const QQuickImageBase);
return d->mirror;
}
-void QSGImageBase::load()
+void QQuickImageBase::load()
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (d->url.isEmpty()) {
d->pix.clear(this);
static int thisRequestFinished = -1;
if (thisRequestProgress == -1) {
thisRequestProgress =
- QSGImageBase::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)");
+ QQuickImageBase::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)");
thisRequestFinished =
- QSGImageBase::staticMetaObject.indexOfSlot("requestFinished()");
+ QQuickImageBase::staticMetaObject.indexOfSlot("requestFinished()");
}
d->pix.connectFinished(this, thisRequestFinished);
}
}
-void QSGImageBase::requestFinished()
+void QQuickImageBase::requestFinished()
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
- QSGImageBase::Status oldStatus = d->status;
+ QQuickImageBase::Status oldStatus = d->status;
qreal oldProgress = d->progress;
if (d->pix.isError()) {
update();
}
-void QSGImageBase::requestProgress(qint64 received, qint64 total)
+void QQuickImageBase::requestProgress(qint64 received, qint64 total)
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
if (d->status == Loading && total > 0) {
d->progress = qreal(received)/total;
emit progressChanged(d->progress);
}
}
-void QSGImageBase::componentComplete()
+void QQuickImageBase::componentComplete()
{
- Q_D(QSGImageBase);
- QSGItem::componentComplete();
+ Q_D(QQuickImageBase);
+ QQuickItem::componentComplete();
if (d->url.isValid())
load();
}
-void QSGImageBase::pixmapChange()
+void QQuickImageBase::pixmapChange()
{
- Q_D(QSGImageBase);
+ Q_D(QQuickImageBase);
setImplicitWidth(d->pix.width());
setImplicitHeight(d->pix.height());
}
**
****************************************************************************/
-#ifndef QSGIMAGEBASE_P_H
-#define QSGIMAGEBASE_P_H
+#ifndef QQUICKIMAGEBASE_P_H
+#define QQUICKIMAGEBASE_P_H
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-class QSGImageBasePrivate;
-class Q_AUTOTEST_EXPORT QSGImageBase : public QSGImplicitSizeItem
+class QQuickImageBasePrivate;
+class Q_AUTOTEST_EXPORT QQuickImageBase : public QQuickImplicitSizeItem
{
Q_OBJECT
Q_ENUMS(Status)
Q_PROPERTY(bool mirror READ mirror WRITE setMirror NOTIFY mirrorChanged)
public:
- QSGImageBase(QSGItem *parent=0);
- ~QSGImageBase();
+ QQuickImageBase(QQuickItem *parent=0);
+ ~QQuickImageBase();
enum Status { Null, Ready, Loading, Error };
Status status() const;
qreal progress() const;
Q_SIGNALS:
void sourceChanged(const QUrl &);
void sourceSizeChanged();
- void statusChanged(QSGImageBase::Status);
+ void statusChanged(QQuickImageBase::Status);
void progressChanged(qreal progress);
void asynchronousChanged();
void cacheChanged();
virtual void load();
virtual void componentComplete();
virtual void pixmapChange();
- QSGImageBase(QSGImageBasePrivate &dd, QSGItem *parent);
+ QQuickImageBase(QQuickImageBasePrivate &dd, QQuickItem *parent);
private Q_SLOTS:
virtual void requestFinished();
void requestProgress(qint64,qint64);
private:
- Q_DISABLE_COPY(QSGImageBase)
- Q_DECLARE_PRIVATE(QSGImageBase)
+ Q_DISABLE_COPY(QQuickImageBase)
+ Q_DECLARE_PRIVATE(QQuickImageBase)
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // QSGIMAGEBASE_P_H
+#endif // QQUICKIMAGEBASE_P_H
**
****************************************************************************/
-#ifndef QSGIMAGEBASE_P_P_H
-#define QSGIMAGEBASE_P_P_H
+#ifndef QQUICKIMAGEBASE_P_P_H
+#define QQUICKIMAGEBASE_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgimplicitsizeitem_p_p.h"
-#include "qsgimagebase_p.h"
+#include "qquickimplicitsizeitem_p_p.h"
+#include "qquickimagebase_p.h"
#include <private/qdeclarativepixmapcache_p.h>
QT_BEGIN_NAMESPACE
class QNetworkReply;
-class QSGImageBasePrivate : public QSGImplicitSizeItemPrivate
+class QQuickImageBasePrivate : public QQuickImplicitSizeItemPrivate
{
- Q_DECLARE_PUBLIC(QSGImageBase)
+ Q_DECLARE_PUBLIC(QQuickImageBase)
public:
- QSGImageBasePrivate()
- : status(QSGImageBase::Null),
+ QQuickImageBasePrivate()
+ : status(QQuickImageBase::Null),
progress(0.0),
explicitSourceSize(false),
async(false),
}
QDeclarativePixmap pix;
- QSGImageBase::Status status;
+ QQuickImageBase::Status status;
QUrl url;
qreal progress;
QSize sourcesize;
QT_END_NAMESPACE
-#endif // QSGIMAGEBASE_P_P_H
+#endif // QQUICKIMAGEBASE_P_P_H
**
****************************************************************************/
-#include "qsgimplicitsizeitem_p.h"
-#include "qsgimplicitsizeitem_p_p.h"
+#include "qquickimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p_p.h"
QT_BEGIN_NAMESPACE
-void QSGImplicitSizeItemPrivate::implicitWidthChanged()
+void QQuickImplicitSizeItemPrivate::implicitWidthChanged()
{
- Q_Q(QSGImplicitSizeItem);
+ Q_Q(QQuickImplicitSizeItem);
emit q->implicitWidthChanged();
}
-void QSGImplicitSizeItemPrivate::implicitHeightChanged()
+void QQuickImplicitSizeItemPrivate::implicitHeightChanged()
{
- Q_Q(QSGImplicitSizeItem);
+ Q_Q(QQuickImplicitSizeItem);
emit q->implicitHeightChanged();
}
-QSGImplicitSizeItem::QSGImplicitSizeItem(QSGItem *parent)
- : QSGItem(*(new QSGImplicitSizeItemPrivate), parent)
+QQuickImplicitSizeItem::QQuickImplicitSizeItem(QQuickItem *parent)
+ : QQuickItem(*(new QQuickImplicitSizeItemPrivate), parent)
{
}
-QSGImplicitSizeItem::QSGImplicitSizeItem(QSGImplicitSizeItemPrivate &dd, QSGItem *parent)
- : QSGItem(dd, parent)
+QQuickImplicitSizeItem::QQuickImplicitSizeItem(QQuickImplicitSizeItemPrivate &dd, QQuickItem *parent)
+ : QQuickItem(dd, parent)
{
}
-void QSGImplicitSizePaintedItemPrivate::implicitWidthChanged()
+void QQuickImplicitSizePaintedItemPrivate::implicitWidthChanged()
{
- Q_Q(QSGImplicitSizePaintedItem);
+ Q_Q(QQuickImplicitSizePaintedItem);
emit q->implicitWidthChanged();
}
-void QSGImplicitSizePaintedItemPrivate::implicitHeightChanged()
+void QQuickImplicitSizePaintedItemPrivate::implicitHeightChanged()
{
- Q_Q(QSGImplicitSizePaintedItem);
+ Q_Q(QQuickImplicitSizePaintedItem);
emit q->implicitHeightChanged();
}
-QSGImplicitSizePaintedItem::QSGImplicitSizePaintedItem(QSGItem *parent)
- : QSGPaintedItem(*(new QSGImplicitSizePaintedItemPrivate), parent)
+QQuickImplicitSizePaintedItem::QQuickImplicitSizePaintedItem(QQuickItem *parent)
+ : QQuickPaintedItem(*(new QQuickImplicitSizePaintedItemPrivate), parent)
{
}
-QSGImplicitSizePaintedItem::QSGImplicitSizePaintedItem(QSGImplicitSizePaintedItemPrivate &dd, QSGItem *parent)
- : QSGPaintedItem(dd, parent)
+QQuickImplicitSizePaintedItem::QQuickImplicitSizePaintedItem(QQuickImplicitSizePaintedItemPrivate &dd, QQuickItem *parent)
+ : QQuickPaintedItem(dd, parent)
{
}
**
****************************************************************************/
-#ifndef QSGIMPLICITSIZEITEM_H
-#define QSGIMPLICITSIZEITEM_H
+#ifndef QQUICKIMPLICITSIZEITEM_H
+#define QQUICKIMPLICITSIZEITEM_H
-#include "qsgpainteditem.h"
+#include "qquickpainteditem.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-class QSGImplicitSizeItemPrivate;
-class Q_AUTOTEST_EXPORT QSGImplicitSizeItem : public QSGItem
+class QQuickImplicitSizeItemPrivate;
+class Q_AUTOTEST_EXPORT QQuickImplicitSizeItem : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(qreal implicitWidth READ implicitWidth NOTIFY implicitWidthChanged)
Q_PROPERTY(qreal implicitHeight READ implicitHeight NOTIFY implicitHeightChanged)
public:
- QSGImplicitSizeItem(QSGItem *parent = 0);
+ QQuickImplicitSizeItem(QQuickItem *parent = 0);
protected:
- QSGImplicitSizeItem(QSGImplicitSizeItemPrivate &dd, QSGItem *parent);
+ QQuickImplicitSizeItem(QQuickImplicitSizeItemPrivate &dd, QQuickItem *parent);
Q_SIGNALS:
void implicitWidthChanged();
void implicitHeightChanged();
private:
- Q_DISABLE_COPY(QSGImplicitSizeItem)
- Q_DECLARE_PRIVATE(QSGImplicitSizeItem)
+ Q_DISABLE_COPY(QQuickImplicitSizeItem)
+ Q_DECLARE_PRIVATE(QQuickImplicitSizeItem)
};
-class QSGImplicitSizePaintedItemPrivate;
-class Q_AUTOTEST_EXPORT QSGImplicitSizePaintedItem : public QSGPaintedItem
+class QQuickImplicitSizePaintedItemPrivate;
+class Q_AUTOTEST_EXPORT QQuickImplicitSizePaintedItem : public QQuickPaintedItem
{
Q_OBJECT
Q_PROPERTY(qreal implicitWidth READ implicitWidth NOTIFY implicitWidthChanged)
Q_PROPERTY(qreal implicitHeight READ implicitHeight NOTIFY implicitHeightChanged)
public:
- QSGImplicitSizePaintedItem(QSGItem *parent = 0);
+ QQuickImplicitSizePaintedItem(QQuickItem *parent = 0);
protected:
- QSGImplicitSizePaintedItem(QSGImplicitSizePaintedItemPrivate &dd, QSGItem *parent);
+ QQuickImplicitSizePaintedItem(QQuickImplicitSizePaintedItemPrivate &dd, QQuickItem *parent);
virtual void drawContents(QPainter *, const QRect &) {};
Q_SIGNALS:
void implicitHeightChanged();
private:
- Q_DISABLE_COPY(QSGImplicitSizePaintedItem)
- Q_DECLARE_PRIVATE(QSGImplicitSizePaintedItem)
+ Q_DISABLE_COPY(QQuickImplicitSizePaintedItem)
+ Q_DECLARE_PRIVATE(QQuickImplicitSizePaintedItem)
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // QSGIMPLICITSIZEITEM_H
+#endif // QQUICKIMPLICITSIZEITEM_H
**
****************************************************************************/
-#ifndef QSGIMPLICITSIZEITEM_P_H
-#define QSGIMPLICITSIZEITEM_P_H
+#ifndef QQUICKIMPLICITSIZEITEM_P_H
+#define QQUICKIMPLICITSIZEITEM_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgitem_p.h"
-#include "qsgpainteditem_p.h"
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickitem_p.h"
+#include "qquickpainteditem_p.h"
+#include "qquickimplicitsizeitem_p.h"
QT_BEGIN_NAMESPACE
-class QSGImplicitSizeItemPrivate : public QSGItemPrivate
+class QQuickImplicitSizeItemPrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGImplicitSizeItem)
+ Q_DECLARE_PUBLIC(QQuickImplicitSizeItem)
public:
- QSGImplicitSizeItemPrivate()
+ QQuickImplicitSizeItemPrivate()
{
}
};
-class QSGImplicitSizePaintedItemPrivate : public QSGPaintedItemPrivate
+class QQuickImplicitSizePaintedItemPrivate : public QQuickPaintedItemPrivate
{
- Q_DECLARE_PUBLIC(QSGImplicitSizePaintedItem)
+ Q_DECLARE_PUBLIC(QQuickImplicitSizePaintedItem)
public:
- QSGImplicitSizePaintedItemPrivate()
+ QQuickImplicitSizePaintedItemPrivate()
{
}
QT_END_NAMESPACE
-#endif // QSGIMPLICITSIZEITEM_P_H
+#endif // QQUICKIMPLICITSIZEITEM_P_H
**
****************************************************************************/
-#include "qsgitem.h"
+#include "qquickitem.h"
-#include "qsgcanvas.h"
+#include "qquickcanvas.h"
#include <QtDeclarative/qjsengine.h>
-#include "qsgcanvas_p.h"
+#include "qquickcanvas_p.h"
-#include "qsgevents_p_p.h"
+#include "qquickevents_p_p.h"
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <private/qdeclarativeopenmetaobject_p.h>
#include <private/qdeclarativestate_p.h>
#include <private/qlistmodelinterface_p.h>
-#include <private/qsgitem_p.h>
+#include <private/qquickitem_p.h>
#include <float.h>
QT_BEGIN_NAMESPACE
/*!
- \qmlclass Transform QSGTransform
+ \qmlclass Transform QQuickTransform
\inqmlmodule QtQuick 2
\ingroup qml-transform-elements
\brief The Transform elements provide a way of building advanced transformations on Items.
*/
/*!
- \qmlclass Translate QSGTranslate
+ \qmlclass Translate QQuickTranslate
\inqmlmodule QtQuick 2
\ingroup qml-transform-elements
\brief The Translate object provides a way to move an Item without changing its x or y properties.
*/
/*!
- \qmlclass Scale QSGScale
+ \qmlclass Scale QQuickScale
\inqmlmodule QtQuick 2
\ingroup qml-transform-elements
\brief The Scale element provides a way to scale an Item.
*/
/*!
- \qmlclass Rotation QSGRotation
+ \qmlclass Rotation QQuickRotation
\inqmlmodule QtQuick 2
\ingroup qml-transform-elements
\brief The Rotation object provides a way to rotate an Item.
The angle to rotate, in degrees clockwise.
*/
-QSGTransformPrivate::QSGTransformPrivate()
+QQuickTransformPrivate::QQuickTransformPrivate()
{
}
-QSGTransform::QSGTransform(QObject *parent)
-: QObject(*(new QSGTransformPrivate), parent)
+QQuickTransform::QQuickTransform(QObject *parent)
+: QObject(*(new QQuickTransformPrivate), parent)
{
}
-QSGTransform::QSGTransform(QSGTransformPrivate &dd, QObject *parent)
+QQuickTransform::QQuickTransform(QQuickTransformPrivate &dd, QObject *parent)
: QObject(dd, parent)
{
}
-QSGTransform::~QSGTransform()
+QQuickTransform::~QQuickTransform()
{
- Q_D(QSGTransform);
+ Q_D(QQuickTransform);
for (int ii = 0; ii < d->items.count(); ++ii) {
- QSGItemPrivate *p = QSGItemPrivate::get(d->items.at(ii));
+ QQuickItemPrivate *p = QQuickItemPrivate::get(d->items.at(ii));
p->transforms.removeOne(this);
- p->dirty(QSGItemPrivate::Transform);
+ p->dirty(QQuickItemPrivate::Transform);
}
}
-void QSGTransform::update()
+void QQuickTransform::update()
{
- Q_D(QSGTransform);
+ Q_D(QQuickTransform);
for (int ii = 0; ii < d->items.count(); ++ii) {
- QSGItemPrivate *p = QSGItemPrivate::get(d->items.at(ii));
- p->dirty(QSGItemPrivate::Transform);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(d->items.at(ii));
+ p->dirty(QQuickItemPrivate::Transform);
}
}
-QSGContents::QSGContents(QSGItem *item)
+QQuickContents::QQuickContents(QQuickItem *item)
: m_item(item), m_x(0), m_y(0), m_width(0), m_height(0)
{
//### optimize
connect(this, SIGNAL(rectChanged(QRectF)), m_item, SIGNAL(childrenRectChanged(QRectF)));
}
-QSGContents::~QSGContents()
+QQuickContents::~QQuickContents()
{
- QList<QSGItem *> children = m_item->childItems();
+ QList<QQuickItem *> children = m_item->childItems();
for (int i = 0; i < children.count(); ++i) {
- QSGItem *child = children.at(i);
- QSGItemPrivate::get(child)->removeItemChangeListener(this, QSGItemPrivate::Geometry | QSGItemPrivate::Destroyed);
+ QQuickItem *child = children.at(i);
+ QQuickItemPrivate::get(child)->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
}
}
-QRectF QSGContents::rectF() const
+QRectF QQuickContents::rectF() const
{
return QRectF(m_x, m_y, m_width, m_height);
}
-void QSGContents::calcHeight(QSGItem *changed)
+void QQuickContents::calcHeight(QQuickItem *changed)
{
qreal oldy = m_y;
qreal oldheight = m_height;
} else {
qreal top = FLT_MAX;
qreal bottom = 0;
- QList<QSGItem *> children = m_item->childItems();
+ QList<QQuickItem *> children = m_item->childItems();
for (int i = 0; i < children.count(); ++i) {
- QSGItem *child = children.at(i);
+ QQuickItem *child = children.at(i);
qreal y = child->y();
if (y + child->height() > bottom)
bottom = y + child->height();
emit rectChanged(rectF());
}
-void QSGContents::calcWidth(QSGItem *changed)
+void QQuickContents::calcWidth(QQuickItem *changed)
{
qreal oldx = m_x;
qreal oldwidth = m_width;
} else {
qreal left = FLT_MAX;
qreal right = 0;
- QList<QSGItem *> children = m_item->childItems();
+ QList<QQuickItem *> children = m_item->childItems();
for (int i = 0; i < children.count(); ++i) {
- QSGItem *child = children.at(i);
+ QQuickItem *child = children.at(i);
qreal x = child->x();
if (x + child->width() > right)
right = x + child->width();
emit rectChanged(rectF());
}
-void QSGContents::complete()
+void QQuickContents::complete()
{
- QList<QSGItem *> children = m_item->childItems();
+ QList<QQuickItem *> children = m_item->childItems();
for (int i = 0; i < children.count(); ++i) {
- QSGItem *child = children.at(i);
- QSGItemPrivate::get(child)->addItemChangeListener(this, QSGItemPrivate::Geometry | QSGItemPrivate::Destroyed);
+ QQuickItem *child = children.at(i);
+ QQuickItemPrivate::get(child)->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
//###what about changes to visibility?
}
calcGeometry();
}
-void QSGContents::itemGeometryChanged(QSGItem *changed, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickContents::itemGeometryChanged(QQuickItem *changed, const QRectF &newGeometry, const QRectF &oldGeometry)
{
Q_UNUSED(changed)
//### we can only pass changed if the left edge has moved left, or the right edge has moved right
calcHeight(/*changed*/);
}
-void QSGContents::itemDestroyed(QSGItem *item)
+void QQuickContents::itemDestroyed(QQuickItem *item)
{
if (item)
- QSGItemPrivate::get(item)->removeItemChangeListener(this, QSGItemPrivate::Geometry | QSGItemPrivate::Destroyed);
+ QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
calcGeometry();
}
-void QSGContents::childRemoved(QSGItem *item)
+void QQuickContents::childRemoved(QQuickItem *item)
{
if (item)
- QSGItemPrivate::get(item)->removeItemChangeListener(this, QSGItemPrivate::Geometry | QSGItemPrivate::Destroyed);
+ QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
calcGeometry();
}
-void QSGContents::childAdded(QSGItem *item)
+void QQuickContents::childAdded(QQuickItem *item)
{
if (item)
- QSGItemPrivate::get(item)->addItemChangeListener(this, QSGItemPrivate::Geometry | QSGItemPrivate::Destroyed);
+ QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
calcWidth(item);
calcHeight(item);
}
-QSGItemKeyFilter::QSGItemKeyFilter(QSGItem *item)
+QQuickItemKeyFilter::QQuickItemKeyFilter(QQuickItem *item)
: m_processPost(false), m_next(0)
{
- QSGItemPrivate *p = item?QSGItemPrivate::get(item):0;
+ QQuickItemPrivate *p = item?QQuickItemPrivate::get(item):0;
if (p) {
m_next = p->keyHandler;
p->keyHandler = this;
}
}
-QSGItemKeyFilter::~QSGItemKeyFilter()
+QQuickItemKeyFilter::~QQuickItemKeyFilter()
{
}
-void QSGItemKeyFilter::keyPressed(QKeyEvent *event, bool post)
+void QQuickItemKeyFilter::keyPressed(QKeyEvent *event, bool post)
{
if (m_next) m_next->keyPressed(event, post);
}
-void QSGItemKeyFilter::keyReleased(QKeyEvent *event, bool post)
+void QQuickItemKeyFilter::keyReleased(QKeyEvent *event, bool post)
{
if (m_next) m_next->keyReleased(event, post);
}
-void QSGItemKeyFilter::inputMethodEvent(QInputMethodEvent *event, bool post)
+void QQuickItemKeyFilter::inputMethodEvent(QInputMethodEvent *event, bool post)
{
if (m_next)
m_next->inputMethodEvent(event, post);
event->ignore();
}
-QVariant QSGItemKeyFilter::inputMethodQuery(Qt::InputMethodQuery query) const
+QVariant QQuickItemKeyFilter::inputMethodQuery(Qt::InputMethodQuery query) const
{
if (m_next) return m_next->inputMethodQuery(query);
return QVariant();
}
-void QSGItemKeyFilter::componentComplete()
+void QQuickItemKeyFilter::componentComplete()
{
if (m_next) m_next->componentComplete();
}
/*!
- \qmlclass KeyNavigation QSGKeyNavigationAttached
+ \qmlclass KeyNavigation QQuickKeyNavigationAttached
\inqmlmodule QtQuick 2
\ingroup qml-basic-interaction-elements
\brief The KeyNavigation attached property supports key navigation by arrow keys.
when the Tab key or Shift+Tab key combination (Backtab) are pressed.
*/
-QSGKeyNavigationAttached::QSGKeyNavigationAttached(QObject *parent)
-: QObject(*(new QSGKeyNavigationAttachedPrivate), parent),
- QSGItemKeyFilter(qobject_cast<QSGItem*>(parent))
+QQuickKeyNavigationAttached::QQuickKeyNavigationAttached(QObject *parent)
+: QObject(*(new QQuickKeyNavigationAttachedPrivate), parent),
+ QQuickItemKeyFilter(qobject_cast<QQuickItem*>(parent))
{
m_processPost = true;
}
-QSGKeyNavigationAttached *
-QSGKeyNavigationAttached::qmlAttachedProperties(QObject *obj)
+QQuickKeyNavigationAttached *
+QQuickKeyNavigationAttached::qmlAttachedProperties(QObject *obj)
{
- return new QSGKeyNavigationAttached(obj);
+ return new QQuickKeyNavigationAttached(obj);
}
-QSGItem *QSGKeyNavigationAttached::left() const
+QQuickItem *QQuickKeyNavigationAttached::left() const
{
- Q_D(const QSGKeyNavigationAttached);
+ Q_D(const QQuickKeyNavigationAttached);
return d->left;
}
-void QSGKeyNavigationAttached::setLeft(QSGItem *i)
+void QQuickKeyNavigationAttached::setLeft(QQuickItem *i)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
if (d->left == i)
return;
d->left = i;
d->leftSet = true;
- QSGKeyNavigationAttached* other =
- qobject_cast<QSGKeyNavigationAttached*>(qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(i));
+ QQuickKeyNavigationAttached* other =
+ qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
if (other && !other->d_func()->rightSet){
- other->d_func()->right = qobject_cast<QSGItem*>(parent());
+ other->d_func()->right = qobject_cast<QQuickItem*>(parent());
emit other->rightChanged();
}
emit leftChanged();
}
-QSGItem *QSGKeyNavigationAttached::right() const
+QQuickItem *QQuickKeyNavigationAttached::right() const
{
- Q_D(const QSGKeyNavigationAttached);
+ Q_D(const QQuickKeyNavigationAttached);
return d->right;
}
-void QSGKeyNavigationAttached::setRight(QSGItem *i)
+void QQuickKeyNavigationAttached::setRight(QQuickItem *i)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
if (d->right == i)
return;
d->right = i;
d->rightSet = true;
- QSGKeyNavigationAttached* other =
- qobject_cast<QSGKeyNavigationAttached*>(qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(i));
+ QQuickKeyNavigationAttached* other =
+ qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
if (other && !other->d_func()->leftSet){
- other->d_func()->left = qobject_cast<QSGItem*>(parent());
+ other->d_func()->left = qobject_cast<QQuickItem*>(parent());
emit other->leftChanged();
}
emit rightChanged();
}
-QSGItem *QSGKeyNavigationAttached::up() const
+QQuickItem *QQuickKeyNavigationAttached::up() const
{
- Q_D(const QSGKeyNavigationAttached);
+ Q_D(const QQuickKeyNavigationAttached);
return d->up;
}
-void QSGKeyNavigationAttached::setUp(QSGItem *i)
+void QQuickKeyNavigationAttached::setUp(QQuickItem *i)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
if (d->up == i)
return;
d->up = i;
d->upSet = true;
- QSGKeyNavigationAttached* other =
- qobject_cast<QSGKeyNavigationAttached*>(qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(i));
+ QQuickKeyNavigationAttached* other =
+ qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
if (other && !other->d_func()->downSet){
- other->d_func()->down = qobject_cast<QSGItem*>(parent());
+ other->d_func()->down = qobject_cast<QQuickItem*>(parent());
emit other->downChanged();
}
emit upChanged();
}
-QSGItem *QSGKeyNavigationAttached::down() const
+QQuickItem *QQuickKeyNavigationAttached::down() const
{
- Q_D(const QSGKeyNavigationAttached);
+ Q_D(const QQuickKeyNavigationAttached);
return d->down;
}
-void QSGKeyNavigationAttached::setDown(QSGItem *i)
+void QQuickKeyNavigationAttached::setDown(QQuickItem *i)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
if (d->down == i)
return;
d->down = i;
d->downSet = true;
- QSGKeyNavigationAttached* other =
- qobject_cast<QSGKeyNavigationAttached*>(qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(i));
+ QQuickKeyNavigationAttached* other =
+ qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
if (other && !other->d_func()->upSet) {
- other->d_func()->up = qobject_cast<QSGItem*>(parent());
+ other->d_func()->up = qobject_cast<QQuickItem*>(parent());
emit other->upChanged();
}
emit downChanged();
}
-QSGItem *QSGKeyNavigationAttached::tab() const
+QQuickItem *QQuickKeyNavigationAttached::tab() const
{
- Q_D(const QSGKeyNavigationAttached);
+ Q_D(const QQuickKeyNavigationAttached);
return d->tab;
}
-void QSGKeyNavigationAttached::setTab(QSGItem *i)
+void QQuickKeyNavigationAttached::setTab(QQuickItem *i)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
if (d->tab == i)
return;
d->tab = i;
d->tabSet = true;
- QSGKeyNavigationAttached* other =
- qobject_cast<QSGKeyNavigationAttached*>(qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(i));
+ QQuickKeyNavigationAttached* other =
+ qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
if (other && !other->d_func()->backtabSet) {
- other->d_func()->backtab = qobject_cast<QSGItem*>(parent());
+ other->d_func()->backtab = qobject_cast<QQuickItem*>(parent());
emit other->backtabChanged();
}
emit tabChanged();
}
-QSGItem *QSGKeyNavigationAttached::backtab() const
+QQuickItem *QQuickKeyNavigationAttached::backtab() const
{
- Q_D(const QSGKeyNavigationAttached);
+ Q_D(const QQuickKeyNavigationAttached);
return d->backtab;
}
-void QSGKeyNavigationAttached::setBacktab(QSGItem *i)
+void QQuickKeyNavigationAttached::setBacktab(QQuickItem *i)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
if (d->backtab == i)
return;
d->backtab = i;
d->backtabSet = true;
- QSGKeyNavigationAttached* other =
- qobject_cast<QSGKeyNavigationAttached*>(qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(i));
+ QQuickKeyNavigationAttached* other =
+ qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
if (other && !other->d_func()->tabSet) {
- other->d_func()->tab = qobject_cast<QSGItem*>(parent());
+ other->d_func()->tab = qobject_cast<QQuickItem*>(parent());
emit other->tabChanged();
}
emit backtabChanged();
handled by the KeyNavigation attached property handler.
\endlist
*/
-QSGKeyNavigationAttached::Priority QSGKeyNavigationAttached::priority() const
+QQuickKeyNavigationAttached::Priority QQuickKeyNavigationAttached::priority() const
{
return m_processPost ? AfterItem : BeforeItem;
}
-void QSGKeyNavigationAttached::setPriority(Priority order)
+void QQuickKeyNavigationAttached::setPriority(Priority order)
{
bool processPost = order == AfterItem;
if (processPost != m_processPost) {
}
}
-void QSGKeyNavigationAttached::keyPressed(QKeyEvent *event, bool post)
+void QQuickKeyNavigationAttached::keyPressed(QKeyEvent *event, bool post)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
event->ignore();
if (post != m_processPost) {
- QSGItemKeyFilter::keyPressed(event, post);
+ QQuickItemKeyFilter::keyPressed(event, post);
return;
}
bool mirror = false;
switch (event->key()) {
case Qt::Key_Left: {
- if (QSGItem *parentItem = qobject_cast<QSGItem*>(parent()))
- mirror = QSGItemPrivate::get(parentItem)->effectiveLayoutMirror;
- QSGItem* leftItem = mirror ? d->right : d->left;
+ if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
+ mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
+ QQuickItem* leftItem = mirror ? d->right : d->left;
if (leftItem) {
setFocusNavigation(leftItem, mirror ? "right" : "left");
event->accept();
break;
}
case Qt::Key_Right: {
- if (QSGItem *parentItem = qobject_cast<QSGItem*>(parent()))
- mirror = QSGItemPrivate::get(parentItem)->effectiveLayoutMirror;
- QSGItem* rightItem = mirror ? d->left : d->right;
+ if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
+ mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
+ QQuickItem* rightItem = mirror ? d->left : d->right;
if (rightItem) {
setFocusNavigation(rightItem, mirror ? "left" : "right");
event->accept();
break;
}
- if (!event->isAccepted()) QSGItemKeyFilter::keyPressed(event, post);
+ if (!event->isAccepted()) QQuickItemKeyFilter::keyPressed(event, post);
}
-void QSGKeyNavigationAttached::keyReleased(QKeyEvent *event, bool post)
+void QQuickKeyNavigationAttached::keyReleased(QKeyEvent *event, bool post)
{
- Q_D(QSGKeyNavigationAttached);
+ Q_D(QQuickKeyNavigationAttached);
event->ignore();
if (post != m_processPost) {
- QSGItemKeyFilter::keyReleased(event, post);
+ QQuickItemKeyFilter::keyReleased(event, post);
return;
}
bool mirror = false;
switch (event->key()) {
case Qt::Key_Left:
- if (QSGItem *parentItem = qobject_cast<QSGItem*>(parent()))
- mirror = QSGItemPrivate::get(parentItem)->effectiveLayoutMirror;
+ if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
+ mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
if (mirror ? d->right : d->left)
event->accept();
break;
case Qt::Key_Right:
- if (QSGItem *parentItem = qobject_cast<QSGItem*>(parent()))
- mirror = QSGItemPrivate::get(parentItem)->effectiveLayoutMirror;
+ if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
+ mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
if (mirror ? d->left : d->right)
event->accept();
break;
break;
}
- if (!event->isAccepted()) QSGItemKeyFilter::keyReleased(event, post);
+ if (!event->isAccepted()) QQuickItemKeyFilter::keyReleased(event, post);
}
-void QSGKeyNavigationAttached::setFocusNavigation(QSGItem *currentItem, const char *dir)
+void QQuickKeyNavigationAttached::setFocusNavigation(QQuickItem *currentItem, const char *dir)
{
- QSGItem *initialItem = currentItem;
+ QQuickItem *initialItem = currentItem;
bool isNextItem = false;
do {
isNextItem = false;
currentItem->setFocus(true);
} else {
QObject *attached =
- qmlAttachedPropertiesObject<QSGKeyNavigationAttached>(currentItem, false);
+ qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(currentItem, false);
if (attached) {
- QSGItem *tempItem = qvariant_cast<QSGItem*>(attached->property(dir));
+ QQuickItem *tempItem = qvariant_cast<QQuickItem*>(attached->property(dir));
if (tempItem) {
currentItem = tempItem;
isNextItem = true;
while (currentItem != initialItem && isNextItem);
}
-const QSGKeysAttached::SigMap QSGKeysAttached::sigMap[] = {
+const QQuickKeysAttached::SigMap QQuickKeysAttached::sigMap[] = {
{ Qt::Key_Left, "leftPressed" },
{ Qt::Key_Right, "rightPressed" },
{ Qt::Key_Up, "upPressed" },
{ 0, 0 }
};
-bool QSGKeysAttachedPrivate::isConnected(const char *signalName)
+bool QQuickKeysAttachedPrivate::isConnected(const char *signalName)
{
return isSignalConnected(signalIndex(signalName));
}
/*!
- \qmlclass Keys QSGKeysAttached
+ \qmlclass Keys QQuickKeysAttached
\inqmlmodule QtQuick 2
\ingroup qml-basic-interaction-elements
\brief The Keys attached property provides key handling to Items.
parameter provides information about the event.
*/
-QSGKeysAttached::QSGKeysAttached(QObject *parent)
-: QObject(*(new QSGKeysAttachedPrivate), parent),
- QSGItemKeyFilter(qobject_cast<QSGItem*>(parent))
+QQuickKeysAttached::QQuickKeysAttached(QObject *parent)
+: QObject(*(new QQuickKeysAttachedPrivate), parent),
+ QQuickItemKeyFilter(qobject_cast<QQuickItem*>(parent))
{
- Q_D(QSGKeysAttached);
+ Q_D(QQuickKeysAttached);
m_processPost = false;
- d->item = qobject_cast<QSGItem*>(parent);
+ d->item = qobject_cast<QQuickItem*>(parent);
}
-QSGKeysAttached::~QSGKeysAttached()
+QQuickKeysAttached::~QQuickKeysAttached()
{
}
-QSGKeysAttached::Priority QSGKeysAttached::priority() const
+QQuickKeysAttached::Priority QQuickKeysAttached::priority() const
{
return m_processPost ? AfterItem : BeforeItem;
}
-void QSGKeysAttached::setPriority(Priority order)
+void QQuickKeysAttached::setPriority(Priority order)
{
bool processPost = order == AfterItem;
if (processPost != m_processPost) {
}
}
-void QSGKeysAttached::componentComplete()
+void QQuickKeysAttached::componentComplete()
{
- Q_D(QSGKeysAttached);
+ Q_D(QQuickKeysAttached);
if (d->item) {
for (int ii = 0; ii < d->targets.count(); ++ii) {
- QSGItem *targetItem = d->targets.at(ii);
- if (targetItem && (targetItem->flags() & QSGItem::ItemAcceptsInputMethod)) {
- d->item->setFlag(QSGItem::ItemAcceptsInputMethod);
+ QQuickItem *targetItem = d->targets.at(ii);
+ if (targetItem && (targetItem->flags() & QQuickItem::ItemAcceptsInputMethod)) {
+ d->item->setFlag(QQuickItem::ItemAcceptsInputMethod);
break;
}
}
}
}
-void QSGKeysAttached::keyPressed(QKeyEvent *event, bool post)
+void QQuickKeysAttached::keyPressed(QKeyEvent *event, bool post)
{
- Q_D(QSGKeysAttached);
+ Q_D(QQuickKeysAttached);
if (post != m_processPost || !d->enabled || d->inPress) {
event->ignore();
- QSGItemKeyFilter::keyPressed(event, post);
+ QQuickItemKeyFilter::keyPressed(event, post);
return;
}
if (d->item && d->item->canvas()) {
d->inPress = true;
for (int ii = 0; ii < d->targets.count(); ++ii) {
- QSGItem *i = d->targets.at(ii);
+ QQuickItem *i = d->targets.at(ii);
if (i && i->isVisible()) {
d->item->canvas()->sendEvent(i, event);
if (event->isAccepted()) {
d->inPress = false;
}
- QSGKeyEvent ke(*event);
+ QQuickKeyEvent ke(*event);
QByteArray keySignal = keyToSignal(event->key());
if (!keySignal.isEmpty()) {
- keySignal += "(QSGKeyEvent*)";
+ keySignal += "(QQuickKeyEvent*)";
if (d->isConnected(keySignal)) {
// If we specifically handle a key then default to accepted
ke.setAccepted(true);
- int idx = QSGKeysAttached::staticMetaObject.indexOfSignal(keySignal);
- metaObject()->method(idx).invoke(this, Qt::DirectConnection, Q_ARG(QSGKeyEvent*, &ke));
+ int idx = QQuickKeysAttached::staticMetaObject.indexOfSignal(keySignal);
+ metaObject()->method(idx).invoke(this, Qt::DirectConnection, Q_ARG(QQuickKeyEvent*, &ke));
}
}
if (!ke.isAccepted())
emit pressed(&ke);
event->setAccepted(ke.isAccepted());
- if (!event->isAccepted()) QSGItemKeyFilter::keyPressed(event, post);
+ if (!event->isAccepted()) QQuickItemKeyFilter::keyPressed(event, post);
}
-void QSGKeysAttached::keyReleased(QKeyEvent *event, bool post)
+void QQuickKeysAttached::keyReleased(QKeyEvent *event, bool post)
{
- Q_D(QSGKeysAttached);
+ Q_D(QQuickKeysAttached);
if (post != m_processPost || !d->enabled || d->inRelease) {
event->ignore();
- QSGItemKeyFilter::keyReleased(event, post);
+ QQuickItemKeyFilter::keyReleased(event, post);
return;
}
if (d->item && d->item->canvas()) {
d->inRelease = true;
for (int ii = 0; ii < d->targets.count(); ++ii) {
- QSGItem *i = d->targets.at(ii);
+ QQuickItem *i = d->targets.at(ii);
if (i && i->isVisible()) {
d->item->canvas()->sendEvent(i, event);
if (event->isAccepted()) {
d->inRelease = false;
}
- QSGKeyEvent ke(*event);
+ QQuickKeyEvent ke(*event);
emit released(&ke);
event->setAccepted(ke.isAccepted());
- if (!event->isAccepted()) QSGItemKeyFilter::keyReleased(event, post);
+ if (!event->isAccepted()) QQuickItemKeyFilter::keyReleased(event, post);
}
-void QSGKeysAttached::inputMethodEvent(QInputMethodEvent *event, bool post)
+void QQuickKeysAttached::inputMethodEvent(QInputMethodEvent *event, bool post)
{
- Q_D(QSGKeysAttached);
+ Q_D(QQuickKeysAttached);
if (post == m_processPost && d->item && !d->inIM && d->item->canvas()) {
d->inIM = true;
for (int ii = 0; ii < d->targets.count(); ++ii) {
- QSGItem *i = d->targets.at(ii);
- if (i && i->isVisible() && (i->flags() & QSGItem::ItemAcceptsInputMethod)) {
+ QQuickItem *i = d->targets.at(ii);
+ if (i && i->isVisible() && (i->flags() & QQuickItem::ItemAcceptsInputMethod)) {
d->item->canvas()->sendEvent(i, event);
if (event->isAccepted()) {
d->imeItem = i;
}
d->inIM = false;
}
- QSGItemKeyFilter::inputMethodEvent(event, post);
+ QQuickItemKeyFilter::inputMethodEvent(event, post);
}
-QVariant QSGKeysAttached::inputMethodQuery(Qt::InputMethodQuery query) const
+QVariant QQuickKeysAttached::inputMethodQuery(Qt::InputMethodQuery query) const
{
- Q_D(const QSGKeysAttached);
+ Q_D(const QQuickKeysAttached);
if (d->item) {
for (int ii = 0; ii < d->targets.count(); ++ii) {
- QSGItem *i = d->targets.at(ii);
- if (i && i->isVisible() && (i->flags() & QSGItem::ItemAcceptsInputMethod) && i == d->imeItem) {
+ QQuickItem *i = d->targets.at(ii);
+ if (i && i->isVisible() && (i->flags() & QQuickItem::ItemAcceptsInputMethod) && i == d->imeItem) {
//### how robust is i == d->imeItem check?
QVariant v = i->inputMethodQuery(query);
if (v.userType() == QVariant::RectF)
}
}
}
- return QSGItemKeyFilter::inputMethodQuery(query);
+ return QQuickItemKeyFilter::inputMethodQuery(query);
}
-QSGKeysAttached *QSGKeysAttached::qmlAttachedProperties(QObject *obj)
+QQuickKeysAttached *QQuickKeysAttached::qmlAttachedProperties(QObject *obj)
{
- return new QSGKeysAttached(obj);
+ return new QQuickKeysAttached(obj);
}
/*!
- \qmlclass LayoutMirroring QSGLayoutMirroringAttached
+ \qmlclass LayoutMirroring QQuickLayoutMirroringAttached
\inqmlmodule QtQuick 2
\ingroup qml-utility-elements
\brief The LayoutMirroring attached property is used to mirror layout behavior.
*/
-QSGLayoutMirroringAttached::QSGLayoutMirroringAttached(QObject *parent) : QObject(parent), itemPrivate(0)
+QQuickLayoutMirroringAttached::QQuickLayoutMirroringAttached(QObject *parent) : QObject(parent), itemPrivate(0)
{
- if (QSGItem *item = qobject_cast<QSGItem*>(parent)) {
- itemPrivate = QSGItemPrivate::get(item);
+ if (QQuickItem *item = qobject_cast<QQuickItem*>(parent)) {
+ itemPrivate = QQuickItemPrivate::get(item);
itemPrivate->attachedLayoutDirection = this;
} else
qmlInfo(parent) << tr("LayoutDirection attached property only works with Items");
}
-QSGLayoutMirroringAttached * QSGLayoutMirroringAttached::qmlAttachedProperties(QObject *object)
+QQuickLayoutMirroringAttached * QQuickLayoutMirroringAttached::qmlAttachedProperties(QObject *object)
{
- return new QSGLayoutMirroringAttached(object);
+ return new QQuickLayoutMirroringAttached(object);
}
-bool QSGLayoutMirroringAttached::enabled() const
+bool QQuickLayoutMirroringAttached::enabled() const
{
return itemPrivate ? itemPrivate->effectiveLayoutMirror : false;
}
-void QSGLayoutMirroringAttached::setEnabled(bool enabled)
+void QQuickLayoutMirroringAttached::setEnabled(bool enabled)
{
if (!itemPrivate)
return;
}
}
-void QSGLayoutMirroringAttached::resetEnabled()
+void QQuickLayoutMirroringAttached::resetEnabled()
{
if (itemPrivate && !itemPrivate->isMirrorImplicit) {
itemPrivate->isMirrorImplicit = true;
}
}
-bool QSGLayoutMirroringAttached::childrenInherit() const
+bool QQuickLayoutMirroringAttached::childrenInherit() const
{
return itemPrivate ? itemPrivate->inheritMirrorFromItem : false;
}
-void QSGLayoutMirroringAttached::setChildrenInherit(bool childrenInherit) {
+void QQuickLayoutMirroringAttached::setChildrenInherit(bool childrenInherit) {
if (itemPrivate && childrenInherit != itemPrivate->inheritMirrorFromItem) {
itemPrivate->inheritMirrorFromItem = childrenInherit;
itemPrivate->resolveLayoutMirror();
}
}
-void QSGItemPrivate::resolveLayoutMirror()
+void QQuickItemPrivate::resolveLayoutMirror()
{
- Q_Q(QSGItem);
- if (QSGItem *parentItem = q->parentItem()) {
- QSGItemPrivate *parentPrivate = QSGItemPrivate::get(parentItem);
+ Q_Q(QQuickItem);
+ if (QQuickItem *parentItem = q->parentItem()) {
+ QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parentItem);
setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent);
} else {
setImplicitLayoutMirror(isMirrorImplicit ? false : effectiveLayoutMirror, inheritMirrorFromItem);
}
}
-void QSGItemPrivate::setImplicitLayoutMirror(bool mirror, bool inherit)
+void QQuickItemPrivate::setImplicitLayoutMirror(bool mirror, bool inherit)
{
inherit = inherit || inheritMirrorFromItem;
if (!isMirrorImplicit && inheritMirrorFromItem)
if (isMirrorImplicit)
setLayoutMirror(inherit ? inheritedLayoutMirror : false);
for (int i = 0; i < childItems.count(); ++i) {
- if (QSGItem *child = qobject_cast<QSGItem *>(childItems.at(i))) {
- QSGItemPrivate *childPrivate = QSGItemPrivate::get(child);
+ if (QQuickItem *child = qobject_cast<QQuickItem *>(childItems.at(i))) {
+ QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(child);
childPrivate->setImplicitLayoutMirror(inheritedLayoutMirror, inheritMirrorFromParent);
}
}
}
-void QSGItemPrivate::setLayoutMirror(bool mirror)
+void QQuickItemPrivate::setLayoutMirror(bool mirror)
{
if (mirror != effectiveLayoutMirror) {
effectiveLayoutMirror = mirror;
if (_anchors) {
- QSGAnchorsPrivate *anchor_d = QSGAnchorsPrivate::get(_anchors);
+ QQuickAnchorsPrivate *anchor_d = QQuickAnchorsPrivate::get(_anchors);
anchor_d->fillChanged();
anchor_d->centerInChanged();
anchor_d->updateHorizontalAnchors();
}
/*!
- \class QSGItem
- \brief The QSGItem class provides the most basic of all visual items in QML.
+ \class QQuickItem
+ \brief The QQuickItem class provides the most basic of all visual items in QML.
- All visual items in Qt Declarative inherit from QSGItem. Although QSGItem
+ All visual items in Qt Declarative inherit from QQuickItem. Although QQuickItem
has no visual appearance, it defines all the properties that are
common across visual items - such as the x and y position, the
width and height, \l {anchor-layout}{anchoring} and key handling.
- You can subclass QSGItem to provide your own custom visual item that inherits
- these features. Note that, because it does not draw anything, QSGItem sets the
- QGraphicsItem::ItemHasNoContents flag. If you subclass QSGItem to create a visual
+ You can subclass QQuickItem to provide your own custom visual item that inherits
+ these features. Note that, because it does not draw anything, QQuickItem sets the
+ QGraphicsItem::ItemHasNoContents flag. If you subclass QQuickItem to create a visual
item, you will need to unset this flag.
*/
/*!
- \qmlclass Item QSGItem
+ \qmlclass Item QQuickItem
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The Item is the most basic of all visual items in QML.
*/
/*!
- \fn void QSGItem::childrenRectChanged(const QRectF &)
+ \fn void QQuickItem::childrenRectChanged(const QRectF &)
\internal
*/
/*!
- \fn void QSGItem::baselineOffsetChanged(qreal)
+ \fn void QQuickItem::baselineOffsetChanged(qreal)
\internal
*/
/*!
- \fn void QSGItem::stateChanged(const QString &state)
+ \fn void QQuickItem::stateChanged(const QString &state)
\internal
*/
/*!
- \fn void QSGItem::parentChanged(QSGItem *)
+ \fn void QQuickItem::parentChanged(QQuickItem *)
\internal
*/
/*!
- \fn void QSGItem::smoothChanged(bool)
+ \fn void QQuickItem::smoothChanged(bool)
\internal
*/
/*!
- \fn void QSGItem::clipChanged(bool)
+ \fn void QQuickItem::clipChanged(bool)
\internal
*/
-/*! \fn void QSGItem::transformOriginChanged(TransformOrigin)
+/*! \fn void QQuickItem::transformOriginChanged(TransformOrigin)
\internal
*/
/*!
- \fn void QSGItem::focusChanged(bool)
+ \fn void QQuickItem::focusChanged(bool)
\internal
*/
/*!
- \fn void QSGItem::activeFocusChanged(bool)
+ \fn void QQuickItem::activeFocusChanged(bool)
\internal
*/
/*!
- \fn QSGItem::QSGItem(QSGItem *parent)
+ \fn QQuickItem::QQuickItem(QQuickItem *parent)
- Constructs a QSGItem with the given \a parent.
+ Constructs a QQuickItem with the given \a parent.
*/
-QSGItem::QSGItem(QSGItem* parent)
-: QObject(*(new QSGItemPrivate), parent)
+QQuickItem::QQuickItem(QQuickItem* parent)
+: QObject(*(new QQuickItemPrivate), parent)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->init(parent);
}
/*! \internal
*/
-QSGItem::QSGItem(QSGItemPrivate &dd, QSGItem *parent)
+QQuickItem::QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent)
: QObject(dd, parent)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->init(parent);
}
#endif
/*!
- Destroys the QSGItem.
+ Destroys the QQuickItem.
*/
-QSGItem::~QSGItem()
+QQuickItem::~QQuickItem()
{
#ifndef QT_NO_DEBUG
--qt_item_count;
qDebug("Item destroyed after qt_print_item_count() was called.");
#endif
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->parentItem)
setParentItem(0);
else if (d->canvas && d->itemNodeInstance)
- QSGCanvasPrivate::get(d->canvas)->cleanup(d->itemNodeInstance); // cleanup root
+ QQuickCanvasPrivate::get(d->canvas)->cleanup(d->itemNodeInstance); // cleanup root
// XXX todo - optimize
while (!d->childItems.isEmpty())
d->childItems.first()->setParentItem(0);
for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
- QSGAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
+ QQuickAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
if (anchor)
anchor->clearItem(this);
}
// XXX todo - the original checks if the parent is being destroyed
for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
- QSGAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
+ QQuickAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
if (anchor && anchor->item && anchor->item->parent() != this) //child will be deleted anyway
anchor->updateOnComplete();
}
for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Destroyed)
+ const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Destroyed)
change.listener->itemDestroyed(this);
}
d->changeListeners.clear();
*/
/*!
- \property QSGItem::parent
+ \property QQuickItem::parent
This property holds the parent of the item.
*/
-void QSGItem::setParentItem(QSGItem *parentItem)
+void QQuickItem::setParentItem(QQuickItem *parentItem)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (parentItem == d->parentItem)
return;
d->removeFromDirtyList();
- QSGItem *oldParentItem = d->parentItem;
- QSGItem *scopeFocusedItem = 0;
+ QQuickItem *oldParentItem = d->parentItem;
+ QQuickItem *scopeFocusedItem = 0;
if (oldParentItem) {
- QSGItemPrivate *op = QSGItemPrivate::get(oldParentItem);
+ QQuickItemPrivate *op = QQuickItemPrivate::get(oldParentItem);
- QSGItem *scopeItem = 0;
+ QQuickItem *scopeItem = 0;
if (d->canvas && hasFocus()) {
scopeItem = oldParentItem;
}
if (scopeFocusedItem)
- QSGCanvasPrivate::get(d->canvas)->clearFocusInScope(scopeItem, scopeFocusedItem,
- QSGCanvasPrivate::DontChangeFocusProperty);
+ QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scopeItem, scopeFocusedItem,
+ QQuickCanvasPrivate::DontChangeFocusProperty);
op->removeChild(this);
}
d->parentItem = parentItem;
- QSGCanvas *parentCanvas = parentItem?QSGItemPrivate::get(parentItem)->canvas:0;
+ QQuickCanvas *parentCanvas = parentItem?QQuickItemPrivate::get(parentItem)->canvas:0;
if (d->canvas != parentCanvas) {
- QSGItemPrivate::InitializationState initState;
+ QQuickItemPrivate::InitializationState initState;
initState.clear();
d->initCanvas(&initState, parentCanvas);
}
- d->dirty(QSGItemPrivate::ParentChanged);
+ d->dirty(QQuickItemPrivate::ParentChanged);
if (d->parentItem)
- QSGItemPrivate::get(d->parentItem)->addChild(this);
+ QQuickItemPrivate::get(d->parentItem)->addChild(this);
d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
d->setEffectiveEnableRecur(d->calcEffectiveEnable());
if (scopeFocusedItem && d->parentItem && d->canvas) {
// We need to test whether this item becomes scope focused
- QSGItem *scopeItem = 0;
+ QQuickItem *scopeItem = 0;
scopeItem = d->parentItem;
while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
if (scopeItem->scopedFocusItem()) {
- QSGItemPrivate::get(scopeFocusedItem)->focus = false;
+ QQuickItemPrivate::get(scopeFocusedItem)->focus = false;
emit scopeFocusedItem->focusChanged(false);
} else {
- QSGCanvasPrivate::get(d->canvas)->setFocusInScope(scopeItem, scopeFocusedItem,
- QSGCanvasPrivate::DontChangeFocusProperty);
+ QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scopeItem, scopeFocusedItem,
+ QQuickCanvasPrivate::DontChangeFocusProperty);
}
}
emit parentChanged(d->parentItem);
}
-void QSGItem::stackBefore(const QSGItem *sibling)
+void QQuickItem::stackBefore(const QQuickItem *sibling)
{
- Q_D(QSGItem);
- if (!sibling || sibling == this || !d->parentItem || d->parentItem != QSGItemPrivate::get(sibling)->parentItem) {
- qWarning("QSGItem::stackBefore: Cannot stack before %p, which must be a sibling", sibling);
+ Q_D(QQuickItem);
+ if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
+ qWarning("QQuickItem::stackBefore: Cannot stack before %p, which must be a sibling", sibling);
return;
}
- QSGItemPrivate *parentPrivate = QSGItemPrivate::get(d->parentItem);
+ QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
int myIndex = parentPrivate->childItems.indexOf(this);
- int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QSGItem *>(sibling));
+ int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
Q_ASSERT(myIndex != -1 && siblingIndex != -1);
parentPrivate->childItems.insert(siblingIndex, this);
- parentPrivate->dirty(QSGItemPrivate::ChildrenStackingChanged);
+ parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
for (int ii = qMin(siblingIndex, myIndex); ii < parentPrivate->childItems.count(); ++ii)
- QSGItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
+ QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
}
-void QSGItem::stackAfter(const QSGItem *sibling)
+void QQuickItem::stackAfter(const QQuickItem *sibling)
{
- Q_D(QSGItem);
- if (!sibling || sibling == this || !d->parentItem || d->parentItem != QSGItemPrivate::get(sibling)->parentItem) {
- qWarning("QSGItem::stackAfter: Cannot stack after %p, which must be a sibling", sibling);
+ Q_D(QQuickItem);
+ if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
+ qWarning("QQuickItem::stackAfter: Cannot stack after %p, which must be a sibling", sibling);
return;
}
- QSGItemPrivate *parentPrivate = QSGItemPrivate::get(d->parentItem);
+ QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
int myIndex = parentPrivate->childItems.indexOf(this);
- int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QSGItem *>(sibling));
+ int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
Q_ASSERT(myIndex != -1 && siblingIndex != -1);
parentPrivate->childItems.insert(siblingIndex + 1, this);
- parentPrivate->dirty(QSGItemPrivate::ChildrenStackingChanged);
+ parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
for (int ii = qMin(myIndex, siblingIndex + 1); ii < parentPrivate->childItems.count(); ++ii)
- QSGItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
+ QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
}
/*!
- Returns the QSGItem parent of this item.
+ Returns the QQuickItem parent of this item.
*/
-QSGItem *QSGItem::parentItem() const
+QQuickItem *QQuickItem::parentItem() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->parentItem;
}
-QSGEngine *QSGItem::sceneGraphEngine() const
+QSGEngine *QQuickItem::sceneGraphEngine() const
{
return canvas()->sceneGraphEngine();
}
-QSGCanvas *QSGItem::canvas() const
+QQuickCanvas *QQuickItem::canvas() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->canvas;
}
-static bool itemZOrder_sort(QSGItem *lhs, QSGItem *rhs)
+static bool itemZOrder_sort(QQuickItem *lhs, QQuickItem *rhs)
{
return lhs->z() < rhs->z();
}
-QList<QSGItem *> QSGItemPrivate::paintOrderChildItems() const
+QList<QQuickItem *> QQuickItemPrivate::paintOrderChildItems() const
{
// XXX todo - optimize, don't sort and return items that are
// ignored anyway, like invisible or disabled items.
- QList<QSGItem *> items = childItems;
+ QList<QQuickItem *> items = childItems;
qStableSort(items.begin(), items.end(), itemZOrder_sort);
return items;
}
-void QSGItemPrivate::addChild(QSGItem *child)
+void QQuickItemPrivate::addChild(QQuickItem *child)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
Q_ASSERT(!childItems.contains(child));
childItems.append(child);
- dirty(QSGItemPrivate::ChildrenChanged);
+ dirty(QQuickItemPrivate::ChildrenChanged);
- itemChange(QSGItem::ItemChildAddedChange, child);
+ itemChange(QQuickItem::ItemChildAddedChange, child);
emit q->childrenChanged();
}
-void QSGItemPrivate::removeChild(QSGItem *child)
+void QQuickItemPrivate::removeChild(QQuickItem *child)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
Q_ASSERT(child);
Q_ASSERT(childItems.contains(child));
childItems.removeOne(child);
Q_ASSERT(!childItems.contains(child));
- dirty(QSGItemPrivate::ChildrenChanged);
+ dirty(QQuickItemPrivate::ChildrenChanged);
- itemChange(QSGItem::ItemChildRemovedChange, child);
+ itemChange(QQuickItem::ItemChildRemovedChange, child);
emit q->childrenChanged();
}
-void QSGItemPrivate::InitializationState::clear()
+void QQuickItemPrivate::InitializationState::clear()
{
focusScope = 0;
}
-void QSGItemPrivate::InitializationState::clear(QSGItem *fs)
+void QQuickItemPrivate::InitializationState::clear(QQuickItem *fs)
{
focusScope = fs;
}
-QSGItem *QSGItemPrivate::InitializationState::getFocusScope(QSGItem *item)
+QQuickItem *QQuickItemPrivate::InitializationState::getFocusScope(QQuickItem *item)
{
if (!focusScope) {
- QSGItem *fs = item->parentItem();
+ QQuickItem *fs = item->parentItem();
while (!fs->isFocusScope())
fs = fs->parentItem();
focusScope = fs;
return focusScope;
}
-void QSGItemPrivate::initCanvas(InitializationState *state, QSGCanvas *c)
+void QQuickItemPrivate::initCanvas(InitializationState *state, QQuickCanvas *c)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
if (canvas) {
removeFromDirtyList();
- QSGCanvasPrivate *c = QSGCanvasPrivate::get(canvas);
+ QQuickCanvasPrivate *c = QQuickCanvasPrivate::get(canvas);
if (polishScheduled)
c->itemsToPolish.remove(q);
if (c->mouseGrabberItem == q)
canvas = c;
if (canvas && polishScheduled)
- QSGCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
+ QQuickCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
itemNodeInstance = 0;
opacityNode = 0;
}
for (int ii = 0; ii < childItems.count(); ++ii) {
- QSGItem *child = childItems.at(ii);
- QSGItemPrivate::get(child)->initCanvas(childState, c);
+ QQuickItem *child = childItems.at(ii);
+ QQuickItemPrivate::get(child)->initCanvas(childState, c);
}
if (c && focus) {
focus = false;
emit q->focusChanged(false);
} else {
- QSGCanvasPrivate::get(canvas)->setFocusInScope(state->getFocusScope(q), q);
+ QQuickCanvasPrivate::get(canvas)->setFocusInScope(state->getFocusScope(q), q);
}
}
dirty(Canvas);
- itemChange(QSGItem::ItemSceneChange, c);
+ itemChange(QQuickItem::ItemSceneChange, c);
}
/*!
Returns a transform that maps points from canvas space into item space.
*/
-QTransform QSGItemPrivate::canvasToItemTransform() const
+QTransform QQuickItemPrivate::canvasToItemTransform() const
{
// XXX todo - optimize
return itemToCanvasTransform().inverted();
/*!
Returns a transform that maps points from item space into canvas space.
*/
-QTransform QSGItemPrivate::itemToCanvasTransform() const
+QTransform QQuickItemPrivate::itemToCanvasTransform() const
{
// XXX todo
- QTransform rv = parentItem?QSGItemPrivate::get(parentItem)->itemToCanvasTransform():QTransform();
+ QTransform rv = parentItem?QQuickItemPrivate::get(parentItem)->itemToCanvasTransform():QTransform();
itemToParentTransform(rv);
return rv;
}
/*!
Motifies \a t with this items local transform relative to its parent.
*/
-void QSGItemPrivate::itemToParentTransform(QTransform &t) const
+void QQuickItemPrivate::itemToParentTransform(QTransform &t) const
{
if (x || y)
t.translate(x, y);
\sa componentComplete()
*/
-bool QSGItem::isComponentComplete() const
+bool QQuickItem::isComponentComplete() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->componentComplete;
}
-QSGItemPrivate::QSGItemPrivate()
-: _anchors(0), _contents(0), baselineOffset(0), _anchorLines(0), _stateGroup(0), origin(QSGItem::Center),
+QQuickItemPrivate::QQuickItemPrivate()
+: _anchors(0), _contents(0), baselineOffset(0), _anchorLines(0), _stateGroup(0), origin(QQuickItem::Center),
flags(0), widthValid(false), heightValid(false), componentComplete(true),
keepMouse(false), hoverEnabled(false), smooth(false), focus(false), activeFocus(false), notifiedFocus(false),
{
}
-void QSGItemPrivate::init(QSGItem *parent)
+void QQuickItemPrivate::init(QQuickItem *parent)
{
#ifndef QT_NO_DEBUG
++qt_item_count;
}
#endif
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
baselineOffset.invalidate();
if (parent) {
q->setParentItem(parent);
- QSGItemPrivate *parentPrivate = QSGItemPrivate::get(parent);
+ QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parent);
setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent);
}
}
-void QSGItemPrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
+void QQuickItemPrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
{
if (!o)
return;
- QSGItem *that = static_cast<QSGItem *>(prop->object);
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
// This test is measurably (albeit only slightly) faster than qobject_cast<>()
const QMetaObject *mo = o->metaObject();
- while (mo && mo != &QSGItem::staticMetaObject) {
+ while (mo && mo != &QQuickItem::staticMetaObject) {
mo = mo->d.superdata;
}
if (mo) {
- QSGItem *item = static_cast<QSGItem *>(o);
+ QQuickItem *item = static_cast<QQuickItem *>(o);
item->setParentItem(that);
} else {
if (o->inherits("QGraphicsItem"))
specify it.
*/
-int QSGItemPrivate::data_count(QDeclarativeListProperty<QObject> *prop)
+int QQuickItemPrivate::data_count(QDeclarativeListProperty<QObject> *prop)
{
Q_UNUSED(prop);
// XXX todo
return 0;
}
-QObject *QSGItemPrivate::data_at(QDeclarativeListProperty<QObject> *prop, int i)
+QObject *QQuickItemPrivate::data_at(QDeclarativeListProperty<QObject> *prop, int i)
{
Q_UNUSED(prop);
Q_UNUSED(i);
return 0;
}
-void QSGItemPrivate::data_clear(QDeclarativeListProperty<QObject> *prop)
+void QQuickItemPrivate::data_clear(QDeclarativeListProperty<QObject> *prop)
{
Q_UNUSED(prop);
// XXX todo
}
-QObject *QSGItemPrivate::resources_at(QDeclarativeListProperty<QObject> *prop, int index)
+QObject *QQuickItemPrivate::resources_at(QDeclarativeListProperty<QObject> *prop, int index)
{
const QObjectList children = prop->object->children();
if (index < children.count())
return 0;
}
-void QSGItemPrivate::resources_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
+void QQuickItemPrivate::resources_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
{
// XXX todo - do we really want this behavior?
o->setParent(prop->object);
}
-int QSGItemPrivate::resources_count(QDeclarativeListProperty<QObject> *prop)
+int QQuickItemPrivate::resources_count(QDeclarativeListProperty<QObject> *prop)
{
return prop->object->children().count();
}
-void QSGItemPrivate::resources_clear(QDeclarativeListProperty<QObject> *prop)
+void QQuickItemPrivate::resources_clear(QDeclarativeListProperty<QObject> *prop)
{
// XXX todo - do we really want this behavior?
const QObjectList children = prop->object->children();
children.at(index)->setParent(0);
}
-QSGItem *QSGItemPrivate::children_at(QDeclarativeListProperty<QSGItem> *prop, int index)
+QQuickItem *QQuickItemPrivate::children_at(QDeclarativeListProperty<QQuickItem> *prop, int index)
{
- QSGItemPrivate *p = QSGItemPrivate::get(static_cast<QSGItem *>(prop->object));
+ QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
if (index >= p->childItems.count() || index < 0)
return 0;
else
return p->childItems.at(index);
}
-void QSGItemPrivate::children_append(QDeclarativeListProperty<QSGItem> *prop, QSGItem *o)
+void QQuickItemPrivate::children_append(QDeclarativeListProperty<QQuickItem> *prop, QQuickItem *o)
{
if (!o)
return;
- QSGItem *that = static_cast<QSGItem *>(prop->object);
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
if (o->parentItem() == that)
o->setParentItem(0);
o->setParentItem(that);
}
-int QSGItemPrivate::children_count(QDeclarativeListProperty<QSGItem> *prop)
+int QQuickItemPrivate::children_count(QDeclarativeListProperty<QQuickItem> *prop)
{
- QSGItemPrivate *p = QSGItemPrivate::get(static_cast<QSGItem *>(prop->object));
+ QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
return p->childItems.count();
}
-void QSGItemPrivate::children_clear(QDeclarativeListProperty<QSGItem> *prop)
+void QQuickItemPrivate::children_clear(QDeclarativeListProperty<QQuickItem> *prop)
{
- QSGItem *that = static_cast<QSGItem *>(prop->object);
- QSGItemPrivate *p = QSGItemPrivate::get(that);
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(that);
while (!p->childItems.isEmpty())
p->childItems.at(0)->setParentItem(0);
}
-int QSGItemPrivate::transform_count(QDeclarativeListProperty<QSGTransform> *prop)
+int QQuickItemPrivate::transform_count(QDeclarativeListProperty<QQuickTransform> *prop)
{
- QSGItem *that = static_cast<QSGItem *>(prop->object);
- return QSGItemPrivate::get(that)->transforms.count();
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
+ return QQuickItemPrivate::get(that)->transforms.count();
}
-void QSGTransform::appendToItem(QSGItem *item)
+void QQuickTransform::appendToItem(QQuickItem *item)
{
- Q_D(QSGTransform);
+ Q_D(QQuickTransform);
if (!item)
return;
- QSGItemPrivate *p = QSGItemPrivate::get(item);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(item);
if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
p->transforms.removeOne(this);
d->items.append(item);
}
- p->dirty(QSGItemPrivate::Transform);
+ p->dirty(QQuickItemPrivate::Transform);
}
-void QSGTransform::prependToItem(QSGItem *item)
+void QQuickTransform::prependToItem(QQuickItem *item)
{
- Q_D(QSGTransform);
+ Q_D(QQuickTransform);
if (!item)
return;
- QSGItemPrivate *p = QSGItemPrivate::get(item);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(item);
if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
p->transforms.removeOne(this);
d->items.append(item);
}
- p->dirty(QSGItemPrivate::Transform);
+ p->dirty(QQuickItemPrivate::Transform);
}
-void QSGItemPrivate::transform_append(QDeclarativeListProperty<QSGTransform> *prop, QSGTransform *transform)
+void QQuickItemPrivate::transform_append(QDeclarativeListProperty<QQuickTransform> *prop, QQuickTransform *transform)
{
if (!transform)
return;
- QSGItem *that = static_cast<QSGItem *>(prop->object);
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
transform->appendToItem(that);
}
-QSGTransform *QSGItemPrivate::transform_at(QDeclarativeListProperty<QSGTransform> *prop, int idx)
+QQuickTransform *QQuickItemPrivate::transform_at(QDeclarativeListProperty<QQuickTransform> *prop, int idx)
{
- QSGItem *that = static_cast<QSGItem *>(prop->object);
- QSGItemPrivate *p = QSGItemPrivate::get(that);
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(that);
if (idx < 0 || idx >= p->transforms.count())
return 0;
return p->transforms.at(idx);
}
-void QSGItemPrivate::transform_clear(QDeclarativeListProperty<QSGTransform> *prop)
+void QQuickItemPrivate::transform_clear(QDeclarativeListProperty<QQuickTransform> *prop)
{
- QSGItem *that = static_cast<QSGItem *>(prop->object);
- QSGItemPrivate *p = QSGItemPrivate::get(that);
+ QQuickItem *that = static_cast<QQuickItem *>(prop->object);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(that);
for (int ii = 0; ii < p->transforms.count(); ++ii) {
- QSGTransform *t = p->transforms.at(ii);
- QSGTransformPrivate *tp = QSGTransformPrivate::get(t);
+ QQuickTransform *t = p->transforms.at(ii);
+ QQuickTransformPrivate *tp = QQuickTransformPrivate::get(t);
tp->items.removeOne(that);
}
p->transforms.clear();
- p->dirty(QSGItemPrivate::Transform);
+ p->dirty(QQuickItemPrivate::Transform);
}
/*!
- \property QSGItem::childrenRect
+ \property QQuickItem::childrenRect
\brief The geometry of an item's children.
This property holds the (collective) position and size of the item's children.
*/
/*!
- \property QSGItem::baselineOffset
+ \property QQuickItem::baselineOffset
\brief The position of the item's baseline in local coordinates.
The baseline of a \l Text item is the imaginary line on which the text
For non-text items, a default baseline offset of 0 is used.
*/
-QSGAnchors *QSGItemPrivate::anchors() const
+QQuickAnchors *QQuickItemPrivate::anchors() const
{
if (!_anchors) {
- Q_Q(const QSGItem);
- _anchors = new QSGAnchors(const_cast<QSGItem *>(q));
+ Q_Q(const QQuickItem);
+ _anchors = new QQuickAnchors(const_cast<QQuickItem *>(q));
if (!componentComplete)
_anchors->classBegin();
}
return _anchors;
}
-QSGItemPrivate::AnchorLines *QSGItemPrivate::anchorLines() const
+QQuickItemPrivate::AnchorLines *QQuickItemPrivate::anchorLines() const
{
- Q_Q(const QSGItem);
+ Q_Q(const QQuickItem);
if (!_anchorLines) _anchorLines =
- new AnchorLines(const_cast<QSGItem *>(q));
+ new AnchorLines(const_cast<QQuickItem *>(q));
return _anchorLines;
}
-void QSGItemPrivate::siblingOrderChanged()
+void QQuickItemPrivate::siblingOrderChanged()
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::SiblingOrder) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::SiblingOrder) {
change.listener->itemSiblingOrderChanged(q);
}
}
}
-QDeclarativeListProperty<QObject> QSGItemPrivate::data()
+QDeclarativeListProperty<QObject> QQuickItemPrivate::data()
{
- return QDeclarativeListProperty<QObject>(q_func(), 0, QSGItemPrivate::data_append,
- QSGItemPrivate::data_count,
- QSGItemPrivate::data_at,
- QSGItemPrivate::data_clear);
+ return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::data_append,
+ QQuickItemPrivate::data_count,
+ QQuickItemPrivate::data_at,
+ QQuickItemPrivate::data_clear);
}
-QRectF QSGItem::childrenRect()
+QRectF QQuickItem::childrenRect()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (!d->_contents) {
- d->_contents = new QSGContents(this);
+ d->_contents = new QQuickContents(this);
if (d->componentComplete)
d->_contents->complete();
}
return d->_contents->rectF();
}
-QList<QSGItem *> QSGItem::childItems() const
+QList<QQuickItem *> QQuickItem::childItems() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->childItems;
}
-bool QSGItem::clip() const
+bool QQuickItem::clip() const
{
return flags() & ItemClipsChildrenToShape;
}
-void QSGItem::setClip(bool c)
+void QQuickItem::setClip(bool c)
{
if (clip() == c)
return;
geometry from \a oldGeometry to \a newGeometry. If the two
geometries are the same, it doesn't do anything.
*/
-void QSGItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->_anchors)
- QSGAnchorsPrivate::get(d->_anchors)->updateMe();
+ QQuickAnchorsPrivate::get(d->_anchors)->updateMe();
for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Geometry)
+ const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Geometry)
change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
}
this item. \a oldNode is the node that was returned the last time the function was called.
The main thread is blocked while this function is executed so it is safe to read
- values from the QSGItem instance and other objects in the main thread.
+ values from the QQuickItem instance and other objects in the main thread.
\warning This is the only function in which it is allowed to make use of scene graph
objects from the main thread. Use of scene graph objects outside this function will
result in race conditions and potential crashes.
*/
-QSGNode *QSGItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
delete oldNode;
return 0;
}
-QSGTransformNode *QSGItemPrivate::createTransformNode()
+QSGTransformNode *QQuickItemPrivate::createTransformNode()
{
return new QSGTransformNode;
}
-void QSGItem::updatePolish()
+void QQuickItem::updatePolish()
{
}
-void QSGItemPrivate::removeItemChangeListener(QSGItemChangeListener *listener, ChangeTypes types)
+void QQuickItemPrivate::removeItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types)
{
ChangeListener change(listener, types);
changeListeners.removeOne(change);
}
-void QSGItem::keyPressEvent(QKeyEvent *event)
+void QQuickItem::keyPressEvent(QKeyEvent *event)
{
event->ignore();
}
-void QSGItem::keyReleaseEvent(QKeyEvent *event)
+void QQuickItem::keyReleaseEvent(QKeyEvent *event)
{
event->ignore();
}
-void QSGItem::inputMethodEvent(QInputMethodEvent *event)
+void QQuickItem::inputMethodEvent(QInputMethodEvent *event)
{
event->ignore();
}
-void QSGItem::focusInEvent(QFocusEvent *)
+void QQuickItem::focusInEvent(QFocusEvent *)
{
}
-void QSGItem::focusOutEvent(QFocusEvent *)
+void QQuickItem::focusOutEvent(QFocusEvent *)
{
}
-void QSGItem::mousePressEvent(QMouseEvent *event)
+void QQuickItem::mousePressEvent(QMouseEvent *event)
{
event->ignore();
}
-void QSGItem::mouseMoveEvent(QMouseEvent *event)
+void QQuickItem::mouseMoveEvent(QMouseEvent *event)
{
event->ignore();
}
-void QSGItem::mouseReleaseEvent(QMouseEvent *event)
+void QQuickItem::mouseReleaseEvent(QMouseEvent *event)
{
event->ignore();
}
-void QSGItem::mouseDoubleClickEvent(QMouseEvent *event)
+void QQuickItem::mouseDoubleClickEvent(QMouseEvent *event)
{
mousePressEvent(event);
}
-void QSGItem::mouseUngrabEvent()
+void QQuickItem::mouseUngrabEvent()
{
// XXX todo
}
-void QSGItem::wheelEvent(QWheelEvent *event)
+void QQuickItem::wheelEvent(QWheelEvent *event)
{
event->ignore();
}
-void QSGItem::touchEvent(QTouchEvent *event)
+void QQuickItem::touchEvent(QTouchEvent *event)
{
event->ignore();
}
-void QSGItem::hoverEnterEvent(QHoverEvent *event)
+void QQuickItem::hoverEnterEvent(QHoverEvent *event)
{
Q_UNUSED(event);
}
-void QSGItem::hoverMoveEvent(QHoverEvent *event)
+void QQuickItem::hoverMoveEvent(QHoverEvent *event)
{
Q_UNUSED(event);
}
-void QSGItem::hoverLeaveEvent(QHoverEvent *event)
+void QQuickItem::hoverLeaveEvent(QHoverEvent *event)
{
Q_UNUSED(event);
}
-void QSGItem::dragEnterEvent(QDragEnterEvent *event)
+void QQuickItem::dragEnterEvent(QDragEnterEvent *event)
{
Q_UNUSED(event);
}
-void QSGItem::dragMoveEvent(QDragMoveEvent *event)
+void QQuickItem::dragMoveEvent(QDragMoveEvent *event)
{
Q_UNUSED(event);
}
-void QSGItem::dragLeaveEvent(QDragLeaveEvent *event)
+void QQuickItem::dragLeaveEvent(QDragLeaveEvent *event)
{
Q_UNUSED(event);
}
-void QSGItem::dropEvent(QDropEvent *event)
+void QQuickItem::dropEvent(QDropEvent *event)
{
Q_UNUSED(event);
}
-bool QSGItem::childMouseEventFilter(QSGItem *, QEvent *)
+bool QQuickItem::childMouseEventFilter(QQuickItem *, QEvent *)
{
return false;
}
-void QSGItem::windowDeactivateEvent()
+void QQuickItem::windowDeactivateEvent()
{
- foreach (QSGItem* item, childItems()) {
+ foreach (QQuickItem* item, childItems()) {
item->windowDeactivateEvent();
}
}
-Qt::InputMethodHints QSGItem::inputMethodHints() const
+Qt::InputMethodHints QQuickItem::inputMethodHints() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->imHints;
}
-void QSGItem::setInputMethodHints(Qt::InputMethodHints hints)
+void QQuickItem::setInputMethodHints(Qt::InputMethodHints hints)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->imHints = hints;
if (!d->canvas || d->canvas->activeFocusItem() != this)
qApp->inputPanel()->update(Qt::ImHints);
}
-void QSGItem::updateMicroFocus()
+void QQuickItem::updateMicroFocus()
{
QInputPanel *p = qApp->inputPanel();
if (p->inputItem() == this)
qApp->inputPanel()->update(Qt::ImQueryInput);
}
-QVariant QSGItem::inputMethodQuery(Qt::InputMethodQuery query) const
+QVariant QQuickItem::inputMethodQuery(Qt::InputMethodQuery query) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
QVariant v;
switch (query) {
return v;
}
-QSGAnchorLine QSGItemPrivate::left() const
+QQuickAnchorLine QQuickItemPrivate::left() const
{
return anchorLines()->left;
}
-QSGAnchorLine QSGItemPrivate::right() const
+QQuickAnchorLine QQuickItemPrivate::right() const
{
return anchorLines()->right;
}
-QSGAnchorLine QSGItemPrivate::horizontalCenter() const
+QQuickAnchorLine QQuickItemPrivate::horizontalCenter() const
{
return anchorLines()->hCenter;
}
-QSGAnchorLine QSGItemPrivate::top() const
+QQuickAnchorLine QQuickItemPrivate::top() const
{
return anchorLines()->top;
}
-QSGAnchorLine QSGItemPrivate::bottom() const
+QQuickAnchorLine QQuickItemPrivate::bottom() const
{
return anchorLines()->bottom;
}
-QSGAnchorLine QSGItemPrivate::verticalCenter() const
+QQuickAnchorLine QQuickItemPrivate::verticalCenter() const
{
return anchorLines()->vCenter;
}
-QSGAnchorLine QSGItemPrivate::baseline() const
+QQuickAnchorLine QQuickItemPrivate::baseline() const
{
return anchorLines()->baseline;
}
-qreal QSGItem::baselineOffset() const
+qreal QQuickItem::baselineOffset() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
if (!d->baselineOffset.isValid()) {
return 0.0;
} else
return d->baselineOffset;
}
-void QSGItem::setBaselineOffset(qreal offset)
+void QQuickItem::setBaselineOffset(qreal offset)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (offset == d->baselineOffset)
return;
d->baselineOffset = offset;
for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Geometry) {
- QSGAnchorsPrivate *anchor = change.listener->anchorPrivate();
+ const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Geometry) {
+ QQuickAnchorsPrivate *anchor = change.listener->anchorPrivate();
if (anchor)
anchor->updateVerticalAnchors();
}
emit baselineOffsetChanged(offset);
}
-void QSGItem::update()
+void QQuickItem::update()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
Q_ASSERT(flags() & ItemHasContents);
- d->dirty(QSGItemPrivate::Content);
+ d->dirty(QQuickItemPrivate::Content);
}
-void QSGItem::polish()
+void QQuickItem::polish()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (!d->polishScheduled) {
d->polishScheduled = true;
if (d->canvas) {
- QSGCanvasPrivate *p = QSGCanvasPrivate::get(d->canvas);
+ QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(d->canvas);
bool maybeupdate = p->itemsToPolish.isEmpty();
p->itemsToPolish.insert(this);
if (maybeupdate) d->canvas->maybeUpdate();
}
}
-void QSGItem::mapFromItem(QDeclarativeV8Function *args) const
+void QQuickItem::mapFromItem(QDeclarativeV8Function *args) const
{
if (args->Length() != 0) {
v8::Local<v8::Value> item = (*args)[0];
QV8Engine *engine = args->engine();
- QSGItem *itemObj = 0;
+ QQuickItem *itemObj = 0;
if (!item->IsNull())
- itemObj = qobject_cast<QSGItem*>(engine->toQObject(item));
+ itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
if (!itemObj && !item->IsNull()) {
qmlInfo(this) << "mapFromItem() given argument \"" << engine->toString(item->ToString())
}
}
-QTransform QSGItem::itemTransform(QSGItem *other, bool *ok) const
+QTransform QQuickItem::itemTransform(QQuickItem *other, bool *ok) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
// XXX todo - we need to be able to handle common parents better and detect
// invalid cases
if (ok) *ok = true;
QTransform t = d->itemToCanvasTransform();
- if (other) t *= QSGItemPrivate::get(other)->canvasToItemTransform();
+ if (other) t *= QQuickItemPrivate::get(other)->canvasToItemTransform();
return t;
}
-void QSGItem::mapToItem(QDeclarativeV8Function *args) const
+void QQuickItem::mapToItem(QDeclarativeV8Function *args) const
{
if (args->Length() != 0) {
v8::Local<v8::Value> item = (*args)[0];
QV8Engine *engine = args->engine();
- QSGItem *itemObj = 0;
+ QQuickItem *itemObj = 0;
if (!item->IsNull())
- itemObj = qobject_cast<QSGItem*>(engine->toQObject(item));
+ itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
if (!itemObj && !item->IsNull()) {
qmlInfo(this) << "mapToItem() given argument \"" << engine->toString(item->ToString())
}
}
-void QSGItem::forceActiveFocus()
+void QQuickItem::forceActiveFocus()
{
setFocus(true);
- QSGItem *parent = parentItem();
+ QQuickItem *parent = parentItem();
while (parent) {
- if (parent->flags() & QSGItem::ItemIsFocusScope) {
+ if (parent->flags() & QQuickItem::ItemIsFocusScope) {
parent->setFocus(true);
}
parent = parent->parentItem();
}
}
-QSGItem *QSGItem::childAt(qreal x, qreal y) const
+QQuickItem *QQuickItem::childAt(qreal x, qreal y) const
{
// XXX todo - should this include transform etc.?
- const QList<QSGItem *> children = childItems();
+ const QList<QQuickItem *> children = childItems();
for (int i = children.count()-1; i >= 0; --i) {
- QSGItem *child = children.at(i);
+ QQuickItem *child = children.at(i);
if (child->isVisible() && child->x() <= x
&& child->x() + child->width() >= x
&& child->y() <= y
return 0;
}
-QDeclarativeListProperty<QObject> QSGItemPrivate::resources()
+QDeclarativeListProperty<QObject> QQuickItemPrivate::resources()
{
- return QDeclarativeListProperty<QObject>(q_func(), 0, QSGItemPrivate::resources_append,
- QSGItemPrivate::resources_count,
- QSGItemPrivate::resources_at,
- QSGItemPrivate::resources_clear);
+ return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::resources_append,
+ QQuickItemPrivate::resources_count,
+ QQuickItemPrivate::resources_at,
+ QQuickItemPrivate::resources_clear);
}
-QDeclarativeListProperty<QSGItem> QSGItemPrivate::children()
+QDeclarativeListProperty<QQuickItem> QQuickItemPrivate::children()
{
- return QDeclarativeListProperty<QSGItem>(q_func(), 0, QSGItemPrivate::children_append,
- QSGItemPrivate::children_count,
- QSGItemPrivate::children_at,
- QSGItemPrivate::children_clear);
+ return QDeclarativeListProperty<QQuickItem>(q_func(), 0, QQuickItemPrivate::children_append,
+ QQuickItemPrivate::children_count,
+ QQuickItemPrivate::children_at,
+ QQuickItemPrivate::children_clear);
}
-QDeclarativeListProperty<QDeclarativeState> QSGItemPrivate::states()
+QDeclarativeListProperty<QDeclarativeState> QQuickItemPrivate::states()
{
return _states()->statesProperty();
}
-QDeclarativeListProperty<QDeclarativeTransition> QSGItemPrivate::transitions()
+QDeclarativeListProperty<QDeclarativeTransition> QQuickItemPrivate::transitions()
{
return _states()->transitionsProperty();
}
-QString QSGItemPrivate::state() const
+QString QQuickItemPrivate::state() const
{
if (!_stateGroup)
return QString();
return _stateGroup->state();
}
-void QSGItemPrivate::setState(const QString &state)
+void QQuickItemPrivate::setState(const QString &state)
{
_states()->setState(state);
}
-QString QSGItem::state() const
+QString QQuickItem::state() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->state();
}
-void QSGItem::setState(const QString &state)
+void QQuickItem::setState(const QString &state)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->setState(state);
}
-QDeclarativeListProperty<QSGTransform> QSGItem::transform()
+QDeclarativeListProperty<QQuickTransform> QQuickItem::transform()
{
- Q_D(QSGItem);
- return QDeclarativeListProperty<QSGTransform>(this, 0, d->transform_append, d->transform_count,
+ Q_D(QQuickItem);
+ return QDeclarativeListProperty<QQuickTransform>(this, 0, d->transform_append, d->transform_count,
d->transform_at, d->transform_clear);
}
-void QSGItem::classBegin()
+void QQuickItem::classBegin()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->componentComplete = false;
if (d->_stateGroup)
d->_stateGroup->classBegin();
d->_anchors->classBegin();
}
-void QSGItem::componentComplete()
+void QQuickItem::componentComplete()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->componentComplete = true;
if (d->_stateGroup)
d->_stateGroup->componentComplete();
if (d->_anchors) {
d->_anchors->componentComplete();
- QSGAnchorsPrivate::get(d->_anchors)->updateOnComplete();
+ QQuickAnchorsPrivate::get(d->_anchors)->updateOnComplete();
}
if (d->keyHandler)
d->keyHandler->componentComplete();
d->_contents->complete();
}
-QDeclarativeStateGroup *QSGItemPrivate::_states()
+QDeclarativeStateGroup *QQuickItemPrivate::_states()
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
if (!_stateGroup) {
_stateGroup = new QDeclarativeStateGroup;
if (!componentComplete)
return _stateGroup;
}
-QSGItemPrivate::AnchorLines::AnchorLines(QSGItem *q)
+QQuickItemPrivate::AnchorLines::AnchorLines(QQuickItem *q)
{
left.item = q;
- left.anchorLine = QSGAnchorLine::Left;
+ left.anchorLine = QQuickAnchorLine::Left;
right.item = q;
- right.anchorLine = QSGAnchorLine::Right;
+ right.anchorLine = QQuickAnchorLine::Right;
hCenter.item = q;
- hCenter.anchorLine = QSGAnchorLine::HCenter;
+ hCenter.anchorLine = QQuickAnchorLine::HCenter;
top.item = q;
- top.anchorLine = QSGAnchorLine::Top;
+ top.anchorLine = QQuickAnchorLine::Top;
bottom.item = q;
- bottom.anchorLine = QSGAnchorLine::Bottom;
+ bottom.anchorLine = QQuickAnchorLine::Bottom;
vCenter.item = q;
- vCenter.anchorLine = QSGAnchorLine::VCenter;
+ vCenter.anchorLine = QQuickAnchorLine::VCenter;
baseline.item = q;
- baseline.anchorLine = QSGAnchorLine::Baseline;
+ baseline.anchorLine = QQuickAnchorLine::Baseline;
}
-QPointF QSGItemPrivate::computeTransformOrigin() const
+QPointF QQuickItemPrivate::computeTransformOrigin() const
{
switch (origin) {
default:
- case QSGItem::TopLeft:
+ case QQuickItem::TopLeft:
return QPointF(0, 0);
- case QSGItem::Top:
+ case QQuickItem::Top:
return QPointF(width / 2., 0);
- case QSGItem::TopRight:
+ case QQuickItem::TopRight:
return QPointF(width, 0);
- case QSGItem::Left:
+ case QQuickItem::Left:
return QPointF(0, height / 2.);
- case QSGItem::Center:
+ case QQuickItem::Center:
return QPointF(width / 2., height / 2.);
- case QSGItem::Right:
+ case QQuickItem::Right:
return QPointF(width, height / 2.);
- case QSGItem::BottomLeft:
+ case QQuickItem::BottomLeft:
return QPointF(0, height);
- case QSGItem::Bottom:
+ case QQuickItem::Bottom:
return QPointF(width / 2., height);
- case QSGItem::BottomRight:
+ case QQuickItem::BottomRight:
return QPointF(width, height);
}
}
-void QSGItemPrivate::transformChanged()
+void QQuickItemPrivate::transformChanged()
{
}
-void QSGItemPrivate::deliverKeyEvent(QKeyEvent *e)
+void QQuickItemPrivate::deliverKeyEvent(QKeyEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
Q_ASSERT(e->isAccepted());
if (keyHandler) {
}
}
-void QSGItemPrivate::deliverInputMethodEvent(QInputMethodEvent *e)
+void QQuickItemPrivate::deliverInputMethodEvent(QInputMethodEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
Q_ASSERT(e->isAccepted());
if (keyHandler) {
}
}
-void QSGItemPrivate::deliverFocusEvent(QFocusEvent *e)
+void QQuickItemPrivate::deliverFocusEvent(QFocusEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
if (e->type() == QEvent::FocusIn) {
q->focusInEvent(e);
}
}
-void QSGItemPrivate::deliverMouseEvent(QMouseEvent *e)
+void QQuickItemPrivate::deliverMouseEvent(QMouseEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
Q_ASSERT(e->isAccepted());
}
}
-void QSGItemPrivate::deliverWheelEvent(QWheelEvent *e)
+void QQuickItemPrivate::deliverWheelEvent(QWheelEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
q->wheelEvent(e);
}
-void QSGItemPrivate::deliverTouchEvent(QTouchEvent *e)
+void QQuickItemPrivate::deliverTouchEvent(QTouchEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
q->touchEvent(e);
}
-void QSGItemPrivate::deliverHoverEvent(QHoverEvent *e)
+void QQuickItemPrivate::deliverHoverEvent(QHoverEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
switch (e->type()) {
default:
Q_ASSERT(!"Unknown event type");
}
}
-void QSGItemPrivate::deliverDragEvent(QEvent *e)
+void QQuickItemPrivate::deliverDragEvent(QEvent *e)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
switch (e->type()) {
default:
Q_ASSERT(!"Unknown event type");
}
}
-void QSGItem::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickItem::itemChange(ItemChange change, const ItemChangeData &value)
{
Q_UNUSED(change);
Q_UNUSED(value);
/*! \internal */
// XXX todo - do we want/need this anymore?
// Note that it's now used for varying clip rect
-QRectF QSGItem::boundingRect() const
+QRectF QQuickItem::boundingRect() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return QRectF(0, 0, d->width, d->height);
}
-QSGItem::TransformOrigin QSGItem::transformOrigin() const
+QQuickItem::TransformOrigin QQuickItem::transformOrigin() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->origin;
}
-void QSGItem::setTransformOrigin(TransformOrigin origin)
+void QQuickItem::setTransformOrigin(TransformOrigin origin)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (origin == d->origin)
return;
d->origin = origin;
- d->dirty(QSGItemPrivate::TransformOrigin);
+ d->dirty(QQuickItemPrivate::TransformOrigin);
emit transformOriginChanged(d->origin);
}
-QPointF QSGItem::transformOriginPoint() const
+QPointF QQuickItem::transformOriginPoint() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
if (!d->transformOriginPoint.isNull())
return d->transformOriginPoint;
return d->computeTransformOrigin();
}
-void QSGItem::setTransformOriginPoint(const QPointF &point)
+void QQuickItem::setTransformOriginPoint(const QPointF &point)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->transformOriginPoint == point)
return;
d->transformOriginPoint = point;
- d->dirty(QSGItemPrivate::TransformOrigin);
+ d->dirty(QQuickItemPrivate::TransformOrigin);
}
-qreal QSGItem::z() const
+qreal QQuickItem::z() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->z;
}
-void QSGItem::setZ(qreal v)
+void QQuickItem::setZ(qreal v)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->z == v)
return;
d->z = v;
- d->dirty(QSGItemPrivate::ZValue);
+ d->dirty(QQuickItemPrivate::ZValue);
if (d->parentItem)
- QSGItemPrivate::get(d->parentItem)->dirty(QSGItemPrivate::ChildrenStackingChanged);
+ QQuickItemPrivate::get(d->parentItem)->dirty(QQuickItemPrivate::ChildrenStackingChanged);
emit zChanged();
}
\sa setKeepMouseGrab()
*/
-qreal QSGItem::rotation() const
+qreal QQuickItem::rotation() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->rotation;
}
-void QSGItem::setRotation(qreal r)
+void QQuickItem::setRotation(qreal r)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->rotation == r)
return;
d->rotation = r;
- d->dirty(QSGItemPrivate::BasicTransform);
+ d->dirty(QQuickItemPrivate::BasicTransform);
d->itemChange(ItemRotationHasChanged, r);
emit rotationChanged();
}
-qreal QSGItem::scale() const
+qreal QQuickItem::scale() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->scale;
}
-void QSGItem::setScale(qreal s)
+void QQuickItem::setScale(qreal s)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->scale == s)
return;
d->scale = s;
- d->dirty(QSGItemPrivate::BasicTransform);
+ d->dirty(QQuickItemPrivate::BasicTransform);
emit scaleChanged();
}
-qreal QSGItem::opacity() const
+qreal QQuickItem::opacity() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->opacity;
}
-void QSGItem::setOpacity(qreal o)
+void QQuickItem::setOpacity(qreal o)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->opacity == o)
return;
d->opacity = o;
- d->dirty(QSGItemPrivate::OpacityValue);
+ d->dirty(QQuickItemPrivate::OpacityValue);
d->itemChange(ItemOpacityHasChanged, o);
emit opacityChanged();
}
-bool QSGItem::isVisible() const
+bool QQuickItem::isVisible() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->effectiveVisible;
}
-void QSGItem::setVisible(bool v)
+void QQuickItem::setVisible(bool v)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (v == d->explicitVisible)
return;
d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
}
-bool QSGItem::isEnabled() const
+bool QQuickItem::isEnabled() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->effectiveEnable;
}
-void QSGItem::setEnabled(bool e)
+void QQuickItem::setEnabled(bool e)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (e == d->explicitEnable)
return;
d->setEffectiveEnableRecur(d->calcEffectiveEnable());
}
-bool QSGItemPrivate::calcEffectiveVisible() const
+bool QQuickItemPrivate::calcEffectiveVisible() const
{
// XXX todo - Should the effective visible of an element with no parent just be the current
// effective visible? This would prevent pointless re-processing in the case of an element
// moving to/from a no-parent situation, but it is different from what graphics view does.
- return explicitVisible && (!parentItem || QSGItemPrivate::get(parentItem)->effectiveVisible);
+ return explicitVisible && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveVisible);
}
-void QSGItemPrivate::setEffectiveVisibleRecur(bool newEffectiveVisible)
+void QQuickItemPrivate::setEffectiveVisibleRecur(bool newEffectiveVisible)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
if (newEffectiveVisible && !explicitVisible) {
// This item locally overrides visibility
effectiveVisible = newEffectiveVisible;
dirty(Visible);
- if (parentItem) QSGItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
+ if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
if (canvas) {
- QSGCanvasPrivate *canvasPriv = QSGCanvasPrivate::get(canvas);
+ QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
if (canvasPriv->mouseGrabberItem == q)
q->ungrabMouse();
}
for (int ii = 0; ii < childItems.count(); ++ii)
- QSGItemPrivate::get(childItems.at(ii))->setEffectiveVisibleRecur(newEffectiveVisible);
+ QQuickItemPrivate::get(childItems.at(ii))->setEffectiveVisibleRecur(newEffectiveVisible);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Visibility)
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Visibility)
change.listener->itemVisibilityChanged(q);
}
emit q->visibleChanged();
}
-bool QSGItemPrivate::calcEffectiveEnable() const
+bool QQuickItemPrivate::calcEffectiveEnable() const
{
// XXX todo - Should the effective enable of an element with no parent just be the current
// effective enable? This would prevent pointless re-processing in the case of an element
// moving to/from a no-parent situation, but it is different from what graphics view does.
- return explicitEnable && (!parentItem || QSGItemPrivate::get(parentItem)->effectiveEnable);
+ return explicitEnable && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveEnable);
}
-void QSGItemPrivate::setEffectiveEnableRecur(bool newEffectiveEnable)
+void QQuickItemPrivate::setEffectiveEnableRecur(bool newEffectiveEnable)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
// XXX todo - need to fixup focus
effectiveEnable = newEffectiveEnable;
if (canvas) {
- QSGCanvasPrivate *canvasPriv = QSGCanvasPrivate::get(canvas);
+ QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
if (canvasPriv->mouseGrabberItem == q)
q->ungrabMouse();
}
for (int ii = 0; ii < childItems.count(); ++ii)
- QSGItemPrivate::get(childItems.at(ii))->setEffectiveEnableRecur(newEffectiveEnable);
+ QQuickItemPrivate::get(childItems.at(ii))->setEffectiveEnableRecur(newEffectiveEnable);
emit q->enabledChanged();
}
-QString QSGItemPrivate::dirtyToString() const
+QString QQuickItemPrivate::dirtyToString() const
{
#define DIRTY_TO_STRING(value) if (dirtyAttributes & value) { \
if (!rv.isEmpty()) \
return rv;
}
-void QSGItemPrivate::dirty(DirtyType type)
+void QQuickItemPrivate::dirty(DirtyType type)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
if (type & (TransformOrigin | Transform | BasicTransform | Position | Size))
transformChanged();
dirtyAttributes |= type;
if (canvas) {
addToDirtyList();
- QSGCanvasPrivate::get(canvas)->dirtyItem(q);
+ QQuickCanvasPrivate::get(canvas)->dirtyItem(q);
}
}
}
-void QSGItemPrivate::addToDirtyList()
+void QQuickItemPrivate::addToDirtyList()
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
Q_ASSERT(canvas);
if (!prevDirtyItem) {
Q_ASSERT(!nextDirtyItem);
- QSGCanvasPrivate *p = QSGCanvasPrivate::get(canvas);
+ QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(canvas);
nextDirtyItem = p->dirtyItemList;
- if (nextDirtyItem) QSGItemPrivate::get(nextDirtyItem)->prevDirtyItem = &nextDirtyItem;
+ if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = &nextDirtyItem;
prevDirtyItem = &p->dirtyItemList;
p->dirtyItemList = q;
p->dirtyItem(q);
Q_ASSERT(prevDirtyItem);
}
-void QSGItemPrivate::removeFromDirtyList()
+void QQuickItemPrivate::removeFromDirtyList()
{
if (prevDirtyItem) {
- if (nextDirtyItem) QSGItemPrivate::get(nextDirtyItem)->prevDirtyItem = prevDirtyItem;
+ if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = prevDirtyItem;
*prevDirtyItem = nextDirtyItem;
prevDirtyItem = 0;
nextDirtyItem = 0;
Q_ASSERT(!nextDirtyItem);
}
-void QSGItemPrivate::refFromEffectItem(bool hide)
+void QQuickItemPrivate::refFromEffectItem(bool hide)
{
++effectRefCount;
if (1 == effectRefCount) {
dirty(EffectReference);
- if (parentItem) QSGItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
+ if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
}
if (hide) {
if (++hideRefCount == 1)
}
}
-void QSGItemPrivate::derefFromEffectItem(bool unhide)
+void QQuickItemPrivate::derefFromEffectItem(bool unhide)
{
Q_ASSERT(effectRefCount);
--effectRefCount;
if (0 == effectRefCount) {
dirty(EffectReference);
- if (parentItem) QSGItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
+ if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
}
if (unhide) {
if (--hideRefCount == 0)
}
}
-void QSGItemPrivate::itemChange(QSGItem::ItemChange change, const QSGItem::ItemChangeData &data)
+void QQuickItemPrivate::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data)
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
switch (change) {
- case QSGItem::ItemChildAddedChange:
+ case QQuickItem::ItemChildAddedChange:
q->itemChange(change, data);
if (_contents && componentComplete)
_contents->childAdded(data.item);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Children) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Children) {
change.listener->itemChildAdded(q, data.item);
}
}
break;
- case QSGItem::ItemChildRemovedChange:
+ case QQuickItem::ItemChildRemovedChange:
q->itemChange(change, data);
if (_contents && componentComplete)
_contents->childRemoved(data.item);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Children) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Children) {
change.listener->itemChildRemoved(q, data.item);
}
}
break;
- case QSGItem::ItemSceneChange:
+ case QQuickItem::ItemSceneChange:
q->itemChange(change, data);
break;
- case QSGItem::ItemVisibleHasChanged:
+ case QQuickItem::ItemVisibleHasChanged:
q->itemChange(change, data);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Visibility) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Visibility) {
change.listener->itemVisibilityChanged(q);
}
}
break;
- case QSGItem::ItemParentHasChanged:
+ case QQuickItem::ItemParentHasChanged:
q->itemChange(change, data);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Parent) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Parent) {
change.listener->itemParentChanged(q, data.item);
}
}
break;
- case QSGItem::ItemOpacityHasChanged:
+ case QQuickItem::ItemOpacityHasChanged:
q->itemChange(change, data);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Opacity) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Opacity) {
change.listener->itemOpacityChanged(q);
}
}
break;
- case QSGItem::ItemActiveFocusHasChanged:
+ case QQuickItem::ItemActiveFocusHasChanged:
q->itemChange(change, data);
break;
- case QSGItem::ItemRotationHasChanged:
+ case QQuickItem::ItemRotationHasChanged:
q->itemChange(change, data);
for (int ii = 0; ii < changeListeners.count(); ++ii) {
- const QSGItemPrivate::ChangeListener &change = changeListeners.at(ii);
- if (change.types & QSGItemPrivate::Rotation) {
+ const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
+ if (change.types & QQuickItemPrivate::Rotation) {
change.listener->itemRotationChanged(q);
}
}
}
/*!
- \property QSGItem::smooth
+ \property QQuickItem::smooth
\brief whether the item is smoothly transformed.
This property is provided purely for the purpose of optimization. Turning
\sa setSmooth()
*/
-bool QSGItem::smooth() const
+bool QQuickItem::smooth() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->smooth;
}
\sa smooth()
*/
-void QSGItem::setSmooth(bool smooth)
+void QQuickItem::setSmooth(bool smooth)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->smooth == smooth)
return;
d->smooth = smooth;
- d->dirty(QSGItemPrivate::Smooth);
+ d->dirty(QQuickItemPrivate::Smooth);
emit smoothChanged(smooth);
}
-QSGItem::Flags QSGItem::flags() const
+QQuickItem::Flags QQuickItem::flags() const
{
- Q_D(const QSGItem);
- return (QSGItem::Flags)d->flags;
+ Q_D(const QQuickItem);
+ return (QQuickItem::Flags)d->flags;
}
-void QSGItem::setFlag(Flag flag, bool enabled)
+void QQuickItem::setFlag(Flag flag, bool enabled)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (enabled)
setFlags((Flags)(d->flags | (quint32)flag));
else
setFlags((Flags)(d->flags & ~(quint32)flag));
}
-void QSGItem::setFlags(Flags flags)
+void QQuickItem::setFlags(Flags flags)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if ((flags & ItemIsFocusScope) != (d->flags & ItemIsFocusScope)) {
if (flags & ItemIsFocusScope && !d->childItems.isEmpty() && d->canvas) {
- qWarning("QSGItem: Cannot set FocusScope once item has children and is in a canvas.");
+ qWarning("QQuickItem: Cannot set FocusScope once item has children and is in a canvas.");
flags &= ~ItemIsFocusScope;
} else if (d->flags & ItemIsFocusScope) {
- qWarning("QSGItem: Cannot unset FocusScope flag.");
+ qWarning("QQuickItem: Cannot unset FocusScope flag.");
flags |= ItemIsFocusScope;
}
}
if ((flags & ItemClipsChildrenToShape ) != (d->flags & ItemClipsChildrenToShape))
- d->dirty(QSGItemPrivate::Clip);
+ d->dirty(QQuickItemPrivate::Clip);
d->flags = flags;
}
-qreal QSGItem::x() const
+qreal QQuickItem::x() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->x;
}
-qreal QSGItem::y() const
+qreal QQuickItem::y() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->y;
}
-QPointF QSGItem::pos() const
+QPointF QQuickItem::pos() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return QPointF(d->x, d->y);
}
-void QSGItem::setX(qreal v)
+void QQuickItem::setX(qreal v)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->x == v)
return;
qreal oldx = d->x;
d->x = v;
- d->dirty(QSGItemPrivate::Position);
+ d->dirty(QQuickItemPrivate::Position);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(oldx, y(), width(), height()));
}
-void QSGItem::setY(qreal v)
+void QQuickItem::setY(qreal v)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->y == v)
return;
qreal oldy = d->y;
d->y = v;
- d->dirty(QSGItemPrivate::Position);
+ d->dirty(QQuickItemPrivate::Position);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(x(), oldy, width(), height()));
}
-void QSGItem::setPos(const QPointF &pos)
+void QQuickItem::setPos(const QPointF &pos)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (QPointF(d->x, d->y) == pos)
return;
d->x = pos.x();
d->y = pos.y();
- d->dirty(QSGItemPrivate::Position);
+ d->dirty(QQuickItemPrivate::Position);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(oldx, oldy, width(), height()));
}
-qreal QSGItem::width() const
+qreal QQuickItem::width() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->width;
}
-void QSGItem::setWidth(qreal w)
+void QQuickItem::setWidth(qreal w)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (qIsNaN(w))
return;
qreal oldWidth = d->width;
d->width = w;
- d->dirty(QSGItemPrivate::Size);
+ d->dirty(QQuickItemPrivate::Size);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(x(), y(), oldWidth, height()));
}
-void QSGItem::resetWidth()
+void QQuickItem::resetWidth()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->widthValid = false;
setImplicitWidth(implicitWidth());
}
-void QSGItemPrivate::implicitWidthChanged()
+void QQuickItemPrivate::implicitWidthChanged()
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
emit q->implicitWidthChanged();
}
-qreal QSGItemPrivate::getImplicitWidth() const
+qreal QQuickItemPrivate::getImplicitWidth() const
{
return implicitWidth;
}
/*!
Returns the width of the item that is implied by other properties that determine the content.
*/
-qreal QSGItem::implicitWidth() const
+qreal QQuickItem::implicitWidth() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->getImplicitWidth();
}
Sets the implied width of the item to \a w.
This is the width implied by other properties that determine the content.
*/
-void QSGItem::setImplicitWidth(qreal w)
+void QQuickItem::setImplicitWidth(qreal w)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
bool changed = w != d->implicitWidth;
d->implicitWidth = w;
if (d->width == w || widthValid()) {
qreal oldWidth = d->width;
d->width = w;
- d->dirty(QSGItemPrivate::Size);
+ d->dirty(QQuickItemPrivate::Size);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(x(), y(), oldWidth, height()));
/*!
Returns whether the width property has been set explicitly.
*/
-bool QSGItem::widthValid() const
+bool QQuickItem::widthValid() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->widthValid;
}
-qreal QSGItem::height() const
+qreal QQuickItem::height() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->height;
}
-void QSGItem::setHeight(qreal h)
+void QQuickItem::setHeight(qreal h)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (qIsNaN(h))
return;
qreal oldHeight = d->height;
d->height = h;
- d->dirty(QSGItemPrivate::Size);
+ d->dirty(QQuickItemPrivate::Size);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(x(), y(), width(), oldHeight));
}
-void QSGItem::resetHeight()
+void QQuickItem::resetHeight()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->heightValid = false;
setImplicitHeight(implicitHeight());
}
-void QSGItemPrivate::implicitHeightChanged()
+void QQuickItemPrivate::implicitHeightChanged()
{
- Q_Q(QSGItem);
+ Q_Q(QQuickItem);
emit q->implicitHeightChanged();
}
-qreal QSGItemPrivate::getImplicitHeight() const
+qreal QQuickItemPrivate::getImplicitHeight() const
{
return implicitHeight;
}
/*!
Returns the height of the item that is implied by other properties that determine the content.
*/
-qreal QSGItem::implicitHeight() const
+qreal QQuickItem::implicitHeight() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->getImplicitHeight();
}
Sets the implied height of the item to \a h.
This is the height implied by other properties that determine the content.
*/
-void QSGItem::setImplicitHeight(qreal h)
+void QQuickItem::setImplicitHeight(qreal h)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
bool changed = h != d->implicitHeight;
d->implicitHeight = h;
if (d->height == h || heightValid()) {
qreal oldHeight = d->height;
d->height = h;
- d->dirty(QSGItemPrivate::Size);
+ d->dirty(QQuickItemPrivate::Size);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(x(), y(), width(), oldHeight));
/*!
Returns whether the height property has been set explicitly.
*/
-bool QSGItem::heightValid() const
+bool QQuickItem::heightValid() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->heightValid;
}
-void QSGItem::setSize(const QSizeF &size)
+void QQuickItem::setSize(const QSizeF &size)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->heightValid = true;
d->widthValid = true;
d->height = size.height();
d->width = size.width();
- d->dirty(QSGItemPrivate::Size);
+ d->dirty(QQuickItemPrivate::Size);
geometryChanged(QRectF(x(), y(), width(), height()),
QRectF(x(), y(), oldWidth, oldHeight));
}
-bool QSGItem::hasActiveFocus() const
+bool QQuickItem::hasActiveFocus() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->activeFocus;
}
-bool QSGItem::hasFocus() const
+bool QQuickItem::hasFocus() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->focus;
}
-void QSGItem::setFocus(bool focus)
+void QQuickItem::setFocus(bool focus)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (d->focus == focus)
return;
if (d->canvas) {
// Need to find our nearest focus scope
- QSGItem *scope = parentItem();
+ QQuickItem *scope = parentItem();
while (scope && !scope->isFocusScope())
scope = scope->parentItem();
if (focus)
- QSGCanvasPrivate::get(d->canvas)->setFocusInScope(scope, this);
+ QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scope, this);
else
- QSGCanvasPrivate::get(d->canvas)->clearFocusInScope(scope, this);
+ QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scope, this);
} else {
d->focus = focus;
emit focusChanged(focus);
}
}
-bool QSGItem::isFocusScope() const
+bool QQuickItem::isFocusScope() const
{
return flags() & ItemIsFocusScope;
}
-QSGItem *QSGItem::scopedFocusItem() const
+QQuickItem *QQuickItem::scopedFocusItem() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
if (!isFocusScope())
return 0;
else
}
-Qt::MouseButtons QSGItem::acceptedMouseButtons() const
+Qt::MouseButtons QQuickItem::acceptedMouseButtons() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->acceptedMouseButtons;
}
-void QSGItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
+void QQuickItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->acceptedMouseButtons = buttons;
}
-bool QSGItem::filtersChildMouseEvents() const
+bool QQuickItem::filtersChildMouseEvents() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->filtersChildMouseEvents;
}
-void QSGItem::setFiltersChildMouseEvents(bool filter)
+void QQuickItem::setFiltersChildMouseEvents(bool filter)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->filtersChildMouseEvents = filter;
}
-bool QSGItem::isUnderMouse() const
+bool QQuickItem::isUnderMouse() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
if (!d->canvas)
return false;
return false;
}
-bool QSGItem::acceptHoverEvents() const
+bool QQuickItem::acceptHoverEvents() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->hoverEnabled;
}
-void QSGItem::setAcceptHoverEvents(bool enabled)
+void QQuickItem::setAcceptHoverEvents(bool enabled)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->hoverEnabled = enabled;
}
-void QSGItem::grabMouse()
+void QQuickItem::grabMouse()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (!d->canvas)
return;
- QSGCanvasPrivate *canvasPriv = QSGCanvasPrivate::get(d->canvas);
+ QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
if (canvasPriv->mouseGrabberItem == this)
return;
- QSGItem *oldGrabber = canvasPriv->mouseGrabberItem;
+ QQuickItem *oldGrabber = canvasPriv->mouseGrabberItem;
canvasPriv->mouseGrabberItem = this;
if (oldGrabber)
oldGrabber->mouseUngrabEvent();
}
-void QSGItem::ungrabMouse()
+void QQuickItem::ungrabMouse()
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
if (!d->canvas)
return;
- QSGCanvasPrivate *canvasPriv = QSGCanvasPrivate::get(d->canvas);
+ QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
if (canvasPriv->mouseGrabberItem != this) {
- qWarning("QSGItem::ungrabMouse(): Item is not the mouse grabber.");
+ qWarning("QQuickItem::ungrabMouse(): Item is not the mouse grabber.");
return;
}
mouseUngrabEvent();
}
-bool QSGItem::keepMouseGrab() const
+bool QQuickItem::keepMouseGrab() const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->keepMouse;
}
\sa keepMouseGrab()
*/
-void QSGItem::setKeepMouseGrab(bool keep)
+void QQuickItem::setKeepMouseGrab(bool keep)
{
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->keepMouse = keep;
}
If \a item is a \c null value, this maps \a x and \a y to the coordinate
system of the root QML view.
*/
-QPointF QSGItem::mapToItem(const QSGItem *item, const QPointF &point) const
+QPointF QQuickItem::mapToItem(const QQuickItem *item, const QPointF &point) const
{
QPointF p = mapToScene(point);
if (item)
return p;
}
-QPointF QSGItem::mapToScene(const QPointF &point) const
+QPointF QQuickItem::mapToScene(const QPointF &point) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->itemToCanvasTransform().map(point);
}
-QRectF QSGItem::mapRectToItem(const QSGItem *item, const QRectF &rect) const
+QRectF QQuickItem::mapRectToItem(const QQuickItem *item, const QRectF &rect) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
QTransform t = d->itemToCanvasTransform();
if (item)
- t *= QSGItemPrivate::get(item)->canvasToItemTransform();
+ t *= QQuickItemPrivate::get(item)->canvasToItemTransform();
return t.mapRect(rect);
}
-QRectF QSGItem::mapRectToScene(const QRectF &rect) const
+QRectF QQuickItem::mapRectToScene(const QRectF &rect) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->itemToCanvasTransform().mapRect(rect);
}
-QPointF QSGItem::mapFromItem(const QSGItem *item, const QPointF &point) const
+QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const
{
QPointF p = item?item->mapToScene(point):point;
return mapFromScene(p);
}
-QPointF QSGItem::mapFromScene(const QPointF &point) const
+QPointF QQuickItem::mapFromScene(const QPointF &point) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->canvasToItemTransform().map(point);
}
-QRectF QSGItem::mapRectFromItem(const QSGItem *item, const QRectF &rect) const
+QRectF QQuickItem::mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
{
- Q_D(const QSGItem);
- QTransform t = item?QSGItemPrivate::get(item)->itemToCanvasTransform():QTransform();
+ Q_D(const QQuickItem);
+ QTransform t = item?QQuickItemPrivate::get(item)->itemToCanvasTransform():QTransform();
t *= d->canvasToItemTransform();
return t.mapRect(rect);
}
-QRectF QSGItem::mapRectFromScene(const QRectF &rect) const
+QRectF QQuickItem::mapRectFromScene(const QRectF &rect) const
{
- Q_D(const QSGItem);
+ Q_D(const QQuickItem);
return d->canvasToItemTransform().mapRect(rect);
}
*/
/*!
- \property QSGItem::clip
+ \property QQuickItem::clip
This property holds whether clipping is enabled. The default clip value is \c false.
If clipping is enabled, an item will clip its own painting, as well
*/
/*!
- \enum QSGItem::TransformOrigin
+ \enum QQuickItem::TransformOrigin
Controls the point about which simple transforms like scale apply.
/*!
- \property QSGItem::anchors
+ \property QQuickItem::anchors
\internal
*/
/*!
- \property QSGItem::left
+ \property QQuickItem::left
\internal
*/
/*!
- \property QSGItem::right
+ \property QQuickItem::right
\internal
*/
/*!
- \property QSGItem::horizontalCenter
+ \property QQuickItem::horizontalCenter
\internal
*/
/*!
- \property QSGItem::top
+ \property QQuickItem::top
\internal
*/
/*!
- \property QSGItem::bottom
+ \property QQuickItem::bottom
\internal
*/
/*!
- \property QSGItem::verticalCenter
+ \property QQuickItem::verticalCenter
\internal
*/
/*!
- \property QSGItem::focus
+ \property QQuickItem::focus
\internal
*/
/*!
- \property QSGItem::transform
+ \property QQuickItem::transform
\internal
*/
/*!
- \property QSGItem::transformOrigin
+ \property QQuickItem::transformOrigin
\internal
*/
/*!
- \property QSGItem::activeFocus
+ \property QQuickItem::activeFocus
\internal
*/
/*!
- \property QSGItem::baseline
+ \property QQuickItem::baseline
\internal
*/
/*!
- \property QSGItem::data
+ \property QQuickItem::data
\internal
*/
/*!
- \property QSGItem::resources
+ \property QQuickItem::resources
\internal
*/
/*!
- \property QSGItem::state
+ \property QQuickItem::state
\internal
*/
/*!
- \property QSGItem::states
+ \property QQuickItem::states
\internal
*/
/*!
- \property QSGItem::transformOriginPoint
+ \property QQuickItem::transformOriginPoint
\internal
*/
/*!
- \property QSGItem::transitions
+ \property QQuickItem::transitions
\internal
*/
-bool QSGItem::event(QEvent *ev)
+bool QQuickItem::event(QEvent *ev)
{
#if 0
if (ev->type() == QEvent::PolishRequest) {
- Q_D(QSGItem);
+ Q_D(QQuickItem);
d->polishScheduled = false;
updatePolish();
return true;
}
#ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug debug, QSGItem *item)
+QDebug operator<<(QDebug debug, QQuickItem *item)
{
if (!item) {
- debug << "QSGItem(0)";
+ debug << "QQuickItem(0)";
return debug;
}
}
#endif
-qint64 QSGItemPrivate::consistentTime = -1;
-void QSGItemPrivate::setConsistentTime(qint64 t)
+qint64 QQuickItemPrivate::consistentTime = -1;
+void QQuickItemPrivate::setConsistentTime(qint64 t)
{
consistentTime = t;
}
{
public:
void start() {
- t1 = QSGItemPrivate::consistentTime;
+ t1 = QQuickItemPrivate::consistentTime;
t2 = 0;
}
qint64 elapsed() {
- return QSGItemPrivate::consistentTime - t1;
+ return QQuickItemPrivate::consistentTime - t1;
}
qint64 restart() {
- qint64 val = QSGItemPrivate::consistentTime - t1;
- t1 = QSGItemPrivate::consistentTime;
+ qint64 val = QQuickItemPrivate::consistentTime - t1;
+ t1 = QQuickItemPrivate::consistentTime;
t2 = 0;
return val;
}
qint64 t2;
};
-void QSGItemPrivate::start(QElapsedTimer &t)
+void QQuickItemPrivate::start(QElapsedTimer &t)
{
- if (QSGItemPrivate::consistentTime == -1)
+ if (QQuickItemPrivate::consistentTime == -1)
t.start();
else
((QElapsedTimerConsistentTimeHack*)&t)->start();
}
-qint64 QSGItemPrivate::elapsed(QElapsedTimer &t)
+qint64 QQuickItemPrivate::elapsed(QElapsedTimer &t)
{
- if (QSGItemPrivate::consistentTime == -1)
+ if (QQuickItemPrivate::consistentTime == -1)
return t.elapsed();
else
return ((QElapsedTimerConsistentTimeHack*)&t)->elapsed();
}
-qint64 QSGItemPrivate::restart(QElapsedTimer &t)
+qint64 QQuickItemPrivate::restart(QElapsedTimer &t)
{
- if (QSGItemPrivate::consistentTime == -1)
+ if (QQuickItemPrivate::consistentTime == -1)
return t.restart();
else
return ((QElapsedTimerConsistentTimeHack*)&t)->restart();
}
/*!
- \fn bool QSGItem::isTextureProvider() const
+ \fn bool QQuickItem::isTextureProvider() const
Returns true if this item is a texture provider. The default
implementation returns false.
*/
/*!
- \fn QSGTextureProvider *QSGItem::textureProvider() const
+ \fn QSGTextureProvider *QQuickItem::textureProvider() const
Returns the texture provider for an item. The default implementation
returns 0.
QT_END_NAMESPACE
-#include <moc_qsgitem.cpp>
+#include <moc_qquickitem.cpp>
**
****************************************************************************/
-#ifndef QSGITEM_H
-#define QSGITEM_H
+#ifndef QQUICKITEM_H
+#define QQUICKITEM_H
#include <QtDeclarative/qdeclarative.h>
#include <QtDeclarative/qdeclarativecomponent.h>
QT_MODULE(Declarative)
-class QSGItem;
-class QSGTransformPrivate;
-class QSGTransform : public QObject
+class QQuickItem;
+class QQuickTransformPrivate;
+class QQuickTransform : public QObject
{
Q_OBJECT
public:
- QSGTransform(QObject *parent = 0);
- ~QSGTransform();
+ QQuickTransform(QObject *parent = 0);
+ ~QQuickTransform();
- void appendToItem(QSGItem *);
- void prependToItem(QSGItem *);
+ void appendToItem(QQuickItem *);
+ void prependToItem(QQuickItem *);
virtual void applyTo(QMatrix4x4 *matrix) const = 0;
void update();
protected:
- QSGTransform(QSGTransformPrivate &dd, QObject *parent);
+ QQuickTransform(QQuickTransformPrivate &dd, QObject *parent);
private:
- Q_DECLARE_PRIVATE(QSGTransform)
+ Q_DECLARE_PRIVATE(QQuickTransform)
};
class QDeclarativeV8Function;
class QDeclarativeState;
-class QSGAnchorLine;
+class QQuickAnchorLine;
class QDeclarativeTransition;
-class QSGKeyEvent;
-class QSGAnchors;
-class QSGItemPrivate;
-class QSGCanvas;
-class QSGDragEvent;
+class QQuickKeyEvent;
+class QQuickAnchors;
+class QQuickItemPrivate;
+class QQuickCanvas;
class QSGEngine;
class QTouchEvent;
class QSGNode;
class QSGTransformNode;
class QSGTextureProvider;
-class Q_DECLARATIVE_EXPORT QSGItem : public QObject, public QDeclarativeParserStatus
+class Q_DECLARATIVE_EXPORT QQuickItem : public QObject, public QDeclarativeParserStatus
{
Q_OBJECT
Q_INTERFACES(QDeclarativeParserStatus)
- Q_PROPERTY(QSGItem *parent READ parentItem WRITE setParentItem NOTIFY parentChanged DESIGNABLE false FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QDeclarativeListProperty<QObject> data READ data DESIGNABLE false)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QDeclarativeListProperty<QObject> resources READ resources DESIGNABLE false)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QDeclarativeListProperty<QSGItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
+ Q_PROPERTY(QQuickItem *parent READ parentItem WRITE setParentItem NOTIFY parentChanged DESIGNABLE false FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QDeclarativeListProperty<QObject> data READ data DESIGNABLE false)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QDeclarativeListProperty<QObject> resources READ resources DESIGNABLE false)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QDeclarativeListProperty<QQuickItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
Q_PROPERTY(QPointF pos READ pos FINAL)
Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged FINAL)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QDeclarativeListProperty<QDeclarativeState> states READ states DESIGNABLE false)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QDeclarativeListProperty<QDeclarativeTransition> transitions READ transitions DESIGNABLE false)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QDeclarativeListProperty<QDeclarativeState> states READ states DESIGNABLE false)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QDeclarativeListProperty<QDeclarativeTransition> transitions READ transitions DESIGNABLE false)
Q_PROPERTY(QString state READ state WRITE setState NOTIFY stateChanged)
Q_PROPERTY(QRectF childrenRect READ childrenRect NOTIFY childrenRectChanged DESIGNABLE false FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchors * anchors READ anchors DESIGNABLE false CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine left READ left CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine right READ right CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine horizontalCenter READ horizontalCenter CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine top READ top CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine bottom READ bottom CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine verticalCenter READ verticalCenter CONSTANT FINAL)
- Q_PRIVATE_PROPERTY(QSGItem::d_func(), QSGAnchorLine baseline READ baseline CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchors * anchors READ anchors DESIGNABLE false CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine left READ left CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine right READ right CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine horizontalCenter READ horizontalCenter CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine top READ top CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine bottom READ bottom CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine verticalCenter READ verticalCenter CONSTANT FINAL)
+ Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine baseline READ baseline CONSTANT FINAL)
Q_PROPERTY(qreal baselineOffset READ baselineOffset WRITE setBaselineOffset NOTIFY baselineOffsetChanged)
Q_PROPERTY(bool clip READ clip WRITE setClip NOTIFY clipChanged)
Q_PROPERTY(qreal scale READ scale WRITE setScale NOTIFY scaleChanged)
Q_PROPERTY(TransformOrigin transformOrigin READ transformOrigin WRITE setTransformOrigin NOTIFY transformOriginChanged)
Q_PROPERTY(QPointF transformOriginPoint READ transformOriginPoint) // XXX todo - notify?
- Q_PROPERTY(QDeclarativeListProperty<QSGTransform> transform READ transform DESIGNABLE false FINAL)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickTransform> transform READ transform DESIGNABLE false FINAL)
Q_PROPERTY(bool smooth READ smooth WRITE setSmooth NOTIFY smoothChanged)
Q_PROPERTY(qreal implicitWidth READ implicitWidth WRITE setImplicitWidth NOTIFY implicitWidthChanged)
ItemIsFocusScope = 0x04,
ItemHasContents = 0x08,
ItemAcceptsDrops = 0x10
- // Remember to increment the size of QSGItemPrivate::flags
+ // Remember to increment the size of QQuickItemPrivate::flags
};
Q_DECLARE_FLAGS(Flags, Flag)
};
union ItemChangeData {
- ItemChangeData(QSGItem *v) : item(v) {}
- ItemChangeData(QSGCanvas *v) : canvas(v) {}
+ ItemChangeData(QQuickItem *v) : item(v) {}
+ ItemChangeData(QQuickCanvas *v) : canvas(v) {}
ItemChangeData(qreal v) : realValue(v) {}
ItemChangeData(bool v) : boolValue(v) {}
- QSGItem *item;
- QSGCanvas *canvas;
+ QQuickItem *item;
+ QQuickCanvas *canvas;
qreal realValue;
bool boolValue;
};
BottomLeft, Bottom, BottomRight
};
- QSGItem(QSGItem *parent = 0);
- virtual ~QSGItem();
+ QQuickItem(QQuickItem *parent = 0);
+ virtual ~QQuickItem();
QSGEngine *sceneGraphEngine() const;
- QSGCanvas *canvas() const;
- QSGItem *parentItem() const;
- void setParentItem(QSGItem *parent);
- void stackBefore(const QSGItem *);
- void stackAfter(const QSGItem *);
+ QQuickCanvas *canvas() const;
+ QQuickItem *parentItem() const;
+ void setParentItem(QQuickItem *parent);
+ void stackBefore(const QQuickItem *);
+ void stackAfter(const QQuickItem *);
QRectF childrenRect();
- QList<QSGItem *> childItems() const;
+ QList<QQuickItem *> childItems() const;
bool clip() const;
void setClip(bool);
qreal baselineOffset() const;
void setBaselineOffset(qreal);
- QDeclarativeListProperty<QSGTransform> transform();
+ QDeclarativeListProperty<QQuickTransform> transform();
qreal x() const;
qreal y() const;
bool hasFocus() const;
void setFocus(bool);
bool isFocusScope() const;
- QSGItem *scopedFocusItem() const;
+ QQuickItem *scopedFocusItem() const;
Qt::MouseButtons acceptedMouseButtons() const;
void setAcceptedMouseButtons(Qt::MouseButtons buttons);
bool filtersChildMouseEvents() const;
void setFiltersChildMouseEvents(bool filter);
- QTransform itemTransform(QSGItem *, bool *) const;
- QPointF mapToItem(const QSGItem *item, const QPointF &point) const;
+ QTransform itemTransform(QQuickItem *, bool *) const;
+ QPointF mapToItem(const QQuickItem *item, const QPointF &point) const;
QPointF mapToScene(const QPointF &point) const;
- QRectF mapRectToItem(const QSGItem *item, const QRectF &rect) const;
+ QRectF mapRectToItem(const QQuickItem *item, const QRectF &rect) const;
QRectF mapRectToScene(const QRectF &rect) const;
- QPointF mapFromItem(const QSGItem *item, const QPointF &point) const;
+ QPointF mapFromItem(const QQuickItem *item, const QPointF &point) const;
QPointF mapFromScene(const QPointF &point) const;
- QRectF mapRectFromItem(const QSGItem *item, const QRectF &rect) const;
+ QRectF mapRectFromItem(const QQuickItem *item, const QRectF &rect) const;
QRectF mapRectFromScene(const QRectF &rect) const;
void polish();
Q_INVOKABLE void mapFromItem(QDeclarativeV8Function*) const;
Q_INVOKABLE void mapToItem(QDeclarativeV8Function*) const;
Q_INVOKABLE void forceActiveFocus();
- Q_INVOKABLE QSGItem *childAt(qreal x, qreal y) const;
+ Q_INVOKABLE QQuickItem *childAt(qreal x, qreal y) const;
Qt::InputMethodHints inputMethodHints() const;
void setInputMethodHints(Qt::InputMethodHints hints);
struct UpdatePaintNodeData {
QSGTransformNode *transformNode;
private:
- friend class QSGCanvasPrivate;
+ friend class QQuickCanvasPrivate;
UpdatePaintNodeData();
};
void stateChanged(const QString &);
void focusChanged(bool);
void activeFocusChanged(bool);
- void parentChanged(QSGItem *);
+ void parentChanged(QQuickItem *);
void transformOriginChanged(TransformOrigin);
void smoothChanged(bool);
void clipChanged(bool);
virtual void dragMoveEvent(QDragMoveEvent *);
virtual void dragLeaveEvent(QDragLeaveEvent *);
virtual void dropEvent(QDropEvent *);
- virtual bool childMouseEventFilter(QSGItem *, QEvent *);
+ virtual bool childMouseEventFilter(QQuickItem *, QEvent *);
virtual void windowDeactivateEvent();
virtual void geometryChanged(const QRectF &newGeometry,
virtual void updatePolish();
protected:
- QSGItem(QSGItemPrivate &dd, QSGItem *parent = 0);
+ QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent = 0);
private:
- friend class QSGCanvas;
- friend class QSGCanvasPrivate;
+ friend class QQuickCanvas;
+ friend class QQuickCanvasPrivate;
friend class QSGRenderer;
- Q_DISABLE_COPY(QSGItem)
- Q_DECLARE_PRIVATE(QSGItem)
+ Q_DISABLE_COPY(QQuickItem)
+ Q_DECLARE_PRIVATE(QQuickItem)
};
// XXX todo
-Q_DECLARE_OPERATORS_FOR_FLAGS(QSGItem::Flags)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickItem::Flags)
#ifndef QT_NO_DEBUG_STREAM
-QDebug Q_DECLARATIVE_EXPORT operator<<(QDebug debug, QSGItem *item);
+QDebug Q_DECLARATIVE_EXPORT operator<<(QDebug debug, QQuickItem *item);
#endif
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGItem)
-QML_DECLARE_TYPE(QSGTransform)
+QML_DECLARE_TYPE(QQuickItem)
+QML_DECLARE_TYPE(QQuickTransform)
QT_END_HEADER
-#endif // QSGITEM_H
+#endif // QQUICKITEM_H
**
****************************************************************************/
-#ifndef QSGITEM_P_H
-#define QSGITEM_P_H
+#ifndef QQUICKITEM_P_H
+#define QQUICKITEM_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgitem.h"
+#include "qquickitem.h"
-#include "qsganchors_p.h"
-#include "qsganchors_p_p.h"
-#include "qsgitemchangelistener_p.h"
+#include "qquickanchors_p.h"
+#include "qquickanchors_p_p.h"
+#include "qquickitemchangelistener_p.h"
-#include "qsgcanvas_p.h"
+#include "qquickcanvas_p.h"
-#include "qsgnode.h"
-#include "qsgclipnode_p.h"
+#include <qsgnode.h>
+#include "qquickclipnode_p.h"
#include <private/qpodvector_p.h>
#include <private/qdeclarativestate_p.h>
QT_BEGIN_NAMESPACE
class QNetworkReply;
-class QSGItemKeyFilter;
-class QSGLayoutMirroringAttached;
+class QQuickItemKeyFilter;
+class QQuickLayoutMirroringAttached;
//### merge into private?
-class QSGContents : public QObject, public QSGItemChangeListener
+class QQuickContents : public QObject, public QQuickItemChangeListener
{
Q_OBJECT
public:
- QSGContents(QSGItem *item);
- ~QSGContents();
+ QQuickContents(QQuickItem *item);
+ ~QQuickContents();
QRectF rectF() const;
- void childRemoved(QSGItem *item);
- void childAdded(QSGItem *item);
+ void childRemoved(QQuickItem *item);
+ void childAdded(QQuickItem *item);
void calcGeometry() { calcWidth(); calcHeight(); }
void complete();
void rectChanged(QRectF);
protected:
- void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
- void itemDestroyed(QSGItem *item);
- //void itemVisibilityChanged(QSGItem *item)
+ void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+ void itemDestroyed(QQuickItem *item);
+ //void itemVisibilityChanged(QQuickItem *item)
private:
- void calcHeight(QSGItem *changed = 0);
- void calcWidth(QSGItem *changed = 0);
+ void calcHeight(QQuickItem *changed = 0);
+ void calcWidth(QQuickItem *changed = 0);
- QSGItem *m_item;
+ QQuickItem *m_item;
qreal m_x;
qreal m_y;
qreal m_width;
qreal m_height;
};
-class QSGTransformPrivate : public QObjectPrivate
+class QQuickTransformPrivate : public QObjectPrivate
{
- Q_DECLARE_PUBLIC(QSGTransform);
+ Q_DECLARE_PUBLIC(QQuickTransform);
public:
- static QSGTransformPrivate* get(QSGTransform *transform) { return transform->d_func(); }
+ static QQuickTransformPrivate* get(QQuickTransform *transform) { return transform->d_func(); }
- QSGTransformPrivate();
+ QQuickTransformPrivate();
- QList<QSGItem *> items;
+ QList<QQuickItem *> items;
};
-class Q_DECLARATIVE_EXPORT QSGItemPrivate : public QObjectPrivate
+class Q_DECLARATIVE_EXPORT QQuickItemPrivate : public QObjectPrivate
{
- Q_DECLARE_PUBLIC(QSGItem)
+ Q_DECLARE_PUBLIC(QQuickItem)
public:
- static QSGItemPrivate* get(QSGItem *item) { return item->d_func(); }
- static const QSGItemPrivate* get(const QSGItem *item) { return item->d_func(); }
+ static QQuickItemPrivate* get(QQuickItem *item) { return item->d_func(); }
+ static const QQuickItemPrivate* get(const QQuickItem *item) { return item->d_func(); }
- QSGItemPrivate();
- void init(QSGItem *parent);
+ QQuickItemPrivate();
+ void init(QQuickItem *parent);
QDeclarativeListProperty<QObject> data();
QDeclarativeListProperty<QObject> resources();
- QDeclarativeListProperty<QSGItem> children();
+ QDeclarativeListProperty<QQuickItem> children();
QDeclarativeListProperty<QDeclarativeState> states();
QDeclarativeListProperty<QDeclarativeTransition> transitions();
QString state() const;
void setState(const QString &);
- QSGAnchorLine left() const;
- QSGAnchorLine right() const;
- QSGAnchorLine horizontalCenter() const;
- QSGAnchorLine top() const;
- QSGAnchorLine bottom() const;
- QSGAnchorLine verticalCenter() const;
- QSGAnchorLine baseline() const;
+ QQuickAnchorLine left() const;
+ QQuickAnchorLine right() const;
+ QQuickAnchorLine horizontalCenter() const;
+ QQuickAnchorLine top() const;
+ QQuickAnchorLine bottom() const;
+ QQuickAnchorLine verticalCenter() const;
+ QQuickAnchorLine baseline() const;
// data property
static void data_append(QDeclarativeListProperty<QObject> *, QObject *);
static void resources_clear(QDeclarativeListProperty<QObject> *);
// children property
- static void children_append(QDeclarativeListProperty<QSGItem> *, QSGItem *);
- static int children_count(QDeclarativeListProperty<QSGItem> *);
- static QSGItem *children_at(QDeclarativeListProperty<QSGItem> *, int);
- static void children_clear(QDeclarativeListProperty<QSGItem> *);
+ static void children_append(QDeclarativeListProperty<QQuickItem> *, QQuickItem *);
+ static int children_count(QDeclarativeListProperty<QQuickItem> *);
+ static QQuickItem *children_at(QDeclarativeListProperty<QQuickItem> *, int);
+ static void children_clear(QDeclarativeListProperty<QQuickItem> *);
// transform property
- static int transform_count(QDeclarativeListProperty<QSGTransform> *list);
- static void transform_append(QDeclarativeListProperty<QSGTransform> *list, QSGTransform *);
- static QSGTransform *transform_at(QDeclarativeListProperty<QSGTransform> *list, int);
- static void transform_clear(QDeclarativeListProperty<QSGTransform> *list);
+ static int transform_count(QDeclarativeListProperty<QQuickTransform> *list);
+ static void transform_append(QDeclarativeListProperty<QQuickTransform> *list, QQuickTransform *);
+ static QQuickTransform *transform_at(QDeclarativeListProperty<QQuickTransform> *list, int);
+ static void transform_clear(QDeclarativeListProperty<QQuickTransform> *list);
- QSGAnchors *anchors() const;
- mutable QSGAnchors *_anchors;
- QSGContents *_contents;
+ QQuickAnchors *anchors() const;
+ mutable QQuickAnchors *_anchors;
+ QQuickContents *_contents;
QDeclarativeNullableValue<qreal> baselineOffset;
struct AnchorLines {
- AnchorLines(QSGItem *);
- QSGAnchorLine left;
- QSGAnchorLine right;
- QSGAnchorLine hCenter;
- QSGAnchorLine top;
- QSGAnchorLine bottom;
- QSGAnchorLine vCenter;
- QSGAnchorLine baseline;
+ AnchorLines(QQuickItem *);
+ QQuickAnchorLine left;
+ QQuickAnchorLine right;
+ QQuickAnchorLine hCenter;
+ QQuickAnchorLine top;
+ QQuickAnchorLine bottom;
+ QQuickAnchorLine vCenter;
+ QQuickAnchorLine baseline;
};
mutable AnchorLines *_anchorLines;
AnchorLines *anchorLines() const;
Q_DECLARE_FLAGS(ChangeTypes, ChangeType)
struct ChangeListener {
- ChangeListener(QSGItemChangeListener *l, QSGItemPrivate::ChangeTypes t) : listener(l), types(t) {}
- QSGItemChangeListener *listener;
- QSGItemPrivate::ChangeTypes types;
+ ChangeListener(QQuickItemChangeListener *l, QQuickItemPrivate::ChangeTypes t) : listener(l), types(t) {}
+ QQuickItemChangeListener *listener;
+ QQuickItemPrivate::ChangeTypes types;
bool operator==(const ChangeListener &other) const { return listener == other.listener && types == other.types; }
};
- void addItemChangeListener(QSGItemChangeListener *listener, ChangeTypes types) {
+ void addItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types) {
changeListeners.append(ChangeListener(listener, types));
}
- void removeItemChangeListener(QSGItemChangeListener *, ChangeTypes types);
+ void removeItemChangeListener(QQuickItemChangeListener *, ChangeTypes types);
QPODVector<ChangeListener,4> changeListeners;
QDeclarativeStateGroup *_states();
QDeclarativeStateGroup *_stateGroup;
- QSGItem::TransformOrigin origin:5;
+ QQuickItem::TransformOrigin origin:5;
quint32 flags:5;
bool widthValid:1;
bool heightValid:1;
bool childrenDoNotOverlap:1;
quint32 dummy:1;
- QSGCanvas *canvas;
- QSGContext *sceneGraphContext() const { Q_ASSERT(canvas); return static_cast<QSGCanvasPrivate *>(QObjectPrivate::get(canvas))->context; }
+ QQuickCanvas *canvas;
+ QSGContext *sceneGraphContext() const { Q_ASSERT(canvas); return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context; }
- QSGItem *parentItem;
- QList<QSGItem *> childItems;
- QList<QSGItem *> paintOrderChildItems() const;
- void addChild(QSGItem *);
- void removeChild(QSGItem *);
+ QQuickItem *parentItem;
+ QList<QQuickItem *> childItems;
+ QList<QQuickItem *> paintOrderChildItems() const;
+ void addChild(QQuickItem *);
+ void removeChild(QQuickItem *);
void siblingOrderChanged();
class InitializationState {
public:
- QSGItem *getFocusScope(QSGItem *item);
+ QQuickItem *getFocusScope(QQuickItem *item);
void clear();
- void clear(QSGItem *focusScope);
+ void clear(QQuickItem *focusScope);
private:
- QSGItem *focusScope;
+ QQuickItem *focusScope;
};
- void initCanvas(InitializationState *, QSGCanvas *);
+ void initCanvas(InitializationState *, QQuickCanvas *);
- QSGItem *subFocusItem;
+ QQuickItem *subFocusItem;
QTransform canvasToItemTransform() const;
QTransform itemToCanvasTransform() const;
qreal rotation;
qreal opacity;
- QSGLayoutMirroringAttached* attachedLayoutDirection;
+ QQuickLayoutMirroringAttached* attachedLayoutDirection;
Qt::MouseButtons acceptedMouseButtons;
Qt::InputMethodHints imHints;
}
QPointF computeTransformOrigin() const;
- QList<QSGTransform *> transforms;
+ QList<QQuickTransform *> transforms;
virtual void transformChanged();
- QSGItemKeyFilter *keyHandler;
+ QQuickItemKeyFilter *keyHandler;
void deliverKeyEvent(QKeyEvent *);
void deliverInputMethodEvent(QInputMethodEvent *);
void deliverFocusEvent(QFocusEvent *);
void dirty(DirtyType);
void addToDirtyList();
void removeFromDirtyList();
- QSGItem *nextDirtyItem;
- QSGItem**prevDirtyItem;
+ QQuickItem *nextDirtyItem;
+ QQuickItem**prevDirtyItem;
inline QSGTransformNode *itemNode();
inline QSGNode *childContainerNode();
QSGTransformNode *itemNodeInstance;
QSGOpacityNode *opacityNode;
- QSGDefaultClipNode *clipNode;
+ QQuickDefaultClipNode *clipNode;
QSGRootNode *rootNode;
QSGNode *groupNode;
QSGNode *paintNode;
int effectRefCount;
int hideRefCount;
- void itemChange(QSGItem::ItemChange, const QSGItem::ItemChangeData &);
+ void itemChange(QQuickItem::ItemChange, const QQuickItem::ItemChangeData &);
virtual void mirrorChange() {}
};
/*
- Key filters can be installed on a QSGItem, but not removed. Currently they
+ Key filters can be installed on a QQuickItem, but not removed. Currently they
are only used by attached objects (which are only destroyed on Item
destruction), so this isn't a problem. If in future this becomes any form
of public API, they will have to support removal too.
*/
-class QSGItemKeyFilter
+class QQuickItemKeyFilter
{
public:
- QSGItemKeyFilter(QSGItem * = 0);
- virtual ~QSGItemKeyFilter();
+ QQuickItemKeyFilter(QQuickItem * = 0);
+ virtual ~QQuickItemKeyFilter();
virtual void keyPressed(QKeyEvent *event, bool post);
virtual void keyReleased(QKeyEvent *event, bool post);
bool m_processPost;
private:
- QSGItemKeyFilter *m_next;
+ QQuickItemKeyFilter *m_next;
};
-class QSGKeyNavigationAttachedPrivate : public QObjectPrivate
+class QQuickKeyNavigationAttachedPrivate : public QObjectPrivate
{
public:
- QSGKeyNavigationAttachedPrivate()
+ QQuickKeyNavigationAttachedPrivate()
: QObjectPrivate(),
left(0), right(0), up(0), down(0), tab(0), backtab(0),
leftSet(false), rightSet(false), upSet(false), downSet(false),
tabSet(false), backtabSet(false) {}
- QSGItem *left;
- QSGItem *right;
- QSGItem *up;
- QSGItem *down;
- QSGItem *tab;
- QSGItem *backtab;
+ QQuickItem *left;
+ QQuickItem *right;
+ QQuickItem *up;
+ QQuickItem *down;
+ QQuickItem *tab;
+ QQuickItem *backtab;
bool leftSet : 1;
bool rightSet : 1;
bool upSet : 1;
bool backtabSet : 1;
};
-class QSGKeyNavigationAttached : public QObject, public QSGItemKeyFilter
+class QQuickKeyNavigationAttached : public QObject, public QQuickItemKeyFilter
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGKeyNavigationAttached)
-
- Q_PROPERTY(QSGItem *left READ left WRITE setLeft NOTIFY leftChanged)
- Q_PROPERTY(QSGItem *right READ right WRITE setRight NOTIFY rightChanged)
- Q_PROPERTY(QSGItem *up READ up WRITE setUp NOTIFY upChanged)
- Q_PROPERTY(QSGItem *down READ down WRITE setDown NOTIFY downChanged)
- Q_PROPERTY(QSGItem *tab READ tab WRITE setTab NOTIFY tabChanged)
- Q_PROPERTY(QSGItem *backtab READ backtab WRITE setBacktab NOTIFY backtabChanged)
+ Q_DECLARE_PRIVATE(QQuickKeyNavigationAttached)
+
+ Q_PROPERTY(QQuickItem *left READ left WRITE setLeft NOTIFY leftChanged)
+ Q_PROPERTY(QQuickItem *right READ right WRITE setRight NOTIFY rightChanged)
+ Q_PROPERTY(QQuickItem *up READ up WRITE setUp NOTIFY upChanged)
+ Q_PROPERTY(QQuickItem *down READ down WRITE setDown NOTIFY downChanged)
+ Q_PROPERTY(QQuickItem *tab READ tab WRITE setTab NOTIFY tabChanged)
+ Q_PROPERTY(QQuickItem *backtab READ backtab WRITE setBacktab NOTIFY backtabChanged)
Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
Q_ENUMS(Priority)
public:
- QSGKeyNavigationAttached(QObject * = 0);
-
- QSGItem *left() const;
- void setLeft(QSGItem *);
- QSGItem *right() const;
- void setRight(QSGItem *);
- QSGItem *up() const;
- void setUp(QSGItem *);
- QSGItem *down() const;
- void setDown(QSGItem *);
- QSGItem *tab() const;
- void setTab(QSGItem *);
- QSGItem *backtab() const;
- void setBacktab(QSGItem *);
+ QQuickKeyNavigationAttached(QObject * = 0);
+
+ QQuickItem *left() const;
+ void setLeft(QQuickItem *);
+ QQuickItem *right() const;
+ void setRight(QQuickItem *);
+ QQuickItem *up() const;
+ void setUp(QQuickItem *);
+ QQuickItem *down() const;
+ void setDown(QQuickItem *);
+ QQuickItem *tab() const;
+ void setTab(QQuickItem *);
+ QQuickItem *backtab() const;
+ void setBacktab(QQuickItem *);
enum Priority { BeforeItem, AfterItem };
Priority priority() const;
void setPriority(Priority);
- static QSGKeyNavigationAttached *qmlAttachedProperties(QObject *);
+ static QQuickKeyNavigationAttached *qmlAttachedProperties(QObject *);
Q_SIGNALS:
void leftChanged();
private:
virtual void keyPressed(QKeyEvent *event, bool post);
virtual void keyReleased(QKeyEvent *event, bool post);
- void setFocusNavigation(QSGItem *currentItem, const char *dir);
+ void setFocusNavigation(QQuickItem *currentItem, const char *dir);
};
-class QSGLayoutMirroringAttached : public QObject
+class QQuickLayoutMirroringAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled RESET resetEnabled NOTIFY enabledChanged)
Q_PROPERTY(bool childrenInherit READ childrenInherit WRITE setChildrenInherit NOTIFY childrenInheritChanged)
public:
- explicit QSGLayoutMirroringAttached(QObject *parent = 0);
+ explicit QQuickLayoutMirroringAttached(QObject *parent = 0);
bool enabled() const;
void setEnabled(bool);
bool childrenInherit() const;
void setChildrenInherit(bool);
- static QSGLayoutMirroringAttached *qmlAttachedProperties(QObject *);
+ static QQuickLayoutMirroringAttached *qmlAttachedProperties(QObject *);
Q_SIGNALS:
void enabledChanged();
void childrenInheritChanged();
private:
- friend class QSGItemPrivate;
- QSGItemPrivate *itemPrivate;
+ friend class QQuickItemPrivate;
+ QQuickItemPrivate *itemPrivate;
};
-class QSGKeysAttachedPrivate : public QObjectPrivate
+class QQuickKeysAttachedPrivate : public QObjectPrivate
{
public:
- QSGKeysAttachedPrivate()
+ QQuickKeysAttachedPrivate()
: QObjectPrivate(), inPress(false), inRelease(false)
, inIM(false), enabled(true), imeItem(0), item(0)
{}
bool enabled : 1;
- QSGItem *imeItem;
- QList<QSGItem *> targets;
- QSGItem *item;
+ QQuickItem *imeItem;
+ QList<QQuickItem *> targets;
+ QQuickItem *item;
};
-class QSGKeysAttached : public QObject, public QSGItemKeyFilter
+class QQuickKeysAttached : public QObject, public QQuickItemKeyFilter
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGKeysAttached)
+ Q_DECLARE_PRIVATE(QQuickKeysAttached)
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
- Q_PROPERTY(QDeclarativeListProperty<QSGItem> forwardTo READ forwardTo)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickItem> forwardTo READ forwardTo)
Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
Q_ENUMS(Priority)
public:
- QSGKeysAttached(QObject *parent=0);
- ~QSGKeysAttached();
+ QQuickKeysAttached(QObject *parent=0);
+ ~QQuickKeysAttached();
- bool enabled() const { Q_D(const QSGKeysAttached); return d->enabled; }
+ bool enabled() const { Q_D(const QQuickKeysAttached); return d->enabled; }
void setEnabled(bool enabled) {
- Q_D(QSGKeysAttached);
+ Q_D(QQuickKeysAttached);
if (enabled != d->enabled) {
d->enabled = enabled;
emit enabledChanged();
Priority priority() const;
void setPriority(Priority);
- QDeclarativeListProperty<QSGItem> forwardTo() {
- Q_D(QSGKeysAttached);
- return QDeclarativeListProperty<QSGItem>(this, d->targets);
+ QDeclarativeListProperty<QQuickItem> forwardTo() {
+ Q_D(QQuickKeysAttached);
+ return QDeclarativeListProperty<QQuickItem>(this, d->targets);
}
virtual void componentComplete();
- static QSGKeysAttached *qmlAttachedProperties(QObject *);
+ static QQuickKeysAttached *qmlAttachedProperties(QObject *);
Q_SIGNALS:
void enabledChanged();
void priorityChanged();
- void pressed(QSGKeyEvent *event);
- void released(QSGKeyEvent *event);
- void digit0Pressed(QSGKeyEvent *event);
- void digit1Pressed(QSGKeyEvent *event);
- void digit2Pressed(QSGKeyEvent *event);
- void digit3Pressed(QSGKeyEvent *event);
- void digit4Pressed(QSGKeyEvent *event);
- void digit5Pressed(QSGKeyEvent *event);
- void digit6Pressed(QSGKeyEvent *event);
- void digit7Pressed(QSGKeyEvent *event);
- void digit8Pressed(QSGKeyEvent *event);
- void digit9Pressed(QSGKeyEvent *event);
-
- void leftPressed(QSGKeyEvent *event);
- void rightPressed(QSGKeyEvent *event);
- void upPressed(QSGKeyEvent *event);
- void downPressed(QSGKeyEvent *event);
- void tabPressed(QSGKeyEvent *event);
- void backtabPressed(QSGKeyEvent *event);
-
- void asteriskPressed(QSGKeyEvent *event);
- void numberSignPressed(QSGKeyEvent *event);
- void escapePressed(QSGKeyEvent *event);
- void returnPressed(QSGKeyEvent *event);
- void enterPressed(QSGKeyEvent *event);
- void deletePressed(QSGKeyEvent *event);
- void spacePressed(QSGKeyEvent *event);
- void backPressed(QSGKeyEvent *event);
- void cancelPressed(QSGKeyEvent *event);
- void selectPressed(QSGKeyEvent *event);
- void yesPressed(QSGKeyEvent *event);
- void noPressed(QSGKeyEvent *event);
- void context1Pressed(QSGKeyEvent *event);
- void context2Pressed(QSGKeyEvent *event);
- void context3Pressed(QSGKeyEvent *event);
- void context4Pressed(QSGKeyEvent *event);
- void callPressed(QSGKeyEvent *event);
- void hangupPressed(QSGKeyEvent *event);
- void flipPressed(QSGKeyEvent *event);
- void menuPressed(QSGKeyEvent *event);
- void volumeUpPressed(QSGKeyEvent *event);
- void volumeDownPressed(QSGKeyEvent *event);
+ void pressed(QQuickKeyEvent *event);
+ void released(QQuickKeyEvent *event);
+ void digit0Pressed(QQuickKeyEvent *event);
+ void digit1Pressed(QQuickKeyEvent *event);
+ void digit2Pressed(QQuickKeyEvent *event);
+ void digit3Pressed(QQuickKeyEvent *event);
+ void digit4Pressed(QQuickKeyEvent *event);
+ void digit5Pressed(QQuickKeyEvent *event);
+ void digit6Pressed(QQuickKeyEvent *event);
+ void digit7Pressed(QQuickKeyEvent *event);
+ void digit8Pressed(QQuickKeyEvent *event);
+ void digit9Pressed(QQuickKeyEvent *event);
+
+ void leftPressed(QQuickKeyEvent *event);
+ void rightPressed(QQuickKeyEvent *event);
+ void upPressed(QQuickKeyEvent *event);
+ void downPressed(QQuickKeyEvent *event);
+ void tabPressed(QQuickKeyEvent *event);
+ void backtabPressed(QQuickKeyEvent *event);
+
+ void asteriskPressed(QQuickKeyEvent *event);
+ void numberSignPressed(QQuickKeyEvent *event);
+ void escapePressed(QQuickKeyEvent *event);
+ void returnPressed(QQuickKeyEvent *event);
+ void enterPressed(QQuickKeyEvent *event);
+ void deletePressed(QQuickKeyEvent *event);
+ void spacePressed(QQuickKeyEvent *event);
+ void backPressed(QQuickKeyEvent *event);
+ void cancelPressed(QQuickKeyEvent *event);
+ void selectPressed(QQuickKeyEvent *event);
+ void yesPressed(QQuickKeyEvent *event);
+ void noPressed(QQuickKeyEvent *event);
+ void context1Pressed(QQuickKeyEvent *event);
+ void context2Pressed(QQuickKeyEvent *event);
+ void context3Pressed(QQuickKeyEvent *event);
+ void context4Pressed(QQuickKeyEvent *event);
+ void callPressed(QQuickKeyEvent *event);
+ void hangupPressed(QQuickKeyEvent *event);
+ void flipPressed(QQuickKeyEvent *event);
+ void menuPressed(QQuickKeyEvent *event);
+ void volumeUpPressed(QQuickKeyEvent *event);
+ void volumeDownPressed(QQuickKeyEvent *event);
private:
virtual void keyPressed(QKeyEvent *event, bool post);
static const SigMap sigMap[];
};
-QSGTransformNode *QSGItemPrivate::itemNode()
+QSGTransformNode *QQuickItemPrivate::itemNode()
{
if (!itemNodeInstance) {
itemNodeInstance = createTransformNode();
itemNodeInstance->setFlag(QSGNode::OwnedByParent, false);
#ifdef QML_RUNTIME_TESTING
- Q_Q(QSGItem);
- itemNodeInstance->description = QString::fromLatin1("QSGItem(%1)").arg(QString::fromLatin1(q->metaObject()->className()));
+ Q_Q(QQuickItem);
+ itemNodeInstance->description = QString::fromLatin1("QQuickItem(%1)").arg(QString::fromLatin1(q->metaObject()->className()));
#endif
}
return itemNodeInstance;
}
-QSGNode *QSGItemPrivate::childContainerNode()
+QSGNode *QQuickItemPrivate::childContainerNode()
{
if (!groupNode) {
groupNode = new QSGNode();
return groupNode;
}
-Q_DECLARE_OPERATORS_FOR_FLAGS(QSGItemPrivate::ChangeTypes);
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickItemPrivate::ChangeTypes);
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGKeysAttached)
-QML_DECLARE_TYPEINFO(QSGKeysAttached, QML_HAS_ATTACHED_PROPERTIES)
-QML_DECLARE_TYPE(QSGKeyNavigationAttached)
-QML_DECLARE_TYPEINFO(QSGKeyNavigationAttached, QML_HAS_ATTACHED_PROPERTIES)
-QML_DECLARE_TYPE(QSGLayoutMirroringAttached)
-QML_DECLARE_TYPEINFO(QSGLayoutMirroringAttached, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickKeysAttached)
+QML_DECLARE_TYPEINFO(QQuickKeysAttached, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickKeyNavigationAttached)
+QML_DECLARE_TYPEINFO(QQuickKeyNavigationAttached, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickLayoutMirroringAttached)
+QML_DECLARE_TYPEINFO(QQuickLayoutMirroringAttached, QML_HAS_ATTACHED_PROPERTIES)
-#endif // QSGITEM_P_H
+#endif // QQUICKITEM_P_H
**
****************************************************************************/
-#ifndef QSGITEMCHANGELISTENER_P_H
-#define QSGITEMCHANGELISTENER_P_H
+#ifndef QQUICKITEMCHANGELISTENER_P_H
+#define QQUICKITEMCHANGELISTENER_P_H
//
// W A R N I N G
QT_BEGIN_NAMESPACE
class QRectF;
-class QSGItem;
-class QSGAnchorsPrivate;
-class QSGItemChangeListener
+class QQuickItem;
+class QQuickAnchorsPrivate;
+class QQuickItemChangeListener
{
public:
- virtual void itemGeometryChanged(QSGItem *, const QRectF &, const QRectF &) {}
- virtual void itemSiblingOrderChanged(QSGItem *) {}
- virtual void itemVisibilityChanged(QSGItem *) {}
- virtual void itemOpacityChanged(QSGItem *) {}
- virtual void itemDestroyed(QSGItem *) {}
- virtual void itemChildAdded(QSGItem *, QSGItem *) {}
- virtual void itemChildRemoved(QSGItem *, QSGItem *) {}
- virtual void itemParentChanged(QSGItem *, QSGItem *) {}
- virtual void itemRotationChanged(QSGItem *) {}
+ virtual void itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &) {}
+ virtual void itemSiblingOrderChanged(QQuickItem *) {}
+ virtual void itemVisibilityChanged(QQuickItem *) {}
+ virtual void itemOpacityChanged(QQuickItem *) {}
+ virtual void itemDestroyed(QQuickItem *) {}
+ virtual void itemChildAdded(QQuickItem *, QQuickItem *) {}
+ virtual void itemChildRemoved(QQuickItem *, QQuickItem *) {}
+ virtual void itemParentChanged(QQuickItem *, QQuickItem *) {}
+ virtual void itemRotationChanged(QQuickItem *) {}
- virtual QSGAnchorsPrivate *anchorPrivate() { return 0; }
+ virtual QQuickAnchorsPrivate *anchorPrivate() { return 0; }
};
QT_END_NAMESPACE
-#endif // QSGITEMCHANGELISTENER_P_H
+#endif // QQUICKITEMCHANGELISTENER_P_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative 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 "qquickitemsmodule_p.h"
+
+#include "qquickitem.h"
+#include "qquickitem_p.h"
+#include "qquickevents_p_p.h"
+#include "qquickrectangle_p.h"
+#include "qquickfocusscope_p.h"
+#include "qquicktext_p.h"
+#include "qquicktextinput_p.h"
+#include "qquicktextedit_p.h"
+#include "qquickimage_p.h"
+#include "qquickborderimage_p.h"
+#include "qquickscalegrid_p_p.h"
+#include "qquickmousearea_p.h"
+#include "qquickpincharea_p.h"
+#include "qquickflickable_p.h"
+#include "qquickflickable_p_p.h"
+#include "qquicklistview_p.h"
+#include "qquickvisualitemmodel_p.h"
+#include "qquickvisualdatamodel_p.h"
+#include "qquickgridview_p.h"
+#include "qquickpathview_p.h"
+#include <private/qdeclarativepath_p.h>
+#include <private/qdeclarativepathinterpolator_p.h>
+#include "qquickpositioners_p.h"
+#include "qquickrepeater_p.h"
+#include "qquickloader_p.h"
+#include "qquickanimatedimage_p.h"
+#include "qquickflipable_p.h"
+#include "qquicktranslate_p.h"
+#include "qquickstateoperations_p.h"
+#include "qquickanimation_p.h"
+#include <private/qquickshadereffect_p.h>
+#include <private/qquickshadereffectsource_p.h>
+//#include <private/qquickpincharea_p.h>
+#include <private/qquickcanvasitem_p.h>
+#include <private/qquickcontext2d_p.h>
+#include "qquicksprite_p.h"
+#include "qquickspriteimage_p.h"
+#include "qquickdrag_p.h"
+#include "qquickdroparea_p.h"
+
+static QDeclarativePrivate::AutoParentResult qquickitem_autoParent(QObject *obj, QObject *parent)
+{
+ QQuickItem *item = qobject_cast<QQuickItem *>(obj);
+ if (!item)
+ return QDeclarativePrivate::IncompatibleObject;
+
+ QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent);
+ if (!parentItem)
+ return QDeclarativePrivate::IncompatibleParent;
+
+ item->setParentItem(parentItem);
+ return QDeclarativePrivate::Parented;
+}
+
+static void qt_quickitems_defineModule(const char *uri, int major, int minor)
+{
+ QDeclarativePrivate::RegisterAutoParent autoparent = { 0, &qquickitem_autoParent };
+ QDeclarativePrivate::qmlregister(QDeclarativePrivate::AutoParentRegistration, &autoparent);
+
+#ifdef QT_NO_MOVIE
+ qmlRegisterTypeNotAvailable(uri,major,minor,"AnimatedImage", qApp->translate("QQuickAnimatedImage","Qt was built without support for QMovie"));
+#else
+ qmlRegisterType<QQuickAnimatedImage>(uri,major,minor,"AnimatedImage");
+#endif
+ qmlRegisterType<QQuickBorderImage>(uri,major,minor,"BorderImage");
+ qmlRegisterType<QQuickColumn>(uri,major,minor,"Column");
+ qmlRegisterType<QQuickFlickable>(uri,major,minor,"Flickable");
+ qmlRegisterType<QQuickFlipable>(uri,major,minor,"Flipable");
+ qmlRegisterType<QQuickFlow>(uri,major,minor,"Flow");
+// qmlRegisterType<QDeclarativeFocusPanel>(uri,major,minor,"FocusPanel");
+ qmlRegisterType<QQuickFocusScope>(uri,major,minor,"FocusScope");
+ qmlRegisterType<QQuickGradient>(uri,major,minor,"Gradient");
+ qmlRegisterType<QQuickGradientStop>(uri,major,minor,"GradientStop");
+ qmlRegisterType<QQuickGrid>(uri,major,minor,"Grid");
+ qmlRegisterType<QQuickGridView>(uri,major,minor,"GridView");
+ qmlRegisterType<QQuickImage>(uri,major,minor,"Image");
+ qmlRegisterType<QQuickItem>(uri,major,minor,"Item");
+ qmlRegisterType<QQuickListView>(uri,major,minor,"ListView");
+ qmlRegisterType<QQuickLoader>(uri,major,minor,"Loader");
+ qmlRegisterType<QQuickMouseArea>(uri,major,minor,"MouseArea");
+ qmlRegisterType<QDeclarativePath>(uri,major,minor,"Path");
+ qmlRegisterType<QDeclarativePathAttribute>(uri,major,minor,"PathAttribute");
+ qmlRegisterType<QDeclarativePathCubic>(uri,major,minor,"PathCubic");
+ qmlRegisterType<QDeclarativePathLine>(uri,major,minor,"PathLine");
+ qmlRegisterType<QDeclarativePathPercent>(uri,major,minor,"PathPercent");
+ qmlRegisterType<QDeclarativePathQuad>(uri,major,minor,"PathQuad");
+ qmlRegisterType<QDeclarativePathCatmullRomCurve>("QtQuick",2,0,"PathCurve");
+ qmlRegisterType<QDeclarativePathArc>("QtQuick",2,0,"PathArc");
+ qmlRegisterType<QDeclarativePathSvg>("QtQuick",2,0,"PathSvg");
+ qmlRegisterType<QQuickPathView>(uri,major,minor,"PathView");
+ qmlRegisterUncreatableType<QQuickBasePositioner>(uri,major,minor,"Positioner",
+ QStringLiteral("Positioner is an abstract type that is only available as an attached property."));
+#ifndef QT_NO_VALIDATOR
+ qmlRegisterType<QIntValidator>(uri,major,minor,"IntValidator");
+ qmlRegisterType<QDoubleValidator>(uri,major,minor,"DoubleValidator");
+ qmlRegisterType<QRegExpValidator>(uri,major,minor,"RegExpValidator");
+#endif
+ qmlRegisterType<QQuickRectangle>(uri,major,minor,"Rectangle");
+ qmlRegisterType<QQuickRepeater>(uri,major,minor,"Repeater");
+ qmlRegisterType<QQuickRow>(uri,major,minor,"Row");
+ qmlRegisterType<QQuickTranslate>(uri,major,minor,"Translate");
+ qmlRegisterType<QQuickRotation>(uri,major,minor,"Rotation");
+ qmlRegisterType<QQuickScale>(uri,major,minor,"Scale");
+ qmlRegisterType<QQuickText>(uri,major,minor,"Text");
+ qmlRegisterType<QQuickTextEdit>(uri,major,minor,"TextEdit");
+ qmlRegisterType<QQuickTextInput>(uri,major,minor,"TextInput");
+ qmlRegisterType<QQuickViewSection>(uri,major,minor,"ViewSection");
+ qmlRegisterType<QQuickVisualDataModel>(uri,major,minor,"VisualDataModel");
+ qmlRegisterType<QQuickVisualDataGroup>(uri,major,minor,"VisualDataGroup");
+ qmlRegisterType<QQuickVisualItemModel>(uri,major,minor,"VisualItemModel");
+
+ qmlRegisterType<QQuickAnchors>();
+ qmlRegisterType<QQuickKeyEvent>();
+ qmlRegisterType<QQuickMouseEvent>();
+ qmlRegisterType<QQuickTransform>();
+ qmlRegisterType<QDeclarativePathElement>();
+ qmlRegisterType<QDeclarativeCurve>();
+ qmlRegisterType<QQuickScaleGrid>();
+ qmlRegisterType<QQuickTextLine>();
+#ifndef QT_NO_VALIDATOR
+ qmlRegisterType<QValidator>();
+#endif
+ qmlRegisterType<QQuickVisualModel>();
+ qmlRegisterType<QQuickPen>();
+ qmlRegisterType<QQuickFlickableVisibleArea>();
+ qRegisterMetaType<QQuickAnchorLine>("QQuickAnchorLine");
+
+ qmlRegisterUncreatableType<QQuickKeyNavigationAttached>(uri,major,minor,"KeyNavigation",QQuickKeyNavigationAttached::tr("KeyNavigation is only available via attached properties"));
+ qmlRegisterUncreatableType<QQuickKeysAttached>(uri,major,minor,"Keys",QQuickKeysAttached::tr("Keys is only available via attached properties"));
+ qmlRegisterUncreatableType<QQuickLayoutMirroringAttached>(uri,major,minor,"LayoutMirroring", QQuickLayoutMirroringAttached::tr("LayoutMirroring is only available via attached properties"));
+
+ qmlRegisterType<QQuickPinchArea>(uri,major,minor,"PinchArea");
+ qmlRegisterType<QQuickPinch>(uri,major,minor,"Pinch");
+ qmlRegisterType<QQuickPinchEvent>();
+
+ qmlRegisterType<QQuickShaderEffectItem>("QtQuick", 2, 0, "ShaderEffectItem"); // TODO: Remove after grace period.
+ qmlRegisterType<QQuickShaderEffect>("QtQuick", 2, 0, "ShaderEffect");
+ qmlRegisterType<QQuickShaderEffectSource>("QtQuick", 2, 0, "ShaderEffectSource");
+ qmlRegisterUncreatableType<QQuickShaderEffectMesh>("QtQuick", 2, 0, "ShaderEffectMesh", QQuickShaderEffectMesh::tr("Cannot create instance of abstract class ShaderEffectMesh."));
+ qmlRegisterType<QQuickGridMesh>("QtQuick", 2, 0, "GridMesh");
+
+ qmlRegisterUncreatableType<QQuickPaintedItem>("QtQuick", 2, 0, "PaintedItem", QQuickPaintedItem::tr("Cannot create instance of abstract class PaintedItem"));
+
+ qmlRegisterType<QQuickCanvasItem>("QtQuick", 2, 0, "Canvas");
+
+ qmlRegisterType<QQuickSprite>("QtQuick", 2, 0, "Sprite");
+ qmlRegisterType<QQuickSpriteImage>("QtQuick", 2, 0, "SpriteImage");
+
+ qmlRegisterType<QQuickParentChange>(uri, major, minor,"ParentChange");
+ qmlRegisterType<QQuickAnchorChanges>(uri, major, minor,"AnchorChanges");
+ qmlRegisterType<QQuickAnchorSet>();
+ qmlRegisterType<QQuickAnchorAnimation>(uri, major, minor,"AnchorAnimation");
+ qmlRegisterType<QQuickParentAnimation>(uri, major, minor,"ParentAnimation");
+ qmlRegisterType<QQuickPathAnimation>("QtQuick",2,0,"PathAnimation");
+ qmlRegisterType<QDeclarativePathInterpolator>("QtQuick",2,0,"PathInterpolator");
+
+ qmlRegisterType<QQuickDropArea>("QtQuick", 2, 0, "DropArea");
+ qmlRegisterType<QQuickDropEvent>();
+ qmlRegisterType<QQuickDropAreaDrag>();
+ qmlRegisterUncreatableType<QQuickDrag>("QtQuick", 2, 0, "Drag", QQuickDragAttached::tr("Drag is only available via attached properties"));
+}
+
+void QQuickItemsModule::defineModule()
+{
+ static bool initialized = false;
+ if (initialized)
+ return;
+ initialized = true;
+
+ // XXX todo - Remove before final integration...
+ QByteArray mode = qgetenv("QMLSCENE_IMPORT_NAME");
+ QByteArray name = "QtQuick";
+ int majorVersion = 2;
+ int minorVersion = 0;
+ if (mode == "quick1") {
+ majorVersion = 1;
+ } else if (mode == "qt") {
+ name = "Qt";
+ majorVersion = 4;
+ minorVersion = 7;
+ }
+
+ qt_quickitems_defineModule(name, majorVersion, minorVersion);
+}
+
**
****************************************************************************/
-#ifndef QSGITEMSMODULE_P_H
-#define QSGITEMSMODULE_P_H
+#ifndef QQUICKITEMSMODULE_P_H
+#define QQUICKITEMSMODULE_P_H
#include <qdeclarative.h>
QT_MODULE(Declarative)
-class QSGItemsModule
+class QQuickItemsModule
{
public:
static void defineModule();
QT_END_HEADER
-#endif // QSGITEMSMODULE_P_H
+#endif // QQUICKITEMSMODULE_P_H
**
****************************************************************************/
-#include "qsgitemview_p_p.h"
+#include "qquickitemview_p_p.h"
QT_BEGIN_NAMESPACE
-FxViewItem::FxViewItem(QSGItem *i, bool own)
+FxViewItem::FxViewItem(QQuickItem *i, bool own)
: item(i), ownItem(own), index(-1)
{
}
}
-QSGItemViewChangeSet::QSGItemViewChangeSet()
+QQuickItemViewChangeSet::QQuickItemViewChangeSet()
: active(false)
{
reset();
}
-bool QSGItemViewChangeSet::hasPendingChanges() const
+bool QQuickItemViewChangeSet::hasPendingChanges() const
{
return !pendingChanges.isEmpty();
}
-void QSGItemViewChangeSet::applyChanges(const QDeclarativeChangeSet &changeSet)
+void QQuickItemViewChangeSet::applyChanges(const QDeclarativeChangeSet &changeSet)
{
pendingChanges.apply(changeSet);
}
}
-void QSGItemViewChangeSet::prepare(int currentIndex, int count)
+void QQuickItemViewChangeSet::prepare(int currentIndex, int count)
{
if (active)
return;
newCurrentIndex = currentIndex;
}
-void QSGItemViewChangeSet::reset()
+void QQuickItemViewChangeSet::reset()
{
itemCount = 0;
newCurrentIndex = -1;
}
-QSGItemView::QSGItemView(QSGFlickablePrivate &dd, QSGItem *parent)
- : QSGFlickable(dd, parent)
+QQuickItemView::QQuickItemView(QQuickFlickablePrivate &dd, QQuickItem *parent)
+ : QQuickFlickable(dd, parent)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->init();
}
-QSGItemView::~QSGItemView()
+QQuickItemView::~QQuickItemView()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->clear();
if (d->ownModel)
delete d->model;
}
-QSGItem *QSGItemView::currentItem() const
+QQuickItem *QQuickItemView::currentItem() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (!d->currentItem)
return 0;
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->currentItem->item;
}
-QVariant QSGItemView::model() const
+QVariant QQuickItemView::model() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->modelVariant;
}
-void QSGItemView::setModel(const QVariant &model)
+void QQuickItemView::setModel(const QVariant &model)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->modelVariant == model)
return;
if (d->model) {
disconnect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
- disconnect(d->model, SIGNAL(createdItem(int,QSGItem*)), this, SLOT(createdItem(int,QSGItem*)));
- disconnect(d->model, SIGNAL(destroyingItem(QSGItem*)), this, SLOT(destroyingItem(QSGItem*)));
+ disconnect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
+ disconnect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
}
- QSGVisualModel *oldModel = d->model;
+ QQuickVisualModel *oldModel = d->model;
d->clear();
d->setPosition(d->contentStartPosition());
d->modelVariant = model;
QObject *object = qvariant_cast<QObject*>(model);
- QSGVisualModel *vim = 0;
- if (object && (vim = qobject_cast<QSGVisualModel *>(object))) {
+ QQuickVisualModel *vim = 0;
+ if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
if (d->ownModel) {
delete oldModel;
d->ownModel = false;
d->model = vim;
} else {
if (!d->ownModel) {
- d->model = new QSGVisualDataModel(qmlContext(this), this);
+ d->model = new QQuickVisualDataModel(qmlContext(this), this);
d->ownModel = true;
if (isComponentComplete())
- static_cast<QSGVisualDataModel *>(d->model.data())->componentComplete();
+ static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
} else {
d->model = oldModel;
}
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
dataModel->setModel(model);
}
if (d->model) {
- d->bufferMode = QSGItemViewPrivate::BufferBefore | QSGItemViewPrivate::BufferAfter;
+ d->bufferMode = QQuickItemViewPrivate::BufferBefore | QQuickItemViewPrivate::BufferAfter;
if (isComponentComplete()) {
updateSections();
d->refill();
if ((d->currentIndex >= d->model->count() || d->currentIndex < 0) && !d->currentIndexCleared) {
setCurrentIndex(0);
} else {
- d->moveReason = QSGItemViewPrivate::SetIndex;
+ d->moveReason = QQuickItemViewPrivate::SetIndex;
d->updateCurrent(d->currentIndex);
if (d->highlight && d->currentItem) {
if (d->autoHighlight)
d->resetHighlightPosition();
d->updateTrackedItem();
}
- d->moveReason = QSGItemViewPrivate::Other;
+ d->moveReason = QQuickItemViewPrivate::Other;
}
d->updateViewport();
}
connect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
- connect(d->model, SIGNAL(createdItem(int,QSGItem*)), this, SLOT(createdItem(int,QSGItem*)));
- connect(d->model, SIGNAL(destroyingItem(QSGItem*)), this, SLOT(destroyingItem(QSGItem*)));
+ connect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
+ connect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
emit countChanged();
}
emit modelChanged();
}
-QDeclarativeComponent *QSGItemView::delegate() const
+QDeclarativeComponent *QQuickItemView::delegate() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->model) {
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
return dataModel->delegate();
}
return 0;
}
-void QSGItemView::setDelegate(QDeclarativeComponent *delegate)
+void QQuickItemView::setDelegate(QDeclarativeComponent *delegate)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (delegate == this->delegate())
return;
if (!d->ownModel) {
- d->model = new QSGVisualDataModel(qmlContext(this));
+ d->model = new QQuickVisualDataModel(qmlContext(this));
d->ownModel = true;
}
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model)) {
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
int oldCount = dataModel->count();
dataModel->setDelegate(delegate);
if (isComponentComplete()) {
d->currentItem = 0;
updateSections();
d->refill();
- d->moveReason = QSGItemViewPrivate::SetIndex;
+ d->moveReason = QQuickItemViewPrivate::SetIndex;
d->updateCurrent(d->currentIndex);
if (d->highlight && d->currentItem) {
if (d->autoHighlight)
d->resetHighlightPosition();
d->updateTrackedItem();
}
- d->moveReason = QSGItemViewPrivate::Other;
+ d->moveReason = QQuickItemViewPrivate::Other;
d->updateViewport();
}
if (oldCount != dataModel->count())
}
-int QSGItemView::count() const
+int QQuickItemView::count() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (!d->model)
return 0;
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->model->count();
}
-int QSGItemView::currentIndex() const
+int QQuickItemView::currentIndex() const
{
- Q_D(const QSGItemView);
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ Q_D(const QQuickItemView);
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->currentIndex;
}
-void QSGItemView::setCurrentIndex(int index)
+void QQuickItemView::setCurrentIndex(int index)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->requestedIndex >= 0) // currently creating item
return;
d->currentIndexCleared = (index == -1);
if (index == d->currentIndex)
return;
if (isComponentComplete() && d->isValid()) {
- d->moveReason = QSGItemViewPrivate::SetIndex;
+ d->moveReason = QQuickItemViewPrivate::SetIndex;
d->updateCurrent(index);
} else if (d->currentIndex != index) {
d->currentIndex = index;
}
-bool QSGItemView::isWrapEnabled() const
+bool QQuickItemView::isWrapEnabled() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->wrap;
}
-void QSGItemView::setWrapEnabled(bool wrap)
+void QQuickItemView::setWrapEnabled(bool wrap)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->wrap == wrap)
return;
d->wrap = wrap;
emit keyNavigationWrapsChanged();
}
-int QSGItemView::cacheBuffer() const
+int QQuickItemView::cacheBuffer() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->buffer;
}
-void QSGItemView::setCacheBuffer(int b)
+void QQuickItemView::setCacheBuffer(int b)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->buffer != b) {
d->buffer = b;
if (isComponentComplete()) {
- d->bufferMode = QSGItemViewPrivate::BufferBefore | QSGItemViewPrivate::BufferAfter;
+ d->bufferMode = QQuickItemViewPrivate::BufferBefore | QQuickItemViewPrivate::BufferAfter;
d->refill();
}
emit cacheBufferChanged();
}
-Qt::LayoutDirection QSGItemView::layoutDirection() const
+Qt::LayoutDirection QQuickItemView::layoutDirection() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->layoutDirection;
}
-void QSGItemView::setLayoutDirection(Qt::LayoutDirection layoutDirection)
+void QQuickItemView::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->layoutDirection != layoutDirection) {
d->layoutDirection = layoutDirection;
d->regenerate();
}
}
-Qt::LayoutDirection QSGItemView::effectiveLayoutDirection() const
+Qt::LayoutDirection QQuickItemView::effectiveLayoutDirection() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->effectiveLayoutMirror)
return d->layoutDirection == Qt::RightToLeft ? Qt::LeftToRight : Qt::RightToLeft;
else
}
-QDeclarativeComponent *QSGItemView::header() const
+QDeclarativeComponent *QQuickItemView::header() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->headerComponent;
}
-QSGItem *QSGItemView::headerItem() const
+QQuickItem *QQuickItemView::headerItem() const
{
- Q_D(const QSGItemView);
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ Q_D(const QQuickItemView);
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->header ? d->header->item : 0;
}
-void QSGItemView::setHeader(QDeclarativeComponent *headerComponent)
+void QQuickItemView::setHeader(QDeclarativeComponent *headerComponent)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->headerComponent != headerComponent) {
d->applyPendingChanges();
delete d->header;
}
}
-QDeclarativeComponent *QSGItemView::footer() const
+QDeclarativeComponent *QQuickItemView::footer() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->footerComponent;
}
-QSGItem *QSGItemView::footerItem() const
+QQuickItem *QQuickItemView::footerItem() const
{
- Q_D(const QSGItemView);
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ Q_D(const QQuickItemView);
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->footer ? d->footer->item : 0;
}
-void QSGItemView::setFooter(QDeclarativeComponent *footerComponent)
+void QQuickItemView::setFooter(QDeclarativeComponent *footerComponent)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->footerComponent != footerComponent) {
d->applyPendingChanges();
delete d->footer;
}
}
-QDeclarativeComponent *QSGItemView::highlight() const
+QDeclarativeComponent *QQuickItemView::highlight() const
{
- Q_D(const QSGItemView);
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ Q_D(const QQuickItemView);
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->highlightComponent;
}
-void QSGItemView::setHighlight(QDeclarativeComponent *highlightComponent)
+void QQuickItemView::setHighlight(QDeclarativeComponent *highlightComponent)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (highlightComponent != d->highlightComponent) {
d->applyPendingChanges();
d->highlightComponent = highlightComponent;
}
}
-QSGItem *QSGItemView::highlightItem() const
+QQuickItem *QQuickItemView::highlightItem() const
{
- Q_D(const QSGItemView);
- const_cast<QSGItemViewPrivate*>(d)->applyPendingChanges();
+ Q_D(const QQuickItemView);
+ const_cast<QQuickItemViewPrivate*>(d)->applyPendingChanges();
return d->highlight ? d->highlight->item : 0;
}
-bool QSGItemView::highlightFollowsCurrentItem() const
+bool QQuickItemView::highlightFollowsCurrentItem() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->autoHighlight;
}
-void QSGItemView::setHighlightFollowsCurrentItem(bool autoHighlight)
+void QQuickItemView::setHighlightFollowsCurrentItem(bool autoHighlight)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->autoHighlight != autoHighlight) {
d->autoHighlight = autoHighlight;
if (autoHighlight)
}
}
-QSGItemView::HighlightRangeMode QSGItemView::highlightRangeMode() const
+QQuickItemView::HighlightRangeMode QQuickItemView::highlightRangeMode() const
{
- Q_D(const QSGItemView);
- return static_cast<QSGItemView::HighlightRangeMode>(d->highlightRange);
+ Q_D(const QQuickItemView);
+ return static_cast<QQuickItemView::HighlightRangeMode>(d->highlightRange);
}
-void QSGItemView::setHighlightRangeMode(HighlightRangeMode mode)
+void QQuickItemView::setHighlightRangeMode(HighlightRangeMode mode)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->highlightRange == mode)
return;
d->highlightRange = mode;
}
//###Possibly rename these properties, since they are very useful even without a highlight?
-qreal QSGItemView::preferredHighlightBegin() const
+qreal QQuickItemView::preferredHighlightBegin() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->highlightRangeStart;
}
-void QSGItemView::setPreferredHighlightBegin(qreal start)
+void QQuickItemView::setPreferredHighlightBegin(qreal start)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->highlightRangeStartValid = true;
if (d->highlightRangeStart == start)
return;
emit preferredHighlightBeginChanged();
}
-void QSGItemView::resetPreferredHighlightBegin()
+void QQuickItemView::resetPreferredHighlightBegin()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->highlightRangeStartValid = false;
if (d->highlightRangeStart == 0)
return;
emit preferredHighlightBeginChanged();
}
-qreal QSGItemView::preferredHighlightEnd() const
+qreal QQuickItemView::preferredHighlightEnd() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->highlightRangeEnd;
}
-void QSGItemView::setPreferredHighlightEnd(qreal end)
+void QQuickItemView::setPreferredHighlightEnd(qreal end)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->highlightRangeEndValid = true;
if (d->highlightRangeEnd == end)
return;
emit preferredHighlightEndChanged();
}
-void QSGItemView::resetPreferredHighlightEnd()
+void QQuickItemView::resetPreferredHighlightEnd()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->highlightRangeEndValid = false;
if (d->highlightRangeEnd == 0)
return;
emit preferredHighlightEndChanged();
}
-int QSGItemView::highlightMoveDuration() const
+int QQuickItemView::highlightMoveDuration() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
return d->highlightMoveDuration;
}
-void QSGItemView::setHighlightMoveDuration(int duration)
+void QQuickItemView::setHighlightMoveDuration(int duration)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->highlightMoveDuration != duration) {
d->highlightMoveDuration = duration;
emit highlightMoveDurationChanged();
}
}
-void QSGItemViewPrivate::positionViewAtIndex(int index, int mode)
+void QQuickItemViewPrivate::positionViewAtIndex(int index, int mode)
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (!isValid())
return;
- if (mode < QSGItemView::Beginning || mode > QSGItemView::Contain)
+ if (mode < QQuickItemView::Beginning || mode > QQuickItemView::Contain)
return;
applyPendingChanges();
if (item) {
const qreal itemPos = item->position();
switch (mode) {
- case QSGItemView::Beginning:
+ case QQuickItemView::Beginning:
pos = itemPos;
if (index < 0 && header)
pos -= headerSize();
break;
- case QSGItemView::Center:
+ case QQuickItemView::Center:
pos = itemPos - (size() - item->size())/2;
break;
- case QSGItemView::End:
+ case QQuickItemView::End:
pos = itemPos - size() + item->size();
if (index >= model->count() && footer)
pos += footerSize();
break;
- case QSGItemView::Visible:
+ case QQuickItemView::Visible:
if (itemPos > pos + size())
pos = itemPos - size() + item->size();
else if (item->endPosition() <= pos)
pos = itemPos;
break;
- case QSGItemView::Contain:
+ case QQuickItemView::Contain:
if (item->endPosition() >= pos + size())
pos = itemPos - size() + item->size();
if (itemPos < pos)
else
minExtent = isContentFlowReversed() ? q->maxXExtent()-size(): -q->minXExtent();
pos = qMax(pos, minExtent);
- moveReason = QSGItemViewPrivate::Other;
+ moveReason = QQuickItemViewPrivate::Other;
q->cancelFlick();
setPosition(pos);
fixupPosition();
}
-void QSGItemView::positionViewAtIndex(int index, int mode)
+void QQuickItemView::positionViewAtIndex(int index, int mode)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (!d->isValid() || index < 0 || index >= d->model->count())
return;
d->positionViewAtIndex(index, mode);
}
-void QSGItemView::positionViewAtBeginning()
+void QQuickItemView::positionViewAtBeginning()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (!d->isValid())
return;
d->positionViewAtIndex(-1, Beginning);
}
-void QSGItemView::positionViewAtEnd()
+void QQuickItemView::positionViewAtEnd()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (!d->isValid())
return;
d->positionViewAtIndex(d->model->count(), End);
}
-int QSGItemView::indexAt(qreal x, qreal y) const
+int QQuickItemView::indexAt(qreal x, qreal y) const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
for (int i = 0; i < d->visibleItems.count(); ++i) {
const FxViewItem *item = d->visibleItems.at(i);
if (item->contains(x, y))
return -1;
}
-void QSGItemViewPrivate::applyPendingChanges()
+void QQuickItemViewPrivate::applyPendingChanges()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (q->isComponentComplete() && currentChanges.hasPendingChanges())
layout();
}
// for debugging only
-void QSGItemViewPrivate::checkVisible() const
+void QQuickItemViewPrivate::checkVisible() const
{
int skip = 0;
for (int i = 0; i < visibleItems.count(); ++i) {
}
}
-void QSGItemViewPrivate::itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickItemViewPrivate::itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_Q(QSGItemView);
- QSGFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
+ Q_Q(QQuickItemView);
+ QQuickFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
if (!q->isComponentComplete())
return;
q->trackedPositionChanged();
}
-void QSGItemView::destroyRemoved()
+void QQuickItemView::destroyRemoved()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
for (QList<FxViewItem*>::Iterator it = d->visibleItems.begin();
it != d->visibleItems.end();) {
FxViewItem *item = *it;
d->layout();
}
-void QSGItemView::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickItemView::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (reset) {
- d->moveReason = QSGItemViewPrivate::SetIndex;
+ d->moveReason = QQuickItemViewPrivate::SetIndex;
d->regenerate();
if (d->highlight && d->currentItem) {
if (d->autoHighlight)
d->resetHighlightPosition();
d->updateTrackedItem();
}
- d->moveReason = QSGItemViewPrivate::Other;
+ d->moveReason = QQuickItemViewPrivate::Other;
emit countChanged();
} else {
}
}
-void QSGItemView::createdItem(int index, QSGItem *item)
+void QQuickItemView::createdItem(int index, QQuickItem *item)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->requestedIndex != index) {
item->setParentItem(contentItem());
d->unrequestedItems.insert(item, index);
}
}
-void QSGItemView::destroyingItem(QSGItem *item)
+void QQuickItemView::destroyingItem(QQuickItem *item)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->unrequestedItems.remove(item);
}
-void QSGItemView::animStopped()
+void QQuickItemView::animStopped()
{
- Q_D(QSGItemView);
- d->bufferMode = QSGItemViewPrivate::NoBuffer;
- if (d->haveHighlightRange && d->highlightRange == QSGItemView::StrictlyEnforceRange)
+ Q_D(QQuickItemView);
+ d->bufferMode = QQuickItemViewPrivate::NoBuffer;
+ if (d->haveHighlightRange && d->highlightRange == QQuickItemView::StrictlyEnforceRange)
d->updateHighlight();
}
-void QSGItemView::trackedPositionChanged()
+void QQuickItemView::trackedPositionChanged()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (!d->trackedItem || !d->currentItem)
return;
- if (d->moveReason == QSGItemViewPrivate::SetIndex) {
+ if (d->moveReason == QQuickItemViewPrivate::SetIndex) {
qreal trackedPos = d->trackedItem->position();
qreal trackedSize = d->trackedItem->size();
if (d->trackedItem != d->currentItem) {
}
}
-void QSGItemView::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickItemView::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
d->markExtentsDirty();
- QSGFlickable::geometryChanged(newGeometry, oldGeometry);
+ QQuickFlickable::geometryChanged(newGeometry, oldGeometry);
}
-qreal QSGItemView::minYExtent() const
+qreal QQuickItemView::minYExtent() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->layoutOrientation() == Qt::Horizontal)
- return QSGFlickable::minYExtent();
+ return QQuickFlickable::minYExtent();
if (d->vData.minExtentDirty) {
d->minExtent = d->vData.startMargin-d->startPosition();
return d->minExtent;
}
-qreal QSGItemView::maxYExtent() const
+qreal QQuickItemView::maxYExtent() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->layoutOrientation() == Qt::Horizontal)
return height();
return d->maxExtent;
}
-qreal QSGItemView::minXExtent() const
+qreal QQuickItemView::minXExtent() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->layoutOrientation() == Qt::Vertical)
- return QSGFlickable::minXExtent();
+ return QQuickFlickable::minXExtent();
if (d->hData.minExtentDirty) {
d->minExtent = -d->startPosition();
return d->minExtent;
}
-qreal QSGItemView::maxXExtent() const
+qreal QQuickItemView::maxXExtent() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->layoutOrientation() == Qt::Vertical)
return width();
return d->maxExtent;
}
-void QSGItemView::setContentX(qreal pos)
+void QQuickItemView::setContentX(qreal pos)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
// Positioning the view manually should override any current movement state
- d->moveReason = QSGItemViewPrivate::Other;
- QSGFlickable::setContentX(pos);
+ d->moveReason = QQuickItemViewPrivate::Other;
+ QQuickFlickable::setContentX(pos);
}
-void QSGItemView::setContentY(qreal pos)
+void QQuickItemView::setContentY(qreal pos)
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
// Positioning the view manually should override any current movement state
- d->moveReason = QSGItemViewPrivate::Other;
- QSGFlickable::setContentY(pos);
+ d->moveReason = QQuickItemViewPrivate::Other;
+ QQuickFlickable::setContentY(pos);
}
-qreal QSGItemView::xOrigin() const
+qreal QQuickItemView::xOrigin() const
{
- Q_D(const QSGItemView);
+ Q_D(const QQuickItemView);
if (d->isContentFlowReversed())
return -maxXExtent() + d->size() - d->hData.startMargin;
else
return -minXExtent() + d->hData.startMargin;
}
-void QSGItemView::updatePolish()
+void QQuickItemView::updatePolish()
{
- Q_D(QSGItemView);
- QSGFlickable::updatePolish();
+ Q_D(QQuickItemView);
+ QQuickFlickable::updatePolish();
d->layout();
}
-void QSGItemView::componentComplete()
+void QQuickItemView::componentComplete()
{
- Q_D(QSGItemView);
+ Q_D(QQuickItemView);
if (d->model && d->ownModel)
- static_cast<QSGVisualDataModel *>(d->model.data())->componentComplete();
+ static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
- QSGFlickable::componentComplete();
+ QQuickFlickable::componentComplete();
updateSections();
d->updateHeader();
d->setPosition(d->contentStartPosition());
if (d->isValid()) {
d->refill();
- d->moveReason = QSGItemViewPrivate::SetIndex;
+ d->moveReason = QQuickItemViewPrivate::SetIndex;
if (d->currentIndex < 0 && !d->currentIndexCleared)
d->updateCurrent(0);
else
d->resetHighlightPosition();
d->updateTrackedItem();
}
- d->moveReason = QSGItemViewPrivate::Other;
+ d->moveReason = QQuickItemViewPrivate::Other;
d->fixupPosition();
}
if (d->model && d->model->count())
-QSGItemViewPrivate::QSGItemViewPrivate()
+QQuickItemViewPrivate::QQuickItemViewPrivate()
: itemCount(0)
, buffer(0), bufferMode(BufferBefore | BufferAfter)
, layoutDirection(Qt::LeftToRight)
, currentIndex(-1), currentItem(0)
, trackedItem(0), requestedIndex(-1)
, highlightComponent(0), highlight(0)
- , highlightRange(QSGItemView::NoHighlightRange)
+ , highlightRange(QQuickItemView::NoHighlightRange)
, highlightRangeStart(0), highlightRangeEnd(0)
, highlightMoveDuration(150)
, headerComponent(0), header(0), footerComponent(0), footer(0)
{
}
-bool QSGItemViewPrivate::isValid() const
+bool QQuickItemViewPrivate::isValid() const
{
return model && model->count() && model->isValid();
}
-qreal QSGItemViewPrivate::position() const
+qreal QQuickItemViewPrivate::position() const
{
- Q_Q(const QSGItemView);
+ Q_Q(const QQuickItemView);
return layoutOrientation() == Qt::Vertical ? q->contentY() : q->contentX();
}
-qreal QSGItemViewPrivate::size() const
+qreal QQuickItemViewPrivate::size() const
{
- Q_Q(const QSGItemView);
+ Q_Q(const QQuickItemView);
return layoutOrientation() == Qt::Vertical ? q->height() : q->width();
}
-qreal QSGItemViewPrivate::startPosition() const
+qreal QQuickItemViewPrivate::startPosition() const
{
return isContentFlowReversed() ? -lastPosition() : originPosition();
}
-qreal QSGItemViewPrivate::endPosition() const
+qreal QQuickItemViewPrivate::endPosition() const
{
return isContentFlowReversed() ? -originPosition() : lastPosition();
}
-qreal QSGItemViewPrivate::contentStartPosition() const
+qreal QQuickItemViewPrivate::contentStartPosition() const
{
- Q_Q(const QSGItemView);
+ Q_Q(const QQuickItemView);
qreal pos = -headerSize();
if (layoutOrientation() == Qt::Vertical)
pos -= vData.startMargin;
return pos;
}
-int QSGItemViewPrivate::findLastVisibleIndex(int defaultValue) const
+int QQuickItemViewPrivate::findLastVisibleIndex(int defaultValue) const
{
if (visibleItems.count()) {
int i = visibleItems.count() - 1;
return defaultValue;
}
-FxViewItem *QSGItemViewPrivate::visibleItem(int modelIndex) const {
+FxViewItem *QQuickItemViewPrivate::visibleItem(int modelIndex) const {
if (modelIndex >= visibleIndex && modelIndex < visibleIndex + visibleItems.count()) {
for (int i = modelIndex - visibleIndex; i < visibleItems.count(); ++i) {
FxViewItem *item = visibleItems.at(i);
return 0;
}
-FxViewItem *QSGItemViewPrivate::firstVisibleItem() const {
+FxViewItem *QQuickItemViewPrivate::firstVisibleItem() const {
const qreal pos = isContentFlowReversed() ? -position()-size() : position();
for (int i = 0; i < visibleItems.count(); ++i) {
FxViewItem *item = visibleItems.at(i);
// Map a model index to visibleItems list index.
// These may differ if removed items are still present in the visible list,
// e.g. doing a removal animation
-int QSGItemViewPrivate::mapFromModel(int modelIndex) const
+int QQuickItemViewPrivate::mapFromModel(int modelIndex) const
{
if (modelIndex < visibleIndex || modelIndex >= visibleIndex + visibleItems.count())
return -1;
return -1; // Not in visibleList
}
-void QSGItemViewPrivate::init()
+void QQuickItemViewPrivate::init()
{
- Q_Q(QSGItemView);
- QSGItemPrivate::get(contentItem)->childrenDoNotOverlap = true;
- q->setFlag(QSGItem::ItemIsFocusScope);
+ Q_Q(QQuickItemView);
+ QQuickItemPrivate::get(contentItem)->childrenDoNotOverlap = true;
+ q->setFlag(QQuickItem::ItemIsFocusScope);
addItemChangeListener(this, Geometry);
QObject::connect(q, SIGNAL(movementEnded()), q, SLOT(animStopped()));
- q->setFlickableDirection(QSGFlickable::VerticalFlick);
+ q->setFlickableDirection(QQuickFlickable::VerticalFlick);
}
-void QSGItemViewPrivate::updateCurrent(int modelIndex)
+void QQuickItemViewPrivate::updateCurrent(int modelIndex)
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
applyPendingChanges();
if (!q->isComponentComplete() || !isValid() || modelIndex < 0 || modelIndex >= model->count()) {
releaseItem(oldCurrentItem);
}
-void QSGItemViewPrivate::clear()
+void QQuickItemViewPrivate::clear()
{
currentChanges.reset();
timeline.clear();
}
-void QSGItemViewPrivate::mirrorChange()
+void QQuickItemViewPrivate::mirrorChange()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
regenerate();
emit q->effectiveLayoutDirectionChanged();
}
-void QSGItemViewPrivate::refill()
+void QQuickItemViewPrivate::refill()
{
if (isContentFlowReversed())
refill(-position()-size(), -position());
refill(position(), position()+size());
}
-void QSGItemViewPrivate::refill(qreal from, qreal to, bool doBuffer)
+void QQuickItemViewPrivate::refill(qreal from, qreal to, bool doBuffer)
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (!isValid() || !q->isComponentComplete())
return;
emit q->countChanged();
}
-void QSGItemViewPrivate::regenerate()
+void QQuickItemViewPrivate::regenerate()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (q->isComponentComplete()) {
currentChanges.reset();
delete header;
}
}
-void QSGItemViewPrivate::updateViewport()
+void QQuickItemViewPrivate::updateViewport()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (isValid()) {
if (layoutOrientation() == Qt::Vertical)
q->setContentHeight(endPosition() - startPosition());
}
}
-void QSGItemViewPrivate::layout()
+void QQuickItemViewPrivate::layout()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (inApplyModelChanges)
return;
updateUnrequestedPositions();
}
-bool QSGItemViewPrivate::applyModelChanges()
+bool QQuickItemViewPrivate::applyModelChanges()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (!q->isComponentComplete() || !currentChanges.hasPendingChanges() || inApplyModelChanges)
return false;
inApplyModelChanges = true;
updateUnrequestedIndexes();
- moveReason = QSGItemViewPrivate::Other;
+ moveReason = QQuickItemViewPrivate::Other;
int prevCount = itemCount;
bool removedVisible = false;
return visibleAffected;
}
-FxViewItem *QSGItemViewPrivate::createItem(int modelIndex)
+FxViewItem *QQuickItemViewPrivate::createItem(int modelIndex)
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
requestedIndex = modelIndex;
FxViewItem *viewItem = 0;
- if (QSGItem *item = model->item(modelIndex, false)) {
+ if (QQuickItem *item = model->item(modelIndex, false)) {
viewItem = newViewItem(modelIndex, item);
if (viewItem) {
viewItem->index = modelIndex;
}
-void QSGItemViewPrivate::releaseItem(FxViewItem *item)
+void QQuickItemViewPrivate::releaseItem(FxViewItem *item)
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
if (!item || !model)
return;
if (trackedItem == item)
trackedItem = 0;
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item->item);
- itemPrivate->removeItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item->item);
+ itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
if (model->release(item->item) == 0) {
// item was not destroyed, and we no longer reference it.
unrequestedItems.insert(item->item, model->indexOf(item->item, q));
delete item;
}
-QSGItem *QSGItemViewPrivate::createHighlightItem()
+QQuickItem *QQuickItemViewPrivate::createHighlightItem()
{
return createComponentItem(highlightComponent, true, true);
}
-QSGItem *QSGItemViewPrivate::createComponentItem(QDeclarativeComponent *component, bool receiveItemGeometryChanges, bool createDefault)
+QQuickItem *QQuickItemViewPrivate::createComponentItem(QDeclarativeComponent *component, bool receiveItemGeometryChanges, bool createDefault)
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
- QSGItem *item = 0;
+ QQuickItem *item = 0;
if (component) {
QDeclarativeContext *creationContext = component->creationContext();
QDeclarativeContext *context = new QDeclarativeContext(
QObject *nobj = component->create(context);
if (nobj) {
QDeclarative_setParent_noEvent(context, nobj);
- item = qobject_cast<QSGItem *>(nobj);
+ item = qobject_cast<QQuickItem *>(nobj);
if (!item)
delete nobj;
} else {
delete context;
}
} else if (createDefault) {
- item = new QSGItem;
+ item = new QQuickItem;
}
if (item) {
QDeclarative_setParent_noEvent(item, q->contentItem());
item->setParentItem(q->contentItem());
if (receiveItemGeometryChanges) {
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
- itemPrivate->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
+ itemPrivate->addItemChangeListener(this, QQuickItemPrivate::Geometry);
}
}
return item;
}
-void QSGItemViewPrivate::updateTrackedItem()
+void QQuickItemViewPrivate::updateTrackedItem()
{
- Q_Q(QSGItemView);
+ Q_Q(QQuickItemView);
FxViewItem *item = currentItem;
if (highlight)
item = highlight;
q->trackedPositionChanged();
}
-void QSGItemViewPrivate::updateUnrequestedIndexes()
+void QQuickItemViewPrivate::updateUnrequestedIndexes()
{
- Q_Q(QSGItemView);
- for (QHash<QSGItem*,int>::iterator it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it)
+ Q_Q(QQuickItemView);
+ for (QHash<QQuickItem*,int>::iterator it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it)
*it = model->indexOf(it.key(), q);
}
-void QSGItemViewPrivate::updateUnrequestedPositions()
+void QQuickItemViewPrivate::updateUnrequestedPositions()
{
- for (QHash<QSGItem*,int>::const_iterator it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it)
+ for (QHash<QQuickItem*,int>::const_iterator it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it)
repositionPackageItemAt(it.key(), it.value());
}
-void QSGItemViewPrivate::updateVisibleIndex()
+void QQuickItemViewPrivate::updateVisibleIndex()
{
visibleIndex = 0;
for (QList<FxViewItem*>::Iterator it = visibleItems.begin(); it != visibleItems.end(); ++it) {
**
****************************************************************************/
-#ifndef QSGITEMVIEW_P_H
-#define QSGITEMVIEW_P_H
+#ifndef QQUICKITEMVIEW_P_H
+#define QQUICKITEMVIEW_P_H
-#include "qsgflickable_p.h"
+#include "qquickflickable_p.h"
QT_BEGIN_HEADER
class QDeclarativeChangeSet;
-class QSGItemViewPrivate;
+class QQuickItemViewPrivate;
-class Q_AUTOTEST_EXPORT QSGItemView : public QSGFlickable
+class Q_AUTOTEST_EXPORT QQuickItemView : public QQuickFlickable
{
Q_OBJECT
Q_PROPERTY(int count READ count NOTIFY countChanged)
Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
- Q_PROPERTY(QSGItem *currentItem READ currentItem NOTIFY currentIndexChanged)
+ Q_PROPERTY(QQuickItem *currentItem READ currentItem NOTIFY currentIndexChanged)
Q_PROPERTY(bool keyNavigationWraps READ isWrapEnabled WRITE setWrapEnabled NOTIFY keyNavigationWrapsChanged)
Q_PROPERTY(int cacheBuffer READ cacheBuffer WRITE setCacheBuffer NOTIFY cacheBufferChanged)
Q_PROPERTY(Qt::LayoutDirection effectiveLayoutDirection READ effectiveLayoutDirection NOTIFY effectiveLayoutDirectionChanged)
Q_PROPERTY(QDeclarativeComponent *header READ header WRITE setHeader NOTIFY headerChanged)
- Q_PROPERTY(QSGItem *headerItem READ headerItem NOTIFY headerItemChanged)
+ Q_PROPERTY(QQuickItem *headerItem READ headerItem NOTIFY headerItemChanged)
Q_PROPERTY(QDeclarativeComponent *footer READ footer WRITE setFooter NOTIFY footerChanged)
- Q_PROPERTY(QSGItem *footerItem READ footerItem NOTIFY footerItemChanged)
+ Q_PROPERTY(QQuickItem *footerItem READ footerItem NOTIFY footerItemChanged)
Q_PROPERTY(QDeclarativeComponent *highlight READ highlight WRITE setHighlight NOTIFY highlightChanged)
- Q_PROPERTY(QSGItem *highlightItem READ highlightItem NOTIFY highlightItemChanged)
+ Q_PROPERTY(QQuickItem *highlightItem READ highlightItem NOTIFY highlightItemChanged)
Q_PROPERTY(bool highlightFollowsCurrentItem READ highlightFollowsCurrentItem WRITE setHighlightFollowsCurrentItem NOTIFY highlightFollowsCurrentItemChanged)
Q_PROPERTY(HighlightRangeMode highlightRangeMode READ highlightRangeMode WRITE setHighlightRangeMode NOTIFY highlightRangeModeChanged)
Q_PROPERTY(qreal preferredHighlightBegin READ preferredHighlightBegin WRITE setPreferredHighlightBegin NOTIFY preferredHighlightBeginChanged RESET resetPreferredHighlightBegin)
Q_ENUMS(PositionMode)
public:
- QSGItemView(QSGFlickablePrivate &dd, QSGItem *parent = 0);
- ~QSGItemView();
+ QQuickItemView(QQuickFlickablePrivate &dd, QQuickItem *parent = 0);
+ ~QQuickItemView();
QVariant model() const;
void setModel(const QVariant &);
int currentIndex() const;
void setCurrentIndex(int idx);
- QSGItem *currentItem() const;
+ QQuickItem *currentItem() const;
bool isWrapEnabled() const;
void setWrapEnabled(bool);
QDeclarativeComponent *footer() const;
void setFooter(QDeclarativeComponent *);
- QSGItem *footerItem() const;
+ QQuickItem *footerItem() const;
QDeclarativeComponent *header() const;
void setHeader(QDeclarativeComponent *);
- QSGItem *headerItem() const;
+ QQuickItem *headerItem() const;
QDeclarativeComponent *highlight() const;
void setHighlight(QDeclarativeComponent *);
- QSGItem *highlightItem() const;
+ QQuickItem *highlightItem() const;
bool highlightFollowsCurrentItem() const;
virtual void setHighlightFollowsCurrentItem(bool);
protected slots:
virtual void updateSections() {}
void destroyRemoved();
- void createdItem(int index, QSGItem *item);
+ void createdItem(int index, QQuickItem *item);
void modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
- void destroyingItem(QSGItem *item);
+ void destroyingItem(QQuickItem *item);
void animStopped();
void trackedPositionChanged();
private:
- Q_DECLARE_PRIVATE(QSGItemView)
+ Q_DECLARE_PRIVATE(QQuickItemView)
};
-class Q_AUTOTEST_EXPORT QSGItemViewAttached : public QObject
+class Q_AUTOTEST_EXPORT QQuickItemViewAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(QString nextSection READ nextSection NOTIFY nextSectionChanged)
public:
- QSGItemViewAttached(QObject *parent)
+ QQuickItemViewAttached(QObject *parent)
: QObject(parent), m_isCurrent(false), m_delayRemove(false) {}
- ~QSGItemViewAttached() {}
+ ~QQuickItemViewAttached() {}
bool isCurrentItem() const { return m_isCurrent; }
void setIsCurrentItem(bool c) {
QT_END_NAMESPACE
QT_END_HEADER
-#endif // QSGITEMVIEW_P_H
+#endif // QQUICKITEMVIEW_P_H
**
****************************************************************************/
-#ifndef QSGITEMVIEW_P_P_H
-#define QSGITEMVIEW_P_P_H
+#ifndef QQUICKITEMVIEW_P_P_H
+#define QQUICKITEMVIEW_P_P_H
-#include "qsgitemview_p.h"
-#include "qsgflickable_p_p.h"
-#include "qsgvisualdatamodel_p.h"
+#include "qquickitemview_p.h"
+#include "qquickflickable_p_p.h"
+#include "qquickvisualdatamodel_p.h"
#include <private/qdeclarativechangeset_p.h>
class FxViewItem
{
public:
- FxViewItem(QSGItem *, bool own);
+ FxViewItem(QQuickItem *, bool own);
~FxViewItem();
// these are positions and sizes along the current direction of scrolling/flicking
virtual bool contains(qreal x, qreal y) const = 0;
- QSGItem *item;
+ QQuickItem *item;
bool ownItem;
int index;
- QSGItemViewAttached *attached;
+ QQuickItemViewAttached *attached;
};
-class QSGItemViewChangeSet
+class QQuickItemViewChangeSet
{
public:
- QSGItemViewChangeSet();
+ QQuickItemViewChangeSet();
bool hasPendingChanges() const;
void prepare(int currentIndex, int count);
bool currentRemoved : 1;
};
-class QSGItemViewPrivate : public QSGFlickablePrivate
+class QQuickItemViewPrivate : public QQuickFlickablePrivate
{
- Q_DECLARE_PUBLIC(QSGItemView)
+ Q_DECLARE_PUBLIC(QQuickItemView)
public:
- QSGItemViewPrivate();
+ QQuickItemViewPrivate();
struct InsertionsResult {
QList<FxViewItem *> addedItems;
FxViewItem *createItem(int modelIndex);
virtual void releaseItem(FxViewItem *item);
- QSGItem *createHighlightItem();
- QSGItem *createComponentItem(QDeclarativeComponent *component, bool receiveItemGeometryChanges, bool createDefault = false);
+ QQuickItem *createHighlightItem();
+ QQuickItem *createComponentItem(QDeclarativeComponent *component, bool receiveItemGeometryChanges, bool createDefault = false);
void updateCurrent(int modelIndex);
void updateTrackedItem();
hData.markExtentsDirty();
}
- QDeclarativeGuard<QSGVisualModel> model;
+ QDeclarativeGuard<QQuickVisualModel> model;
QVariant modelVariant;
int itemCount;
int buffer;
int currentIndex;
FxViewItem *currentItem;
FxViewItem *trackedItem;
- QHash<QSGItem*,int> unrequestedItems;
+ QHash<QQuickItem*,int> unrequestedItems;
int requestedIndex;
- QSGItemViewChangeSet currentChanges;
+ QQuickItemViewChangeSet currentChanges;
// XXX split into struct
QDeclarativeComponent *highlightComponent;
virtual bool removeNonVisibleItems(qreal bufferFrom, qreal bufferTo) = 0;
virtual void visibleItemsChanged() = 0;
- virtual FxViewItem *newViewItem(int index, QSGItem *item) = 0;
- virtual void repositionPackageItemAt(QSGItem *item, int index) = 0;
+ virtual FxViewItem *newViewItem(int index, QQuickItem *item) = 0;
+ virtual void repositionPackageItemAt(QQuickItem *item, int index) = 0;
virtual void resetItemPosition(FxViewItem *item, FxViewItem *toItem) = 0;
virtual void resetFirstItemPosition() = 0;
virtual void moveItemBy(FxViewItem *item, qreal forwards, qreal backwards) = 0;
virtual void initializeCurrentItem() {}
virtual void updateSections() {}
- virtual void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+ virtual void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
};
QT_END_HEADER
-#endif // QSGITEMVIEW_P_P_H
+#endif // QQUICKITEMVIEW_P_P_H
**
****************************************************************************/
-#include "qsglistview_p.h"
-#include "qsgitemview_p_p.h"
-#include "qsgvisualitemmodel_p.h"
+#include "qquicklistview_p.h"
+#include "qquickitemview_p_p.h"
+#include "qquickvisualitemmodel_p.h"
#include <QtDeclarative/qdeclarativeexpression.h>
#include <QtDeclarative/qdeclarativeengine.h>
class FxListItemSG;
-class QSGListViewPrivate : public QSGItemViewPrivate
+class QQuickListViewPrivate : public QQuickItemViewPrivate
{
- Q_DECLARE_PUBLIC(QSGListView)
+ Q_DECLARE_PUBLIC(QQuickListView)
public:
- static QSGListViewPrivate* get(QSGListView *item) { return item->d_func(); }
+ static QQuickListViewPrivate* get(QQuickListView *item) { return item->d_func(); }
virtual Qt::Orientation layoutOrientation() const;
virtual bool isContentFlowReversed() const;
virtual bool removeNonVisibleItems(qreal bufferFrom, qreal bufferTo);
virtual void visibleItemsChanged();
- virtual FxViewItem *newViewItem(int index, QSGItem *item);
+ virtual FxViewItem *newViewItem(int index, QQuickItem *item);
virtual void initializeViewItem(FxViewItem *item);
virtual void releaseItem(FxViewItem *item);
- virtual void repositionPackageItemAt(QSGItem *item, int index);
+ virtual void repositionPackageItemAt(QQuickItem *item, int index);
virtual void resetItemPosition(FxViewItem *item, FxViewItem *toItem);
virtual void resetFirstItemPosition();
virtual void moveItemBy(FxViewItem *item, qreal forwards, qreal backwards);
bool applyInsertionChange(const QDeclarativeChangeSet::Insert &, FxViewItem *firstVisible, InsertionsResult *);
virtual void updateSections();
- QSGItem *getSectionItem(const QString §ion);
- void releaseSectionItem(QSGItem *item);
+ QQuickItem *getSectionItem(const QString §ion);
+ void releaseSectionItem(QQuickItem *item);
void updateInlineSection(FxListItemSG *);
void updateCurrentSection();
void updateStickySections();
void updateAverage();
- void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+ void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
virtual void fixupPosition();
virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);
- virtual void flick(QSGItemViewPrivate::AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+ virtual void flick(QQuickItemViewPrivate::AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity);
- QSGListView::Orientation orient;
+ QQuickListView::Orientation orient;
qreal visiblePos;
qreal averageSize;
qreal spacing;
- QSGListView::SnapMode snapMode;
+ QQuickListView::SnapMode snapMode;
QSmoothedAnimation *highlightPosAnimator;
QSmoothedAnimation *highlightSizeAnimator;
qreal highlightResizeSpeed;
int highlightResizeDuration;
- QSGViewSection *sectionCriteria;
+ QQuickViewSection *sectionCriteria;
QString currentSection;
static const int sectionCacheSize = 5;
- QSGItem *sectionCache[sectionCacheSize];
- QSGItem *currentSectionItem;
+ QQuickItem *sectionCache[sectionCacheSize];
+ QQuickItem *currentSectionItem;
QString currentStickySection;
- QSGItem *nextSectionItem;
+ QQuickItem *nextSectionItem;
QString nextStickySection;
QString lastVisibleSection;
QString nextSection;
bool correctFlick : 1;
bool inFlickCorrection : 1;
- QSGListViewPrivate()
- : orient(QSGListView::Vertical)
+ QQuickListViewPrivate()
+ : orient(QQuickListView::Vertical)
, visiblePos(0)
, averageSize(100.0), spacing(0.0)
- , snapMode(QSGListView::NoSnap)
+ , snapMode(QQuickListView::NoSnap)
, highlightPosAnimator(0), highlightSizeAnimator(0)
, highlightMoveSpeed(400), highlightResizeSpeed(400), highlightResizeDuration(-1)
, sectionCriteria(0), currentSectionItem(0), nextSectionItem(0)
, overshootDist(0.0), correctFlick(false), inFlickCorrection(false)
{}
- friend class QSGViewSection;
+ friend class QQuickViewSection;
};
//----------------------------------------------------------------------------
-QSGViewSection::QSGViewSection(QSGListView *parent)
+QQuickViewSection::QQuickViewSection(QQuickListView *parent)
: QObject(parent), m_criteria(FullString), m_delegate(0), m_labelPositioning(InlineLabels)
- , m_view(parent ? QSGListViewPrivate::get(parent) : 0)
+ , m_view(parent ? QQuickListViewPrivate::get(parent) : 0)
{
}
-void QSGViewSection::setProperty(const QString &property)
+void QQuickViewSection::setProperty(const QString &property)
{
if (property != m_property) {
m_property = property;
}
}
-void QSGViewSection::setCriteria(QSGViewSection::SectionCriteria criteria)
+void QQuickViewSection::setCriteria(QQuickViewSection::SectionCriteria criteria)
{
if (criteria != m_criteria) {
m_criteria = criteria;
}
}
-void QSGViewSection::setDelegate(QDeclarativeComponent *delegate)
+void QQuickViewSection::setDelegate(QDeclarativeComponent *delegate)
{
if (delegate != m_delegate) {
m_delegate = delegate;
}
}
-QString QSGViewSection::sectionString(const QString &value)
+QString QQuickViewSection::sectionString(const QString &value)
{
if (m_criteria == FirstCharacter)
return value.isEmpty() ? QString() : value.at(0);
return value;
}
-void QSGViewSection::setLabelPositioning(int l)
+void QQuickViewSection::setLabelPositioning(int l)
{
if (m_labelPositioning != l) {
m_labelPositioning = l;
class FxListItemSG : public FxViewItem
{
public:
- FxListItemSG(QSGItem *i, QSGListView *v, bool own) : FxViewItem(i, own), section(0), view(v) {
- attached = static_cast<QSGListViewAttached*>(qmlAttachedPropertiesObject<QSGListView>(item));
+ FxListItemSG(QQuickItem *i, QQuickListView *v, bool own) : FxViewItem(i, own), section(0), view(v) {
+ attached = static_cast<QQuickListViewAttached*>(qmlAttachedPropertiesObject<QQuickListView>(item));
if (attached)
- static_cast<QSGListViewAttached*>(attached)->setView(view);
+ static_cast<QQuickListViewAttached*>(attached)->setView(view);
}
~FxListItemSG() {}
qreal position() const {
if (section) {
- if (view->orientation() == QSGListView::Vertical)
+ if (view->orientation() == QQuickListView::Vertical)
return section->y();
else
return (view->effectiveLayoutDirection() == Qt::RightToLeft ? -section->width()-section->x() : section->x());
}
}
qreal itemPosition() const {
- if (view->orientation() == QSGListView::Vertical)
+ if (view->orientation() == QQuickListView::Vertical)
return item->y();
else
return (view->effectiveLayoutDirection() == Qt::RightToLeft ? -item->width()-item->x() : item->x());
}
qreal size() const {
if (section)
- return (view->orientation() == QSGListView::Vertical ? item->height()+section->height() : item->width()+section->width());
+ return (view->orientation() == QQuickListView::Vertical ? item->height()+section->height() : item->width()+section->width());
else
- return (view->orientation() == QSGListView::Vertical ? item->height() : item->width());
+ return (view->orientation() == QQuickListView::Vertical ? item->height() : item->width());
}
qreal itemSize() const {
- return (view->orientation() == QSGListView::Vertical ? item->height() : item->width());
+ return (view->orientation() == QQuickListView::Vertical ? item->height() : item->width());
}
qreal sectionSize() const {
if (section)
- return (view->orientation() == QSGListView::Vertical ? section->height() : section->width());
+ return (view->orientation() == QQuickListView::Vertical ? section->height() : section->width());
return 0.0;
}
qreal endPosition() const {
- if (view->orientation() == QSGListView::Vertical) {
+ if (view->orientation() == QQuickListView::Vertical) {
return item->y() + item->height();
} else {
return (view->effectiveLayoutDirection() == Qt::RightToLeft
}
}
void setPosition(qreal pos) {
- if (view->orientation() == QSGListView::Vertical) {
+ if (view->orientation() == QQuickListView::Vertical) {
if (section) {
section->setY(pos);
pos += section->height();
}
}
void setSize(qreal size) {
- if (view->orientation() == QSGListView::Vertical)
+ if (view->orientation() == QQuickListView::Vertical)
item->setHeight(size);
else
item->setWidth(size);
y >= item->y() && y < item->y() + item->height());
}
- QSGItem *section;
- QSGListView *view;
+ QQuickItem *section;
+ QQuickListView *view;
};
//----------------------------------------------------------------------------
-bool QSGListViewPrivate::isContentFlowReversed() const
+bool QQuickListViewPrivate::isContentFlowReversed() const
{
return isRightToLeft();
}
-Qt::Orientation QSGListViewPrivate::layoutOrientation() const
+Qt::Orientation QQuickListViewPrivate::layoutOrientation() const
{
return static_cast<Qt::Orientation>(orient);
}
-bool QSGListViewPrivate::isRightToLeft() const
+bool QQuickListViewPrivate::isRightToLeft() const
{
- Q_Q(const QSGListView);
- return orient == QSGListView::Horizontal && q->effectiveLayoutDirection() == Qt::RightToLeft;
+ Q_Q(const QQuickListView);
+ return orient == QQuickListView::Horizontal && q->effectiveLayoutDirection() == Qt::RightToLeft;
}
// Returns the item before modelIndex, if created.
// May return an item marked for removal.
-FxViewItem *QSGListViewPrivate::itemBefore(int modelIndex) const
+FxViewItem *QQuickListViewPrivate::itemBefore(int modelIndex) const
{
if (modelIndex < visibleIndex)
return 0;
return 0;
}
-void QSGListViewPrivate::setPosition(qreal pos)
+void QQuickListViewPrivate::setPosition(qreal pos)
{
- Q_Q(QSGListView);
- if (orient == QSGListView::Vertical) {
- q->QSGFlickable::setContentY(pos);
+ Q_Q(QQuickListView);
+ if (orient == QQuickListView::Vertical) {
+ q->QQuickFlickable::setContentY(pos);
} else {
if (isRightToLeft())
- q->QSGFlickable::setContentX(-pos-size());
+ q->QQuickFlickable::setContentX(-pos-size());
else
- q->QSGFlickable::setContentX(pos);
+ q->QQuickFlickable::setContentX(pos);
}
}
-qreal QSGListViewPrivate::originPosition() const
+qreal QQuickListViewPrivate::originPosition() const
{
qreal pos = 0;
if (!visibleItems.isEmpty()) {
return pos;
}
-qreal QSGListViewPrivate::lastPosition() const
+qreal QQuickListViewPrivate::lastPosition() const
{
qreal pos = 0;
if (!visibleItems.isEmpty()) {
return pos;
}
-qreal QSGListViewPrivate::positionAt(int modelIndex) const
+qreal QQuickListViewPrivate::positionAt(int modelIndex) const
{
if (FxViewItem *item = visibleItem(modelIndex))
return item->position();
return 0;
}
-qreal QSGListViewPrivate::endPositionAt(int modelIndex) const
+qreal QQuickListViewPrivate::endPositionAt(int modelIndex) const
{
if (FxViewItem *item = visibleItem(modelIndex))
return item->endPosition();
return 0;
}
-QString QSGListViewPrivate::sectionAt(int modelIndex)
+QString QQuickListViewPrivate::sectionAt(int modelIndex)
{
if (FxViewItem *item = visibleItem(modelIndex))
return item->attached->section();
return section;
}
-qreal QSGListViewPrivate::snapPosAt(qreal pos)
+qreal QQuickListViewPrivate::snapPosAt(qreal pos)
{
if (FxViewItem *snapItem = snapItemAt(pos))
return snapItem->position();
return qRound((pos - originPosition()) / averageSize) * averageSize + originPosition();
}
-FxViewItem *QSGListViewPrivate::snapItemAt(qreal pos)
+FxViewItem *QQuickListViewPrivate::snapItemAt(qreal pos)
{
FxViewItem *snapItem = 0;
qreal prevItemSize = 0;
return snapItem;
}
-void QSGListViewPrivate::changedVisibleIndex(int newIndex)
+void QQuickListViewPrivate::changedVisibleIndex(int newIndex)
{
visiblePos = positionAt(newIndex);
visibleIndex = newIndex;
}
-void QSGListViewPrivate::init()
+void QQuickListViewPrivate::init()
{
- QSGItemViewPrivate::init();
- ::memset(sectionCache, 0, sizeof(QSGItem*) * sectionCacheSize);
+ QQuickItemViewPrivate::init();
+ ::memset(sectionCache, 0, sizeof(QQuickItem*) * sectionCacheSize);
}
-void QSGListViewPrivate::clear()
+void QQuickListViewPrivate::clear()
{
for (int i = 0; i < sectionCacheSize; ++i) {
delete sectionCache[i];
currentSectionItem = 0;
nextSectionItem = 0;
lastVisibleSection = QString();
- QSGItemViewPrivate::clear();
+ QQuickItemViewPrivate::clear();
}
-FxViewItem *QSGListViewPrivate::newViewItem(int modelIndex, QSGItem *item)
+FxViewItem *QQuickListViewPrivate::newViewItem(int modelIndex, QQuickItem *item)
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
FxListItemSG *listItem = new FxListItemSG(item, q, false);
listItem->index = modelIndex;
}
if (modelIndex < model->count()-1) {
if (FxViewItem *item = visibleItem(modelIndex+1))
- listItem->attached->m_nextSection = static_cast<QSGListViewAttached*>(item->attached)->section();
+ listItem->attached->m_nextSection = static_cast<QQuickListViewAttached*>(item->attached)->section();
else
listItem->attached->m_nextSection = sectionAt(modelIndex+1);
}
return listItem;
}
-void QSGListViewPrivate::initializeViewItem(FxViewItem *item)
+void QQuickListViewPrivate::initializeViewItem(FxViewItem *item)
{
- QSGItemViewPrivate::initializeViewItem(item);
+ QQuickItemViewPrivate::initializeViewItem(item);
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item->item);
- itemPrivate->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item->item);
+ itemPrivate->addItemChangeListener(this, QQuickItemPrivate::Geometry);
if (sectionCriteria && sectionCriteria->delegate()) {
if (item->attached->m_prevSection != item->attached->m_section)
}
}
-void QSGListViewPrivate::releaseItem(FxViewItem *item)
+void QQuickListViewPrivate::releaseItem(FxViewItem *item)
{
if (item) {
FxListItemSG* listItem = static_cast<FxListItemSG*>(item);
delete listItem->section;
}
}
- QSGItemViewPrivate::releaseItem(item);
+ QQuickItemViewPrivate::releaseItem(item);
}
-bool QSGListViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool doBuffer)
+bool QQuickListViewPrivate::addVisibleItems(qreal fillFrom, qreal fillTo, bool doBuffer)
{
qreal itemEnd = visiblePos;
if (visibleItems.count()) {
return changed;
}
-bool QSGListViewPrivate::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
+bool QQuickListViewPrivate::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
{
FxViewItem *item = 0;
bool changed = false;
return changed;
}
-void QSGListViewPrivate::visibleItemsChanged()
+void QQuickListViewPrivate::visibleItemsChanged()
{
if (visibleItems.count())
visiblePos = (*visibleItems.constBegin())->position();
updateUnrequestedPositions();
}
-void QSGListViewPrivate::layoutVisibleItems()
+void QQuickListViewPrivate::layoutVisibleItems()
{
if (!visibleItems.isEmpty()) {
bool fixedCurrent = currentItem && (*visibleItems.constBegin())->item == currentItem->item;
}
}
-void QSGListViewPrivate::repositionPackageItemAt(QSGItem *item, int index)
+void QQuickListViewPrivate::repositionPackageItemAt(QQuickItem *item, int index)
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
qreal pos = position();
- if (orient == QSGListView::Vertical) {
+ if (orient == QQuickListView::Vertical) {
if (item->y() + item->height() > pos && item->y() < pos + q->height())
item->setY(positionAt(index));
} else {
}
}
-void QSGListViewPrivate::resetItemPosition(FxViewItem *item, FxViewItem *toItem)
+void QQuickListViewPrivate::resetItemPosition(FxViewItem *item, FxViewItem *toItem)
{
if (item == toItem)
return;
static_cast<FxListItemSG*>(item)->setPosition(toItem->position());
}
-void QSGListViewPrivate::resetFirstItemPosition()
+void QQuickListViewPrivate::resetFirstItemPosition()
{
FxListItemSG *item = static_cast<FxListItemSG*>(visibleItems.first());
item->setPosition(0);
}
-void QSGListViewPrivate::moveItemBy(FxViewItem *item, qreal forwards, qreal backwards)
+void QQuickListViewPrivate::moveItemBy(FxViewItem *item, qreal forwards, qreal backwards)
{
qreal diff = forwards - backwards;
static_cast<FxListItemSG*>(item)->setPosition(item->position() + diff);
}
-void QSGListViewPrivate::createHighlight()
+void QQuickListViewPrivate::createHighlight()
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
bool changed = false;
if (highlight) {
if (trackedItem == highlight)
}
if (currentItem) {
- QSGItem *item = createHighlightItem();
+ QQuickItem *item = createHighlightItem();
if (item) {
FxListItemSG *newHighlight = new FxListItemSG(item, q, true);
newHighlight->setSize(static_cast<FxListItemSG*>(currentItem)->itemSize());
newHighlight->setPosition(static_cast<FxListItemSG*>(currentItem)->itemPosition());
}
- const QLatin1String posProp(orient == QSGListView::Vertical ? "y" : "x");
+ const QLatin1String posProp(orient == QQuickListView::Vertical ? "y" : "x");
highlightPosAnimator = new QSmoothedAnimation(q);
highlightPosAnimator->target = QDeclarativeProperty(item, posProp);
highlightPosAnimator->velocity = highlightMoveSpeed;
highlightPosAnimator->userDuration = highlightMoveDuration;
- const QLatin1String sizeProp(orient == QSGListView::Vertical ? "height" : "width");
+ const QLatin1String sizeProp(orient == QQuickListView::Vertical ? "height" : "width");
highlightSizeAnimator = new QSmoothedAnimation(q);
highlightSizeAnimator->velocity = highlightResizeSpeed;
highlightSizeAnimator->userDuration = highlightResizeDuration;
emit q->highlightItemChanged();
}
-void QSGListViewPrivate::updateHighlight()
+void QQuickListViewPrivate::updateHighlight()
{
applyPendingChanges();
if ((!currentItem && highlight) || (currentItem && !highlight))
createHighlight();
- bool strictHighlight = haveHighlightRange && highlightRange == QSGListView::StrictlyEnforceRange;
+ bool strictHighlight = haveHighlightRange && highlightRange == QQuickListView::StrictlyEnforceRange;
if (currentItem && autoHighlight && highlight && (!strictHighlight || !pressed)) {
// auto-update highlight
FxListItemSG *listItem = static_cast<FxListItemSG*>(currentItem);
? -listItem->itemPosition()-listItem->itemSize()
: listItem->itemPosition();
highlightSizeAnimator->to = listItem->itemSize();
- if (orient == QSGListView::Vertical) {
+ if (orient == QQuickListView::Vertical) {
if (highlight->item->width() == 0)
highlight->item->setWidth(currentItem->item->width());
} else {
updateTrackedItem();
}
-void QSGListViewPrivate::resetHighlightPosition()
+void QQuickListViewPrivate::resetHighlightPosition()
{
if (highlight && currentItem)
static_cast<FxListItemSG*>(highlight)->setPosition(static_cast<FxListItemSG*>(currentItem)->itemPosition());
}
-QSGItem * QSGListViewPrivate::getSectionItem(const QString §ion)
+QQuickItem * QQuickListViewPrivate::getSectionItem(const QString §ion)
{
- Q_Q(QSGListView);
- QSGItem *sectionItem = 0;
+ Q_Q(QQuickListView);
+ QQuickItem *sectionItem = 0;
int i = sectionCacheSize-1;
while (i >= 0 && !sectionCache[i])
--i;
QObject *nobj = sectionCriteria->delegate()->beginCreate(context);
if (nobj) {
QDeclarative_setParent_noEvent(context, nobj);
- sectionItem = qobject_cast<QSGItem *>(nobj);
+ sectionItem = qobject_cast<QQuickItem *>(nobj);
if (!sectionItem) {
delete nobj;
} else {
return sectionItem;
}
-void QSGListViewPrivate::releaseSectionItem(QSGItem *item)
+void QQuickListViewPrivate::releaseSectionItem(QQuickItem *item)
{
int i = 0;
do {
delete item;
}
-void QSGListViewPrivate::updateInlineSection(FxListItemSG *listItem)
+void QQuickListViewPrivate::updateInlineSection(FxListItemSG *listItem)
{
if (!sectionCriteria || !sectionCriteria->delegate())
return;
if (listItem->attached->m_prevSection != listItem->attached->m_section
- && (sectionCriteria->labelPositioning() & QSGViewSection::InlineLabels
- || (listItem->index == 0 && sectionCriteria->labelPositioning() & QSGViewSection::CurrentLabelAtStart))) {
+ && (sectionCriteria->labelPositioning() & QQuickViewSection::InlineLabels
+ || (listItem->index == 0 && sectionCriteria->labelPositioning() & QQuickViewSection::CurrentLabelAtStart))) {
if (!listItem->section) {
qreal pos = listItem->position();
listItem->section = getSectionItem(listItem->attached->m_section);
}
}
-void QSGListViewPrivate::updateStickySections()
+void QQuickListViewPrivate::updateStickySections()
{
if (!sectionCriteria || visibleItems.isEmpty()
|| (!sectionCriteria->labelPositioning() && !currentSectionItem && !nextSectionItem))
bool isRtl = isRightToLeft();
qreal viewPos = isRightToLeft() ? -position()-size() : position();
- QSGItem *sectionItem = 0;
- QSGItem *lastSectionItem = 0;
+ QQuickItem *sectionItem = 0;
+ QQuickItem *lastSectionItem = 0;
int index = 0;
while (index < visibleItems.count()) {
- if (QSGItem *section = static_cast<FxListItemSG *>(visibleItems.at(index))->section) {
+ if (QQuickItem *section = static_cast<FxListItemSG *>(visibleItems.at(index))->section) {
// Find the current section header and last visible section header
// and hide them if they will overlap a static section header.
- qreal sectionPos = orient == QSGListView::Vertical ? section->y() : section->x();
- qreal sectionSize = orient == QSGListView::Vertical ? section->height() : section->width();
+ qreal sectionPos = orient == QQuickListView::Vertical ? section->y() : section->x();
+ qreal sectionSize = orient == QQuickListView::Vertical ? section->height() : section->width();
bool visTop = true;
- if (sectionCriteria->labelPositioning() & QSGViewSection::CurrentLabelAtStart)
+ if (sectionCriteria->labelPositioning() & QQuickViewSection::CurrentLabelAtStart)
visTop = isRtl ? -sectionPos-sectionSize >= viewPos : sectionPos >= viewPos;
bool visBot = true;
- if (sectionCriteria->labelPositioning() & QSGViewSection::NextLabelAtEnd)
+ if (sectionCriteria->labelPositioning() & QQuickViewSection::NextLabelAtEnd)
visBot = isRtl ? -sectionPos <= viewPos + size() : sectionPos + sectionSize < viewPos + size();
section->setVisible(visBot && visTop);
if (visTop && !sectionItem)
}
// Current section header
- if (sectionCriteria->labelPositioning() & QSGViewSection::CurrentLabelAtStart) {
+ if (sectionCriteria->labelPositioning() & QQuickViewSection::CurrentLabelAtStart) {
if (!currentSectionItem) {
currentSectionItem = getSectionItem(currentSection);
} else if (currentStickySection != currentSection) {
if (!currentSectionItem)
return;
- qreal sectionSize = orient == QSGListView::Vertical ? currentSectionItem->height() : currentSectionItem->width();
- bool atBeginning = orient == QSGListView::Vertical ? vData.atBeginning : (isRightToLeft() ? hData.atEnd : hData.atBeginning);
+ qreal sectionSize = orient == QQuickListView::Vertical ? currentSectionItem->height() : currentSectionItem->width();
+ bool atBeginning = orient == QQuickListView::Vertical ? vData.atBeginning : (isRightToLeft() ? hData.atEnd : hData.atBeginning);
currentSectionItem->setVisible(!atBeginning && (!header || header->endPosition() < viewPos));
qreal pos = isRtl ? position() + size() - sectionSize : viewPos;
if (sectionItem) {
- qreal sectionPos = orient == QSGListView::Vertical ? sectionItem->y() : sectionItem->x();
+ qreal sectionPos = orient == QQuickListView::Vertical ? sectionItem->y() : sectionItem->x();
pos = isRtl ? qMax(pos, sectionPos + sectionSize) : qMin(pos, sectionPos - sectionSize);
}
if (header)
pos = isRtl ? qMin(header->endPosition(), pos) : qMax(header->endPosition(), pos);
if (footer)
pos = isRtl ? qMax(-footer->position(), pos) : qMin(footer->position() - sectionSize, pos);
- if (orient == QSGListView::Vertical)
+ if (orient == QQuickListView::Vertical)
currentSectionItem->setY(pos);
else
currentSectionItem->setX(pos);
}
// Next section footer
- if (sectionCriteria->labelPositioning() & QSGViewSection::NextLabelAtEnd) {
+ if (sectionCriteria->labelPositioning() & QQuickViewSection::NextLabelAtEnd) {
if (!nextSectionItem) {
nextSectionItem = getSectionItem(nextSection);
} else if (nextStickySection != nextSection) {
if (!nextSectionItem)
return;
- qreal sectionSize = orient == QSGListView::Vertical ? nextSectionItem->height() : nextSectionItem->width();
+ qreal sectionSize = orient == QQuickListView::Vertical ? nextSectionItem->height() : nextSectionItem->width();
nextSectionItem->setVisible(!nextSection.isEmpty());
qreal pos = isRtl ? position() : viewPos + size() - sectionSize;
if (lastSectionItem) {
- qreal sectionPos = orient == QSGListView::Vertical ? lastSectionItem->y() : lastSectionItem->x();
+ qreal sectionPos = orient == QQuickListView::Vertical ? lastSectionItem->y() : lastSectionItem->x();
pos = isRtl ? qMin(pos, sectionPos - sectionSize) : qMax(pos, sectionPos + sectionSize);
}
if (header)
pos = isRtl ? qMin(header->endPosition() - sectionSize, pos) : qMax(header->endPosition(), pos);
- if (orient == QSGListView::Vertical)
+ if (orient == QQuickListView::Vertical)
nextSectionItem->setY(pos);
else
nextSectionItem->setX(pos);
}
}
-void QSGListViewPrivate::updateSections()
+void QQuickListViewPrivate::updateSections()
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
if (!q->isComponentComplete())
return;
- QSGItemViewPrivate::updateSections();
+ QQuickItemViewPrivate::updateSections();
if (sectionCriteria && !visibleItems.isEmpty()) {
QString prevSection;
if (visibleIndex > 0)
prevSection = sectionAt(visibleIndex-1);
- QSGListViewAttached *prevAtt = 0;
+ QQuickListViewAttached *prevAtt = 0;
int idx = -1;
for (int i = 0; i < visibleItems.count(); ++i) {
- QSGListViewAttached *attached = static_cast<QSGListViewAttached*>(visibleItems.at(i)->attached);
+ QQuickListViewAttached *attached = static_cast<QQuickListViewAttached*>(visibleItems.at(i)->attached);
attached->setPrevSection(prevSection);
if (visibleItems.at(i)->index != -1) {
QString propValue = model->stringValue(visibleItems.at(i)->index, sectionCriteria->property());
updateStickySections();
}
-void QSGListViewPrivate::updateCurrentSection()
+void QQuickListViewPrivate::updateCurrentSection()
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
if (!sectionCriteria || visibleItems.isEmpty()) {
if (!currentSection.isEmpty()) {
currentSection.clear();
}
return;
}
- bool inlineSections = sectionCriteria->labelPositioning() & QSGViewSection::InlineLabels;
+ bool inlineSections = sectionCriteria->labelPositioning() & QQuickViewSection::InlineLabels;
qreal sectionThreshold = position();
if (currentSectionItem && !inlineSections)
- sectionThreshold += orient == QSGListView::Vertical ? currentSectionItem->height() : currentSectionItem->width();
+ sectionThreshold += orient == QQuickListView::Vertical ? currentSectionItem->height() : currentSectionItem->width();
int index = 0;
int modelIndex = visibleIndex;
while (index < visibleItems.count() && visibleItems.at(index)->endPosition() <= sectionThreshold) {
emit q->currentSectionChanged();
}
- if (sectionCriteria->labelPositioning() & QSGViewSection::NextLabelAtEnd) {
+ if (sectionCriteria->labelPositioning() & QQuickViewSection::NextLabelAtEnd) {
// Don't want to scan for next section on every movement, so remember
// the last section in the visible area and only scan for the next
// section when that changes. Clearing lastVisibleSection will also
QString lastSection = currentSection;
qreal endPos = isRightToLeft() ? -position() : position() + size();
if (nextSectionItem && !inlineSections)
- endPos -= orient == QSGListView::Vertical ? nextSectionItem->height() : nextSectionItem->width();
+ endPos -= orient == QQuickListView::Vertical ? nextSectionItem->height() : nextSectionItem->width();
while (index < visibleItems.count() && static_cast<FxListItemSG*>(visibleItems.at(index))->itemPosition() < endPos) {
if (visibleItems.at(index)->index != -1)
modelIndex = visibleItems.at(index)->index;
}
}
-void QSGListViewPrivate::initializeCurrentItem()
+void QQuickListViewPrivate::initializeCurrentItem()
{
- QSGItemViewPrivate::initializeCurrentItem();
+ QQuickItemViewPrivate::initializeCurrentItem();
if (currentItem) {
FxListItemSG *listItem = static_cast<FxListItemSG *>(currentItem);
}
}
-void QSGListViewPrivate::updateAverage()
+void QQuickListViewPrivate::updateAverage()
{
if (!visibleItems.count())
return;
averageSize = qRound(sum / visibleItems.count());
}
-qreal QSGListViewPrivate::headerSize() const
+qreal QQuickListViewPrivate::headerSize() const
{
return header ? header->size() : 0.0;
}
-qreal QSGListViewPrivate::footerSize() const
+qreal QQuickListViewPrivate::footerSize() const
{
return footer ? footer->size() : 0.0;
}
-bool QSGListViewPrivate::showHeaderForIndex(int index) const
+bool QQuickListViewPrivate::showHeaderForIndex(int index) const
{
return index == 0;
}
-bool QSGListViewPrivate::showFooterForIndex(int index) const
+bool QQuickListViewPrivate::showFooterForIndex(int index) const
{
return index == model->count()-1;
}
-void QSGListViewPrivate::updateFooter()
+void QQuickListViewPrivate::updateFooter()
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
bool created = false;
if (!footer) {
- QSGItem *item = createComponentItem(footerComponent, true);
+ QQuickItem *item = createComponentItem(footerComponent, true);
if (!item)
return;
item->setZ(1);
emit q->footerItemChanged();
}
-void QSGListViewPrivate::updateHeader()
+void QQuickListViewPrivate::updateHeader()
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
bool created = false;
if (!header) {
- QSGItem *item = createComponentItem(headerComponent, true);
+ QQuickItem *item = createComponentItem(headerComponent, true);
if (!item)
return;
item->setZ(1);
emit q->headerItemChanged();
}
-void QSGListViewPrivate::itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickListViewPrivate::itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_Q(QSGListView);
- QSGItemViewPrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
+ Q_Q(QQuickListView);
+ QQuickItemViewPrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
if (!q->isComponentComplete())
return;
if (item != contentItem && (!highlight || item != highlight->item)) {
- if ((orient == QSGListView::Vertical && newGeometry.height() != oldGeometry.height())
- || (orient == QSGListView::Horizontal && newGeometry.width() != oldGeometry.width())) {
+ if ((orient == QQuickListView::Vertical && newGeometry.height() != oldGeometry.height())
+ || (orient == QQuickListView::Horizontal && newGeometry.width() != oldGeometry.width())) {
forceLayout = true;
q->polish();
}
}
}
-void QSGListViewPrivate::fixupPosition()
+void QQuickListViewPrivate::fixupPosition()
{
- if ((haveHighlightRange && highlightRange == QSGListView::StrictlyEnforceRange)
- || snapMode != QSGListView::NoSnap)
+ if ((haveHighlightRange && highlightRange == QQuickListView::StrictlyEnforceRange)
+ || snapMode != QQuickListView::NoSnap)
moveReason = Other;
- if (orient == QSGListView::Vertical)
+ if (orient == QQuickListView::Vertical)
fixupY();
else
fixupX();
}
-void QSGListViewPrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
+void QQuickListViewPrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
{
- if ((orient == QSGListView::Horizontal && &data == &vData)
- || (orient == QSGListView::Vertical && &data == &hData))
+ if ((orient == QQuickListView::Horizontal && &data == &vData)
+ || (orient == QQuickListView::Vertical && &data == &hData))
return;
correctFlick = false;
fixupMode = moveReason == Mouse ? fixupMode : Immediate;
- bool strictHighlightRange = haveHighlightRange && highlightRange == QSGListView::StrictlyEnforceRange;
+ bool strictHighlightRange = haveHighlightRange && highlightRange == QQuickListView::StrictlyEnforceRange;
qreal viewPos = isRightToLeft() ? -position()-size() : position();
- if (snapMode != QSGListView::NoSnap && moveReason != QSGListViewPrivate::SetIndex) {
+ if (snapMode != QQuickListView::NoSnap && moveReason != QQuickListViewPrivate::SetIndex) {
qreal tempPosition = isRightToLeft() ? -position()-size() : position();
- if (snapMode == QSGListView::SnapOneItem && moveReason == Mouse) {
+ if (snapMode == QQuickListView::SnapOneItem && moveReason == Mouse) {
// if we've been dragged < averageSize/2 then bias towards the next item
qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
qreal bias = 0;
else
pos = qMax(qMin(bottomItem->position() - highlightRangeEnd, -maxExtent), -minExtent);
} else {
- QSGItemViewPrivate::fixup(data, minExtent, maxExtent);
+ QQuickItemViewPrivate::fixup(data, minExtent, maxExtent);
return;
}
}
vTime = timeline.time();
}
- } else if (currentItem && strictHighlightRange && moveReason != QSGListViewPrivate::SetIndex) {
+ } else if (currentItem && strictHighlightRange && moveReason != QQuickListViewPrivate::SetIndex) {
updateHighlight();
qreal pos = static_cast<FxListItemSG*>(currentItem)->itemPosition();
if (viewPos < pos + static_cast<FxListItemSG*>(currentItem)->itemSize() - highlightRangeEnd)
}
vTime = timeline.time();
} else {
- QSGItemViewPrivate::fixup(data, minExtent, maxExtent);
+ QQuickItemViewPrivate::fixup(data, minExtent, maxExtent);
}
data.inOvershoot = false;
fixupMode = Normal;
}
-void QSGListViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+void QQuickListViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
data.fixingUp = false;
moveReason = Mouse;
- if ((!haveHighlightRange || highlightRange != QSGListView::StrictlyEnforceRange) && snapMode == QSGListView::NoSnap) {
+ if ((!haveHighlightRange || highlightRange != QQuickListView::StrictlyEnforceRange) && snapMode == QQuickListView::NoSnap) {
correctFlick = true;
- QSGItemViewPrivate::flick(data, minExtent, maxExtent, vSize, fixupCallback, velocity);
+ QQuickItemViewPrivate::flick(data, minExtent, maxExtent, vSize, fixupCallback, velocity);
return;
}
qreal maxDistance = 0;
// -ve velocity means list is moving up/left
if (velocity > 0) {
if (data.move.value() < minExtent) {
- if (snapMode == QSGListView::SnapOneItem && !hData.flicking && !vData.flicking) {
+ if (snapMode == QQuickListView::SnapOneItem && !hData.flicking && !vData.flicking) {
// if we've been dragged < averageSize/2 then bias towards the next item
qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
qreal bias = dist < averageSize/2 ? averageSize/2 : 0;
maxDistance = qAbs(minExtent - data.move.value());
}
}
- if (snapMode == QSGListView::NoSnap && highlightRange != QSGListView::StrictlyEnforceRange)
+ if (snapMode == QQuickListView::NoSnap && highlightRange != QQuickListView::StrictlyEnforceRange)
data.flickTarget = minExtent;
} else {
if (data.move.value() > maxExtent) {
- if (snapMode == QSGListView::SnapOneItem && !hData.flicking && !vData.flicking) {
+ if (snapMode == QQuickListView::SnapOneItem && !hData.flicking && !vData.flicking) {
// if we've been dragged < averageSize/2 then bias towards the next item
qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
qreal bias = -dist < averageSize/2 ? averageSize/2 : 0;
maxDistance = qAbs(maxExtent - data.move.value());
}
}
- if (snapMode == QSGListView::NoSnap && highlightRange != QSGListView::StrictlyEnforceRange)
+ if (snapMode == QQuickListView::NoSnap && highlightRange != QQuickListView::StrictlyEnforceRange)
data.flickTarget = maxExtent;
}
- bool overShoot = boundsBehavior == QSGFlickable::DragAndOvershootBounds;
+ bool overShoot = boundsBehavior == QQuickFlickable::DragAndOvershootBounds;
if (maxDistance > 0 || overShoot) {
// These modes require the list to stop exactly on an item boundary.
// The initial flick will estimate the boundary to stop on.
dist = qMin(dist, maxDistance);
if (v > 0)
dist = -dist;
- if ((maxDistance > 0.0 && v2 / (2.0f * maxDistance) < accel) || snapMode == QSGListView::SnapOneItem) {
- if (snapMode != QSGListView::SnapOneItem) {
+ if ((maxDistance > 0.0 && v2 / (2.0f * maxDistance) < accel) || snapMode == QQuickListView::SnapOneItem) {
+ if (snapMode != QQuickListView::SnapOneItem) {
qreal distTemp = isRightToLeft() ? -dist : dist;
data.flickTarget = -snapPosAt(-(dataValue - highlightRangeStart) + distTemp) + highlightRangeStart;
}
} else {
// reevaluate the target boundary.
qreal newtarget = data.flickTarget;
- if (snapMode != QSGListView::NoSnap || highlightRange == QSGListView::StrictlyEnforceRange) {
+ if (snapMode != QQuickListView::NoSnap || highlightRange == QQuickListView::StrictlyEnforceRange) {
qreal tempFlickTarget = isRightToLeft() ? -data.flickTarget+size() : data.flickTarget;
newtarget = -snapPosAt(-(tempFlickTarget - highlightRangeStart)) + highlightRangeStart;
newtarget = isRightToLeft() ? -newtarget+size() : newtarget;
//----------------------------------------------------------------------------
/*!
- \qmlclass ListView QSGListView
+ \qmlclass ListView QQuickListView
\inqmlmodule QtQuick 2
\ingroup qml-view-elements
\inherits Flickable
\sa {QML Data Models}, GridView, {declarative/modelviews/listview}{ListView examples}
*/
-QSGListView::QSGListView(QSGItem *parent)
- : QSGItemView(*(new QSGListViewPrivate), parent)
+QQuickListView::QQuickListView(QQuickItem *parent)
+ : QQuickItemView(*(new QQuickListViewPrivate), parent)
{
}
-QSGListView::~QSGListView()
+QQuickListView::~QQuickListView()
{
}
\o ListView.NoHighlightRange - this is the default value.
\endlist
*/
-void QSGListView::setHighlightFollowsCurrentItem(bool autoHighlight)
+void QQuickListView::setHighlightFollowsCurrentItem(bool autoHighlight)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->autoHighlight != autoHighlight) {
if (!autoHighlight) {
if (d->highlightPosAnimator)
if (d->highlightSizeAnimator)
d->highlightSizeAnimator->stop();
}
- QSGItemView::setHighlightFollowsCurrentItem(autoHighlight);
+ QQuickItemView::setHighlightFollowsCurrentItem(autoHighlight);
}
}
The default value is 0.
*/
-qreal QSGListView::spacing() const
+qreal QQuickListView::spacing() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->spacing;
}
-void QSGListView::setSpacing(qreal spacing)
+void QQuickListView::setSpacing(qreal spacing)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (spacing != d->spacing) {
d->spacing = spacing;
d->forceLayout = true;
\image listview-highlight.png
\endtable
*/
-QSGListView::Orientation QSGListView::orientation() const
+QQuickListView::Orientation QQuickListView::orientation() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->orient;
}
-void QSGListView::setOrientation(QSGListView::Orientation orientation)
+void QQuickListView::setOrientation(QQuickListView::Orientation orientation)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->orient != orientation) {
d->orient = orientation;
if (d->orient == Vertical) {
\sa {declarative/modelviews/listview}{ListView examples}
*/
-QSGViewSection *QSGListView::sectionCriteria()
+QQuickViewSection *QQuickListView::sectionCriteria()
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (!d->sectionCriteria) {
- d->sectionCriteria = new QSGViewSection(this);
+ d->sectionCriteria = new QQuickViewSection(this);
connect(d->sectionCriteria, SIGNAL(propertyChanged()), this, SLOT(updateSections()));
}
return d->sectionCriteria;
\qmlproperty string QtQuick2::ListView::currentSection
This property holds the section that is currently at the beginning of the view.
*/
-QString QSGListView::currentSection() const
+QString QQuickListView::currentSection() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->currentSection;
}
\sa highlightFollowsCurrentItem
*/
-qreal QSGListView::highlightMoveSpeed() const
+qreal QQuickListView::highlightMoveSpeed() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->highlightMoveSpeed;
}
-void QSGListView::setHighlightMoveSpeed(qreal speed)
+void QQuickListView::setHighlightMoveSpeed(qreal speed)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->highlightMoveSpeed != speed) {
d->highlightMoveSpeed = speed;
if (d->highlightPosAnimator)
}
}
-void QSGListView::setHighlightMoveDuration(int duration)
+void QQuickListView::setHighlightMoveDuration(int duration)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->highlightMoveDuration != duration) {
if (d->highlightPosAnimator)
d->highlightPosAnimator->userDuration = duration;
- QSGItemView::setHighlightMoveDuration(duration);
+ QQuickItemView::setHighlightMoveDuration(duration);
}
}
-qreal QSGListView::highlightResizeSpeed() const
+qreal QQuickListView::highlightResizeSpeed() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->highlightResizeSpeed;
}
-void QSGListView::setHighlightResizeSpeed(qreal speed)
+void QQuickListView::setHighlightResizeSpeed(qreal speed)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->highlightResizeSpeed != speed) {
d->highlightResizeSpeed = speed;
if (d->highlightSizeAnimator)
}
}
-int QSGListView::highlightResizeDuration() const
+int QQuickListView::highlightResizeDuration() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->highlightResizeDuration;
}
-void QSGListView::setHighlightResizeDuration(int duration)
+void QQuickListView::setHighlightResizeDuration(int duration)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->highlightResizeDuration != duration) {
d->highlightResizeDuration = duration;
if (d->highlightSizeAnimator)
\sa highlightRangeMode
*/
-QSGListView::SnapMode QSGListView::snapMode() const
+QQuickListView::SnapMode QQuickListView::snapMode() const
{
- Q_D(const QSGListView);
+ Q_D(const QQuickListView);
return d->snapMode;
}
-void QSGListView::setSnapMode(SnapMode mode)
+void QQuickListView::setSnapMode(SnapMode mode)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->snapMode != mode) {
d->snapMode = mode;
emit snapModeChanged();
\sa footer
*/
-void QSGListView::viewportMoved()
+void QQuickListView::viewportMoved()
{
- Q_D(QSGListView);
- QSGItemView::viewportMoved();
+ Q_D(QQuickListView);
+ QQuickItemView::viewportMoved();
if (!d->itemCount)
return;
// Recursion can occur due to refill changing the content size.
d->lazyRelease = true;
d->refill();
if (d->hData.flicking || d->vData.flicking || d->hData.moving || d->vData.moving)
- d->moveReason = QSGListViewPrivate::Mouse;
- if (d->moveReason != QSGListViewPrivate::SetIndex) {
+ d->moveReason = QQuickListViewPrivate::Mouse;
+ if (d->moveReason != QQuickListViewPrivate::SetIndex) {
if (d->haveHighlightRange && d->highlightRange == StrictlyEnforceRange && d->highlight) {
// reposition highlight
qreal pos = d->highlight->position();
if ((minY - d->vData.move.value() < height()/2 || d->vData.flickTarget - d->vData.move.value() < height()/2)
&& minY != d->vData.flickTarget)
d->flickY(-d->vData.smoothVelocity.value());
- d->bufferMode = QSGListViewPrivate::BufferBefore;
+ d->bufferMode = QQuickListViewPrivate::BufferBefore;
} else if (d->vData.velocity < 0) {
const qreal maxY = maxYExtent();
if ((d->vData.move.value() - maxY < height()/2 || d->vData.move.value() - d->vData.flickTarget < height()/2)
&& maxY != d->vData.flickTarget)
d->flickY(-d->vData.smoothVelocity.value());
- d->bufferMode = QSGListViewPrivate::BufferAfter;
+ d->bufferMode = QQuickListViewPrivate::BufferAfter;
}
}
if ((minX - d->hData.move.value() < width()/2 || d->hData.flickTarget - d->hData.move.value() < width()/2)
&& minX != d->hData.flickTarget)
d->flickX(-d->hData.smoothVelocity.value());
- d->bufferMode = d->isRightToLeft() ? QSGListViewPrivate::BufferAfter : QSGListViewPrivate::BufferBefore;
+ d->bufferMode = d->isRightToLeft() ? QQuickListViewPrivate::BufferAfter : QQuickListViewPrivate::BufferBefore;
} else if (d->hData.velocity < 0) {
const qreal maxX = maxXExtent();
if ((d->hData.move.value() - maxX < width()/2 || d->hData.move.value() - d->hData.flickTarget < width()/2)
&& maxX != d->hData.flickTarget)
d->flickX(-d->hData.smoothVelocity.value());
- d->bufferMode = d->isRightToLeft() ? QSGListViewPrivate::BufferBefore : QSGListViewPrivate::BufferAfter;
+ d->bufferMode = d->isRightToLeft() ? QQuickListViewPrivate::BufferBefore : QQuickListViewPrivate::BufferAfter;
}
}
d->inFlickCorrection = false;
d->inViewportMoved = false;
}
-void QSGListView::keyPressEvent(QKeyEvent *event)
+void QQuickListView::keyPressEvent(QKeyEvent *event)
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (d->model && d->model->count() && d->interactive) {
- if ((d->orient == QSGListView::Horizontal && !d->isRightToLeft() && event->key() == Qt::Key_Left)
- || (d->orient == QSGListView::Horizontal && d->isRightToLeft() && event->key() == Qt::Key_Right)
- || (d->orient == QSGListView::Vertical && event->key() == Qt::Key_Up)) {
+ if ((d->orient == QQuickListView::Horizontal && !d->isRightToLeft() && event->key() == Qt::Key_Left)
+ || (d->orient == QQuickListView::Horizontal && d->isRightToLeft() && event->key() == Qt::Key_Right)
+ || (d->orient == QQuickListView::Vertical && event->key() == Qt::Key_Up)) {
if (currentIndex() > 0 || (d->wrap && !event->isAutoRepeat())) {
decrementCurrentIndex();
event->accept();
event->accept();
return;
}
- } else if ((d->orient == QSGListView::Horizontal && !d->isRightToLeft() && event->key() == Qt::Key_Right)
- || (d->orient == QSGListView::Horizontal && d->isRightToLeft() && event->key() == Qt::Key_Left)
- || (d->orient == QSGListView::Vertical && event->key() == Qt::Key_Down)) {
+ } else if ((d->orient == QQuickListView::Horizontal && !d->isRightToLeft() && event->key() == Qt::Key_Right)
+ || (d->orient == QQuickListView::Horizontal && d->isRightToLeft() && event->key() == Qt::Key_Left)
+ || (d->orient == QQuickListView::Vertical && event->key() == Qt::Key_Down)) {
if (currentIndex() < d->model->count() - 1 || (d->wrap && !event->isAutoRepeat())) {
incrementCurrentIndex();
event->accept();
}
}
event->ignore();
- QSGItemView::keyPressEvent(event);
+ QQuickItemView::keyPressEvent(event);
}
-void QSGListView::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickListView::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_D(QSGListView);
- if (d->isRightToLeft() && d->orient == QSGListView::Horizontal) {
+ Q_D(QQuickListView);
+ if (d->isRightToLeft() && d->orient == QQuickListView::Horizontal) {
// maintain position relative to the right edge
int dx = newGeometry.width() - oldGeometry.width();
setContentX(contentX() - dx);
}
- QSGItemView::geometryChanged(newGeometry, oldGeometry);
+ QQuickItemView::geometryChanged(newGeometry, oldGeometry);
}
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGListView::incrementCurrentIndex()
+void QQuickListView::incrementCurrentIndex()
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
int count = d->model ? d->model->count() : 0;
if (count && (currentIndex() < count - 1 || d->wrap)) {
- d->moveReason = QSGListViewPrivate::SetIndex;
+ d->moveReason = QQuickListViewPrivate::SetIndex;
int index = currentIndex()+1;
setCurrentIndex((index >= 0 && index < count) ? index : 0);
}
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGListView::decrementCurrentIndex()
+void QQuickListView::decrementCurrentIndex()
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
int count = d->model ? d->model->count() : 0;
if (count && (currentIndex() > 0 || d->wrap)) {
- d->moveReason = QSGListViewPrivate::SetIndex;
+ d->moveReason = QQuickListViewPrivate::SetIndex;
int index = currentIndex()-1;
setCurrentIndex((index >= 0 && index < count) ? index : count-1);
}
}
-void QSGListView::updateSections()
+void QQuickListView::updateSections()
{
- Q_D(QSGListView);
+ Q_D(QQuickListView);
if (isComponentComplete() && d->model) {
QList<QByteArray> roles;
if (d->sectionCriteria && !d->sectionCriteria->property().isEmpty())
}
}
-bool QSGListViewPrivate::applyInsertionChange(const QDeclarativeChangeSet::Insert &change, FxViewItem *firstVisible, InsertionsResult *insertResult)
+bool QQuickListViewPrivate::applyInsertionChange(const QDeclarativeChangeSet::Insert &change, FxViewItem *firstVisible, InsertionsResult *insertResult)
{
- Q_Q(QSGListView);
+ Q_Q(QQuickListView);
int modelIndex = change.index;
int count = change.count;
\bold Note: methods should only be called after the Component has completed.
*/
-QSGListViewAttached *QSGListView::qmlAttachedProperties(QObject *obj)
+QQuickListViewAttached *QQuickListView::qmlAttachedProperties(QObject *obj)
{
- return new QSGListViewAttached(obj);
+ return new QQuickListViewAttached(obj);
}
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGLISTVIEW_P_H
-#define QSGLISTVIEW_P_H
+#ifndef QQUICKLISTVIEW_P_H
+#define QQUICKLISTVIEW_P_H
-#include "qsgitemview_p.h"
+#include "qquickitemview_p.h"
#include <private/qdeclarativeguard_p.h>
QT_MODULE(Declarative)
-class QSGListView;
-class QSGListViewPrivate;
-class Q_AUTOTEST_EXPORT QSGViewSection : public QObject
+class QQuickListView;
+class QQuickListViewPrivate;
+class Q_AUTOTEST_EXPORT QQuickViewSection : public QObject
{
Q_OBJECT
Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY propertyChanged)
Q_ENUMS(SectionCriteria)
Q_ENUMS(LabelPositioning)
public:
- QSGViewSection(QSGListView *parent=0);
+ QQuickViewSection(QQuickListView *parent=0);
QString property() const { return m_property; }
void setProperty(const QString &);
SectionCriteria m_criteria;
QDeclarativeComponent *m_delegate;
int m_labelPositioning;
- QSGListViewPrivate *m_view;
+ QQuickListViewPrivate *m_view;
};
-class QSGVisualModel;
-class QSGListViewAttached;
-class Q_AUTOTEST_EXPORT QSGListView : public QSGItemView
+class QQuickVisualModel;
+class QQuickListViewAttached;
+class Q_AUTOTEST_EXPORT QQuickListView : public QQuickItemView
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGListView)
+ Q_DECLARE_PRIVATE(QQuickListView)
// XXX deprecate these two properties (only duration should be necessary)
Q_PROPERTY(qreal highlightMoveSpeed READ highlightMoveSpeed WRITE setHighlightMoveSpeed NOTIFY highlightMoveSpeedChanged)
Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
Q_PROPERTY(Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged)
- Q_PROPERTY(QSGViewSection *section READ sectionCriteria CONSTANT)
+ Q_PROPERTY(QQuickViewSection *section READ sectionCriteria CONSTANT)
Q_PROPERTY(QString currentSection READ currentSection NOTIFY currentSectionChanged)
Q_PROPERTY(SnapMode snapMode READ snapMode WRITE setSnapMode NOTIFY snapModeChanged)
Q_CLASSINFO("DefaultProperty", "data")
public:
- QSGListView(QSGItem *parent=0);
- ~QSGListView();
+ QQuickListView(QQuickItem *parent=0);
+ ~QQuickListView();
qreal spacing() const;
void setSpacing(qreal spacing);
Orientation orientation() const;
void setOrientation(Orientation);
- QSGViewSection *sectionCriteria();
+ QQuickViewSection *sectionCriteria();
QString currentSection() const;
virtual void setHighlightFollowsCurrentItem(bool);
SnapMode snapMode() const;
void setSnapMode(SnapMode mode);
- static QSGListViewAttached *qmlAttachedProperties(QObject *);
+ static QQuickListViewAttached *qmlAttachedProperties(QObject *);
public Q_SLOTS:
void incrementCurrentIndex();
void updateSections();
};
-class QSGListViewAttached : public QSGItemViewAttached
+class QQuickListViewAttached : public QQuickItemViewAttached
{
Q_OBJECT
public:
- QSGListViewAttached(QObject *parent)
- : QSGItemViewAttached(parent), m_view(0) {}
- ~QSGListViewAttached() {}
+ QQuickListViewAttached(QObject *parent)
+ : QQuickItemViewAttached(parent), m_view(0) {}
+ ~QQuickListViewAttached() {}
- Q_PROPERTY(QSGListView *view READ view NOTIFY viewChanged)
- QSGListView *view() { return m_view; }
- void setView(QSGListView *view) {
+ Q_PROPERTY(QQuickListView *view READ view NOTIFY viewChanged)
+ QQuickListView *view() { return m_view; }
+ void setView(QQuickListView *view) {
if (view != m_view) {
m_view = view;
emit viewChanged();
void viewChanged();
public:
- QDeclarativeGuard<QSGListView> m_view;
+ QDeclarativeGuard<QQuickListView> m_view;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPEINFO(QSGListView, QML_HAS_ATTACHED_PROPERTIES)
-QML_DECLARE_TYPE(QSGListView)
-QML_DECLARE_TYPE(QSGViewSection)
+QML_DECLARE_TYPEINFO(QQuickListView, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickListView)
+QML_DECLARE_TYPE(QQuickViewSection)
QT_END_HEADER
-#endif // QSGLISTVIEW_P_H
+#endif // QQUICKLISTVIEW_P_H
**
****************************************************************************/
-#include "qsgloader_p_p.h"
+#include "qquickloader_p_p.h"
#include <QtDeclarative/qdeclarativeinfo.h>
QT_BEGIN_NAMESPACE
-QSGLoaderPrivate::QSGLoaderPrivate()
+QQuickLoaderPrivate::QQuickLoaderPrivate()
: item(0), component(0), itemContext(0), incubator(0), updatingSize(false),
itemWidthValid(false), itemHeightValid(false),
active(true), loadingFromSource(false), asynchronous(false)
{
}
-QSGLoaderPrivate::~QSGLoaderPrivate()
+QQuickLoaderPrivate::~QQuickLoaderPrivate()
{
delete incubator;
disposeInitialPropertyValues();
}
-void QSGLoaderPrivate::itemGeometryChanged(QSGItem *resizeItem, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickLoaderPrivate::itemGeometryChanged(QQuickItem *resizeItem, const QRectF &newGeometry, const QRectF &oldGeometry)
{
if (resizeItem == item) {
if (!updatingSize && newGeometry.width() != oldGeometry.width())
itemHeightValid = true;
_q_updateSize(false);
}
- QSGItemChangeListener::itemGeometryChanged(resizeItem, newGeometry, oldGeometry);
+ QQuickItemChangeListener::itemGeometryChanged(resizeItem, newGeometry, oldGeometry);
}
-void QSGLoaderPrivate::clear()
+void QQuickLoaderPrivate::clear()
{
disposeInitialPropertyValues();
source = QUrl();
if (item) {
- QSGItemPrivate *p = QSGItemPrivate::get(item);
- p->removeItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(item);
+ p->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
// We can't delete immediately because our item may have triggered
// the Loader to load a different item.
}
}
-void QSGLoaderPrivate::initResize()
+void QQuickLoaderPrivate::initResize()
{
- QSGItemPrivate *p = QSGItemPrivate::get(item);
- p->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(item);
+ p->addItemChangeListener(this, QQuickItemPrivate::Geometry);
// We may override the item's size, so we need to remember
// whether the item provided its own valid size.
itemWidthValid = p->widthValid;
}
/*!
- \qmlclass Loader QSGLoader
+ \qmlclass Loader QQuickLoader
\inqmlmodule QtQuick 2
\ingroup qml-utility-elements
\inherits Item
\sa {dynamic-object-creation}{Dynamic Object Creation}
*/
-QSGLoader::QSGLoader(QSGItem *parent)
- : QSGImplicitSizeItem(*(new QSGLoaderPrivate), parent)
+QQuickLoader::QQuickLoader(QQuickItem *parent)
+ : QQuickImplicitSizeItem(*(new QQuickLoaderPrivate), parent)
{
setFlag(ItemIsFocusScope);
}
-QSGLoader::~QSGLoader()
+QQuickLoader::~QQuickLoader()
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (d->item) {
- QSGItemPrivate *p = QSGItemPrivate::get(d->item);
- p->removeItemChangeListener(d, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(d->item);
+ p->removeItemChangeListener(d, QQuickItemPrivate::Geometry);
}
}
\sa source, sourceComponent
*/
-bool QSGLoader::active() const
+bool QQuickLoader::active() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
return d->active;
}
-void QSGLoader::setActive(bool newVal)
+void QQuickLoader::setActive(bool newVal)
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (d->active != newVal) {
d->active = newVal;
if (newVal == true) {
}
} else {
if (d->item) {
- QSGItemPrivate *p = QSGItemPrivate::get(d->item);
- p->removeItemChangeListener(d, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(d->item);
+ p->removeItemChangeListener(d, QQuickItemPrivate::Geometry);
// We can't delete immediately because our item may have triggered
// the Loader to load a different item.
\sa sourceComponent, status, progress
*/
-QUrl QSGLoader::source() const
+QUrl QQuickLoader::source() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
return d->source;
}
-void QSGLoader::setSource(const QUrl &url)
+void QQuickLoader::setSource(const QUrl &url)
{
setSource(url, true); // clear previous values
}
-void QSGLoader::setSource(const QUrl &url, bool needsClear)
+void QQuickLoader::setSource(const QUrl &url, bool needsClear)
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (d->source == url)
return;
emit sourceChanged();
}
-void QSGLoader::loadFromSource()
+void QQuickLoader::loadFromSource()
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (d->source.isEmpty()) {
emit sourceChanged();
emit statusChanged();
\sa source, progress
*/
-QDeclarativeComponent *QSGLoader::sourceComponent() const
+QDeclarativeComponent *QQuickLoader::sourceComponent() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
return d->component;
}
-void QSGLoader::setSourceComponent(QDeclarativeComponent *comp)
+void QQuickLoader::setSourceComponent(QDeclarativeComponent *comp)
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (comp == d->component)
return;
emit sourceComponentChanged();
}
-void QSGLoader::resetSourceComponent()
+void QQuickLoader::resetSourceComponent()
{
setSourceComponent(0);
}
-void QSGLoader::loadFromSourceComponent()
+void QQuickLoader::loadFromSourceComponent()
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (!d->component) {
emit sourceComponentChanged();
emit statusChanged();
\sa source, active
*/
-void QSGLoader::setSource(QDeclarativeV8Function *args)
+void QQuickLoader::setSource(QDeclarativeV8Function *args)
{
Q_ASSERT(args);
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
bool ipvError = false;
args->returnValue(v8::Undefined());
setSource(sourceUrl, false); // already cleared and set ipv above.
}
-void QSGLoaderPrivate::disposeInitialPropertyValues()
+void QQuickLoaderPrivate::disposeInitialPropertyValues()
{
if (!initialPropertyValues.IsEmpty())
qPersistentDispose(initialPropertyValues);
qPersistentDispose(qmlGlobalForIpv);
}
-void QSGLoaderPrivate::load()
+void QQuickLoaderPrivate::load()
{
- Q_Q(QSGLoader);
+ Q_Q(QQuickLoader);
if (!q->isComponentComplete() || !component)
return;
}
}
-void QSGLoaderIncubator::setInitialState(QObject *o)
+void QQuickLoaderIncubator::setInitialState(QObject *o)
{
loader->setInitialState(o);
}
-void QSGLoaderPrivate::setInitialState(QObject *obj)
+void QQuickLoaderPrivate::setInitialState(QObject *obj)
{
- Q_Q(QSGLoader);
+ Q_Q(QQuickLoader);
- QSGItem *item = qobject_cast<QSGItem*>(obj);
+ QQuickItem *item = qobject_cast<QQuickItem*>(obj);
if (item) {
QDeclarative_setParent_noEvent(itemContext, obj);
QDeclarative_setParent_noEvent(item, q);
d->initializeObjectWithInitialProperties(qmlGlobalForIpv, initialPropertyValues, obj);
}
-void QSGLoaderIncubator::statusChanged(Status status)
+void QQuickLoaderIncubator::statusChanged(Status status)
{
loader->incubatorStateChanged(status);
}
-void QSGLoaderPrivate::incubatorStateChanged(QDeclarativeIncubator::Status status)
+void QQuickLoaderPrivate::incubatorStateChanged(QDeclarativeIncubator::Status status)
{
- Q_Q(QSGLoader);
+ Q_Q(QQuickLoader);
if (status == QDeclarativeIncubator::Loading || status == QDeclarativeIncubator::Null)
return;
if (status == QDeclarativeIncubator::Ready) {
QObject *obj = incubator->object();
- item = qobject_cast<QSGItem*>(obj);
+ item = qobject_cast<QQuickItem*>(obj);
if (item) {
initResize();
} else {
- qmlInfo(q) << QSGLoader::tr("Loader does not support loading non-visual elements.");
+ qmlInfo(q) << QQuickLoader::tr("Loader does not support loading non-visual elements.");
delete itemContext;
itemContext = 0;
delete obj;
disposeInitialPropertyValues(); // cleanup
}
-void QSGLoaderPrivate::_q_sourceLoaded()
+void QQuickLoaderPrivate::_q_sourceLoaded()
{
- Q_Q(QSGLoader);
+ Q_Q(QQuickLoader);
if (!component || !component->errors().isEmpty()) {
if (component)
QDeclarativeEnginePrivate::warning(qmlEngine(q), component->errors());
}
}
if (!incubator)
- incubator = new QSGLoaderIncubator(this, asynchronous ? QDeclarativeIncubator::Asynchronous : QDeclarativeIncubator::AsynchronousIfNested);
+ incubator = new QQuickLoaderIncubator(this, asynchronous ? QDeclarativeIncubator::Asynchronous : QDeclarativeIncubator::AsynchronousIfNested);
component->create(*incubator, itemContext);
\sa progress
*/
-QSGLoader::Status QSGLoader::status() const
+QQuickLoader::Status QQuickLoader::status() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
if (!d->active)
return Null;
return d->source.isEmpty() ? Null : Error;
}
-void QSGLoader::componentComplete()
+void QQuickLoader::componentComplete()
{
- Q_D(QSGLoader);
- QSGItem::componentComplete();
+ Q_D(QQuickLoader);
+ QQuickItem::componentComplete();
if (active()) {
if (d->loadingFromSource) {
d->component = new QDeclarativeComponent(qmlEngine(this), d->source, this);
\sa status
*/
-qreal QSGLoader::progress() const
+qreal QQuickLoader::progress() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
if (d->item)
return 1.0;
Note that this property affects object instantiation only; it is unrelated to
loading a component asynchronously via a network.
*/
-bool QSGLoader::asynchronous() const
+bool QQuickLoader::asynchronous() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
return d->asynchronous;
}
-void QSGLoader::setAsynchronous(bool a)
+void QQuickLoader::setAsynchronous(bool a)
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (d->asynchronous == a)
return;
emit asynchronousChanged();
}
-void QSGLoaderPrivate::_q_updateSize(bool loaderGeometryChanged)
+void QQuickLoaderPrivate::_q_updateSize(bool loaderGeometryChanged)
{
- Q_Q(QSGLoader);
+ Q_Q(QQuickLoader);
if (!item || updatingSize)
return;
\qmlproperty Item QtQuick2::Loader::item
This property holds the top-level item that is currently loaded.
*/
-QSGItem *QSGLoader::item() const
+QQuickItem *QQuickLoader::item() const
{
- Q_D(const QSGLoader);
+ Q_D(const QQuickLoader);
return d->item;
}
-void QSGLoader::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickLoader::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_D(QSGLoader);
+ Q_D(QQuickLoader);
if (newGeometry != oldGeometry) {
d->_q_updateSize();
}
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
}
-QUrl QSGLoaderPrivate::resolveSourceUrl(QDeclarativeV8Function *args)
+QUrl QQuickLoaderPrivate::resolveSourceUrl(QDeclarativeV8Function *args)
{
QV8Engine *v8engine = args->engine();
QString arg = v8engine->toString((*args)[0]->ToString());
return context->resolvedUrl(QUrl(arg));
}
-v8::Handle<v8::Object> QSGLoaderPrivate::extractInitialPropertyValues(QDeclarativeV8Function *args, QObject *loader, bool *error)
+v8::Handle<v8::Object> QQuickLoaderPrivate::extractInitialPropertyValues(QDeclarativeV8Function *args, QObject *loader, bool *error)
{
v8::Local<v8::Object> valuemap;
if (args->Length() >= 2) {
return valuemap;
}
-#include <moc_qsgloader_p.cpp>
+#include <moc_qquickloader_p.cpp>
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGLOADER_P_H
-#define QSGLOADER_P_H
+#ifndef QQUICKLOADER_P_H
+#define QQUICKLOADER_P_H
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGLoaderPrivate;
-class Q_AUTOTEST_EXPORT QSGLoader : public QSGImplicitSizeItem
+class QQuickLoaderPrivate;
+class Q_AUTOTEST_EXPORT QQuickLoader : public QQuickImplicitSizeItem
{
Q_OBJECT
Q_ENUMS(Status)
Q_PROPERTY(bool active READ active WRITE setActive NOTIFY activeChanged)
Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
Q_PROPERTY(QDeclarativeComponent *sourceComponent READ sourceComponent WRITE setSourceComponent RESET resetSourceComponent NOTIFY sourceComponentChanged)
- Q_PROPERTY(QSGItem *item READ item NOTIFY itemChanged)
+ Q_PROPERTY(QQuickItem *item READ item NOTIFY itemChanged)
Q_PROPERTY(Status status READ status NOTIFY statusChanged)
Q_PROPERTY(qreal progress READ progress NOTIFY progressChanged)
Q_PROPERTY(bool asynchronous READ asynchronous WRITE setAsynchronous NOTIFY asynchronousChanged)
public:
- QSGLoader(QSGItem *parent = 0);
- virtual ~QSGLoader();
+ QQuickLoader(QQuickItem *parent = 0);
+ virtual ~QQuickLoader();
bool active() const;
void setActive(bool newVal);
bool asynchronous() const;
void setAsynchronous(bool a);
- QSGItem *item() const;
+ QQuickItem *item() const;
Q_SIGNALS:
void itemChanged();
void setSource(const QUrl &sourceUrl, bool needsClear);
void loadFromSource();
void loadFromSourceComponent();
- Q_DISABLE_COPY(QSGLoader)
- Q_DECLARE_PRIVATE(QSGLoader)
+ Q_DISABLE_COPY(QQuickLoader)
+ Q_DECLARE_PRIVATE(QQuickLoader)
Q_PRIVATE_SLOT(d_func(), void _q_sourceLoaded())
Q_PRIVATE_SLOT(d_func(), void _q_updateSize())
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGLoader)
+QML_DECLARE_TYPE(QQuickLoader)
QT_END_HEADER
-#endif // QSGLOADER_P_H
+#endif // QQUICKLOADER_P_H
**
****************************************************************************/
-#ifndef QSGLOADER_P_P_H
-#define QSGLOADER_P_P_H
+#ifndef QQUICKLOADER_P_P_H
+#define QQUICKLOADER_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgloader_p.h"
-#include "qsgimplicitsizeitem_p_p.h"
-#include "qsgitemchangelistener_p.h"
+#include "qquickloader_p.h"
+#include "qquickimplicitsizeitem_p_p.h"
+#include "qquickitemchangelistener_p.h"
#include <qdeclarativeincubator.h>
#include <private/qv8_p.h>
QT_BEGIN_NAMESPACE
-class QSGLoaderPrivate;
-class QSGLoaderIncubator : public QDeclarativeIncubator
+class QQuickLoaderPrivate;
+class QQuickLoaderIncubator : public QDeclarativeIncubator
{
public:
- QSGLoaderIncubator(QSGLoaderPrivate *l, IncubationMode mode) : QDeclarativeIncubator(mode), loader(l) {}
+ QQuickLoaderIncubator(QQuickLoaderPrivate *l, IncubationMode mode) : QDeclarativeIncubator(mode), loader(l) {}
protected:
virtual void statusChanged(Status);
virtual void setInitialState(QObject *);
private:
- QSGLoaderPrivate *loader;
+ QQuickLoaderPrivate *loader;
};
class QDeclarativeContext;
-class QSGLoaderPrivate : public QSGImplicitSizeItemPrivate, public QSGItemChangeListener
+class QQuickLoaderPrivate : public QQuickImplicitSizeItemPrivate, public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGLoader)
+ Q_DECLARE_PUBLIC(QQuickLoader)
public:
- QSGLoaderPrivate();
- ~QSGLoaderPrivate();
+ QQuickLoaderPrivate();
+ ~QQuickLoaderPrivate();
- void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+ void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
void clear();
void initResize();
void load();
v8::Handle<v8::Object> extractInitialPropertyValues(QDeclarativeV8Function *args, QObject *loader, bool *error);
QUrl source;
- QSGItem *item;
+ QQuickItem *item;
QDeclarativeComponent *component;
QDeclarativeContext *itemContext;
- QSGLoaderIncubator *incubator;
+ QQuickLoaderIncubator *incubator;
v8::Persistent<v8::Object> initialPropertyValues;
v8::Persistent<v8::Object> qmlGlobalForIpv;
bool updatingSize: 1;
QT_END_NAMESPACE
-#endif // QSGLOADER_P_P_H
+#endif // QQUICKLOADER_P_P_H
**
****************************************************************************/
-#include "qsgmousearea_p.h"
-#include "qsgmousearea_p_p.h"
-#include "qsgcanvas.h"
-#include "qsgevents_p_p.h"
-#include "qsgdrag_p.h"
+#include "qquickmousearea_p.h"
+#include "qquickmousearea_p_p.h"
+#include "qquickcanvas.h"
+#include "qquickevents_p_p.h"
+#include "qquickdrag_p.h"
#include <QtGui/qevent.h>
#include <QtGui/qguiapplication.h>
QT_BEGIN_NAMESPACE
static const int PressAndHoldDelay = 800;
-QSGDrag::QSGDrag(QObject *parent)
+QQuickDrag::QQuickDrag(QObject *parent)
: QObject(parent), _target(0), _axis(XandYAxis), _xmin(-FLT_MAX),
_xmax(FLT_MAX), _ymin(-FLT_MAX), _ymax(FLT_MAX), _active(false), _filterChildren(false)
{
}
-QSGDrag::~QSGDrag()
+QQuickDrag::~QQuickDrag()
{
}
-QSGItem *QSGDrag::target() const
+QQuickItem *QQuickDrag::target() const
{
return _target;
}
-void QSGDrag::setTarget(QSGItem *t)
+void QQuickDrag::setTarget(QQuickItem *t)
{
if (_target == t)
return;
emit targetChanged();
}
-void QSGDrag::resetTarget()
+void QQuickDrag::resetTarget()
{
if (_target == 0)
return;
emit targetChanged();
}
-QSGDrag::Axis QSGDrag::axis() const
+QQuickDrag::Axis QQuickDrag::axis() const
{
return _axis;
}
-void QSGDrag::setAxis(QSGDrag::Axis a)
+void QQuickDrag::setAxis(QQuickDrag::Axis a)
{
if (_axis == a)
return;
emit axisChanged();
}
-qreal QSGDrag::xmin() const
+qreal QQuickDrag::xmin() const
{
return _xmin;
}
-void QSGDrag::setXmin(qreal m)
+void QQuickDrag::setXmin(qreal m)
{
if (_xmin == m)
return;
emit minimumXChanged();
}
-qreal QSGDrag::xmax() const
+qreal QQuickDrag::xmax() const
{
return _xmax;
}
-void QSGDrag::setXmax(qreal m)
+void QQuickDrag::setXmax(qreal m)
{
if (_xmax == m)
return;
emit maximumXChanged();
}
-qreal QSGDrag::ymin() const
+qreal QQuickDrag::ymin() const
{
return _ymin;
}
-void QSGDrag::setYmin(qreal m)
+void QQuickDrag::setYmin(qreal m)
{
if (_ymin == m)
return;
emit minimumYChanged();
}
-qreal QSGDrag::ymax() const
+qreal QQuickDrag::ymax() const
{
return _ymax;
}
-void QSGDrag::setYmax(qreal m)
+void QQuickDrag::setYmax(qreal m)
{
if (_ymax == m)
return;
emit maximumYChanged();
}
-bool QSGDrag::active() const
+bool QQuickDrag::active() const
{
return _active;
}
-void QSGDrag::setActive(bool drag)
+void QQuickDrag::setActive(bool drag)
{
if (_active == drag)
return;
emit activeChanged();
}
-bool QSGDrag::filterChildren() const
+bool QQuickDrag::filterChildren() const
{
return _filterChildren;
}
-void QSGDrag::setFilterChildren(bool filter)
+void QQuickDrag::setFilterChildren(bool filter)
{
if (_filterChildren == filter)
return;
emit filterChildrenChanged();
}
-QSGDragAttached *QSGDrag::qmlAttachedProperties(QObject *obj)
+QQuickDragAttached *QQuickDrag::qmlAttachedProperties(QObject *obj)
{
- return new QSGDragAttached(obj);
+ return new QQuickDragAttached(obj);
}
-QSGMouseAreaPrivate::QSGMouseAreaPrivate()
+QQuickMouseAreaPrivate::QQuickMouseAreaPrivate()
: absorb(true), hovered(false), pressed(false), longPress(false),
moved(false), stealMouse(false), doubleClick(false), preventStealing(false),
drag(0)
{
}
-QSGMouseAreaPrivate::~QSGMouseAreaPrivate()
+QQuickMouseAreaPrivate::~QQuickMouseAreaPrivate()
{
delete drag;
}
-void QSGMouseAreaPrivate::init()
+void QQuickMouseAreaPrivate::init()
{
- Q_Q(QSGMouseArea);
+ Q_Q(QQuickMouseArea);
q->setAcceptedMouseButtons(Qt::LeftButton);
q->setFiltersChildMouseEvents(true);
}
-void QSGMouseAreaPrivate::saveEvent(QMouseEvent *event)
+void QQuickMouseAreaPrivate::saveEvent(QMouseEvent *event)
{
lastPos = event->localPos();
lastScenePos = event->windowPos();
lastModifiers = event->modifiers();
}
-bool QSGMouseAreaPrivate::isPressAndHoldConnected()
+bool QQuickMouseAreaPrivate::isPressAndHoldConnected()
{
- Q_Q(QSGMouseArea);
- static int idx = QObjectPrivate::get(q)->signalIndex("pressAndHold(QSGMouseEvent*)");
+ Q_Q(QQuickMouseArea);
+ static int idx = QObjectPrivate::get(q)->signalIndex("pressAndHold(QQuickMouseEvent*)");
return QObjectPrivate::get(q)->isSignalConnected(idx);
}
-bool QSGMouseAreaPrivate::isDoubleClickConnected()
+bool QQuickMouseAreaPrivate::isDoubleClickConnected()
{
- Q_Q(QSGMouseArea);
- static int idx = QObjectPrivate::get(q)->signalIndex("doubleClicked(QSGMouseEvent*)");
+ Q_Q(QQuickMouseArea);
+ static int idx = QObjectPrivate::get(q)->signalIndex("doubleClicked(QQuickMouseEvent*)");
return QObjectPrivate::get(q)->isSignalConnected(idx);
}
-bool QSGMouseAreaPrivate::isClickConnected()
+bool QQuickMouseAreaPrivate::isClickConnected()
{
- Q_Q(QSGMouseArea);
- static int idx = QObjectPrivate::get(q)->signalIndex("clicked(QSGMouseEvent*)");
+ Q_Q(QQuickMouseArea);
+ static int idx = QObjectPrivate::get(q)->signalIndex("clicked(QQuickMouseEvent*)");
return QObjectPrivate::get(q)->isSignalConnected(idx);
}
-void QSGMouseAreaPrivate::propagate(QSGMouseEvent* event, PropagateType t)
+void QQuickMouseAreaPrivate::propagate(QQuickMouseEvent* event, PropagateType t)
{
- Q_Q(QSGMouseArea);
+ Q_Q(QQuickMouseArea);
QPointF scenePos = q->mapToScene(QPointF(event->x(), event->y()));
propagateHelper(event, canvas->rootItem(), scenePos, t);
}
-bool QSGMouseAreaPrivate::propagateHelper(QSGMouseEvent *ev, QSGItem *item,const QPointF &sp, PropagateType sig)
+bool QQuickMouseAreaPrivate::propagateHelper(QQuickMouseEvent *ev, QQuickItem *item,const QPointF &sp, PropagateType sig)
{
- //Based off of QSGCanvas::deliverInitialMousePressEvent
+ //Based off of QQuickCanvas::deliverInitialMousePressEvent
//But specific to MouseArea, so doesn't belong in canvas
- Q_Q(const QSGMouseArea);
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+ Q_Q(const QQuickMouseArea);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->opacity == 0.0)
return false;
- if (itemPrivate->flags & QSGItem::ItemClipsChildrenToShape) {
+ if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
QPointF p = item->mapFromScene(sp);
if (!QRectF(0, 0, item->width(), item->height()).contains(p))
return false;
}
- QList<QSGItem *> children = itemPrivate->paintOrderChildItems();
+ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
for (int ii = children.count() - 1; ii >= 0; --ii) {
- QSGItem *child = children.at(ii);
+ QQuickItem *child = children.at(ii);
if (!child->isVisible() || !child->isEnabled())
continue;
if (propagateHelper(ev, child, sp, sig))
return true;
}
- QSGMouseArea* ma = qobject_cast<QSGMouseArea*>(item);
+ QQuickMouseArea* ma = qobject_cast<QQuickMouseArea*>(item);
if (ma && ma != q && itemPrivate->acceptedMouseButtons & ev->button()) {
switch (sig) {
case Click:
}
/*!
- \qmlclass MouseArea QSGMouseArea
+ \qmlclass MouseArea QQuickMouseArea
\inqmlmodule QtQuick 2
\ingroup qml-basic-interaction-elements
\brief The MouseArea item enables simple mouse handling.
the logic when the MouseArea has lost the mouse handling to the \l Flickable,
\c onCanceled should be used in addition to onReleased.
*/
-QSGMouseArea::QSGMouseArea(QSGItem *parent)
- : QSGItem(*(new QSGMouseAreaPrivate), parent)
+QQuickMouseArea::QQuickMouseArea(QQuickItem *parent)
+ : QQuickItem(*(new QQuickMouseAreaPrivate), parent)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
d->init();
}
-QSGMouseArea::~QSGMouseArea()
+QQuickMouseArea::~QQuickMouseArea()
{
}
The coordinates are relative to the MouseArea.
*/
-qreal QSGMouseArea::mouseX() const
+qreal QQuickMouseArea::mouseX() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->lastPos.x();
}
-qreal QSGMouseArea::mouseY() const
+qreal QQuickMouseArea::mouseY() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->lastPos.y();
}
By default, this property is true.
*/
-bool QSGMouseArea::isEnabled() const
+bool QQuickMouseArea::isEnabled() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->absorb;
}
-void QSGMouseArea::setEnabled(bool a)
+void QQuickMouseArea::setEnabled(bool a)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (a != d->absorb) {
d->absorb = a;
emit enabledChanged();
By default this property is false.
*/
-bool QSGMouseArea::preventStealing() const
+bool QQuickMouseArea::preventStealing() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->preventStealing;
}
-void QSGMouseArea::setPreventStealing(bool prevent)
+void QQuickMouseArea::setPreventStealing(bool prevent)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (prevent != d->preventStealing) {
d->preventStealing = prevent;
setKeepMouseGrab(d->preventStealing && d->absorb);
\sa acceptedButtons
*/
-Qt::MouseButtons QSGMouseArea::pressedButtons() const
+Qt::MouseButtons QQuickMouseArea::pressedButtons() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->lastButtons;
}
-void QSGMouseArea::mousePressEvent(QMouseEvent *event)
+void QQuickMouseArea::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
d->moved = false;
d->stealMouse = d->preventStealing;
if (!d->absorb)
- QSGItem::mousePressEvent(event);
+ QQuickItem::mousePressEvent(event);
else {
d->longPress = false;
d->saveEvent(event);
if (d->drag) {
- d->dragX = drag()->axis() & QSGDrag::XAxis;
- d->dragY = drag()->axis() & QSGDrag::YAxis;
+ d->dragX = drag()->axis() & QQuickDrag::XAxis;
+ d->dragY = drag()->axis() & QQuickDrag::YAxis;
}
if (d->drag)
d->drag->setActive(false);
}
}
-void QSGMouseArea::mouseMoveEvent(QMouseEvent *event)
+void QQuickMouseArea::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (!d->absorb) {
- QSGItem::mouseMoveEvent(event);
+ QQuickItem::mouseMoveEvent(event);
return;
}
d->moved = true;
}
- QSGMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress);
+ QQuickMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress);
emit mouseXChanged(&me);
me.setPosition(d->lastPos);
emit mouseYChanged(&me);
emit positionChanged(&me);
}
-void QSGMouseArea::mouseReleaseEvent(QMouseEvent *event)
+void QQuickMouseArea::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
d->stealMouse = false;
if (!d->absorb) {
- QSGItem::mouseReleaseEvent(event);
+ QQuickItem::mouseReleaseEvent(event);
} else {
d->saveEvent(event);
setPressed(false);
// If we don't accept hover, we need to reset containsMouse.
if (!acceptHoverEvents())
setHovered(false);
- QSGCanvas *c = canvas();
+ QQuickCanvas *c = canvas();
if (c && c->mouseGrabberItem() == this)
ungrabMouse();
setKeepMouseGrab(false);
d->doubleClick = false;
}
-void QSGMouseArea::mouseDoubleClickEvent(QMouseEvent *event)
+void QQuickMouseArea::mouseDoubleClickEvent(QMouseEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (d->absorb) {
d->saveEvent(event);
- QSGMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, true, false);
+ QQuickMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, true, false);
me.setAccepted(d->isDoubleClickConnected());
emit this->doubleClicked(&me);
if (!me.isAccepted())
- d->propagate(&me, QSGMouseAreaPrivate::DoubleClick);
+ d->propagate(&me, QQuickMouseAreaPrivate::DoubleClick);
d->doubleClick = d->isDoubleClickConnected() || me.isAccepted();
}
- QSGItem::mouseDoubleClickEvent(event);
+ QQuickItem::mouseDoubleClickEvent(event);
}
-void QSGMouseArea::hoverEnterEvent(QHoverEvent *event)
+void QQuickMouseArea::hoverEnterEvent(QHoverEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (!d->absorb) {
- QSGItem::hoverEnterEvent(event);
+ QQuickItem::hoverEnterEvent(event);
} else {
d->lastPos = event->posF();
d->lastModifiers = event->modifiers();
setHovered(true);
- QSGMouseEvent me(d->lastPos.x(), d->lastPos.y(), Qt::NoButton, Qt::NoButton, d->lastModifiers, false, false);
+ QQuickMouseEvent me(d->lastPos.x(), d->lastPos.y(), Qt::NoButton, Qt::NoButton, d->lastModifiers, false, false);
emit mouseXChanged(&me);
me.setPosition(d->lastPos);
emit mouseYChanged(&me);
}
}
-void QSGMouseArea::hoverMoveEvent(QHoverEvent *event)
+void QQuickMouseArea::hoverMoveEvent(QHoverEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (!d->absorb) {
- QSGItem::hoverMoveEvent(event);
+ QQuickItem::hoverMoveEvent(event);
} else {
d->lastPos = event->posF();
d->lastModifiers = event->modifiers();
- QSGMouseEvent me(d->lastPos.x(), d->lastPos.y(), Qt::NoButton, Qt::NoButton, d->lastModifiers, false, false);
+ QQuickMouseEvent me(d->lastPos.x(), d->lastPos.y(), Qt::NoButton, Qt::NoButton, d->lastModifiers, false, false);
emit mouseXChanged(&me);
me.setPosition(d->lastPos);
emit mouseYChanged(&me);
}
}
-void QSGMouseArea::hoverLeaveEvent(QHoverEvent *event)
+void QQuickMouseArea::hoverLeaveEvent(QHoverEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (!d->absorb)
- QSGItem::hoverLeaveEvent(event);
+ QQuickItem::hoverLeaveEvent(event);
else
setHovered(false);
}
-void QSGMouseArea::ungrabMouse()
+void QQuickMouseArea::ungrabMouse()
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (d->pressed) {
// if our mouse grab has been removed (probably by Flickable), fix our
// state
}
}
-void QSGMouseArea::mouseUngrabEvent()
+void QQuickMouseArea::mouseUngrabEvent()
{
ungrabMouse();
}
-bool QSGMouseArea::sendMouseEvent(QMouseEvent *event)
+bool QQuickMouseArea::sendMouseEvent(QMouseEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
QRectF myRect = mapRectToScene(QRectF(0, 0, width(), height()));
- QSGCanvas *c = canvas();
- QSGItem *grabber = c ? c->mouseGrabberItem() : 0;
+ QQuickCanvas *c = canvas();
+ QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || myRect.contains(event->windowPos())) && (!grabber || !grabber->keepMouseGrab())) {
QMouseEvent mouseEvent(event->type(), mapFromScene(event->windowPos()), event->windowPos(), event->screenPos(),
return false;
}
-bool QSGMouseArea::childMouseEventFilter(QSGItem *i, QEvent *e)
+bool QQuickMouseArea::childMouseEventFilter(QQuickItem *i, QEvent *e)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (!d->absorb || !isVisible() || !d->drag || !d->drag->filterChildren())
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
switch (e->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
break;
}
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
}
-void QSGMouseArea::timerEvent(QTimerEvent *event)
+void QQuickMouseArea::timerEvent(QTimerEvent *event)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (event->timerId() == d->pressAndHoldTimer.timerId()) {
d->pressAndHoldTimer.stop();
bool dragged = d->drag && d->drag->active();
if (d->pressed && dragged == false && d->hovered == true) {
d->longPress = true;
- QSGMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress);
+ QQuickMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress);
me.setAccepted(d->isPressAndHoldConnected());
emit pressAndHold(&me);
if (!me.isAccepted())
- d->propagate(&me, QSGMouseAreaPrivate::PressAndHold);
+ d->propagate(&me, QQuickMouseAreaPrivate::PressAndHold);
if (!me.isAccepted()) // no one handled the long press - allow click
d->longPress = false;
}
}
}
-void QSGMouseArea::windowDeactivateEvent()
+void QQuickMouseArea::windowDeactivateEvent()
{
ungrabMouse();
- QSGItem::windowDeactivateEvent();
+ QQuickItem::windowDeactivateEvent();
}
-void QSGMouseArea::geometryChanged(const QRectF &newGeometry,
+void QQuickMouseArea::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
- Q_D(QSGMouseArea);
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ Q_D(QQuickMouseArea);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
if (d->lastScenePos.isNull)
d->lastScenePos = mapToScene(d->lastPos);
d->lastPos = mapFromScene(d->lastScenePos);
}
-void QSGMouseArea::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickMouseArea::itemChange(ItemChange change, const ItemChangeData &value)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
switch (change) {
case ItemVisibleHasChanged:
if (acceptHoverEvents() && d->hovered != (isVisible() && isUnderMouse()))
break;
}
- QSGItem::itemChange(change, value);
+ QQuickItem::itemChange(change, value);
}
/*!
This property affects the containsMouse property and the onEntered, onExited and
onPositionChanged signals.
*/
-bool QSGMouseArea::hoverEnabled() const
+bool QQuickMouseArea::hoverEnabled() const
{
return acceptHoverEvents();
}
-void QSGMouseArea::setHoverEnabled(bool h)
+void QQuickMouseArea::setHoverEnabled(bool h)
{
if (h == acceptHoverEvents())
return;
\warning This property is not updated if the area moves under the mouse: \e containsMouse will not change.
In addition, if hoverEnabled is false, containsMouse will only be valid when the mouse is pressed.
*/
-bool QSGMouseArea::hovered() const
+bool QQuickMouseArea::hovered() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->hovered;
}
\qmlproperty bool QtQuick2::MouseArea::pressed
This property holds whether the mouse area is currently pressed.
*/
-bool QSGMouseArea::pressed() const
+bool QQuickMouseArea::pressed() const
{
- Q_D(const QSGMouseArea);
+ Q_D(const QQuickMouseArea);
return d->pressed;
}
-void QSGMouseArea::setHovered(bool h)
+void QQuickMouseArea::setHovered(bool h)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (d->hovered != h) {
d->hovered = h;
emit hoveredChanged();
The default value is \c Qt.LeftButton.
*/
-Qt::MouseButtons QSGMouseArea::acceptedButtons() const
+Qt::MouseButtons QQuickMouseArea::acceptedButtons() const
{
return acceptedMouseButtons();
}
-void QSGMouseArea::setAcceptedButtons(Qt::MouseButtons buttons)
+void QQuickMouseArea::setAcceptedButtons(Qt::MouseButtons buttons)
{
if (buttons != acceptedMouseButtons()) {
setAcceptedMouseButtons(buttons);
}
}
-bool QSGMouseArea::setPressed(bool p)
+bool QQuickMouseArea::setPressed(bool p)
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
bool dragged = d->drag && d->drag->active();
bool isclick = d->pressed == true && p == false && dragged == false && d->hovered == true;
if (d->pressed != p) {
d->pressed = p;
- QSGMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, isclick, d->longPress);
+ QQuickMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, isclick, d->longPress);
if (d->pressed) {
if (!d->doubleClick)
emit pressed(&me);
me.setAccepted(d->isClickConnected());
emit clicked(&me);
if (!me.isAccepted())
- d->propagate(&me, QSGMouseAreaPrivate::Click);
+ d->propagate(&me, QQuickMouseAreaPrivate::Click);
}
}
*/
-QSGDrag *QSGMouseArea::drag()
+QQuickDrag *QQuickMouseArea::drag()
{
- Q_D(QSGMouseArea);
+ Q_D(QQuickMouseArea);
if (!d->drag)
- d->drag = new QSGDrag;
+ d->drag = new QQuickDrag;
return d->drag;
}
**
****************************************************************************/
-#ifndef QSGMOUSEAREA_P_H
-#define QSGMOUSEAREA_P_H
+#ifndef QQUICKMOUSEAREA_P_H
+#define QQUICKMOUSEAREA_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <QtCore/qstringlist.h>
QT_MODULE(Declarative)
-class QSGDragAttached;
-class QSGMouseEvent;
-class Q_AUTOTEST_EXPORT QSGDrag : public QObject
+class QQuickDragAttached;
+class QQuickMouseEvent;
+class Q_AUTOTEST_EXPORT QQuickDrag : public QObject
{
Q_OBJECT
Q_ENUMS(Axis)
- Q_PROPERTY(QSGItem *target READ target WRITE setTarget NOTIFY targetChanged RESET resetTarget)
+ Q_PROPERTY(QQuickItem *target READ target WRITE setTarget NOTIFY targetChanged RESET resetTarget)
Q_PROPERTY(Axis axis READ axis WRITE setAxis NOTIFY axisChanged)
Q_PROPERTY(qreal minimumX READ xmin WRITE setXmin NOTIFY minimumXChanged)
Q_PROPERTY(qreal maximumX READ xmax WRITE setXmax NOTIFY maximumXChanged)
//### consider drag and drop
public:
- QSGDrag(QObject *parent=0);
- ~QSGDrag();
+ QQuickDrag(QObject *parent=0);
+ ~QQuickDrag();
- QSGItem *target() const;
- void setTarget(QSGItem *target);
+ QQuickItem *target() const;
+ void setTarget(QQuickItem *target);
void resetTarget();
enum Axis { XAxis=0x01, YAxis=0x02, XandYAxis=0x03 };
bool filterChildren() const;
void setFilterChildren(bool);
- static QSGDragAttached *qmlAttachedProperties(QObject *obj);
+ static QQuickDragAttached *qmlAttachedProperties(QObject *obj);
Q_SIGNALS:
void targetChanged();
void filterChildrenChanged();
private:
- QSGItem *_target;
+ QQuickItem *_target;
Axis _axis;
qreal _xmin;
qreal _xmax;
qreal _ymax;
bool _active : 1;
bool _filterChildren: 1;
- Q_DISABLE_COPY(QSGDrag)
+ Q_DISABLE_COPY(QQuickDrag)
};
-class QSGMouseAreaPrivate;
+class QQuickMouseAreaPrivate;
// used in QtLocation
-class Q_DECLARATIVE_EXPORT QSGMouseArea : public QSGItem
+class Q_DECLARATIVE_EXPORT QQuickMouseArea : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(Qt::MouseButtons pressedButtons READ pressedButtons NOTIFY pressedChanged)
Q_PROPERTY(Qt::MouseButtons acceptedButtons READ acceptedButtons WRITE setAcceptedButtons NOTIFY acceptedButtonsChanged)
Q_PROPERTY(bool hoverEnabled READ hoverEnabled WRITE setHoverEnabled NOTIFY hoverEnabledChanged)
- Q_PROPERTY(QSGDrag *drag READ drag CONSTANT) //### add flicking to QSGDrag or add a QDeclarativeFlick ???
+ Q_PROPERTY(QQuickDrag *drag READ drag CONSTANT) //### add flicking to QQuickDrag or add a QDeclarativeFlick ???
Q_PROPERTY(bool preventStealing READ preventStealing WRITE setPreventStealing NOTIFY preventStealingChanged)
public:
- QSGMouseArea(QSGItem *parent=0);
- ~QSGMouseArea();
+ QQuickMouseArea(QQuickItem *parent=0);
+ ~QQuickMouseArea();
qreal mouseX() const;
qreal mouseY() const;
bool hoverEnabled() const;
void setHoverEnabled(bool h);
- QSGDrag *drag();
+ QQuickDrag *drag();
bool preventStealing() const;
void setPreventStealing(bool prevent);
void enabledChanged();
void acceptedButtonsChanged();
void hoverEnabledChanged();
- void positionChanged(QSGMouseEvent *mouse);
- void mouseXChanged(QSGMouseEvent *mouse);
- void mouseYChanged(QSGMouseEvent *mouse);
+ void positionChanged(QQuickMouseEvent *mouse);
+ void mouseXChanged(QQuickMouseEvent *mouse);
+ void mouseYChanged(QQuickMouseEvent *mouse);
void preventStealingChanged();
- void pressed(QSGMouseEvent *mouse);
- void pressAndHold(QSGMouseEvent *mouse);
- void released(QSGMouseEvent *mouse);
- void clicked(QSGMouseEvent *mouse);
- void doubleClicked(QSGMouseEvent *mouse);
+ void pressed(QQuickMouseEvent *mouse);
+ void pressAndHold(QQuickMouseEvent *mouse);
+ void released(QQuickMouseEvent *mouse);
+ void clicked(QQuickMouseEvent *mouse);
+ void doubleClicked(QQuickMouseEvent *mouse);
void entered();
void exited();
void canceled();
virtual void hoverEnterEvent(QHoverEvent *event);
virtual void hoverMoveEvent(QHoverEvent *event);
virtual void hoverLeaveEvent(QHoverEvent *event);
- virtual bool childMouseEventFilter(QSGItem *i, QEvent *e);
+ virtual bool childMouseEventFilter(QQuickItem *i, QEvent *e);
virtual void timerEvent(QTimerEvent *event);
virtual void windowDeactivateEvent();
void ungrabMouse();
private:
- Q_DISABLE_COPY(QSGMouseArea)
- Q_DECLARE_PRIVATE(QSGMouseArea)
+ Q_DISABLE_COPY(QQuickMouseArea)
+ Q_DECLARE_PRIVATE(QQuickMouseArea)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGDrag)
-QML_DECLARE_TYPEINFO(QSGDrag, QML_HAS_ATTACHED_PROPERTIES)
-QML_DECLARE_TYPE(QSGMouseArea)
+QML_DECLARE_TYPE(QQuickDrag)
+QML_DECLARE_TYPEINFO(QQuickDrag, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickMouseArea)
QT_END_HEADER
-#endif // QSGMOUSEAREA_P_H
+#endif // QQUICKMOUSEAREA_P_H
**
****************************************************************************/
-#ifndef QSGMOUSEAREA_P_P_H
-#define QSGMOUSEAREA_P_P_H
+#ifndef QQUICKMOUSEAREA_P_P_H
+#define QQUICKMOUSEAREA_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgitem_p.h"
+#include "qquickitem_p.h"
#include <QtGui/qevent.h>
#include <QtCore/qbasictimer.h>
QT_BEGIN_NAMESPACE
-class QSGMouseEvent;
-class QSGMouseArea;
-class QSGMouseAreaPrivate : public QSGItemPrivate
+class QQuickMouseEvent;
+class QQuickMouseArea;
+class QQuickMouseAreaPrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGMouseArea)
+ Q_DECLARE_PUBLIC(QQuickMouseArea)
public:
- QSGMouseAreaPrivate();
- ~QSGMouseAreaPrivate();
+ QQuickMouseAreaPrivate();
+ ~QQuickMouseAreaPrivate();
void init();
void saveEvent(QMouseEvent *event);
DoubleClick,
PressAndHold
};
- void propagate(QSGMouseEvent* event, PropagateType);
- bool propagateHelper(QSGMouseEvent*, QSGItem*,const QPointF &, PropagateType);
+ void propagate(QQuickMouseEvent* event, PropagateType);
+ bool propagateHelper(QQuickMouseEvent*, QQuickItem*,const QPointF &, PropagateType);
bool isPressAndHoldConnected();
bool isDoubleClickConnected();
bool stealMouse : 1;
bool doubleClick : 1;
bool preventStealing : 1;
- QSGDrag *drag;
+ QQuickDrag *drag;
QPointF startScene;
QPointF targetStartPos;
QPointF lastPos;
QT_END_NAMESPACE
-#endif // QSGMOUSEAREA_P_P_H
+#endif // QQUICKMOUSEAREA_P_P_H
**
****************************************************************************/
-#include "qsgninepatchnode_p.h"
+#include "qquickninepatchnode_p.h"
#include <private/qsgadaptationlayer_p.h>
#include <private/qmath_p.h>
-QSGNinePatchNode::QSGNinePatchNode()
+QQuickNinePatchNode::QQuickNinePatchNode()
: m_geometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 0)
- , m_horizontalTileMode(QSGBorderImage::Stretch)
- , m_verticalTileMode(QSGBorderImage::Stretch)
+ , m_horizontalTileMode(QQuickBorderImage::Stretch)
+ , m_verticalTileMode(QQuickBorderImage::Stretch)
, m_dirtyGeometry(false)
, m_mirror(false)
{
#endif
}
-void QSGNinePatchNode::setInnerRect(const QRectF &rect)
+void QQuickNinePatchNode::setInnerRect(const QRectF &rect)
{
if (m_innerRect == rect)
return;
m_dirtyGeometry = true;
}
-void QSGNinePatchNode::setRect(const QRectF &rect)
+void QQuickNinePatchNode::setRect(const QRectF &rect)
{
if (m_targetRect == rect)
return;
m_dirtyGeometry = true;
}
-void QSGNinePatchNode::setHorzontalTileMode(QSGBorderImage::TileMode mode)
+void QQuickNinePatchNode::setHorzontalTileMode(QQuickBorderImage::TileMode mode)
{
- if (mode == QSGBorderImage::TileMode(m_horizontalTileMode))
+ if (mode == QQuickBorderImage::TileMode(m_horizontalTileMode))
return;
m_horizontalTileMode = mode;
m_dirtyGeometry = true;
}
-void QSGNinePatchNode::setVerticalTileMode(QSGBorderImage::TileMode mode)
+void QQuickNinePatchNode::setVerticalTileMode(QQuickBorderImage::TileMode mode)
{
- if (mode == QSGBorderImage::TileMode(m_verticalTileMode))
+ if (mode == QQuickBorderImage::TileMode(m_verticalTileMode))
return;
m_verticalTileMode = mode;
m_dirtyGeometry = true;
}
-void QSGNinePatchNode::setFiltering(QSGTexture::Filtering filtering)
+void QQuickNinePatchNode::setFiltering(QSGTexture::Filtering filtering)
{
if (m_material.filtering() == filtering)
return;
markDirty(DirtyMaterial);
}
-QSGTexture::Filtering QSGNinePatchNode::filtering() const
+QSGTexture::Filtering QQuickNinePatchNode::filtering() const
{
return m_material.filtering();
}
-void QSGNinePatchNode::setTexture(QSGTexture *texture)
+void QQuickNinePatchNode::setTexture(QSGTexture *texture)
{
if (texture == m_material.texture())
return;
markDirty(DirtyMaterial);
}
-QSGTexture *QSGNinePatchNode::texture() const
+QSGTexture *QQuickNinePatchNode::texture() const
{
return m_material.texture();
}
-void QSGNinePatchNode::setMirror(bool m)
+void QQuickNinePatchNode::setMirror(bool m)
{
if (m_mirror == m)
return;
}
-void QSGNinePatchNode::update()
+void QQuickNinePatchNode::update()
{
if (!m_dirtyGeometry)
return;
float xTexSize = m_innerRect.width(); // Size of the texture to stretch/tile
float xSize = m_targetRect.width() - m_innerRect.left() - rightBorder; // Size of area to fill with chunks
- if (m_horizontalTileMode == QSGBorderImage::Repeat) {
+ if (m_horizontalTileMode == QQuickBorderImage::Repeat) {
xChunkCount = qCeil(xSize / xTexSize);
xChunkSize = xTexSize;
- } else if (m_horizontalTileMode == QSGBorderImage::Round) {
+ } else if (m_horizontalTileMode == QQuickBorderImage::Round) {
xChunkCount = qCeil(xSize / xTexSize);
qreal fullWidth = xChunkCount * xTexSize;
xChunkSize = xTexSize * xSize / fullWidth;
float yTexSize = m_innerRect.height(); // Size of the texture to stretch/tile
float ySize = m_targetRect.height() - m_innerRect.top() - bottomBorder;
- if (m_verticalTileMode == QSGBorderImage::Repeat) {
+ if (m_verticalTileMode == QQuickBorderImage::Repeat) {
yChunkCount = qCeil(ySize / yTexSize);
yChunkSize = yTexSize;
- } else if (m_verticalTileMode == QSGBorderImage::Round) {
+ } else if (m_verticalTileMode == QQuickBorderImage::Round) {
yChunkCount = qCeil(ySize / yTexSize);
qreal fullHeight = yChunkCount * yTexSize;
yChunkSize = yTexSize * ySize / fullHeight;
// Special case the last one
if (yc == yChunkCount - 1) {
- float t = m_verticalTileMode == QSGBorderImage::Repeat
+ float t = m_verticalTileMode == QQuickBorderImage::Repeat
? yTexChunk1 + (yTexChunk2 - yTexChunk1) * (m_targetRect.height() - bottomBorder - yy) / yChunkSize
: yTexChunk2;
fillRow(v, m_targetRect.height() - bottomBorder, t, xChunkCount, xChunkSize, textureSubRect, textureSize);
markDirty(QSGNode::DirtyGeometry);
}
-void QSGNinePatchNode::fillRow(QSGGeometry::TexturedPoint2D *&v, float y, float ty, int xChunkCount, float xChunkSize,
+void QQuickNinePatchNode::fillRow(QSGGeometry::TexturedPoint2D *&v, float y, float ty, int xChunkCount, float xChunkSize,
const QRectF &tsr, // texture sub rect, for atlasses
const QSize &ts) // texture size in pixels
{
// Special case the last one
if (xc == xChunkCount - 1) {
- float t = m_horizontalTileMode == QSGBorderImage::Repeat
+ float t = m_horizontalTileMode == QQuickBorderImage::Repeat
? xTexChunk1 + (xTexChunk2 - xTexChunk1) * (m_targetRect.width() - rightBorder - xx) / xChunkSize
: xTexChunk2;
v->set(m_targetRect.width() - rightBorder, y, t, ty);
**
****************************************************************************/
-#ifndef QSGNINEPATCHNODE_H
-#define QSGNINEPATCHNODE_H
+#ifndef QQUICKNINEPATCHNODE_H
+#define QQUICKNINEPATCHNODE_H
#include "qsgnode.h"
#include "qsgtexturematerial.h"
-#include "qsgborderimage_p.h"
+#include "qquickborderimage_p.h"
class TextureReference;
-class QSGNinePatchNode : public QSGGeometryNode
+class QQuickNinePatchNode : public QSGGeometryNode
{
public:
- QSGNinePatchNode();
+ QQuickNinePatchNode();
void setTexture(QSGTexture *texture);
QSGTexture *texture() const;
void setFiltering(QSGTexture::Filtering filtering);
QSGTexture::Filtering filtering() const;
- void setHorzontalTileMode(QSGBorderImage::TileMode mode);
- QSGBorderImage::TileMode horizontalTileMode() const {
- return (QSGBorderImage::TileMode) m_horizontalTileMode;
+ void setHorzontalTileMode(QQuickBorderImage::TileMode mode);
+ QQuickBorderImage::TileMode horizontalTileMode() const {
+ return (QQuickBorderImage::TileMode) m_horizontalTileMode;
}
- void setVerticalTileMode(QSGBorderImage::TileMode mode);
- QSGBorderImage::TileMode verticalTileMode() const {
- return (QSGBorderImage::TileMode) m_verticalTileMode;
+ void setVerticalTileMode(QQuickBorderImage::TileMode mode);
+ QQuickBorderImage::TileMode verticalTileMode() const {
+ return (QQuickBorderImage::TileMode) m_verticalTileMode;
}
void setMirror(bool m);
uint m_mirror : 1;
};
-#endif // QSGNINEPATCHNODE_H
+#endif // QQUICKNINEPATCHNODE_H
**
****************************************************************************/
-#include "qsgpainteditem.h"
-#include <private/qsgpainteditem_p.h>
-#include <private/qsgpainternode_p.h>
+#include "qquickpainteditem.h"
+#include <private/qquickpainteditem_p.h>
+#include <private/qsgpainternode_p.h>
#include <private/qsgcontext_p.h>
#include <private/qsgadaptationlayer_p.h>
+
#include <qmath.h>
QT_BEGIN_NAMESPACE
/*!
- \class QSGPaintedItem
- \brief The QSGPaintedItem class provides a way to use the QPainter API in the
+ \class QQuickPaintedItem
+ \brief The QQuickPaintedItem class provides a way to use the QPainter API in the
QML Scene Graph.
\inmodule QtDeclarative
- The QSGPaintedItem makes it possible to use the QPainter API with the QML Scene Graph.
+ The QQuickPaintedItem makes it possible to use the QPainter API with the QML Scene Graph.
It sets up a textured rectangle in the Scene Graph and uses a QPainter to paint
onto the texture. The render target can be either a QImage or a QOpenGLFramebufferObject.
When the render target is a QImage, QPainter first renders into the image then
To enable QPainter to do anti-aliased rendering, use setAntialiasing().
- QSGPaintedItem is meant to make it easier to port old code that is using the
+ QQuickPaintedItem is meant to make it easier to port old code that is using the
QPainter API to the QML Scene Graph API and it should be used only for that purpose.
- To write your own painted item, you first create a subclass of QSGPaintedItem, and then
+ To write your own painted item, you first create a subclass of QQuickPaintedItem, and then
start by implementing its only pure virtual public function: paint(), which implements
the actual painting. To get the size of the area painted by the item, use
contentsBoundingRect().
*/
/*!
- \enum QSGPaintedItem::RenderTarget
+ \enum QQuickPaintedItem::RenderTarget
- This enum describes QSGPaintedItem's render targets. The render target is the
+ This enum describes QQuickPaintedItem's render targets. The render target is the
surface QPainter paints onto before the item is rendered on screen.
\value Image The default; QPainter paints into a QImage using the raster paint engine.
*/
/*!
- \enum QSGPaintedItem::PerformanceHint
+ \enum QQuickPaintedItem::PerformanceHint
This enum describes flags that you can enable to improve rendering
- performance in QSGPaintedItem. By default, none of these flags are set.
+ performance in QQuickPaintedItem. By default, none of these flags are set.
\value FastFBOResizing If your item gets resized often and you are using the
- QSGPaintedItem::FramebufferObject render target, set this flag to true to reduce the
+ QQuickPaintedItem::FramebufferObject render target, set this flag to true to reduce the
item resizing time at the cost of using more graphics memory. Resizing a Framebuffer object
is a costly operation, by enabling this property the Framebuffer Object will use a texture
larger than the actual size of the item to avoid as much as possible resizing it.
/*!
\internal
*/
-QSGPaintedItemPrivate::QSGPaintedItemPrivate()
- : QSGItemPrivate()
+QQuickPaintedItemPrivate::QQuickPaintedItemPrivate()
+ : QQuickItemPrivate()
, contentsScale(1.0)
, fillColor(Qt::transparent)
- , renderTarget(QSGPaintedItem::Image)
+ , renderTarget(QQuickPaintedItem::Image)
, performanceHints(0)
, geometryDirty(false)
, contentsDirty(false)
}
/*!
- Constructs a QSGPaintedItem with the given \a parent item.
+ Constructs a QQuickPaintedItem with the given \a parent item.
*/
-QSGPaintedItem::QSGPaintedItem(QSGItem *parent)
- : QSGItem(*(new QSGPaintedItemPrivate), parent)
+QQuickPaintedItem::QQuickPaintedItem(QQuickItem *parent)
+ : QQuickItem(*(new QQuickPaintedItemPrivate), parent)
{
setFlag(ItemHasContents);
}
/*!
\internal
*/
-QSGPaintedItem::QSGPaintedItem(QSGPaintedItemPrivate &dd, QSGItem *parent)
- : QSGItem(dd, parent)
+QQuickPaintedItem::QQuickPaintedItem(QQuickPaintedItemPrivate &dd, QQuickItem *parent)
+ : QQuickItem(dd, parent)
{
setFlag(ItemHasContents);
}
/*!
- Destroys the QSGPaintedItem.
+ Destroys the QQuickPaintedItem.
*/
-QSGPaintedItem::~QSGPaintedItem()
+QQuickPaintedItem::~QQuickPaintedItem()
{
}
\sa paint()
*/
-void QSGPaintedItem::update(const QRect &rect)
+void QQuickPaintedItem::update(const QRect &rect)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
d->contentsDirty = true;
if (rect.isNull() && !d->dirtyRect.isNull())
d->dirtyRect = contentsBoundingRect().toAlignedRect();
else
d->dirtyRect |= (contentsBoundingRect() & rect).toAlignedRect();
- QSGItem::update();
+ QQuickItem::update();
}
/*!
\sa setOpaquePainting()
*/
-bool QSGPaintedItem::opaquePainting() const
+bool QQuickPaintedItem::opaquePainting() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->opaquePainting;
}
\sa opaquePainting()
*/
-void QSGPaintedItem::setOpaquePainting(bool opaque)
+void QQuickPaintedItem::setOpaquePainting(bool opaque)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->opaquePainting == opaque)
return;
d->opaquePainting = opaque;
- QSGItem::update();
+ QQuickItem::update();
}
/*!
\sa setAntialiasing()
*/
-bool QSGPaintedItem::antialiasing() const
+bool QQuickPaintedItem::antialiasing() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->antialiasing;
}
\sa antialiasing()
*/
-void QSGPaintedItem::setAntialiasing(bool enable)
+void QQuickPaintedItem::setAntialiasing(bool enable)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->antialiasing == enable)
return;
\sa setMipmap()
*/
-bool QSGPaintedItem::mipmap() const
+bool QQuickPaintedItem::mipmap() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->mipmap;
}
\sa mipmap()
*/
-void QSGPaintedItem::setMipmap(bool enable)
+void QQuickPaintedItem::setMipmap(bool enable)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->mipmap == enable)
return;
\sa setPerformanceHint(), setPerformanceHints()
*/
-QSGPaintedItem::PerformanceHints QSGPaintedItem::performanceHints() const
+QQuickPaintedItem::PerformanceHints QQuickPaintedItem::performanceHints() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->performanceHints;
}
\sa setPerformanceHints(), performanceHints()
*/
-void QSGPaintedItem::setPerformanceHint(QSGPaintedItem::PerformanceHint hint, bool enabled)
+void QQuickPaintedItem::setPerformanceHint(QQuickPaintedItem::PerformanceHint hint, bool enabled)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
PerformanceHints oldHints = d->performanceHints;
if (enabled)
d->performanceHints |= hint;
\sa setPerformanceHint(), performanceHints()
*/
-void QSGPaintedItem::setPerformanceHints(QSGPaintedItem::PerformanceHints hints)
+void QQuickPaintedItem::setPerformanceHints(QQuickPaintedItem::PerformanceHints hints)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->performanceHints == hints)
return;
d->performanceHints = hints;
Use this function to know the area painted by the item.
- \sa QSGItem::width(), QSGItem::height(), contentsSize(), contentsScale()
+ \sa QQuickItem::width(), QQuickItem::height(), contentsSize(), contentsScale()
*/
-QRectF QSGPaintedItem::contentsBoundingRect() const
+QRectF QQuickPaintedItem::contentsBoundingRect() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
qreal w = d->width;
QSizeF sz = d->contentsSize * d->contentsScale;
}
/*!
- \property QSGPaintedItem::contentsSize
+ \property QQuickPaintedItem::contentsSize
\brief The size of the contents
The contents size is the size of the item in regards to how it is painted
using the paint() function. This is distinct from the size of the
item in regards to height() and width().
*/
-QSize QSGPaintedItem::contentsSize() const
+QSize QQuickPaintedItem::contentsSize() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->contentsSize;
}
-void QSGPaintedItem::setContentsSize(const QSize &size)
+void QQuickPaintedItem::setContentsSize(const QSize &size)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->contentsSize == size)
return;
/*!
This convenience function is equivalent to calling setContentsSize(QSize()).
*/
-void QSGPaintedItem::resetContentsSize()
+void QQuickPaintedItem::resetContentsSize()
{
setContentsSize(QSize());
}
/*!
- \property QSGPaintedItem::contentsScale
+ \property QQuickPaintedItem::contentsScale
\brief The scale of the contents
All painting happening in paint() is scaled by the contents scale. This is distinct
The default value is 1.
*/
-qreal QSGPaintedItem::contentsScale() const
+qreal QQuickPaintedItem::contentsScale() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->contentsScale;
}
-void QSGPaintedItem::setContentsScale(qreal scale)
+void QQuickPaintedItem::setContentsScale(qreal scale)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->contentsScale == scale)
return;
}
/*!
- \property QSGPaintedItem::fillColor
+ \property QQuickPaintedItem::fillColor
\brief The item's background fill color.
By default, the fill color is set to Qt::transparent.
*/
-QColor QSGPaintedItem::fillColor() const
+QColor QQuickPaintedItem::fillColor() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->fillColor;
}
-void QSGPaintedItem::setFillColor(const QColor &c)
+void QQuickPaintedItem::setFillColor(const QColor &c)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->fillColor == c)
return;
}
/*!
- \property QSGPaintedItem::renderTarget
+ \property QQuickPaintedItem::renderTarget
\brief The item's render target.
This property defines which render target the QPainter renders into, it can be either
- QSGPaintedItem::Image or QSGPaintedItem::FramebufferObject. Both have certains benefits,
+ QQuickPaintedItem::Image or QQuickPaintedItem::FramebufferObject. Both have certains benefits,
typically performance versus quality. Using a framebuffer object avoids a costly upload
of the image contents to the texture in graphics memory, while using an image enables
high quality anti-aliasing.
\warning Resizing a framebuffer object is a costly operation, avoid using
- the QSGPaintedItem::FramebufferObject render target if the item gets resized often.
+ the QQuickPaintedItem::FramebufferObject render target if the item gets resized often.
- By default, the render target is QSGPaintedItem::Image.
+ By default, the render target is QQuickPaintedItem::Image.
*/
-QSGPaintedItem::RenderTarget QSGPaintedItem::renderTarget() const
+QQuickPaintedItem::RenderTarget QQuickPaintedItem::renderTarget() const
{
- Q_D(const QSGPaintedItem);
+ Q_D(const QQuickPaintedItem);
return d->renderTarget;
}
-void QSGPaintedItem::setRenderTarget(RenderTarget target)
+void QQuickPaintedItem::setRenderTarget(RenderTarget target)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (d->renderTarget == target)
return;
}
/*!
- \fn virtual void QSGPaintedItem::paint(QPainter *painter) = 0
+ \fn virtual void QQuickPaintedItem::paint(QPainter *painter) = 0
This function, which is usually called by the QML Scene Graph, paints the
contents of an item in local coordinates.
The function is called after the item has been filled with the fillColor.
- Reimplement this function in a QSGPaintedItem subclass to provide the
+ Reimplement this function in a QQuickPaintedItem subclass to provide the
item's painting implementation, using \a painter.
\note The QML Scene Graph uses two separate threads, the main thread does things such as
/*!
This function is called after the item's geometry has changed.
*/
-void QSGPaintedItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickPaintedItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
d->geometryDirty = true;
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
}
This function is called when the Scene Graph node associated to the item needs to
be updated.
*/
-QSGNode *QSGPaintedItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+QSGNode *QQuickPaintedItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
Q_UNUSED(data);
- Q_D(QSGPaintedItem);
+ Q_D(QQuickPaintedItem);
if (width() <= 0 || height() <= 0) {
delete oldNode;
**
****************************************************************************/
-#ifndef QSGPAINTEDITEM_P_H
-#define QSGPAINTEDITEM_P_H
+#ifndef QQUICKPAINTEDITEM_P_H
+#define QQUICKPAINTEDITEM_P_H
-#include <qsgitem.h>
+#include <qquickitem.h>
#include <QtGui/qcolor.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-class QSGPaintedItemPrivate;
-class Q_DECLARATIVE_EXPORT QSGPaintedItem : public QSGItem
+class QQuickPaintedItemPrivate;
+class Q_DECLARATIVE_EXPORT QQuickPaintedItem : public QQuickItem
{
Q_OBJECT
Q_ENUMS(RenderTarget)
Q_PROPERTY(qreal contentsScale READ contentsScale WRITE setContentsScale NOTIFY contentsScaleChanged)
Q_PROPERTY(RenderTarget renderTarget READ renderTarget WRITE setRenderTarget NOTIFY renderTargetChanged)
public:
- QSGPaintedItem(QSGItem *parent = 0);
- virtual ~QSGPaintedItem();
+ QQuickPaintedItem(QQuickItem *parent = 0);
+ virtual ~QQuickPaintedItem();
enum RenderTarget {
Image,
void renderTargetChanged();
protected:
- QSGPaintedItem(QSGPaintedItemPrivate &dd, QSGItem *parent = 0);
+ QQuickPaintedItem(QQuickPaintedItemPrivate &dd, QQuickItem *parent = 0);
virtual void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
private:
- Q_DISABLE_COPY(QSGPaintedItem)
- Q_DECLARE_PRIVATE(QSGPaintedItem)
+ Q_DISABLE_COPY(QQuickPaintedItem)
+ Q_DECLARE_PRIVATE(QQuickPaintedItem)
};
-Q_DECLARE_OPERATORS_FOR_FLAGS(QSGPaintedItem::PerformanceHints)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickPaintedItem::PerformanceHints)
QT_END_NAMESPACE
QT_END_HEADER
-#endif // QSGPAINTEDITEM_P_H
+#endif // QQUICKPAINTEDITEM_P_H
**
****************************************************************************/
-#ifndef QSGPAINTEDITEM_P_P_H
-#define QSGPAINTEDITEM_P_P_H
+#ifndef QQUICKPAINTEDITEM_P_P_H
+#define QQUICKPAINTEDITEM_P_P_H
-#include "qsgitem_p.h"
+#include "qquickitem_p.h"
#include <QtGui/qcolor.h>
QT_BEGIN_NAMESPACE
-class QSGPaintedItemPrivate : public QSGItemPrivate
+class QQuickPaintedItemPrivate : public QQuickItemPrivate
{
public:
- QSGPaintedItemPrivate();
+ QQuickPaintedItemPrivate();
QSize contentsSize;
qreal contentsScale;
QColor fillColor;
- QSGPaintedItem::RenderTarget renderTarget;
- QSGPaintedItem::PerformanceHints performanceHints;
+ QQuickPaintedItem::RenderTarget renderTarget;
+ QQuickPaintedItem::PerformanceHints performanceHints;
QRect dirtyRect;
QT_END_NAMESPACE
-#endif // QSGPAINTEDITEM_P_P_H
+#endif // QQUICKPAINTEDITEM_P_P_H
**
****************************************************************************/
-#include "qsgpathview_p.h"
-#include "qsgpathview_p_p.h"
-#include "qsgcanvas.h"
+#include "qquickpathview_p.h"
+#include "qquickpathview_p_p.h"
+#include "qquickcanvas.h"
#include <private/qdeclarativestate_p.h>
#include <private/qdeclarativeopenmetaobject_p.h>
static QDeclarativeOpenMetaObjectType *qPathViewAttachedType = 0;
-QSGPathViewAttached::QSGPathViewAttached(QObject *parent)
+QQuickPathViewAttached::QQuickPathViewAttached(QObject *parent)
: QObject(parent), m_percent(-1), m_view(0), m_onPath(false), m_isCurrent(false)
{
if (qPathViewAttachedType) {
}
}
-QSGPathViewAttached::~QSGPathViewAttached()
+QQuickPathViewAttached::~QQuickPathViewAttached()
{
}
-QVariant QSGPathViewAttached::value(const QByteArray &name) const
+QVariant QQuickPathViewAttached::value(const QByteArray &name) const
{
return m_metaobject->value(name);
}
-void QSGPathViewAttached::setValue(const QByteArray &name, const QVariant &val)
+void QQuickPathViewAttached::setValue(const QByteArray &name, const QVariant &val)
{
m_metaobject->setValue(name, val);
}
-void QSGPathViewPrivate::init()
+void QQuickPathViewPrivate::init()
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
offset = 0;
q->setAcceptedMouseButtons(Qt::LeftButton);
- q->setFlag(QSGItem::ItemIsFocusScope);
+ q->setFlag(QQuickItem::ItemIsFocusScope);
q->setFiltersChildMouseEvents(true);
FAST_CONNECT(&tl, SIGNAL(updated()), q, SLOT(ticked()))
lastPosTime.invalidate();
FAST_CONNECT(&tl, SIGNAL(completed()), q, SLOT(movementEnding()))
}
-QSGItem *QSGPathViewPrivate::getItem(int modelIndex, bool onPath)
+QQuickItem *QQuickPathViewPrivate::getItem(int modelIndex, bool onPath)
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
requestedIndex = modelIndex;
- QSGItem *item = model->item(modelIndex, false);
+ QQuickItem *item = model->item(modelIndex, false);
if (item) {
if (!attType) {
// pre-create one metatype to share with all attached objects
- attType = new QDeclarativeOpenMetaObjectType(&QSGPathViewAttached::staticMetaObject, qmlEngine(q));
+ attType = new QDeclarativeOpenMetaObjectType(&QQuickPathViewAttached::staticMetaObject, qmlEngine(q));
foreach (const QString &attr, path->attributes())
attType->createProperty(attr.toUtf8());
}
qPathViewAttachedType = attType;
- QSGPathViewAttached *att = static_cast<QSGPathViewAttached *>(qmlAttachedPropertiesObject<QSGPathView>(item));
+ QQuickPathViewAttached *att = static_cast<QQuickPathViewAttached *>(qmlAttachedPropertiesObject<QQuickPathView>(item));
qPathViewAttachedType = 0;
if (att) {
att->m_view = q;
att->setOnPath(onPath);
}
item->setParentItem(q);
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
- itemPrivate->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
+ itemPrivate->addItemChangeListener(this, QQuickItemPrivate::Geometry);
}
requestedIndex = -1;
return item;
}
-void QSGPathViewPrivate::releaseItem(QSGItem *item)
+void QQuickPathViewPrivate::releaseItem(QQuickItem *item)
{
if (!item || !model)
return;
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
- itemPrivate->removeItemChangeListener(this, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
+ itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
if (model->release(item) == 0) {
// item was not destroyed, and we no longer reference it.
- if (QSGPathViewAttached *att = attached(item))
+ if (QQuickPathViewAttached *att = attached(item))
att->setOnPath(false);
}
}
-QSGPathViewAttached *QSGPathViewPrivate::attached(QSGItem *item)
+QQuickPathViewAttached *QQuickPathViewPrivate::attached(QQuickItem *item)
{
- return static_cast<QSGPathViewAttached *>(qmlAttachedPropertiesObject<QSGPathView>(item, false));
+ return static_cast<QQuickPathViewAttached *>(qmlAttachedPropertiesObject<QQuickPathView>(item, false));
}
-void QSGPathViewPrivate::clear()
+void QQuickPathViewPrivate::clear()
{
if (currentItem) {
releaseItem(currentItem);
currentItem = 0;
}
for (int i=0; i<items.count(); i++){
- QSGItem *p = items[i];
+ QQuickItem *p = items[i];
releaseItem(p);
}
items.clear();
}
-void QSGPathViewPrivate::updateMappedRange()
+void QQuickPathViewPrivate::updateMappedRange()
{
if (model && pathItems != -1 && pathItems < modelCount)
mappedRange = qreal(pathItems)/modelCount;
mappedRange = 1.0;
}
-qreal QSGPathViewPrivate::positionOfIndex(qreal index) const
+qreal QQuickPathViewPrivate::positionOfIndex(qreal index) const
{
qreal pos = -1.0;
if (model && index >= 0 && index < modelCount) {
qreal start = 0.0;
- if (haveHighlightRange && highlightRangeMode != QSGPathView::NoHighlightRange)
+ if (haveHighlightRange && highlightRangeMode != QQuickPathView::NoHighlightRange)
start = highlightRangeStart;
qreal globalPos = index + offset;
globalPos = qmlMod(globalPos, qreal(modelCount)) / modelCount;
return pos;
}
-void QSGPathViewPrivate::createHighlight()
+void QQuickPathViewPrivate::createHighlight()
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (!q->isComponentComplete())
return;
changed = true;
}
- QSGItem *item = 0;
+ QQuickItem *item = 0;
if (highlightComponent) {
QDeclarativeContext *creationContext = highlightComponent->creationContext();
QDeclarativeContext *highlightContext = new QDeclarativeContext(
QObject *nobj = highlightComponent->create(highlightContext);
if (nobj) {
QDeclarative_setParent_noEvent(highlightContext, nobj);
- item = qobject_cast<QSGItem *>(nobj);
+ item = qobject_cast<QQuickItem *>(nobj);
if (!item)
delete nobj;
} else {
delete highlightContext;
}
} else {
- item = new QSGItem;
+ item = new QQuickItem;
}
if (item) {
QDeclarative_setParent_noEvent(item, q);
emit q->highlightItemChanged();
}
-void QSGPathViewPrivate::updateHighlight()
+void QQuickPathViewPrivate::updateHighlight()
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (!q->isComponentComplete() || !isValid())
return;
if (highlightItem) {
- if (haveHighlightRange && highlightRangeMode == QSGPathView::StrictlyEnforceRange) {
+ if (haveHighlightRange && highlightRangeMode == QQuickPathView::StrictlyEnforceRange) {
updateItem(highlightItem, highlightRangeStart);
} else {
qreal target = currentIndex;
}
}
-void QSGPathViewPrivate::setHighlightPosition(qreal pos)
+void QQuickPathViewPrivate::setHighlightPosition(qreal pos)
{
if (pos != highlightPosition) {
qreal start = 0.0;
qreal end = 1.0;
- if (haveHighlightRange && highlightRangeMode != QSGPathView::NoHighlightRange) {
+ if (haveHighlightRange && highlightRangeMode != QQuickPathView::NoHighlightRange) {
start = highlightRangeStart;
end = highlightRangeEnd;
}
highlightPosition = pos;
qreal pathPos = positionOfIndex(pos);
updateItem(highlightItem, pathPos);
- if (QSGPathViewAttached *att = attached(highlightItem))
+ if (QQuickPathViewAttached *att = attached(highlightItem))
att->setOnPath(pathPos != -1.0);
}
}
-void QSGPathView::pathUpdated()
+void QQuickPathView::pathUpdated()
{
- Q_D(QSGPathView);
- QList<QSGItem*>::iterator it = d->items.begin();
+ Q_D(QQuickPathView);
+ QList<QQuickItem*>::iterator it = d->items.begin();
while (it != d->items.end()) {
- QSGItem *item = *it;
- if (QSGPathViewAttached *att = d->attached(item))
+ QQuickItem *item = *it;
+ if (QQuickPathViewAttached *att = d->attached(item))
att->m_percent = -1;
++it;
}
refill();
}
-void QSGPathViewPrivate::updateItem(QSGItem *item, qreal percent)
+void QQuickPathViewPrivate::updateItem(QQuickItem *item, qreal percent)
{
- if (QSGPathViewAttached *att = attached(item)) {
+ if (QQuickPathViewAttached *att = attached(item)) {
if (qFuzzyCompare(att->m_percent, percent))
return;
att->m_percent = percent;
item->setY(qRound(pf.y() - item->height()/2));
}
-void QSGPathViewPrivate::regenerate()
+void QQuickPathViewPrivate::regenerate()
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (!q->isComponentComplete())
return;
}
/*!
- \qmlclass PathView QSGPathView
+ \qmlclass PathView QQuickPathView
\inqmlmodule QtQuick 2
\ingroup qml-view-elements
\brief The PathView element lays out model-provided items on a path.
\sa Path, {declarative/modelviews/pathview}{PathView example}
*/
-QSGPathView::QSGPathView(QSGItem *parent)
- : QSGItem(*(new QSGPathViewPrivate), parent)
+QQuickPathView::QQuickPathView(QQuickItem *parent)
+ : QQuickItem(*(new QQuickPathViewPrivate), parent)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
d->init();
}
-QSGPathView::~QSGPathView()
+QQuickPathView::~QQuickPathView()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
d->clear();
if (d->attType)
d->attType->release();
\sa {qmlmodels}{Data Models}
*/
-QVariant QSGPathView::model() const
+QVariant QQuickPathView::model() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->modelVariant;
}
-void QSGPathView::setModel(const QVariant &model)
+void QQuickPathView::setModel(const QVariant &model)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->modelVariant == model)
return;
if (d->model) {
disconnect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
- disconnect(d->model, SIGNAL(createdItem(int,QSGItem*)), this, SLOT(createdItem(int,QSGItem*)));
+ disconnect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
for (int i=0; i<d->items.count(); i++){
- QSGItem *p = d->items[i];
+ QQuickItem *p = d->items[i];
d->model->release(p);
}
d->items.clear();
d->modelVariant = model;
QObject *object = qvariant_cast<QObject*>(model);
- QSGVisualModel *vim = 0;
- if (object && (vim = qobject_cast<QSGVisualModel *>(object))) {
+ QQuickVisualModel *vim = 0;
+ if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
if (d->ownModel) {
delete d->model;
d->ownModel = false;
d->model = vim;
} else {
if (!d->ownModel) {
- d->model = new QSGVisualDataModel(qmlContext(this));
+ d->model = new QQuickVisualDataModel(qmlContext(this));
d->ownModel = true;
if (isComponentComplete())
- static_cast<QSGVisualDataModel *>(d->model.data())->componentComplete();
+ static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
}
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
dataModel->setModel(model);
}
d->modelCount = 0;
if (d->model) {
connect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
- connect(d->model, SIGNAL(createdItem(int,QSGItem*)), this, SLOT(createdItem(int,QSGItem*)));
+ connect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
d->modelCount = d->model->count();
if (d->model->count())
d->offset = qmlMod(d->offset, qreal(d->model->count()));
\qmlproperty int QtQuick2::PathView::count
This property holds the number of items in the model.
*/
-int QSGPathView::count() const
+int QQuickPathView::count() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->model ? d->modelCount : 0;
}
This property holds the path used to lay out the items.
For more information see the \l Path documentation.
*/
-QDeclarativePath *QSGPathView::path() const
+QDeclarativePath *QQuickPathView::path() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->path;
}
-void QSGPathView::setPath(QDeclarativePath *path)
+void QQuickPathView::setPath(QDeclarativePath *path)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->path == path)
return;
if (d->path)
\qmlproperty int QtQuick2::PathView::currentIndex
This property holds the index of the current item.
*/
-int QSGPathView::currentIndex() const
+int QQuickPathView::currentIndex() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->currentIndex;
}
-void QSGPathView::setCurrentIndex(int idx)
+void QQuickPathView::setCurrentIndex(int idx)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->model && d->modelCount)
idx = qAbs(idx % d->modelCount);
if (d->model && idx != d->currentIndex) {
if (d->currentItem) {
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setIsCurrentItem(false);
d->releaseItem(d->currentItem);
}
d->currentItem = 0;
- d->moveReason = QSGPathViewPrivate::SetIndex;
+ d->moveReason = QQuickPathViewPrivate::SetIndex;
d->currentIndex = idx;
if (d->modelCount) {
int itemIndex = (idx - d->firstIndex + d->modelCount) % d->modelCount;
if (itemIndex < d->items.count()) {
d->currentItem = d->model->item(d->currentIndex, true);
d->currentItem->setFocus(true);
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setIsCurrentItem(true);
} else {
d->currentItem = d->getItem(d->currentIndex, false);
d->updateItem(d->currentItem, d->currentIndex < d->firstIndex ? 0.0 : 1.0);
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setIsCurrentItem(true);
if (d->model->completePending())
d->model->completeItem();
}
- if (d->haveHighlightRange && d->highlightRangeMode == QSGPathView::StrictlyEnforceRange)
+ if (d->haveHighlightRange && d->highlightRangeMode == QQuickPathView::StrictlyEnforceRange)
d->snapToCurrent();
d->currentItemOffset = d->positionOfIndex(d->currentIndex);
d->updateHighlight();
}
}
-QSGItem *QSGPathView::currentItem() const
+QQuickItem *QQuickPathView::currentItem() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->currentItem;
}
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGPathView::incrementCurrentIndex()
+void QQuickPathView::incrementCurrentIndex()
{
- Q_D(QSGPathView);
- d->moveDirection = QSGPathViewPrivate::Positive;
+ Q_D(QQuickPathView);
+ d->moveDirection = QQuickPathViewPrivate::Positive;
setCurrentIndex(currentIndex()+1);
}
\bold Note: methods should only be called after the Component has completed.
*/
-void QSGPathView::decrementCurrentIndex()
+void QQuickPathView::decrementCurrentIndex()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->model && d->modelCount) {
int idx = currentIndex()-1;
if (idx < 0)
idx = d->modelCount - 1;
- d->moveDirection = QSGPathViewPrivate::Negative;
+ d->moveDirection = QQuickPathViewPrivate::Negative;
setCurrentIndex(idx);
}
}
The offset specifies how far along the path the items are from their initial positions.
This is a real number that ranges from 0.0 to the count of items in the model.
*/
-qreal QSGPathView::offset() const
+qreal QQuickPathView::offset() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->offset;
}
-void QSGPathView::setOffset(qreal offset)
+void QQuickPathView::setOffset(qreal offset)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
d->setOffset(offset);
d->updateCurrent();
}
-void QSGPathViewPrivate::setOffset(qreal o)
+void QQuickPathViewPrivate::setOffset(qreal o)
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (offset != o) {
if (isValid() && q->isComponentComplete()) {
offset = qmlMod(o, qreal(modelCount));
}
}
-void QSGPathViewPrivate::setAdjustedOffset(qreal o)
+void QQuickPathViewPrivate::setAdjustedOffset(qreal o)
{
setOffset(o+offsetAdj);
}
\sa highlightItem, highlightRangeMode
*/
-QDeclarativeComponent *QSGPathView::highlight() const
+QDeclarativeComponent *QQuickPathView::highlight() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->highlightComponent;
}
-void QSGPathView::setHighlight(QDeclarativeComponent *highlight)
+void QQuickPathView::setHighlight(QDeclarativeComponent *highlight)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (highlight != d->highlightComponent) {
d->highlightComponent = highlight;
d->createHighlight();
\sa highlight
*/
-QSGItem *QSGPathView::highlightItem()
+QQuickItem *QQuickPathView::highlightItem()
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->highlightItem;
}
/*!
Note that a valid range requires preferredHighlightEnd to be greater
than or equal to preferredHighlightBegin.
*/
-qreal QSGPathView::preferredHighlightBegin() const
+qreal QQuickPathView::preferredHighlightBegin() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->highlightRangeStart;
}
-void QSGPathView::setPreferredHighlightBegin(qreal start)
+void QQuickPathView::setPreferredHighlightBegin(qreal start)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->highlightRangeStart == start || start < 0 || start > 1.0)
return;
d->highlightRangeStart = start;
emit preferredHighlightBeginChanged();
}
-qreal QSGPathView::preferredHighlightEnd() const
+qreal QQuickPathView::preferredHighlightEnd() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->highlightRangeEnd;
}
-void QSGPathView::setPreferredHighlightEnd(qreal end)
+void QQuickPathView::setPreferredHighlightEnd(qreal end)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->highlightRangeEnd == end || end < 0 || end > 1.0)
return;
d->highlightRangeEnd = end;
emit preferredHighlightEndChanged();
}
-QSGPathView::HighlightRangeMode QSGPathView::highlightRangeMode() const
+QQuickPathView::HighlightRangeMode QQuickPathView::highlightRangeMode() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->highlightRangeMode;
}
-void QSGPathView::setHighlightRangeMode(HighlightRangeMode mode)
+void QQuickPathView::setHighlightRangeMode(HighlightRangeMode mode)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->highlightRangeMode == mode)
return;
d->highlightRangeMode = mode;
The default value for the duration is 300ms.
*/
-int QSGPathView::highlightMoveDuration() const
+int QQuickPathView::highlightMoveDuration() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->highlightMoveDuration;
}
-void QSGPathView::setHighlightMoveDuration(int duration)
+void QQuickPathView::setHighlightMoveDuration(int duration)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->highlightMoveDuration == duration)
return;
d->highlightMoveDuration = duration;
dragMargin is greater than zero, a drag can be initiated by clicking
within dragMargin pixels of the path.
*/
-qreal QSGPathView::dragMargin() const
+qreal QQuickPathView::dragMargin() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->dragMargin;
}
-void QSGPathView::setDragMargin(qreal dragMargin)
+void QQuickPathView::setDragMargin(qreal dragMargin)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->dragMargin == dragMargin)
return;
d->dragMargin = dragMargin;
The default is 100.
*/
-qreal QSGPathView::flickDeceleration() const
+qreal QQuickPathView::flickDeceleration() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->deceleration;
}
-void QSGPathView::setFlickDeceleration(qreal dec)
+void QQuickPathView::setFlickDeceleration(qreal dec)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->deceleration == dec)
return;
d->deceleration = dec;
This property is useful for temporarily disabling flicking. This allows
special interaction with PathView's children.
*/
-bool QSGPathView::isInteractive() const
+bool QQuickPathView::isInteractive() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->interactive;
}
-void QSGPathView::setInteractive(bool interactive)
+void QQuickPathView::setInteractive(bool interactive)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (interactive != d->interactive) {
d->interactive = interactive;
if (!interactive)
This property holds whether the view is currently moving
due to the user either dragging or flicking the view.
*/
-bool QSGPathView::isMoving() const
+bool QQuickPathView::isMoving() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->moving;
}
This property holds whether the view is currently moving
due to the user flicking the view.
*/
-bool QSGPathView::isFlicking() const
+bool QQuickPathView::isFlicking() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->flicking;
}
Here is an example delegate:
\snippet doc/src/snippets/declarative/pathview/pathview.qml 1
*/
-QDeclarativeComponent *QSGPathView::delegate() const
+QDeclarativeComponent *QQuickPathView::delegate() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
if (d->model) {
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
return dataModel->delegate();
}
return 0;
}
-void QSGPathView::setDelegate(QDeclarativeComponent *delegate)
+void QQuickPathView::setDelegate(QDeclarativeComponent *delegate)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (delegate == this->delegate())
return;
if (!d->ownModel) {
- d->model = new QSGVisualDataModel(qmlContext(this));
+ d->model = new QQuickVisualDataModel(qmlContext(this));
d->ownModel = true;
}
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model)) {
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
int oldCount = dataModel->count();
dataModel->setDelegate(delegate);
d->modelCount = dataModel->count();
\qmlproperty int QtQuick2::PathView::pathItemCount
This property holds the number of items visible on the path at any one time.
*/
-int QSGPathView::pathItemCount() const
+int QQuickPathView::pathItemCount() const
{
- Q_D(const QSGPathView);
+ Q_D(const QQuickPathView);
return d->pathItems;
}
-void QSGPathView::setPathItemCount(int i)
+void QQuickPathView::setPathItemCount(int i)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (i == d->pathItems)
return;
if (i < 1)
emit pathItemCountChanged();
}
-QPointF QSGPathViewPrivate::pointNear(const QPointF &point, qreal *nearPercent) const
+QPointF QQuickPathViewPrivate::pointNear(const QPointF &point, qreal *nearPercent) const
{
//XXX maybe do recursively at increasing resolution.
qreal mindist = 1e10; // big number
return nearPoint;
}
-void QSGPathView::mousePressEvent(QMouseEvent *event)
+void QQuickPathView::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->interactive) {
d->handleMousePressEvent(event);
event->accept();
} else {
- QSGItem::mousePressEvent(event);
+ QQuickItem::mousePressEvent(event);
}
}
-void QSGPathViewPrivate::handleMousePressEvent(QMouseEvent *event)
+void QQuickPathViewPrivate::handleMousePressEvent(QMouseEvent *event)
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (!interactive || !items.count())
return;
QPointF scenePoint = q->mapToScene(event->localPos());
lastElapsed = 0;
lastDist = 0;
- QSGItemPrivate::start(lastPosTime);
+ QQuickItemPrivate::start(lastPosTime);
tl.clear();
}
-void QSGPathView::mouseMoveEvent(QMouseEvent *event)
+void QQuickPathView::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->interactive) {
d->handleMouseMoveEvent(event);
if (d->stealMouse)
setKeepMouseGrab(true);
event->accept();
} else {
- QSGItem::mouseMoveEvent(event);
+ QQuickItem::mouseMoveEvent(event);
}
}
-void QSGPathViewPrivate::handleMouseMoveEvent(QMouseEvent *event)
+void QQuickPathViewPrivate::handleMouseMoveEvent(QMouseEvent *event)
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (!interactive || !lastPosTime.isValid())
return;
}
if (stealMouse) {
- moveReason = QSGPathViewPrivate::Mouse;
+ moveReason = QQuickPathViewPrivate::Mouse;
qreal diff = (newPc - startPc)*modelCount*mappedRange;
if (diff) {
q->setOffset(offset + diff);
else if (diff < -modelCount/2)
diff += modelCount;
- lastElapsed = QSGItemPrivate::restart(lastPosTime);
+ lastElapsed = QQuickItemPrivate::restart(lastPosTime);
lastDist = diff;
startPc = newPc;
}
}
}
-void QSGPathView::mouseReleaseEvent(QMouseEvent *event)
+void QQuickPathView::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->interactive) {
d->handleMouseReleaseEvent(event);
event->accept();
ungrabMouse();
} else {
- QSGItem::mouseReleaseEvent(event);
+ QQuickItem::mouseReleaseEvent(event);
}
}
-void QSGPathViewPrivate::handleMouseReleaseEvent(QMouseEvent *)
+void QQuickPathViewPrivate::handleMouseReleaseEvent(QMouseEvent *)
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
stealMouse = false;
q->setKeepMouseGrab(false);
if (!interactive || !lastPosTime.isValid())
return;
- qreal elapsed = qreal(lastElapsed + QSGItemPrivate::elapsed(lastPosTime)) / 1000.;
+ qreal elapsed = qreal(lastElapsed + QQuickItemPrivate::elapsed(lastPosTime)) / 1000.;
qreal velocity = elapsed > 0. ? lastDist / elapsed : 0;
if (model && modelCount && qAbs(velocity) > 1.) {
qreal count = pathItems == -1 ? modelCount : pathItems;
qreal accel = deceleration/10;
// + 0.25 to encourage moving at least one item in the flick direction
qreal dist = qMin(qreal(modelCount-1), qreal(v2 / (accel * 2.0) + 0.25));
- if (haveHighlightRange && highlightRangeMode == QSGPathView::StrictlyEnforceRange) {
+ if (haveHighlightRange && highlightRangeMode == QQuickPathView::StrictlyEnforceRange) {
// round to nearest item.
if (velocity > 0.)
dist = qRound(dist + offset) - offset;
q->movementEnding();
}
-bool QSGPathView::sendMouseEvent(QMouseEvent *event)
+bool QQuickPathView::sendMouseEvent(QMouseEvent *event)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
QRectF myRect = mapRectToScene(QRectF(0, 0, width(), height()));
- QSGCanvas *c = canvas();
- QSGItem *grabber = c ? c->mouseGrabberItem() : 0;
+ QQuickCanvas *c = canvas();
+ QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || myRect.contains(event->windowPos())) && (!grabber || !grabber->keepMouseGrab())) {
QMouseEvent mouseEvent(event->type(), mapFromScene(event->windowPos()), event->windowPos(), event->screenPos(),
return false;
}
-bool QSGPathView::childMouseEventFilter(QSGItem *i, QEvent *e)
+bool QQuickPathView::childMouseEventFilter(QQuickItem *i, QEvent *e)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (!isVisible() || !d->interactive)
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
switch (e->type()) {
case QEvent::MouseButtonPress:
break;
}
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
}
-void QSGPathView::mouseUngrabEvent()
+void QQuickPathView::mouseUngrabEvent()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->stealMouse) {
// if our mouse grab has been removed (probably by a Flickable),
// fix our state
}
}
-void QSGPathView::updatePolish()
+void QQuickPathView::updatePolish()
{
- QSGItem::updatePolish();
+ QQuickItem::updatePolish();
refill();
}
-void QSGPathView::componentComplete()
+void QQuickPathView::componentComplete()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->model && d->ownModel)
- static_cast<QSGVisualDataModel *>(d->model.data())->componentComplete();
+ static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
d->createHighlight();
// It is possible that a refill has already happended to to Path
emit countChanged();
}
-void QSGPathView::refill()
+void QQuickPathView::refill()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (!d->isValid() || !isComponentComplete())
return;
// first move existing items and remove items off path
int idx = d->firstIndex;
- QList<QSGItem*>::iterator it = d->items.begin();
+ QList<QQuickItem*>::iterator it = d->items.begin();
while (it != d->items.end()) {
qreal pos = d->positionOfIndex(idx);
- QSGItem *item = *it;
+ QQuickItem *item = *it;
if (pos >= 0.0) {
d->updateItem(item, pos);
if (idx == d->currentIndex) {
if (d->items.count() < count) {
int idx = qRound(d->modelCount - d->offset) % d->modelCount;
qreal startPos = 0.0;
- if (d->haveHighlightRange && d->highlightRangeMode != QSGPathView::NoHighlightRange)
+ if (d->haveHighlightRange && d->highlightRangeMode != QQuickPathView::NoHighlightRange)
startPos = d->highlightRangeStart;
if (d->firstIndex >= 0) {
startPos = d->positionOfIndex(d->firstIndex);
qreal pos = d->positionOfIndex(idx);
while ((pos > startPos || !d->items.count()) && d->items.count() < count) {
// qDebug() << "append" << idx;
- QSGItem *item = d->getItem(idx);
+ QQuickItem *item = d->getItem(idx);
if (d->model->completePending())
item->setZ(idx+1);
if (d->currentIndex == idx) {
pos = d->positionOfIndex(idx);
while ((pos >= 0.0 && pos < startPos) && d->items.count() < count) {
// qDebug() << "prepend" << idx;
- QSGItem *item = d->getItem(idx);
+ QQuickItem *item = d->getItem(idx);
if (d->model->completePending())
item->setZ(idx+1);
if (d->currentIndex == idx) {
if (!currentVisible) {
d->currentItemOffset = 1.0;
if (d->currentItem) {
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setOnPath(false);
} else if (d->currentIndex >= 0 && d->currentIndex < d->modelCount) {
d->currentItem = d->getItem(d->currentIndex, false);
d->updateItem(d->currentItem, d->currentIndex < d->firstIndex ? 0.0 : 1.0);
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setIsCurrentItem(true);
if (d->model->completePending())
d->model->completeItem();
} else if (!d->currentItem) {
d->currentItem = d->model->item(d->currentIndex, true);
d->currentItem->setFocus(true);
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setIsCurrentItem(true);
}
- if (d->highlightItem && d->haveHighlightRange && d->highlightRangeMode == QSGPathView::StrictlyEnforceRange) {
+ if (d->highlightItem && d->haveHighlightRange && d->highlightRangeMode == QQuickPathView::StrictlyEnforceRange) {
d->updateItem(d->highlightItem, d->highlightRangeStart);
- if (QSGPathViewAttached *att = d->attached(d->highlightItem))
+ if (QQuickPathViewAttached *att = d->attached(d->highlightItem))
att->setOnPath(true);
- } else if (d->highlightItem && d->moveReason != QSGPathViewPrivate::SetIndex) {
+ } else if (d->highlightItem && d->moveReason != QQuickPathViewPrivate::SetIndex) {
d->updateItem(d->highlightItem, d->currentItemOffset);
- if (QSGPathViewAttached *att = d->attached(d->highlightItem))
+ if (QQuickPathViewAttached *att = d->attached(d->highlightItem))
att->setOnPath(currentVisible);
}
while (d->itemCache.count())
d->releaseItem(d->itemCache.takeLast());
}
-void QSGPathView::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickPathView::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (!d->model || !d->model->isValid() || !d->path || !isComponentComplete())
return;
moveId = r.moveId;
moveOffset = d->currentIndex - r.index;
} else if (d->currentItem) {
- if (QSGPathViewAttached *att = d->attached(d->currentItem))
+ if (QQuickPathViewAttached *att = d->attached(d->currentItem))
att->setIsCurrentItem(true);
d->releaseItem(d->currentItem);
d->currentItem = 0;
} else if (removed) {
d->regenerate();
d->updateCurrent();
- if (!d->flicking && !d->moving && d->haveHighlightRange && d->highlightRangeMode == QSGPathView::StrictlyEnforceRange)
+ if (!d->flicking && !d->moving && d->haveHighlightRange && d->highlightRangeMode == QQuickPathView::StrictlyEnforceRange)
d->snapToCurrent();
} else if (inserted) {
d->firstIndex = -1;
emit countChanged();
}
-void QSGPathView::createdItem(int index, QSGItem *item)
+void QQuickPathView::createdItem(int index, QQuickItem *item)
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->requestedIndex != index) {
if (!d->attType) {
// pre-create one metatype to share with all attached objects
- d->attType = new QDeclarativeOpenMetaObjectType(&QSGPathViewAttached::staticMetaObject, qmlEngine(this));
+ d->attType = new QDeclarativeOpenMetaObjectType(&QQuickPathViewAttached::staticMetaObject, qmlEngine(this));
foreach (const QString &attr, d->path->attributes())
d->attType->createProperty(attr.toUtf8());
}
qPathViewAttachedType = d->attType;
- QSGPathViewAttached *att = static_cast<QSGPathViewAttached *>(qmlAttachedPropertiesObject<QSGPathView>(item));
+ QQuickPathViewAttached *att = static_cast<QQuickPathViewAttached *>(qmlAttachedPropertiesObject<QQuickPathView>(item));
qPathViewAttachedType = 0;
if (att) {
att->m_view = this;
}
}
-void QSGPathView::destroyingItem(QSGItem *item)
+void QQuickPathView::destroyingItem(QQuickItem *item)
{
Q_UNUSED(item);
}
-void QSGPathView::ticked()
+void QQuickPathView::ticked()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
d->updateCurrent();
}
-void QSGPathView::movementEnding()
+void QQuickPathView::movementEnding()
{
- Q_D(QSGPathView);
+ Q_D(QQuickPathView);
if (d->flicking) {
d->flicking = false;
emit flickingChanged();
}
// find the item closest to the snap position
-int QSGPathViewPrivate::calcCurrentIndex()
+int QQuickPathViewPrivate::calcCurrentIndex()
{
int current = -1;
if (modelCount && model && items.count()) {
return current;
}
-void QSGPathViewPrivate::updateCurrent()
+void QQuickPathViewPrivate::updateCurrent()
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (moveReason != Mouse)
return;
- if (!modelCount || !haveHighlightRange || highlightRangeMode != QSGPathView::StrictlyEnforceRange)
+ if (!modelCount || !haveHighlightRange || highlightRangeMode != QQuickPathView::StrictlyEnforceRange)
return;
int idx = calcCurrentIndex();
if (model && idx != currentIndex) {
if (currentItem) {
- if (QSGPathViewAttached *att = attached(currentItem))
+ if (QQuickPathViewAttached *att = attached(currentItem))
att->setIsCurrentItem(false);
releaseItem(currentItem);
}
if (itemIndex < items.count()) {
currentItem = model->item(currentIndex, true);
currentItem->setFocus(true);
- if (QSGPathViewAttached *att = attached(currentItem))
+ if (QQuickPathViewAttached *att = attached(currentItem))
att->setIsCurrentItem(true);
} else if (currentIndex >= 0 && currentIndex < modelCount) {
currentItem = getItem(currentIndex, false);
updateItem(currentItem, currentIndex < firstIndex ? 0.0 : 1.0);
- if (QSGPathViewAttached *att = attached(currentItem))
+ if (QQuickPathViewAttached *att = attached(currentItem))
att->setIsCurrentItem(true);
if (model->completePending())
model->completeItem();
}
}
-void QSGPathViewPrivate::fixOffsetCallback(void *d)
+void QQuickPathViewPrivate::fixOffsetCallback(void *d)
{
- ((QSGPathViewPrivate *)d)->fixOffset();
+ ((QQuickPathViewPrivate *)d)->fixOffset();
}
-void QSGPathViewPrivate::fixOffset()
+void QQuickPathViewPrivate::fixOffset()
{
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (model && items.count()) {
- if (haveHighlightRange && highlightRangeMode == QSGPathView::StrictlyEnforceRange) {
+ if (haveHighlightRange && highlightRangeMode == QQuickPathView::StrictlyEnforceRange) {
int curr = calcCurrentIndex();
if (curr != currentIndex)
q->setCurrentIndex(curr);
}
}
-void QSGPathViewPrivate::snapToCurrent()
+void QQuickPathViewPrivate::snapToCurrent()
{
if (!model || modelCount <= 0)
return;
moveDirection = Shortest;
}
-QSGPathViewAttached *QSGPathView::qmlAttachedProperties(QObject *obj)
+QQuickPathViewAttached *QQuickPathView::qmlAttachedProperties(QObject *obj)
{
- return new QSGPathViewAttached(obj);
+ return new QQuickPathViewAttached(obj);
}
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGPATHVIEW_P_H
-#define QSGPATHVIEW_P_H
+#ifndef QQUICKPATHVIEW_P_H
+#define QQUICKPATHVIEW_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <private/qdeclarativepath_p.h>
class QDeclarativeChangeSet;
-class QSGPathViewPrivate;
-class QSGPathViewAttached;
-class Q_AUTOTEST_EXPORT QSGPathView : public QSGItem
+class QQuickPathViewPrivate;
+class QQuickPathViewAttached;
+class Q_AUTOTEST_EXPORT QQuickPathView : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QVariant model READ model WRITE setModel NOTIFY modelChanged)
Q_PROPERTY(QDeclarativePath *path READ path WRITE setPath NOTIFY pathChanged)
Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
- Q_PROPERTY(QSGItem *currentItem READ currentItem NOTIFY currentIndexChanged)
+ Q_PROPERTY(QQuickItem *currentItem READ currentItem NOTIFY currentIndexChanged)
Q_PROPERTY(qreal offset READ offset WRITE setOffset NOTIFY offsetChanged)
Q_PROPERTY(QDeclarativeComponent *highlight READ highlight WRITE setHighlight NOTIFY highlightChanged)
- Q_PROPERTY(QSGItem *highlightItem READ highlightItem NOTIFY highlightItemChanged)
+ Q_PROPERTY(QQuickItem *highlightItem READ highlightItem NOTIFY highlightItemChanged)
Q_PROPERTY(qreal preferredHighlightBegin READ preferredHighlightBegin WRITE setPreferredHighlightBegin NOTIFY preferredHighlightBeginChanged)
Q_PROPERTY(qreal preferredHighlightEnd READ preferredHighlightEnd WRITE setPreferredHighlightEnd NOTIFY preferredHighlightEndChanged)
Q_ENUMS(HighlightRangeMode)
public:
- QSGPathView(QSGItem *parent=0);
- virtual ~QSGPathView();
+ QQuickPathView(QQuickItem *parent=0);
+ virtual ~QQuickPathView();
QVariant model() const;
void setModel(const QVariant &);
int currentIndex() const;
void setCurrentIndex(int idx);
- QSGItem *currentItem() const;
+ QQuickItem *currentItem() const;
qreal offset() const;
void setOffset(qreal offset);
QDeclarativeComponent *highlight() const;
void setHighlight(QDeclarativeComponent *highlight);
- QSGItem *highlightItem();
+ QQuickItem *highlightItem();
enum HighlightRangeMode { NoHighlightRange, ApplyRange, StrictlyEnforceRange };
HighlightRangeMode highlightRangeMode() const;
int pathItemCount() const;
void setPathItemCount(int);
- static QSGPathViewAttached *qmlAttachedProperties(QObject *);
+ static QQuickPathViewAttached *qmlAttachedProperties(QObject *);
public Q_SLOTS:
void incrementCurrentIndex();
void mouseMoveEvent(QMouseEvent *event);
void mouseReleaseEvent(QMouseEvent *);
bool sendMouseEvent(QMouseEvent *event);
- bool childMouseEventFilter(QSGItem *, QEvent *);
+ bool childMouseEventFilter(QQuickItem *, QEvent *);
void mouseUngrabEvent();
void componentComplete();
void ticked();
void movementEnding();
void modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
- void createdItem(int index, QSGItem *item);
- void destroyingItem(QSGItem *item);
+ void createdItem(int index, QQuickItem *item);
+ void destroyingItem(QQuickItem *item);
void pathUpdated();
private:
- friend class QSGPathViewAttached;
- Q_DISABLE_COPY(QSGPathView)
- Q_DECLARE_PRIVATE(QSGPathView)
+ friend class QQuickPathViewAttached;
+ Q_DISABLE_COPY(QQuickPathView)
+ Q_DECLARE_PRIVATE(QQuickPathView)
};
class QDeclarativeOpenMetaObject;
-class QSGPathViewAttached : public QObject
+class QQuickPathViewAttached : public QObject
{
Q_OBJECT
- Q_PROPERTY(QSGPathView *view READ view CONSTANT)
+ Q_PROPERTY(QQuickPathView *view READ view CONSTANT)
Q_PROPERTY(bool isCurrentItem READ isCurrentItem NOTIFY currentItemChanged)
Q_PROPERTY(bool onPath READ isOnPath NOTIFY pathChanged)
public:
- QSGPathViewAttached(QObject *parent);
- ~QSGPathViewAttached();
+ QQuickPathViewAttached(QObject *parent);
+ ~QQuickPathViewAttached();
- QSGPathView *view() { return m_view; }
+ QQuickPathView *view() { return m_view; }
bool isCurrentItem() const { return m_isCurrent; }
void setIsCurrentItem(bool c) {
void pathChanged();
private:
- friend class QSGPathViewPrivate;
- friend class QSGPathView;
- QSGPathView *m_view;
+ friend class QQuickPathViewPrivate;
+ friend class QQuickPathView;
+ QQuickPathView *m_view;
QDeclarativeOpenMetaObject *m_metaobject;
bool m_onPath : 1;
bool m_isCurrent : 1;
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGPathView)
-QML_DECLARE_TYPEINFO(QSGPathView, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickPathView)
+QML_DECLARE_TYPEINFO(QQuickPathView, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
-#endif // QSGPATHVIEW_P_H
+#endif // QQUICKPATHVIEW_P_H
**
****************************************************************************/
-#ifndef QDECLARATIVEPATHVIEW_P_H
-#define QDECLARATIVEPATHVIEW_P_H
+#ifndef QQUICKPATHVIEW_P_P_H
+#define QQUICKPATHVIEW_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgpathview_p.h"
-#include "qsgitem_p.h"
-#include "qsgvisualdatamodel_p.h"
+#include "qquickpathview_p.h"
+#include "qquickitem_p.h"
+#include "qquickvisualdatamodel_p.h"
#include <QtDeclarative/qdeclarative.h>
#include <QtCore/qdatetime.h>
QT_BEGIN_NAMESPACE
class QDeclarativeOpenMetaObjectType;
-class QSGPathViewAttached;
-class QSGPathViewPrivate : public QSGItemPrivate, public QSGItemChangeListener
+class QQuickPathViewAttached;
+class QQuickPathViewPrivate : public QQuickItemPrivate, public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGPathView)
+ Q_DECLARE_PUBLIC(QQuickPathView)
public:
- QSGPathViewPrivate()
+ QQuickPathViewPrivate()
: path(0), currentIndex(0), currentItemOffset(0.0), startPc(0), lastDist(0)
, lastElapsed(0), offset(0.0), offsetAdj(0.0), mappedRange(1.0)
, stealMouse(false), ownModel(false), interactive(true), haveHighlightRange(true)
, autoHighlight(true), highlightUp(false), layoutScheduled(false)
, moving(false), flicking(false)
, dragMargin(0), deceleration(100)
- , moveOffset(this, &QSGPathViewPrivate::setAdjustedOffset)
+ , moveOffset(this, &QQuickPathViewPrivate::setAdjustedOffset)
, firstIndex(-1), pathItems(-1), requestedIndex(-1)
, moveReason(Other), moveDirection(Shortest), attType(0), highlightComponent(0), highlightItem(0)
- , moveHighlight(this, &QSGPathViewPrivate::setHighlightPosition)
+ , moveHighlight(this, &QQuickPathViewPrivate::setHighlightPosition)
, highlightPosition(0)
, highlightRangeStart(0), highlightRangeEnd(0)
- , highlightRangeMode(QSGPathView::StrictlyEnforceRange)
+ , highlightRangeMode(QQuickPathView::StrictlyEnforceRange)
, highlightMoveDuration(300), modelCount(0)
{
}
void init();
- void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) {
+ void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) {
if ((newGeometry.size() != oldGeometry.size())
&& (!highlightItem || item != highlightItem)) {
- if (QSGPathViewAttached *att = attached(item))
+ if (QQuickPathViewAttached *att = attached(item))
att->m_percent = -1;
scheduleLayout();
}
}
void scheduleLayout() {
- Q_Q(QSGPathView);
+ Q_Q(QQuickPathView);
if (!layoutScheduled) {
layoutScheduled = true;
q->polish();
}
}
- QSGItem *getItem(int modelIndex, bool onPath = true);
- void releaseItem(QSGItem *item);
- QSGPathViewAttached *attached(QSGItem *item);
+ QQuickItem *getItem(int modelIndex, bool onPath = true);
+ void releaseItem(QQuickItem *item);
+ QQuickPathViewAttached *attached(QQuickItem *item);
void clear();
void updateMappedRange();
qreal positionOfIndex(qreal index) const;
void setOffset(qreal offset);
void setAdjustedOffset(qreal offset);
void regenerate();
- void updateItem(QSGItem *, qreal);
+ void updateItem(QQuickItem *, qreal);
void snapToCurrent();
QPointF pointNear(const QPointF &point, qreal *nearPercent=0) const;
QDeclarativePath *path;
int currentIndex;
- QDeclarativeGuard<QSGItem> currentItem;
+ QDeclarativeGuard<QQuickItem> currentItem;
qreal currentItemOffset;
qreal startPc;
QPointF startPoint;
qreal dragMargin;
qreal deceleration;
QDeclarativeTimeLine tl;
- QDeclarativeTimeLineValueProxy<QSGPathViewPrivate> moveOffset;
+ QDeclarativeTimeLineValueProxy<QQuickPathViewPrivate> moveOffset;
int firstIndex;
int pathItems;
int requestedIndex;
- QList<QSGItem *> items;
- QList<QSGItem *> itemCache;
- QDeclarativeGuard<QSGVisualModel> model;
+ QList<QQuickItem *> items;
+ QList<QQuickItem *> itemCache;
+ QDeclarativeGuard<QQuickVisualModel> model;
QVariant modelVariant;
enum MovementReason { Other, SetIndex, Mouse };
MovementReason moveReason;
MovementDirection moveDirection;
QDeclarativeOpenMetaObjectType *attType;
QDeclarativeComponent *highlightComponent;
- QSGItem *highlightItem;
- QDeclarativeTimeLineValueProxy<QSGPathViewPrivate> moveHighlight;
+ QQuickItem *highlightItem;
+ QDeclarativeTimeLineValueProxy<QQuickPathViewPrivate> moveHighlight;
qreal highlightPosition;
qreal highlightRangeStart;
qreal highlightRangeEnd;
- QSGPathView::HighlightRangeMode highlightRangeMode;
+ QQuickPathView::HighlightRangeMode highlightRangeMode;
int highlightMoveDuration;
int modelCount;
};
**
****************************************************************************/
-#include "qsgpincharea_p_p.h"
-#include "qsgcanvas.h"
+#include "qquickpincharea_p_p.h"
+#include "qquickcanvas.h"
#include <QtGui/qevent.h>
#include <QtGui/qguiapplication.h>
QT_BEGIN_NAMESPACE
/*!
- \qmlclass PinchEvent QSGPinchEvent
+ \qmlclass PinchEvent QQuickPinchEvent
\inqmlmodule QtQuick 2
\ingroup qml-event-elements
\brief The PinchEvent object provides information about a pinch event.
all touch points have been released.
*/
-QSGPinch::QSGPinch()
+QQuickPinch::QQuickPinch()
: m_target(0), m_minScale(1.0), m_maxScale(1.0)
, m_minRotation(0.0), m_maxRotation(0.0)
, m_axis(NoDrag), m_xmin(-FLT_MAX), m_xmax(FLT_MAX)
{
}
-QSGPinchAreaPrivate::~QSGPinchAreaPrivate()
+QQuickPinchAreaPrivate::~QQuickPinchAreaPrivate()
{
delete pinch;
}
/*!
- \qmlclass PinchArea QSGPinchArea
+ \qmlclass PinchArea QQuickPinchArea
\inqmlmodule QtQuick 2
\brief The PinchArea item enables simple pinch gesture handling.
\inherits Item
\endlist
*/
-QSGPinchArea::QSGPinchArea(QSGItem *parent)
- : QSGItem(*(new QSGPinchAreaPrivate), parent)
+QQuickPinchArea::QQuickPinchArea(QQuickItem *parent)
+ : QQuickItem(*(new QQuickPinchAreaPrivate), parent)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
d->init();
}
-QSGPinchArea::~QSGPinchArea()
+QQuickPinchArea::~QQuickPinchArea()
{
}
/*!
This property defaults to true.
*/
-bool QSGPinchArea::isEnabled() const
+bool QQuickPinchArea::isEnabled() const
{
- Q_D(const QSGPinchArea);
+ Q_D(const QQuickPinchArea);
return d->absorb;
}
-void QSGPinchArea::setEnabled(bool a)
+void QQuickPinchArea::setEnabled(bool a)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
if (a != d->absorb) {
d->absorb = a;
emit enabledChanged();
}
}
-void QSGPinchArea::touchEvent(QTouchEvent *event)
+void QQuickPinchArea::touchEvent(QTouchEvent *event)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
if (!d->absorb || !isVisible()) {
- QSGItem::event(event);
+ QQuickItem::event(event);
return;
}
updatePinch();
break;
default:
- QSGItem::event(event);
+ QQuickItem::event(event);
}
}
-void QSGPinchArea::updatePinch()
+void QQuickPinchArea::updatePinch()
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
if (d->touchPoints.count() == 0) {
if (d->inPinch) {
d->inPinch = false;
QPointF pinchCenter = mapFromScene(d->sceneLastCenter);
- QSGPinchEvent pe(pinchCenter, d->pinchLastScale, d->pinchLastAngle, d->pinchRotation);
+ QQuickPinchEvent pe(pinchCenter, d->pinchLastScale, d->pinchLastAngle, d->pinchRotation);
pe.setStartCenter(d->pinchStartCenter);
pe.setPreviousCenter(pinchCenter);
pe.setPreviousAngle(d->pinchLastAngle);
d->pinchRejected = false;
d->stealMouse = false;
setKeepMouseGrab(false);
- QSGCanvas *c = canvas();
+ QQuickCanvas *c = canvas();
if (c && c->mouseGrabberItem() == this)
ungrabMouse();
return;
d->pinchRotation = 0.0;
d->lastPoint1 = p1;
d->lastPoint2 = p2;
- QSGPinchEvent pe(d->pinchStartCenter, 1.0, angle, 0.0);
+ QQuickPinchEvent pe(d->pinchStartCenter, 1.0, angle, 0.0);
pe.setStartCenter(d->pinchStartCenter);
pe.setPreviousCenter(d->pinchStartCenter);
pe.setPreviousAngle(d->pinchLastAngle);
if (pe.accepted()) {
d->inPinch = true;
d->stealMouse = true;
- QSGCanvas *c = canvas();
+ QQuickCanvas *c = canvas();
if (c && c->mouseGrabberItem() != this)
grabMouse();
setKeepMouseGrab(true);
da += 360;
d->pinchRotation += da;
QPointF pinchCenter = mapFromScene(sceneCenter);
- QSGPinchEvent pe(pinchCenter, scale, angle, d->pinchRotation);
+ QQuickPinchEvent pe(pinchCenter, scale, angle, d->pinchRotation);
pe.setStartCenter(d->pinchStartCenter);
pe.setPreviousCenter(mapFromScene(d->sceneLastCenter));
pe.setPreviousAngle(d->pinchLastAngle);
s = qMin(qMax(pinch()->minimumScale(),s), pinch()->maximumScale());
pinch()->target()->setScale(s);
QPointF pos = sceneCenter - d->sceneStartCenter + d->pinchStartPos;
- if (pinch()->axis() & QSGPinch::XAxis) {
+ if (pinch()->axis() & QQuickPinch::XAxis) {
qreal x = pos.x();
if (x < pinch()->xmin())
x = pinch()->xmin();
x = pinch()->xmax();
pinch()->target()->setX(x);
}
- if (pinch()->axis() & QSGPinch::YAxis) {
+ if (pinch()->axis() & QQuickPinch::YAxis) {
qreal y = pos.y();
if (y < pinch()->ymin())
y = pinch()->ymin();
}
}
-void QSGPinchArea::mousePressEvent(QMouseEvent *event)
+void QQuickPinchArea::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
d->stealMouse = false;
if (!d->absorb)
- QSGItem::mousePressEvent(event);
+ QQuickItem::mousePressEvent(event);
else {
setKeepMouseGrab(false);
event->setAccepted(true);
}
}
-void QSGPinchArea::mouseMoveEvent(QMouseEvent *event)
+void QQuickPinchArea::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
if (!d->absorb) {
- QSGItem::mouseMoveEvent(event);
+ QQuickItem::mouseMoveEvent(event);
return;
}
}
-void QSGPinchArea::mouseReleaseEvent(QMouseEvent *event)
+void QQuickPinchArea::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
d->stealMouse = false;
if (!d->absorb) {
- QSGItem::mouseReleaseEvent(event);
+ QQuickItem::mouseReleaseEvent(event);
} else {
- QSGCanvas *c = canvas();
+ QQuickCanvas *c = canvas();
if (c && c->mouseGrabberItem() == this)
ungrabMouse();
setKeepMouseGrab(false);
}
}
-void QSGPinchArea::mouseUngrabEvent()
+void QQuickPinchArea::mouseUngrabEvent()
{
setKeepMouseGrab(false);
}
-bool QSGPinchArea::sendMouseEvent(QMouseEvent *event)
+bool QQuickPinchArea::sendMouseEvent(QMouseEvent *event)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
QRectF myRect = mapRectToScene(QRectF(0, 0, width(), height()));
- QSGCanvas *c = canvas();
- QSGItem *grabber = c ? c->mouseGrabberItem() : 0;
+ QQuickCanvas *c = canvas();
+ QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || myRect.contains(event->windowPos())) && (!grabber || !grabber->keepMouseGrab())) {
QMouseEvent mouseEvent(event->type(), mapFromScene(event->windowPos()), event->windowPos(), event->screenPos(),
return false;
}
-bool QSGPinchArea::childMouseEventFilter(QSGItem *i, QEvent *e)
+bool QQuickPinchArea::childMouseEventFilter(QQuickItem *i, QEvent *e)
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
if (!d->absorb || !isVisible())
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
switch (e->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
break;
}
- return QSGItem::childMouseEventFilter(i, e);
+ return QQuickItem::childMouseEventFilter(i, e);
}
-void QSGPinchArea::geometryChanged(const QRectF &newGeometry,
+void QQuickPinchArea::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
}
-void QSGPinchArea::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickPinchArea::itemChange(ItemChange change, const ItemChangeData &value)
{
- QSGItem::itemChange(change, value);
+ QQuickItem::itemChange(change, value);
}
-QSGPinch *QSGPinchArea::pinch()
+QQuickPinch *QQuickPinchArea::pinch()
{
- Q_D(QSGPinchArea);
+ Q_D(QQuickPinchArea);
if (!d->pinch)
- d->pinch = new QSGPinch;
+ d->pinch = new QQuickPinch;
return d->pinch;
}
**
****************************************************************************/
-#ifndef QSGPINCHAREA_H
-#define QSGPINCHAREA_H
+#ifndef QQUICKPINCHAREA_H
+#define QQUICKPINCHAREA_H
-#include "qsgitem.h"
+#include "qquickitem.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class Q_AUTOTEST_EXPORT QSGPinch : public QObject
+class Q_AUTOTEST_EXPORT QQuickPinch : public QObject
{
Q_OBJECT
Q_ENUMS(Axis)
- Q_PROPERTY(QSGItem *target READ target WRITE setTarget RESET resetTarget)
+ Q_PROPERTY(QQuickItem *target READ target WRITE setTarget RESET resetTarget)
Q_PROPERTY(qreal minimumScale READ minimumScale WRITE setMinimumScale NOTIFY minimumScaleChanged)
Q_PROPERTY(qreal maximumScale READ maximumScale WRITE setMaximumScale NOTIFY maximumScaleChanged)
Q_PROPERTY(qreal minimumRotation READ minimumRotation WRITE setMinimumRotation NOTIFY minimumRotationChanged)
Q_PROPERTY(bool active READ active NOTIFY activeChanged)
public:
- QSGPinch();
+ QQuickPinch();
- QSGItem *target() const { return m_target; }
- void setTarget(QSGItem *target) {
+ QQuickItem *target() const { return m_target; }
+ void setTarget(QQuickItem *target) {
if (target == m_target)
return;
m_target = target;
void activeChanged();
private:
- QSGItem *m_target;
+ QQuickItem *m_target;
qreal m_minScale;
qreal m_maxScale;
qreal m_minRotation;
bool m_active;
};
-class Q_AUTOTEST_EXPORT QSGPinchEvent : public QObject
+class Q_AUTOTEST_EXPORT QQuickPinchEvent : public QObject
{
Q_OBJECT
Q_PROPERTY(bool accepted READ accepted WRITE setAccepted)
public:
- QSGPinchEvent(QPointF c, qreal s, qreal a, qreal r)
+ QQuickPinchEvent(QPointF c, qreal s, qreal a, qreal r)
: QObject(), m_center(c), m_scale(s), m_angle(a), m_rotation(r)
, m_pointCount(0), m_accepted(true) {}
};
-class QSGMouseEvent;
-class QSGPinchAreaPrivate;
-class Q_AUTOTEST_EXPORT QSGPinchArea : public QSGItem
+class QQuickMouseEvent;
+class QQuickPinchAreaPrivate;
+class Q_AUTOTEST_EXPORT QQuickPinchArea : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
- Q_PROPERTY(QSGPinch *pinch READ pinch CONSTANT)
+ Q_PROPERTY(QQuickPinch *pinch READ pinch CONSTANT)
public:
- QSGPinchArea(QSGItem *parent=0);
- ~QSGPinchArea();
+ QQuickPinchArea(QQuickItem *parent=0);
+ ~QQuickPinchArea();
bool isEnabled() const;
void setEnabled(bool);
- QSGPinch *pinch();
+ QQuickPinch *pinch();
Q_SIGNALS:
void enabledChanged();
- void pinchStarted(QSGPinchEvent *pinch);
- void pinchUpdated(QSGPinchEvent *pinch);
- void pinchFinished(QSGPinchEvent *pinch);
+ void pinchStarted(QQuickPinchEvent *pinch);
+ void pinchUpdated(QQuickPinchEvent *pinch);
+ void pinchFinished(QQuickPinchEvent *pinch);
protected:
virtual void mousePressEvent(QMouseEvent *event);
virtual void mouseMoveEvent(QMouseEvent *event);
virtual void mouseUngrabEvent();
virtual bool sendMouseEvent(QMouseEvent *event);
- virtual bool childMouseEventFilter(QSGItem *i, QEvent *e);
+ virtual bool childMouseEventFilter(QQuickItem *i, QEvent *e);
virtual void touchEvent(QTouchEvent *event);
virtual void geometryChanged(const QRectF &newGeometry,
void handleRelease();
private:
- Q_DISABLE_COPY(QSGPinchArea)
- Q_DECLARE_PRIVATE(QSGPinchArea)
+ Q_DISABLE_COPY(QQuickPinchArea)
+ Q_DECLARE_PRIVATE(QQuickPinchArea)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGPinch)
-QML_DECLARE_TYPE(QSGPinchEvent)
-QML_DECLARE_TYPE(QSGPinchArea)
+QML_DECLARE_TYPE(QQuickPinch)
+QML_DECLARE_TYPE(QQuickPinchEvent)
+QML_DECLARE_TYPE(QQuickPinchArea)
QT_END_HEADER
-#endif // QSGPINCHAREA_H
+#endif // QQUICKPINCHAREA_H
**
****************************************************************************/
-#ifndef QSGPINCHAREA_P_H
-#define QSGPINCHAREA_P_H
+#ifndef QQUICKPINCHAREA_P_H
+#define QQUICKPINCHAREA_P_H
//
// W A R N I N G
#include <qevent.h>
-#include "qsgitem_p.h"
-#include "qsgpincharea_p.h"
+#include "qquickitem_p.h"
+#include "qquickpincharea_p.h"
QT_BEGIN_NAMESPACE
-class QSGPinch;
-class QSGPinchAreaPrivate : public QSGItemPrivate
+class QQuickPinch;
+class QQuickPinchAreaPrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGPinchArea)
+ Q_DECLARE_PUBLIC(QQuickPinchArea)
public:
- QSGPinchAreaPrivate()
+ QQuickPinchAreaPrivate()
: absorb(true), stealMouse(false), inPinch(false)
, pinchRejected(false), pinchActivated(false), initPinch(false)
, pinch(0), pinchStartDist(0), pinchStartScale(1.0)
{
}
- ~QSGPinchAreaPrivate();
+ ~QQuickPinchAreaPrivate();
void init()
{
- Q_Q(QSGPinchArea);
+ Q_Q(QQuickPinchArea);
q->setAcceptedMouseButtons(Qt::LeftButton);
q->setFiltersChildMouseEvents(true);
}
bool pinchRejected : 1;
bool pinchActivated : 1;
bool initPinch : 1;
- QSGPinch *pinch;
+ QQuickPinch *pinch;
QPointF sceneStartPoint1;
QPointF sceneStartPoint2;
QPointF lastPoint1;
QT_END_NAMESPACE
-#endif // QSGPINCHAREA_P_H
+#endif // QQUICKPINCHAREA_P_H
**
****************************************************************************/
-#include "qsgpositioners_p.h"
-#include "qsgpositioners_p_p.h"
+#include "qquickpositioners_p.h"
+#include "qquickpositioners_p_p.h"
#include <QtDeclarative/qdeclarative.h>
#include <QtDeclarative/qdeclarativeinfo.h>
QT_BEGIN_NAMESPACE
-static const QSGItemPrivate::ChangeTypes watchedChanges
- = QSGItemPrivate::Geometry
- | QSGItemPrivate::SiblingOrder
- | QSGItemPrivate::Visibility
- | QSGItemPrivate::Destroyed;
+static const QQuickItemPrivate::ChangeTypes watchedChanges
+ = QQuickItemPrivate::Geometry
+ | QQuickItemPrivate::SiblingOrder
+ | QQuickItemPrivate::Visibility
+ | QQuickItemPrivate::Destroyed;
-void QSGBasePositionerPrivate::watchChanges(QSGItem *other)
+void QQuickBasePositionerPrivate::watchChanges(QQuickItem *other)
{
- QSGItemPrivate *otherPrivate = QSGItemPrivate::get(other);
+ QQuickItemPrivate *otherPrivate = QQuickItemPrivate::get(other);
otherPrivate->addItemChangeListener(this, watchedChanges);
}
-void QSGBasePositionerPrivate::unwatchChanges(QSGItem* other)
+void QQuickBasePositionerPrivate::unwatchChanges(QQuickItem* other)
{
- QSGItemPrivate *otherPrivate = QSGItemPrivate::get(other);
+ QQuickItemPrivate *otherPrivate = QQuickItemPrivate::get(other);
otherPrivate->removeItemChangeListener(this, watchedChanges);
}
-QSGBasePositioner::QSGBasePositioner(PositionerType at, QSGItem *parent)
- : QSGImplicitSizeItem(*(new QSGBasePositionerPrivate), parent)
+QQuickBasePositioner::QQuickBasePositioner(PositionerType at, QQuickItem *parent)
+ : QQuickImplicitSizeItem(*(new QQuickBasePositionerPrivate), parent)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
d->init(at);
}
/*!
\internal
- \class QSGBasePositioner
- \brief The QSGBasePositioner class provides a base for QSGGraphics layouts.
+ \class QQuickBasePositioner
+ \brief The QQuickBasePositioner class provides a base for QQuickGraphics layouts.
- To create a QSGGraphics Positioner, simply subclass QSGBasePositioner and implement
+ To create a QQuickGraphics Positioner, simply subclass QQuickBasePositioner and implement
doLayout(), which is automatically called when the layout might need
- updating. In doLayout() use the setX and setY functions from QSGBasePositioner, and the
+ updating. In doLayout() use the setX and setY functions from QQuickBasePositioner, and the
base class will apply the positions along with the appropriate transitions. The items to
position are provided in order as the protected member positionedItems.
changes into one calculation.
*/
-QSGBasePositioner::QSGBasePositioner(QSGBasePositionerPrivate &dd, PositionerType at, QSGItem *parent)
- : QSGImplicitSizeItem(dd, parent)
+QQuickBasePositioner::QQuickBasePositioner(QQuickBasePositionerPrivate &dd, PositionerType at, QQuickItem *parent)
+ : QQuickImplicitSizeItem(dd, parent)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
d->init(at);
}
-QSGBasePositioner::~QSGBasePositioner()
+QQuickBasePositioner::~QQuickBasePositioner()
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
for (int i = 0; i < positionedItems.count(); ++i)
d->unwatchChanges(positionedItems.at(i).item);
positionedItems.clear();
}
-void QSGBasePositioner::updatePolish()
+void QQuickBasePositioner::updatePolish()
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (d->positioningDirty)
prePositioning();
}
-int QSGBasePositioner::spacing() const
+int QQuickBasePositioner::spacing() const
{
- Q_D(const QSGBasePositioner);
+ Q_D(const QQuickBasePositioner);
return d->spacing;
}
-void QSGBasePositioner::setSpacing(int s)
+void QQuickBasePositioner::setSpacing(int s)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (s==d->spacing)
return;
d->spacing = s;
emit spacingChanged();
}
-QDeclarativeTransition *QSGBasePositioner::move() const
+QDeclarativeTransition *QQuickBasePositioner::move() const
{
- Q_D(const QSGBasePositioner);
+ Q_D(const QQuickBasePositioner);
return d->moveTransition;
}
-void QSGBasePositioner::setMove(QDeclarativeTransition *mt)
+void QQuickBasePositioner::setMove(QDeclarativeTransition *mt)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (mt == d->moveTransition)
return;
d->moveTransition = mt;
emit moveChanged();
}
-QDeclarativeTransition *QSGBasePositioner::add() const
+QDeclarativeTransition *QQuickBasePositioner::add() const
{
- Q_D(const QSGBasePositioner);
+ Q_D(const QQuickBasePositioner);
return d->addTransition;
}
-void QSGBasePositioner::setAdd(QDeclarativeTransition *add)
+void QQuickBasePositioner::setAdd(QDeclarativeTransition *add)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (add == d->addTransition)
return;
emit addChanged();
}
-void QSGBasePositioner::componentComplete()
+void QQuickBasePositioner::componentComplete()
{
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
positionedItems.reserve(childItems().count());
prePositioning();
reportConflictingAnchors();
}
-void QSGBasePositioner::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickBasePositioner::itemChange(ItemChange change, const ItemChangeData &value)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (change == ItemChildAddedChange){
d->setPositioningDirty();
} else if (change == ItemChildRemovedChange) {
- QSGItem *child = value.item;
- QSGBasePositioner::PositionedItem posItem(child);
+ QQuickItem *child = value.item;
+ QQuickBasePositioner::PositionedItem posItem(child);
int idx = positionedItems.find(posItem);
if (idx >= 0) {
d->unwatchChanges(child);
d->setPositioningDirty();
}
- QSGItem::itemChange(change, value);
+ QQuickItem::itemChange(change, value);
}
-void QSGBasePositioner::prePositioning()
+void QQuickBasePositioner::prePositioning()
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (!isComponentComplete())
return;
d->positioningDirty = false;
d->doingPositioning = true;
//Need to order children by creation order modified by stacking order
- QList<QSGItem *> children = childItems();
+ QList<QQuickItem *> children = childItems();
QPODVector<PositionedItem,8> oldItems;
positionedItems.copyAndClear(oldItems);
for (int ii = 0; ii < children.count(); ++ii) {
- QSGItem *child = children.at(ii);
- QSGItemPrivate *childPrivate = QSGItemPrivate::get(child);
+ QQuickItem *child = children.at(ii);
+ QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(child);
PositionedItem *item = 0;
PositionedItem posItem(child);
int wIdx = oldItems.find(posItem);
setImplicitWidth(contentSize.width());
}
-void QSGBasePositioner::positionX(int x, const PositionedItem &target)
+void QQuickBasePositioner::positionX(int x, const PositionedItem &target)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (d->type == Horizontal || d->type == Both) {
if (target.isNew) {
if (!d->addTransition || !d->addTransition->enabled())
}
}
-void QSGBasePositioner::positionY(int y, const PositionedItem &target)
+void QQuickBasePositioner::positionY(int y, const PositionedItem &target)
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
if (d->type == Vertical || d->type == Both) {
if (target.isNew) {
if (!d->addTransition || !d->addTransition->enabled())
}
}
-void QSGBasePositioner::finishApplyTransitions()
+void QQuickBasePositioner::finishApplyTransitions()
{
- Q_D(QSGBasePositioner);
+ Q_D(QQuickBasePositioner);
// Note that if a transition is not set the transition manager will
// apply the changes directly, in the case add/move aren't set
d->addTransitionManager.transition(d->addActions, d->addTransition);
d->moveActions.clear();
}
-QSGPositionerAttached *QSGBasePositioner::qmlAttachedProperties(QObject *obj)
+QQuickPositionerAttached *QQuickBasePositioner::qmlAttachedProperties(QObject *obj)
{
- return new QSGPositionerAttached(obj);
+ return new QQuickPositionerAttached(obj);
}
-void QSGBasePositioner::updateAttachedProperties(QSGPositionerAttached *specificProperty, QSGItem *specificPropertyOwner) const
+void QQuickBasePositioner::updateAttachedProperties(QQuickPositionerAttached *specificProperty, QQuickItem *specificPropertyOwner) const
{
// If this function is deemed too expensive or shows up in profiles, it could
// be changed to run only when there are attached properties present. This
// could be a flag in the positioner that is set by the attached property
// constructor.
- QSGPositionerAttached *prevLastProperty = 0;
- QSGPositionerAttached *lastProperty = 0;
+ QQuickPositionerAttached *prevLastProperty = 0;
+ QQuickPositionerAttached *lastProperty = 0;
int visibleItemIndex = 0;
for (int ii = 0; ii < positionedItems.count(); ++ii) {
if (!child.item)
continue;
- QSGPositionerAttached *property = 0;
+ QQuickPositionerAttached *property = 0;
if (specificProperty) {
if (specificPropertyOwner == child.item) {
property = specificProperty;
}
} else {
- property = static_cast<QSGPositionerAttached *>(qmlAttachedPropertiesObject<QSGBasePositioner>(child.item, false));
+ property = static_cast<QQuickPositionerAttached *>(qmlAttachedPropertiesObject<QQuickBasePositioner>(child.item, false));
}
if (child.isVisible) {
}
/*!
- \qmlclass Positioner QSGPositionerAttached
+ \qmlclass Positioner QQuickPositionerAttached
\inqmlmodule QtQuick 2
\ingroup qml-positioning-elements
\brief The Positioner type provides attached properties that contain details on where an item exists in a positioner.
where it exists within the positioner.
*/
-QSGPositionerAttached::QSGPositionerAttached(QObject *parent) : QObject(parent), m_index(-1), m_isFirstItem(false), m_isLastItem(false)
+QQuickPositionerAttached::QQuickPositionerAttached(QObject *parent) : QObject(parent), m_index(-1), m_isFirstItem(false), m_isLastItem(false)
{
- QSGItem *attachedItem = qobject_cast<QSGItem *>(parent);
+ QQuickItem *attachedItem = qobject_cast<QQuickItem *>(parent);
if (attachedItem) {
- QSGBasePositioner *positioner = qobject_cast<QSGBasePositioner *>(attachedItem->parent());
+ QQuickBasePositioner *positioner = qobject_cast<QQuickBasePositioner *>(attachedItem->parent());
if (positioner) {
positioner->updateAttachedProperties(this, attachedItem);
}
This property allows the item to determine
its index within the positioner.
*/
-void QSGPositionerAttached::setIndex(int index)
+void QQuickPositionerAttached::setIndex(int index)
{
if (m_index == index)
return;
These properties allow the item to determine if it
is the first or last item in the positioner, respectively.
*/
-void QSGPositionerAttached::setIsFirstItem(bool isFirstItem)
+void QQuickPositionerAttached::setIsFirstItem(bool isFirstItem)
{
if (m_isFirstItem == isFirstItem)
return;
emit isFirstItemChanged();
}
-void QSGPositionerAttached::setIsLastItem(bool isLastItem)
+void QQuickPositionerAttached::setIsLastItem(bool isLastItem)
{
if (m_isLastItem == isLastItem)
return;
}
/*!
- \qmlclass Column QSGColumn
+ \qmlclass Column QQuickColumn
\inqmlmodule QtQuick 2
\ingroup qml-positioning-elements
\brief The Column item arranges its children vertically.
\sa Grid::spacing
*/
-QSGColumn::QSGColumn(QSGItem *parent)
-: QSGBasePositioner(Vertical, parent)
+QQuickColumn::QQuickColumn(QQuickItem *parent)
+: QQuickBasePositioner(Vertical, parent)
{
}
-void QSGColumn::doPositioning(QSizeF *contentSize)
+void QQuickColumn::doPositioning(QSizeF *contentSize)
{
int voffset = 0;
contentSize->setHeight(voffset);
}
-void QSGColumn::reportConflictingAnchors()
+void QQuickColumn::reportConflictingAnchors()
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate*>(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
for (int ii = 0; ii < positionedItems.count(); ++ii) {
const PositionedItem &child = positionedItems.at(ii);
if (child.item) {
- QSGAnchors *anchors = QSGItemPrivate::get(static_cast<QSGItem *>(child.item))->_anchors;
+ QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
if (anchors) {
- QSGAnchors::Anchors usedAnchors = anchors->usedAnchors();
- if (usedAnchors & QSGAnchors::TopAnchor ||
- usedAnchors & QSGAnchors::BottomAnchor ||
- usedAnchors & QSGAnchors::VCenterAnchor ||
+ QQuickAnchors::Anchors usedAnchors = anchors->usedAnchors();
+ if (usedAnchors & QQuickAnchors::TopAnchor ||
+ usedAnchors & QQuickAnchors::BottomAnchor ||
+ usedAnchors & QQuickAnchors::VCenterAnchor ||
anchors->fill() || anchors->centerIn()) {
d->anchorConflict = true;
break;
}
}
/*!
- \qmlclass Row QSGRow
+ \qmlclass Row QQuickRow
\inqmlmodule QtQuick 2
\ingroup qml-positioning-elements
\brief The Row item arranges its children horizontally.
\sa Grid::spacing
*/
-QSGRow::QSGRow(QSGItem *parent)
-: QSGBasePositioner(Horizontal, parent)
+QQuickRow::QQuickRow(QQuickItem *parent)
+: QQuickBasePositioner(Horizontal, parent)
{
}
/*!
\sa Grid::layoutDirection, Flow::layoutDirection, {declarative/righttoleft/layoutdirection}{Layout directions example}
*/
-Qt::LayoutDirection QSGRow::layoutDirection() const
+Qt::LayoutDirection QQuickRow::layoutDirection() const
{
- return QSGBasePositionerPrivate::getLayoutDirection(this);
+ return QQuickBasePositionerPrivate::getLayoutDirection(this);
}
-void QSGRow::setLayoutDirection(Qt::LayoutDirection layoutDirection)
+void QQuickRow::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate* >(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate* >(QQuickBasePositionerPrivate::get(this));
if (d->layoutDirection != layoutDirection) {
d->layoutDirection = layoutDirection;
// For RTL layout the positioning changes when the width changes.
if (d->layoutDirection == Qt::RightToLeft)
- d->addItemChangeListener(d, QSGItemPrivate::Geometry);
+ d->addItemChangeListener(d, QQuickItemPrivate::Geometry);
else
- d->removeItemChangeListener(d, QSGItemPrivate::Geometry);
+ d->removeItemChangeListener(d, QQuickItemPrivate::Geometry);
prePositioning();
emit layoutDirectionChanged();
emit effectiveLayoutDirectionChanged();
\sa Row::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
-Qt::LayoutDirection QSGRow::effectiveLayoutDirection() const
+Qt::LayoutDirection QQuickRow::effectiveLayoutDirection() const
{
- return QSGBasePositionerPrivate::getEffectiveLayoutDirection(this);
+ return QQuickBasePositionerPrivate::getEffectiveLayoutDirection(this);
}
-void QSGRow::doPositioning(QSizeF *contentSize)
+void QQuickRow::doPositioning(QSizeF *contentSize)
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate* >(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate* >(QQuickBasePositionerPrivate::get(this));
int hoffset = 0;
QList<int> hoffsets;
}
}
-void QSGRow::reportConflictingAnchors()
+void QQuickRow::reportConflictingAnchors()
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate*>(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
for (int ii = 0; ii < positionedItems.count(); ++ii) {
const PositionedItem &child = positionedItems.at(ii);
if (child.item) {
- QSGAnchors *anchors = QSGItemPrivate::get(static_cast<QSGItem *>(child.item))->_anchors;
+ QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
if (anchors) {
- QSGAnchors::Anchors usedAnchors = anchors->usedAnchors();
- if (usedAnchors & QSGAnchors::LeftAnchor ||
- usedAnchors & QSGAnchors::RightAnchor ||
- usedAnchors & QSGAnchors::HCenterAnchor ||
+ QQuickAnchors::Anchors usedAnchors = anchors->usedAnchors();
+ if (usedAnchors & QQuickAnchors::LeftAnchor ||
+ usedAnchors & QQuickAnchors::RightAnchor ||
+ usedAnchors & QQuickAnchors::HCenterAnchor ||
anchors->fill() || anchors->centerIn()) {
d->anchorConflict = true;
break;
}
/*!
- \qmlclass Grid QSGGrid
+ \qmlclass Grid QQuickGrid
\inqmlmodule QtQuick 2
\ingroup qml-positioning-elements
\brief The Grid item positions its children in a grid.
\sa rows, columns
*/
-QSGGrid::QSGGrid(QSGItem *parent) :
- QSGBasePositioner(Both, parent), m_rows(-1), m_columns(-1), m_rowSpacing(-1), m_columnSpacing(-1), m_flow(LeftToRight)
+QQuickGrid::QQuickGrid(QQuickItem *parent) :
+ QQuickBasePositioner(Both, parent), m_rows(-1), m_columns(-1), m_rowSpacing(-1), m_columnSpacing(-1), m_flow(LeftToRight)
{
}
number of rows, some rows will be of zero width.
*/
-void QSGGrid::setColumns(const int columns)
+void QQuickGrid::setColumns(const int columns)
{
if (columns == m_columns)
return;
emit columnsChanged();
}
-void QSGGrid::setRows(const int rows)
+void QQuickGrid::setRows(const int rows)
{
if (rows == m_rows)
return;
other from top to bottom, then wrapped to the next column.
\endlist
*/
-QSGGrid::Flow QSGGrid::flow() const
+QQuickGrid::Flow QQuickGrid::flow() const
{
return m_flow;
}
-void QSGGrid::setFlow(Flow flow)
+void QQuickGrid::setFlow(Flow flow)
{
if (m_flow != flow) {
m_flow = flow;
\sa columnSpacing
\since QtQuick2.0
*/
-void QSGGrid::setRowSpacing(const int rowSpacing)
+void QQuickGrid::setRowSpacing(const int rowSpacing)
{
if (rowSpacing == m_rowSpacing)
return;
\sa rowSpacing
\since QtQuick2.0
*/
-void QSGGrid::setColumnSpacing(const int columnSpacing)
+void QQuickGrid::setColumnSpacing(const int columnSpacing)
{
if (columnSpacing == m_columnSpacing)
return;
\sa Flow::layoutDirection, Row::layoutDirection, {declarative/righttoleft/layoutdirection}{Layout directions example}
*/
-Qt::LayoutDirection QSGGrid::layoutDirection() const
+Qt::LayoutDirection QQuickGrid::layoutDirection() const
{
- return QSGBasePositionerPrivate::getLayoutDirection(this);
+ return QQuickBasePositionerPrivate::getLayoutDirection(this);
}
-void QSGGrid::setLayoutDirection(Qt::LayoutDirection layoutDirection)
+void QQuickGrid::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate*>(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
if (d->layoutDirection != layoutDirection) {
d->layoutDirection = layoutDirection;
// For RTL layout the positioning changes when the width changes.
if (d->layoutDirection == Qt::RightToLeft)
- d->addItemChangeListener(d, QSGItemPrivate::Geometry);
+ d->addItemChangeListener(d, QQuickItemPrivate::Geometry);
else
- d->removeItemChangeListener(d, QSGItemPrivate::Geometry);
+ d->removeItemChangeListener(d, QQuickItemPrivate::Geometry);
prePositioning();
emit layoutDirectionChanged();
emit effectiveLayoutDirectionChanged();
\sa Grid::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
-Qt::LayoutDirection QSGGrid::effectiveLayoutDirection() const
+Qt::LayoutDirection QQuickGrid::effectiveLayoutDirection() const
{
- return QSGBasePositionerPrivate::getEffectiveLayoutDirection(this);
+ return QQuickBasePositionerPrivate::getEffectiveLayoutDirection(this);
}
-void QSGGrid::doPositioning(QSizeF *contentSize)
+void QQuickGrid::doPositioning(QSizeF *contentSize)
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate*>(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
int c = m_columns;
int r = m_rows;
//Is allocating the extra QPODVector too much overhead?
}
}
-void QSGGrid::reportConflictingAnchors()
+void QQuickGrid::reportConflictingAnchors()
{
- QSGBasePositionerPrivate *d = static_cast<QSGBasePositionerPrivate*>(QSGBasePositionerPrivate::get(this));
+ QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
for (int ii = 0; ii < positionedItems.count(); ++ii) {
const PositionedItem &child = positionedItems.at(ii);
if (child.item) {
- QSGAnchors *anchors = QSGItemPrivate::get(static_cast<QSGItem *>(child.item))->_anchors;
+ QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
if (anchors && (anchors->usedAnchors() || anchors->fill() || anchors->centerIn())) {
d->anchorConflict = true;
break;
}
/*!
- \qmlclass Flow QSGFlow
+ \qmlclass Flow QQuickFlow
\inqmlmodule QtQuick 2
\ingroup qml-positioning-elements
\brief The Flow item arranges its children side by side, wrapping as necessary.
\sa Grid::spacing
*/
-class QSGFlowPrivate : public QSGBasePositionerPrivate
+class QQuickFlowPrivate : public QQuickBasePositionerPrivate
{
- Q_DECLARE_PUBLIC(QSGFlow)
+ Q_DECLARE_PUBLIC(QQuickFlow)
public:
- QSGFlowPrivate()
- : QSGBasePositionerPrivate(), flow(QSGFlow::LeftToRight)
+ QQuickFlowPrivate()
+ : QQuickBasePositionerPrivate(), flow(QQuickFlow::LeftToRight)
{}
- QSGFlow::Flow flow;
+ QQuickFlow::Flow flow;
};
-QSGFlow::QSGFlow(QSGItem *parent)
-: QSGBasePositioner(*(new QSGFlowPrivate), Both, parent)
+QQuickFlow::QQuickFlow(QQuickItem *parent)
+: QQuickBasePositioner(*(new QQuickFlowPrivate), Both, parent)
{
- Q_D(QSGFlow);
+ Q_D(QQuickFlow);
// Flow layout requires relayout if its own size changes too.
- d->addItemChangeListener(d, QSGItemPrivate::Geometry);
+ d->addItemChangeListener(d, QQuickItemPrivate::Geometry);
}
/*!
then wrapped to the next column.
\endlist
*/
-QSGFlow::Flow QSGFlow::flow() const
+QQuickFlow::Flow QQuickFlow::flow() const
{
- Q_D(const QSGFlow);
+ Q_D(const QQuickFlow);
return d->flow;
}
-void QSGFlow::setFlow(Flow flow)
+void QQuickFlow::setFlow(Flow flow)
{
- Q_D(QSGFlow);
+ Q_D(QQuickFlow);
if (d->flow != flow) {
d->flow = flow;
prePositioning();
\sa Grid::layoutDirection, Row::layoutDirection, {declarative/righttoleft/layoutdirection}{Layout directions example}
*/
-Qt::LayoutDirection QSGFlow::layoutDirection() const
+Qt::LayoutDirection QQuickFlow::layoutDirection() const
{
- Q_D(const QSGFlow);
+ Q_D(const QQuickFlow);
return d->layoutDirection;
}
-void QSGFlow::setLayoutDirection(Qt::LayoutDirection layoutDirection)
+void QQuickFlow::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
- Q_D(QSGFlow);
+ Q_D(QQuickFlow);
if (d->layoutDirection != layoutDirection) {
d->layoutDirection = layoutDirection;
prePositioning();
\sa Flow::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
-Qt::LayoutDirection QSGFlow::effectiveLayoutDirection() const
+Qt::LayoutDirection QQuickFlow::effectiveLayoutDirection() const
{
- return QSGBasePositionerPrivate::getEffectiveLayoutDirection(this);
+ return QQuickBasePositionerPrivate::getEffectiveLayoutDirection(this);
}
-void QSGFlow::doPositioning(QSizeF *contentSize)
+void QQuickFlow::doPositioning(QSizeF *contentSize)
{
- Q_D(QSGFlow);
+ Q_D(QQuickFlow);
int hoffset = 0;
int voffset = 0;
}
}
-void QSGFlow::reportConflictingAnchors()
+void QQuickFlow::reportConflictingAnchors()
{
- Q_D(QSGFlow);
+ Q_D(QQuickFlow);
for (int ii = 0; ii < positionedItems.count(); ++ii) {
const PositionedItem &child = positionedItems.at(ii);
if (child.item) {
- QSGAnchors *anchors = QSGItemPrivate::get(static_cast<QSGItem *>(child.item))->_anchors;
+ QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
if (anchors && (anchors->usedAnchors() || anchors->fill() || anchors->centerIn())) {
d->anchorConflict = true;
break;
**
****************************************************************************/
-#ifndef QSGPOSITIONERS_P_H
-#define QSGPOSITIONERS_P_H
+#ifndef QQUICKPOSITIONERS_P_H
+#define QQUICKPOSITIONERS_P_H
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p.h"
#include <private/qdeclarativestate_p.h>
#include <private/qpodvector_p.h>
QT_MODULE(Declarative)
-class QSGBasePositionerPrivate;
+class QQuickBasePositionerPrivate;
-class QSGPositionerAttached : public QObject
+class QQuickPositionerAttached : public QObject
{
Q_OBJECT
public:
- QSGPositionerAttached(QObject *parent);
+ QQuickPositionerAttached(QObject *parent);
Q_PROPERTY(int index READ index NOTIFY indexChanged)
Q_PROPERTY(bool isFirstItem READ isFirstItem NOTIFY isFirstItemChanged)
bool m_isLastItem;
};
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGBasePositioner : public QSGImplicitSizeItem
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickBasePositioner : public QQuickImplicitSizeItem
{
Q_OBJECT
Q_PROPERTY(QDeclarativeTransition *add READ add WRITE setAdd NOTIFY addChanged)
public:
enum PositionerType { None = 0x0, Horizontal = 0x1, Vertical = 0x2, Both = 0x3 };
- QSGBasePositioner(PositionerType, QSGItem *parent);
- ~QSGBasePositioner();
+ QQuickBasePositioner(PositionerType, QQuickItem *parent);
+ ~QQuickBasePositioner();
int spacing() const;
void setSpacing(int);
QDeclarativeTransition *add() const;
void setAdd(QDeclarativeTransition *);
- static QSGPositionerAttached *qmlAttachedProperties(QObject *obj);
+ static QQuickPositionerAttached *qmlAttachedProperties(QObject *obj);
- void updateAttachedProperties(QSGPositionerAttached *specificProperty = 0, QSGItem *specificPropertyOwner = 0) const;
+ void updateAttachedProperties(QQuickPositionerAttached *specificProperty = 0, QQuickItem *specificPropertyOwner = 0) const;
protected:
- QSGBasePositioner(QSGBasePositionerPrivate &dd, PositionerType at, QSGItem *parent);
+ QQuickBasePositioner(QQuickBasePositionerPrivate &dd, PositionerType at, QQuickItem *parent);
virtual void componentComplete();
virtual void itemChange(ItemChange, const ItemChangeData &);
void finishApplyTransitions();
virtual void reportConflictingAnchors()=0;
class PositionedItem {
public :
- PositionedItem(QSGItem *i) : item(i), isNew(false), isVisible(true) {}
+ PositionedItem(QQuickItem *i) : item(i), isNew(false), isVisible(true) {}
bool operator==(const PositionedItem &other) const { return other.item == item; }
- QSGItem *item;
+ QQuickItem *item;
bool isNew;
bool isVisible;
};
void positionY(int,const PositionedItem &target);
private:
- Q_DISABLE_COPY(QSGBasePositioner)
- Q_DECLARE_PRIVATE(QSGBasePositioner)
+ Q_DISABLE_COPY(QQuickBasePositioner)
+ Q_DECLARE_PRIVATE(QQuickBasePositioner)
};
-class Q_AUTOTEST_EXPORT QSGColumn : public QSGBasePositioner
+class Q_AUTOTEST_EXPORT QQuickColumn : public QQuickBasePositioner
{
Q_OBJECT
public:
- QSGColumn(QSGItem *parent=0);
+ QQuickColumn(QQuickItem *parent=0);
protected:
virtual void doPositioning(QSizeF *contentSize);
virtual void reportConflictingAnchors();
private:
- Q_DISABLE_COPY(QSGColumn)
+ Q_DISABLE_COPY(QQuickColumn)
};
-class Q_AUTOTEST_EXPORT QSGRow: public QSGBasePositioner
+class Q_AUTOTEST_EXPORT QQuickRow: public QQuickBasePositioner
{
Q_OBJECT
Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection NOTIFY layoutDirectionChanged)
Q_PROPERTY(Qt::LayoutDirection effectiveLayoutDirection READ effectiveLayoutDirection NOTIFY effectiveLayoutDirectionChanged)
public:
- QSGRow(QSGItem *parent=0);
+ QQuickRow(QQuickItem *parent=0);
Qt::LayoutDirection layoutDirection() const;
void setLayoutDirection (Qt::LayoutDirection);
virtual void doPositioning(QSizeF *contentSize);
virtual void reportConflictingAnchors();
private:
- Q_DISABLE_COPY(QSGRow)
+ Q_DISABLE_COPY(QQuickRow)
};
-class Q_AUTOTEST_EXPORT QSGGrid : public QSGBasePositioner
+class Q_AUTOTEST_EXPORT QQuickGrid : public QQuickBasePositioner
{
Q_OBJECT
Q_PROPERTY(int rows READ rows WRITE setRows NOTIFY rowsChanged)
Q_PROPERTY(Qt::LayoutDirection effectiveLayoutDirection READ effectiveLayoutDirection NOTIFY effectiveLayoutDirectionChanged)
public:
- QSGGrid(QSGItem *parent=0);
+ QQuickGrid(QQuickItem *parent=0);
int rows() const {return m_rows;}
void setRows(const int rows);
int m_rowSpacing;
int m_columnSpacing;
Flow m_flow;
- Q_DISABLE_COPY(QSGGrid)
+ Q_DISABLE_COPY(QQuickGrid)
};
-class QSGFlowPrivate;
-class Q_AUTOTEST_EXPORT QSGFlow: public QSGBasePositioner
+class QQuickFlowPrivate;
+class Q_AUTOTEST_EXPORT QQuickFlow: public QQuickBasePositioner
{
Q_OBJECT
Q_PROPERTY(Flow flow READ flow WRITE setFlow NOTIFY flowChanged)
Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection NOTIFY layoutDirectionChanged)
Q_PROPERTY(Qt::LayoutDirection effectiveLayoutDirection READ effectiveLayoutDirection NOTIFY effectiveLayoutDirectionChanged)
public:
- QSGFlow(QSGItem *parent=0);
+ QQuickFlow(QQuickItem *parent=0);
Q_ENUMS(Flow)
enum Flow { LeftToRight, TopToBottom };
virtual void doPositioning(QSizeF *contentSize);
virtual void reportConflictingAnchors();
protected:
- QSGFlow(QSGFlowPrivate &dd, QSGItem *parent);
+ QQuickFlow(QQuickFlowPrivate &dd, QQuickItem *parent);
private:
- Q_DISABLE_COPY(QSGFlow)
- Q_DECLARE_PRIVATE(QSGFlow)
+ Q_DISABLE_COPY(QQuickFlow)
+ Q_DECLARE_PRIVATE(QQuickFlow)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGColumn)
-QML_DECLARE_TYPE(QSGRow)
-QML_DECLARE_TYPE(QSGGrid)
-QML_DECLARE_TYPE(QSGFlow)
+QML_DECLARE_TYPE(QQuickColumn)
+QML_DECLARE_TYPE(QQuickRow)
+QML_DECLARE_TYPE(QQuickGrid)
+QML_DECLARE_TYPE(QQuickFlow)
-QML_DECLARE_TYPE(QSGBasePositioner)
-QML_DECLARE_TYPEINFO(QSGBasePositioner, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickBasePositioner)
+QML_DECLARE_TYPEINFO(QQuickBasePositioner, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
-#endif // QSGPOSITIONERS_P_H
+#endif // QQUICKPOSITIONERS_P_H
**
****************************************************************************/
-#ifndef QSGPOSITIONERS_P_P_H
-#define QSGPOSITIONERS_P_P_H
+#ifndef QQUICKPOSITIONERS_P_P_H
+#define QQUICKPOSITIONERS_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgpositioners_p.h"
-#include "qsgimplicitsizeitem_p_p.h"
+#include "qquickpositioners_p.h"
+#include "qquickimplicitsizeitem_p_p.h"
#include <private/qdeclarativestate_p.h>
#include <private/qdeclarativetransitionmanager_p_p.h>
QT_BEGIN_NAMESPACE
-class QSGBasePositionerPrivate : public QSGImplicitSizeItemPrivate, public QSGItemChangeListener
+class QQuickBasePositionerPrivate : public QQuickImplicitSizeItemPrivate, public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGBasePositioner)
+ Q_DECLARE_PUBLIC(QQuickBasePositioner)
public:
- QSGBasePositionerPrivate()
- : spacing(0), type(QSGBasePositioner::None)
+ QQuickBasePositionerPrivate()
+ : spacing(0), type(QQuickBasePositioner::None)
, moveTransition(0), addTransition(0), positioningDirty(false)
, doingPositioning(false), anchorConflict(false), layoutDirection(Qt::LeftToRight)
{
}
- void init(QSGBasePositioner::PositionerType at)
+ void init(QQuickBasePositioner::PositionerType at)
{
type = at;
childrenDoNotOverlap = true;
int spacing;
- QSGBasePositioner::PositionerType type;
+ QQuickBasePositioner::PositionerType type;
QDeclarativeTransition *moveTransition;
QDeclarativeTransition *addTransition;
QDeclarativeStateOperation::ActionList addActions;
QDeclarativeTransitionManager addTransitionManager;
QDeclarativeTransitionManager moveTransitionManager;
- void watchChanges(QSGItem *other);
- void unwatchChanges(QSGItem* other);
+ void watchChanges(QQuickItem *other);
+ void unwatchChanges(QQuickItem* other);
void setPositioningDirty() {
- Q_Q(QSGBasePositioner);
+ Q_Q(QQuickBasePositioner);
if (!positioningDirty) {
positioningDirty = true;
q->polish();
Qt::LayoutDirection layoutDirection;
void mirrorChange() {
- if (type != QSGBasePositioner::Vertical)
+ if (type != QQuickBasePositioner::Vertical)
setPositioningDirty();
}
bool isLeftToRight() const {
- if (type == QSGBasePositioner::Vertical)
+ if (type == QQuickBasePositioner::Vertical)
return true;
else
return effectiveLayoutMirror ? layoutDirection == Qt::RightToLeft : layoutDirection == Qt::LeftToRight;
}
- virtual void itemSiblingOrderChanged(QSGItem* other)
+ virtual void itemSiblingOrderChanged(QQuickItem* other)
{
Q_UNUSED(other);
setPositioningDirty();
}
- void itemGeometryChanged(QSGItem *, const QRectF &newGeometry, const QRectF &oldGeometry)
+ void itemGeometryChanged(QQuickItem *, const QRectF &newGeometry, const QRectF &oldGeometry)
{
if (newGeometry.size() != oldGeometry.size())
setPositioningDirty();
}
- virtual void itemVisibilityChanged(QSGItem *)
+ virtual void itemVisibilityChanged(QQuickItem *)
{
setPositioningDirty();
}
- void itemDestroyed(QSGItem *item)
+ void itemDestroyed(QQuickItem *item)
{
- Q_Q(QSGBasePositioner);
- q->positionedItems.removeOne(QSGBasePositioner::PositionedItem(item));
+ Q_Q(QQuickBasePositioner);
+ q->positionedItems.removeOne(QQuickBasePositioner::PositionedItem(item));
}
- static Qt::LayoutDirection getLayoutDirection(const QSGBasePositioner *positioner)
+ static Qt::LayoutDirection getLayoutDirection(const QQuickBasePositioner *positioner)
{
return positioner->d_func()->layoutDirection;
}
- static Qt::LayoutDirection getEffectiveLayoutDirection(const QSGBasePositioner *positioner)
+ static Qt::LayoutDirection getEffectiveLayoutDirection(const QQuickBasePositioner *positioner)
{
if (positioner->d_func()->effectiveLayoutMirror)
return positioner->d_func()->layoutDirection == Qt::RightToLeft ? Qt::LeftToRight : Qt::RightToLeft;
QT_END_NAMESPACE
-#endif // QSGPOSITIONERS_P_P_H
+#endif // QQUICKPOSITIONERS_P_P_H
**
****************************************************************************/
-#include "qsgrectangle_p.h"
-#include "qsgrectangle_p_p.h"
+#include "qquickrectangle_p.h"
+#include "qquickrectangle_p_p.h"
#include <private/qsgcontext_p.h>
#include <private/qsgadaptationlayer_p.h>
// XXX todo - should we change rectangle to draw entirely within its width/height?
/*!
\internal
- \class QSGPen
- \brief The QSGPen class provides a pen used for drawing rectangle borders on a QSGView.
+ \class QQuickPen
+ \brief The QQuickPen class provides a pen used for drawing rectangle borders on a QQuickView.
By default, the pen is invalid and nothing is drawn. You must either set a color (then the default
width is 1) or a width (then the default color is black).
\endqml
*/
-QSGPen::QSGPen(QObject *parent)
+QQuickPen::QQuickPen(QObject *parent)
: QObject(parent)
, m_width(1)
, m_color("#000000")
{
}
-qreal QSGPen::width() const
+qreal QQuickPen::width() const
{
return m_width;
}
-void QSGPen::setWidth(qreal w)
+void QQuickPen::setWidth(qreal w)
{
if (m_width == w && m_valid)
return;
emit penChanged();
}
-QColor QSGPen::color() const
+QColor QQuickPen::color() const
{
return m_color;
}
-void QSGPen::setColor(const QColor &c)
+void QQuickPen::setColor(const QColor &c)
{
m_color = c;
m_valid = m_color.alpha() && (qRound(m_width) >= 1 || (!m_aligned && m_width > 0));
emit penChanged();
}
-bool QSGPen::aligned() const
+bool QQuickPen::aligned() const
{
return m_aligned;
}
-void QSGPen::setAligned(bool aligned)
+void QQuickPen::setAligned(bool aligned)
{
if (aligned == m_aligned)
return;
emit penChanged();
}
-bool QSGPen::isValid() const
+bool QQuickPen::isValid() const
{
return m_valid;
}
/*!
- \qmlclass GradientStop QSGGradientStop
+ \qmlclass GradientStop QQuickGradientStop
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The GradientStop item defines the color at a position in a Gradient.
\sa Gradient
*/
-QSGGradientStop::QSGGradientStop(QObject *parent)
+QQuickGradientStop::QQuickGradientStop(QObject *parent)
: QObject(parent)
{
}
-qreal QSGGradientStop::position() const
+qreal QQuickGradientStop::position() const
{
return m_position;
}
-void QSGGradientStop::setPosition(qreal position)
+void QQuickGradientStop::setPosition(qreal position)
{
m_position = position; updateGradient();
}
-QColor QSGGradientStop::color() const
+QColor QQuickGradientStop::color() const
{
return m_color;
}
-void QSGGradientStop::setColor(const QColor &color)
+void QQuickGradientStop::setColor(const QColor &color)
{
m_color = color; updateGradient();
}
-void QSGGradientStop::updateGradient()
+void QQuickGradientStop::updateGradient()
{
- if (QSGGradient *grad = qobject_cast<QSGGradient*>(parent()))
+ if (QQuickGradient *grad = qobject_cast<QQuickGradient*>(parent()))
grad->doUpdate();
}
/*!
- \qmlclass Gradient QSGGradient
+ \qmlclass Gradient QQuickGradient
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The Gradient item defines a gradient fill.
To set the gradient stops, define them as children of the Gradient element.
*/
-QSGGradient::QSGGradient(QObject *parent)
+QQuickGradient::QQuickGradient(QObject *parent)
: QObject(parent), m_gradient(0)
{
}
-QSGGradient::~QSGGradient()
+QQuickGradient::~QQuickGradient()
{
delete m_gradient;
}
-QDeclarativeListProperty<QSGGradientStop> QSGGradient::stops()
+QDeclarativeListProperty<QQuickGradientStop> QQuickGradient::stops()
{
- return QDeclarativeListProperty<QSGGradientStop>(this, m_stops);
+ return QDeclarativeListProperty<QQuickGradientStop>(this, m_stops);
}
-const QGradient *QSGGradient::gradient() const
+const QGradient *QQuickGradient::gradient() const
{
if (!m_gradient && !m_stops.isEmpty()) {
m_gradient = new QLinearGradient(0,0,0,1.0);
for (int i = 0; i < m_stops.count(); ++i) {
- const QSGGradientStop *stop = m_stops.at(i);
+ const QQuickGradientStop *stop = m_stops.at(i);
m_gradient->setCoordinateMode(QGradient::ObjectBoundingMode);
m_gradient->setColorAt(stop->position(), stop->color());
}
return m_gradient;
}
-void QSGGradient::doUpdate()
+void QQuickGradient::doUpdate()
{
delete m_gradient;
m_gradient = 0;
emit updated();
}
-int QSGRectanglePrivate::doUpdateSlotIdx = -1;
+int QQuickRectanglePrivate::doUpdateSlotIdx = -1;
/*!
- \qmlclass Rectangle QSGRectangle
+ \qmlclass Rectangle QQuickRectangle
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The Rectangle item provides a filled rectangle with an optional border.
\sa Image
*/
-QSGRectangle::QSGRectangle(QSGItem *parent)
-: QSGItem(*(new QSGRectanglePrivate), parent)
+QQuickRectangle::QQuickRectangle(QQuickItem *parent)
+: QQuickItem(*(new QQuickRectanglePrivate), parent)
{
setFlag(ItemHasContents);
}
-void QSGRectangle::doUpdate()
+void QQuickRectangle::doUpdate()
{
- Q_D(QSGRectangle);
+ Q_D(QQuickRectangle);
qreal penMargin = 0;
qreal penOffset = 0;
if (d->pen && d->pen->isValid()) {
if (penMargin != d->penMargin || penOffset != d->penOffset) {
d->penMargin = penMargin;
d->penOffset = penOffset;
- d->dirty(QSGItemPrivate::Size); // update clip
+ d->dirty(QQuickItemPrivate::Size); // update clip
}
update();
}
Here, the innermost rectangle's border is clipped on the bottom and right edges by its
parent. To avoid this, the border width can be set to two instead of one.
*/
-QSGPen *QSGRectangle::border()
+QQuickPen *QQuickRectangle::border()
{
- Q_D(QSGRectangle);
+ Q_D(QQuickRectangle);
return d->getPen();
}
\sa Gradient, color
*/
-QSGGradient *QSGRectangle::gradient() const
+QQuickGradient *QQuickRectangle::gradient() const
{
- Q_D(const QSGRectangle);
+ Q_D(const QQuickRectangle);
return d->gradient;
}
-void QSGRectangle::setGradient(QSGGradient *gradient)
+void QQuickRectangle::setGradient(QQuickGradient *gradient)
{
- Q_D(QSGRectangle);
+ Q_D(QQuickRectangle);
if (d->gradient == gradient)
return;
static int updatedSignalIdx = -1;
if (updatedSignalIdx < 0)
- updatedSignalIdx = QSGGradient::staticMetaObject.indexOfSignal("updated()");
+ updatedSignalIdx = QQuickGradient::staticMetaObject.indexOfSignal("updated()");
if (d->doUpdateSlotIdx < 0)
- d->doUpdateSlotIdx = QSGRectangle::staticMetaObject.indexOfSlot("doUpdate()");
+ d->doUpdateSlotIdx = QQuickRectangle::staticMetaObject.indexOfSlot("doUpdate()");
if (d->gradient)
QMetaObject::disconnect(d->gradient, updatedSignalIdx, this, d->doUpdateSlotIdx);
d->gradient = gradient;
painted as a normal rectangle. The same radius is used by all 4 corners; there is currently
no way to specify different radii for different corners.
*/
-qreal QSGRectangle::radius() const
+qreal QQuickRectangle::radius() const
{
- Q_D(const QSGRectangle);
+ Q_D(const QQuickRectangle);
return d->radius;
}
-void QSGRectangle::setRadius(qreal radius)
+void QQuickRectangle::setRadius(qreal radius)
{
- Q_D(QSGRectangle);
+ Q_D(QQuickRectangle);
if (d->radius == radius)
return;
\sa gradient
*/
-QColor QSGRectangle::color() const
+QColor QQuickRectangle::color() const
{
- Q_D(const QSGRectangle);
+ Q_D(const QQuickRectangle);
return d->color;
}
-void QSGRectangle::setColor(const QColor &c)
+void QQuickRectangle::setColor(const QColor &c)
{
- Q_D(QSGRectangle);
+ Q_D(QQuickRectangle);
if (d->color == c)
return;
emit colorChanged();
}
-QSGNode *QSGRectangle::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+QSGNode *QQuickRectangle::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
Q_UNUSED(data);
- Q_D(QSGRectangle);
+ Q_D(QQuickRectangle);
if (width() <= 0 || height() <= 0) {
delete oldNode;
QGradientStops stops;
if (d->gradient) {
- QList<QSGGradientStop *> qxstops = d->gradient->m_stops;
+ QList<QQuickGradientStop *> qxstops = d->gradient->m_stops;
for (int i = 0; i < qxstops.size(); ++i){
int j = 0;
while (j < stops.size() && stops.at(j).first < qxstops[i]->position())
On this image, smooth is turned off on the top half and on on the bottom half.
*/
-QRectF QSGRectangle::boundingRect() const
+QRectF QQuickRectangle::boundingRect() const
{
- Q_D(const QSGRectangle);
+ Q_D(const QQuickRectangle);
return QRectF(d->penOffset - d->penMargin, d->penOffset - d->penMargin,
d->width + 2 * d->penMargin, d->height + 2 * d->penMargin);
}
**
****************************************************************************/
-#ifndef QSGRECTANGLE_P_H
-#define QSGRECTANGLE_P_H
+#ifndef QQUICKRECTANGLE_P_H
+#define QQUICKRECTANGLE_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <QtGui/qbrush.h>
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGPen : public QObject
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickPen : public QObject
{
Q_OBJECT
Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY penChanged)
Q_PROPERTY(bool aligned READ aligned WRITE setAligned NOTIFY penChanged)
public:
- QSGPen(QObject *parent=0);
+ QQuickPen(QObject *parent=0);
qreal width() const;
void setWidth(qreal w);
bool m_valid : 1;
};
-class Q_AUTOTEST_EXPORT QSGGradientStop : public QObject
+class Q_AUTOTEST_EXPORT QQuickGradientStop : public QObject
{
Q_OBJECT
Q_PROPERTY(QColor color READ color WRITE setColor)
public:
- QSGGradientStop(QObject *parent=0);
+ QQuickGradientStop(QObject *parent=0);
qreal position() const;
void setPosition(qreal position);
QColor m_color;
};
-class Q_AUTOTEST_EXPORT QSGGradient : public QObject
+class Q_AUTOTEST_EXPORT QQuickGradient : public QObject
{
Q_OBJECT
- Q_PROPERTY(QDeclarativeListProperty<QSGGradientStop> stops READ stops)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickGradientStop> stops READ stops)
Q_CLASSINFO("DefaultProperty", "stops")
public:
- QSGGradient(QObject *parent=0);
- ~QSGGradient();
+ QQuickGradient(QObject *parent=0);
+ ~QQuickGradient();
- QDeclarativeListProperty<QSGGradientStop> stops();
+ QDeclarativeListProperty<QQuickGradientStop> stops();
const QGradient *gradient() const;
void doUpdate();
private:
- QList<QSGGradientStop *> m_stops;
+ QList<QQuickGradientStop *> m_stops;
mutable QGradient *m_gradient;
- friend class QSGRectangle;
- friend class QSGGradientStop;
+ friend class QQuickRectangle;
+ friend class QQuickGradientStop;
};
-class QSGRectanglePrivate;
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGRectangle : public QSGItem
+class QQuickRectanglePrivate;
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickRectangle : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
- Q_PROPERTY(QSGGradient *gradient READ gradient WRITE setGradient)
- Q_PROPERTY(QSGPen * border READ border CONSTANT)
+ Q_PROPERTY(QQuickGradient *gradient READ gradient WRITE setGradient)
+ Q_PROPERTY(QQuickPen * border READ border CONSTANT)
Q_PROPERTY(qreal radius READ radius WRITE setRadius NOTIFY radiusChanged)
public:
- QSGRectangle(QSGItem *parent=0);
+ QQuickRectangle(QQuickItem *parent=0);
QColor color() const;
void setColor(const QColor &);
- QSGPen *border();
+ QQuickPen *border();
- QSGGradient *gradient() const;
- void setGradient(QSGGradient *gradient);
+ QQuickGradient *gradient() const;
+ void setGradient(QQuickGradient *gradient);
qreal radius() const;
void setRadius(qreal radius);
void doUpdate();
private:
- Q_DISABLE_COPY(QSGRectangle)
- Q_DECLARE_PRIVATE(QSGRectangle)
+ Q_DISABLE_COPY(QQuickRectangle)
+ Q_DECLARE_PRIVATE(QQuickRectangle)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGPen)
-QML_DECLARE_TYPE(QSGGradientStop)
-QML_DECLARE_TYPE(QSGGradient)
-QML_DECLARE_TYPE(QSGRectangle)
+QML_DECLARE_TYPE(QQuickPen)
+QML_DECLARE_TYPE(QQuickGradientStop)
+QML_DECLARE_TYPE(QQuickGradient)
+QML_DECLARE_TYPE(QQuickRectangle)
QT_END_HEADER
-#endif // QSGRECTANGLE_P_H
+#endif // QQUICKRECTANGLE_P_H
**
****************************************************************************/
-#ifndef QSGRECTANGLE_P_P_H
-#define QSGRECTANGLE_P_P_H
+#ifndef QQUICKRECTANGLE_P_P_H
+#define QQUICKRECTANGLE_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgitem_p.h"
+#include "qquickitem_p.h"
QT_BEGIN_NAMESPACE
-class QSGGradient;
-class QSGRectangle;
-class QSGRectanglePrivate : public QSGItemPrivate
+class QQuickGradient;
+class QQuickRectangle;
+class QQuickRectanglePrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGRectangle)
+ Q_DECLARE_PUBLIC(QQuickRectangle)
public:
- QSGRectanglePrivate() :
+ QQuickRectanglePrivate() :
color(Qt::white), gradient(0), pen(0), radius(0), penMargin(0), penOffset(0)
{
}
- ~QSGRectanglePrivate()
+ ~QQuickRectanglePrivate()
{
delete pen;
}
QColor color;
- QSGGradient *gradient;
- QSGPen *pen;
+ QQuickGradient *gradient;
+ QQuickPen *pen;
qreal radius;
qreal penMargin;
qreal penOffset;
static int doUpdateSlotIdx;
- QSGPen *getPen() {
+ QQuickPen *getPen() {
if (!pen) {
- Q_Q(QSGRectangle);
- pen = new QSGPen;
+ Q_Q(QQuickRectangle);
+ pen = new QQuickPen;
static int penChangedSignalIdx = -1;
if (penChangedSignalIdx < 0)
- penChangedSignalIdx = QSGPen::staticMetaObject.indexOfSignal("penChanged()");
+ penChangedSignalIdx = QQuickPen::staticMetaObject.indexOfSignal("penChanged()");
if (doUpdateSlotIdx < 0)
- doUpdateSlotIdx = QSGRectangle::staticMetaObject.indexOfSlot("doUpdate()");
+ doUpdateSlotIdx = QQuickRectangle::staticMetaObject.indexOfSlot("doUpdate()");
QMetaObject::connect(pen, penChangedSignalIdx, q, doUpdateSlotIdx);
}
return pen;
QT_END_NAMESPACE
-#endif // QSGRECTANGLE_P_P_H
+#endif // QQUICKRECTANGLE_P_P_H
**
****************************************************************************/
-#include "qsgrepeater_p.h"
-#include "qsgrepeater_p_p.h"
-#include "qsgvisualdatamodel_p.h"
+#include "qquickrepeater_p.h"
+#include "qquickrepeater_p_p.h"
+#include "qquickvisualdatamodel_p.h"
#include <private/qdeclarativeglobal_p.h>
#include <private/qdeclarativelistaccessor_p.h>
QT_BEGIN_NAMESPACE
-QSGRepeaterPrivate::QSGRepeaterPrivate()
+QQuickRepeaterPrivate::QQuickRepeaterPrivate()
: model(0), ownModel(false)
{
}
-QSGRepeaterPrivate::~QSGRepeaterPrivate()
+QQuickRepeaterPrivate::~QQuickRepeaterPrivate()
{
if (ownModel)
delete model;
}
/*!
- \qmlclass Repeater QSGRepeater
+ \qmlclass Repeater QQuickRepeater
\inqmlmodule QtQuick 2
\ingroup qml-utility-elements
\inherits Item
Do not keep a reference to \a item if it was created by this repeater, as
in these cases it will be deleted shortly after the handler is called.
*/
-QSGRepeater::QSGRepeater(QSGItem *parent)
- : QSGItem(*(new QSGRepeaterPrivate), parent)
+QQuickRepeater::QQuickRepeater(QQuickItem *parent)
+ : QQuickItem(*(new QQuickRepeaterPrivate), parent)
{
}
-QSGRepeater::~QSGRepeater()
+QQuickRepeater::~QQuickRepeater()
{
}
\sa {qmlmodels}{Data Models}
*/
-QVariant QSGRepeater::model() const
+QVariant QQuickRepeater::model() const
{
- Q_D(const QSGRepeater);
+ Q_D(const QQuickRepeater);
return d->dataSource;
}
-void QSGRepeater::setModel(const QVariant &model)
+void QQuickRepeater::setModel(const QVariant &model)
{
- Q_D(QSGRepeater);
+ Q_D(QQuickRepeater);
if (d->dataSource == model)
return;
disconnect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
/*
- disconnect(d->model, SIGNAL(createdItem(int,QSGItem*)), this, SLOT(createdItem(int,QSGItem*)));
- disconnect(d->model, SIGNAL(destroyingItem(QSGItem*)), this, SLOT(destroyingItem(QSGItem*)));
+ disconnect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
+ disconnect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
*/
}
d->dataSource = model;
QObject *object = qvariant_cast<QObject*>(model);
- QSGVisualModel *vim = 0;
- if (object && (vim = qobject_cast<QSGVisualModel *>(object))) {
+ QQuickVisualModel *vim = 0;
+ if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
if (d->ownModel) {
delete d->model;
d->ownModel = false;
d->model = vim;
} else {
if (!d->ownModel) {
- d->model = new QSGVisualDataModel(qmlContext(this));
+ d->model = new QQuickVisualDataModel(qmlContext(this));
d->ownModel = true;
if (isComponentComplete())
- static_cast<QSGVisualDataModel *>(d->model)->componentComplete();
+ static_cast<QQuickVisualDataModel *>(d->model)->componentComplete();
}
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
dataModel->setModel(model);
}
if (d->model) {
connect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
/*
- connect(d->model, SIGNAL(createdItem(int,QSGItem*)), this, SLOT(createdItem(int,QSGItem*)));
- connect(d->model, SIGNAL(destroyingItem(QSGItem*)), this, SLOT(destroyingItem(QSGItem*)));
+ connect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
+ connect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
*/
regenerate();
}
\sa {QML Data Models}
*/
-QDeclarativeComponent *QSGRepeater::delegate() const
+QDeclarativeComponent *QQuickRepeater::delegate() const
{
- Q_D(const QSGRepeater);
+ Q_D(const QQuickRepeater);
if (d->model) {
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
return dataModel->delegate();
}
return 0;
}
-void QSGRepeater::setDelegate(QDeclarativeComponent *delegate)
+void QQuickRepeater::setDelegate(QDeclarativeComponent *delegate)
{
- Q_D(QSGRepeater);
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model))
+ Q_D(QQuickRepeater);
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (delegate == dataModel->delegate())
return;
if (!d->ownModel) {
- d->model = new QSGVisualDataModel(qmlContext(this));
+ d->model = new QQuickVisualDataModel(qmlContext(this));
d->ownModel = true;
}
- if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(d->model)) {
+ if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
dataModel->setDelegate(delegate);
regenerate();
emit delegateChanged();
This property holds the number of items in the repeater.
*/
-int QSGRepeater::count() const
+int QQuickRepeater::count() const
{
- Q_D(const QSGRepeater);
+ Q_D(const QQuickRepeater);
if (d->model)
return d->model->count();
return 0;
Returns the \l Item that has been created at the given \a index, or \c null
if no item exists at \a index.
*/
-QSGItem *QSGRepeater::itemAt(int index) const
+QQuickItem *QQuickRepeater::itemAt(int index) const
{
- Q_D(const QSGRepeater);
+ Q_D(const QQuickRepeater);
if (index >= 0 && index < d->deletables.count())
return d->deletables[index];
return 0;
}
-void QSGRepeater::componentComplete()
+void QQuickRepeater::componentComplete()
{
- Q_D(QSGRepeater);
+ Q_D(QQuickRepeater);
if (d->model && d->ownModel)
- static_cast<QSGVisualDataModel *>(d->model)->componentComplete();
- QSGItem::componentComplete();
+ static_cast<QQuickVisualDataModel *>(d->model)->componentComplete();
+ QQuickItem::componentComplete();
regenerate();
if (d->model && d->model->count())
emit countChanged();
}
-void QSGRepeater::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickRepeater::itemChange(ItemChange change, const ItemChangeData &value)
{
- QSGItem::itemChange(change, value);
+ QQuickItem::itemChange(change, value);
if (change == ItemParentHasChanged) {
regenerate();
}
}
-void QSGRepeater::clear()
+void QQuickRepeater::clear()
{
- Q_D(QSGRepeater);
+ Q_D(QQuickRepeater);
bool complete = isComponentComplete();
if (d->model) {
while (d->deletables.count() > 0) {
- QSGItem *item = d->deletables.takeLast();
+ QQuickItem *item = d->deletables.takeLast();
if (complete)
emit itemRemoved(d->deletables.count()-1, item);
d->model->release(item);
d->deletables.clear();
}
-void QSGRepeater::regenerate()
+void QQuickRepeater::regenerate()
{
- Q_D(QSGRepeater);
+ Q_D(QQuickRepeater);
if (!isComponentComplete())
return;
return;
for (int ii = 0; ii < count(); ++ii) {
- QSGItem *item = d->model->item(ii);
+ QQuickItem *item = d->model->item(ii);
if (item) {
QDeclarative_setParent_noEvent(item, parentItem());
item->setParentItem(parentItem());
}
}
-void QSGRepeater::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickRepeater::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
- Q_D(QSGRepeater);
+ Q_D(QQuickRepeater);
if (!isComponentComplete())
return;
}
int difference = 0;
- QHash<int, QList<QPointer<QSGItem> > > moved;
+ QHash<int, QList<QPointer<QQuickItem> > > moved;
foreach (const QDeclarativeChangeSet::Remove &remove, changeSet.removes()) {
int index = qMin(remove.index, d->deletables.count());
int count = qMin(remove.index + remove.count, d->deletables.count()) - index;
d->deletables.begin() + index,
d->deletables.begin() + index + count);
} else while (count--) {
- QSGItem *item = d->deletables.takeAt(index);
+ QQuickItem *item = d->deletables.takeAt(index);
emit itemRemoved(index, item);
if (item)
d->model->release(item);
foreach (const QDeclarativeChangeSet::Insert &insert, changeSet.inserts()) {
int index = qMin(insert.index, d->deletables.count());
if (insert.isMove()) {
- QList<QPointer<QSGItem> > items = moved.value(insert.moveId);
+ QList<QPointer<QQuickItem> > items = moved.value(insert.moveId);
d->deletables = d->deletables.mid(0, index) + items + d->deletables.mid(index);
- QSGItem *stackBefore = index + items.count() < d->deletables.count()
+ QQuickItem *stackBefore = index + items.count() < d->deletables.count()
? d->deletables.at(index + items.count())
: this;
for (int i = index; i < index + items.count(); ++i)
d->deletables.at(i)->stackBefore(stackBefore);
} else for (int i = 0; i < insert.count; ++i) {
int modelIndex = index + i;
- QSGItem *item = d->model->item(modelIndex);
+ QQuickItem *item = d->model->item(modelIndex);
if (item) {
QDeclarative_setParent_noEvent(item, parentItem());
item->setParentItem(parentItem());
**
****************************************************************************/
-#ifndef QSGREPEATER_P_H
-#define QSGREPEATER_P_H
+#ifndef QQUICKREPEATER_P_H
+#define QQUICKREPEATER_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
QT_BEGIN_HEADER
class QDeclarativeChangeSet;
-class QSGRepeaterPrivate;
-class Q_AUTOTEST_EXPORT QSGRepeater : public QSGItem
+class QQuickRepeaterPrivate;
+class Q_AUTOTEST_EXPORT QQuickRepeater : public QQuickItem
{
Q_OBJECT
Q_CLASSINFO("DefaultProperty", "delegate")
public:
- QSGRepeater(QSGItem *parent=0);
- virtual ~QSGRepeater();
+ QQuickRepeater(QQuickItem *parent=0);
+ virtual ~QQuickRepeater();
QVariant model() const;
void setModel(const QVariant &);
int count() const;
- Q_INVOKABLE QSGItem *itemAt(int index) const;
+ Q_INVOKABLE QQuickItem *itemAt(int index) const;
Q_SIGNALS:
void modelChanged();
void delegateChanged();
void countChanged();
- void itemAdded(int index, QSGItem *item);
- void itemRemoved(int index, QSGItem *item);
+ void itemAdded(int index, QQuickItem *item);
+ void itemRemoved(int index, QQuickItem *item);
private:
void clear();
void modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
private:
- Q_DISABLE_COPY(QSGRepeater)
- Q_DECLARE_PRIVATE(QSGRepeater)
+ Q_DISABLE_COPY(QQuickRepeater)
+ Q_DECLARE_PRIVATE(QQuickRepeater)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGRepeater)
+QML_DECLARE_TYPE(QQuickRepeater)
QT_END_HEADER
-#endif // QSGREPEATER_P_H
+#endif // QQUICKREPEATER_P_H
**
****************************************************************************/
-#ifndef QSGREPEATER_P_P_H
-#define QSGREPEATER_P_P_H
+#ifndef QQUICKREPEATER_P_P_H
+#define QQUICKREPEATER_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgrepeater_p.h"
-#include "qsgitem_p.h"
+#include "qquickrepeater_p.h"
+#include "qquickitem_p.h"
#include <QtCore/qpointer.h>
QT_BEGIN_NAMESPACE
class QDeclarativeContext;
-class QSGVisualModel;
-class QSGRepeaterPrivate : public QSGItemPrivate
+class QQuickVisualModel;
+class QQuickRepeaterPrivate : public QQuickItemPrivate
{
- Q_DECLARE_PUBLIC(QSGRepeater)
+ Q_DECLARE_PUBLIC(QQuickRepeater)
public:
- QSGRepeaterPrivate();
- ~QSGRepeaterPrivate();
+ QQuickRepeaterPrivate();
+ ~QQuickRepeaterPrivate();
- QSGVisualModel *model;
+ QQuickVisualModel *model;
QVariant dataSource;
bool ownModel;
- QList<QPointer<QSGItem> > deletables;
+ QList<QPointer<QQuickItem> > deletables;
};
QT_END_NAMESPACE
-#endif // QSGREPEATER_P_P_H
+#endif // QQUICKREPEATER_P_P_H
**
****************************************************************************/
-#include "qsgscalegrid_p_p.h"
+#include "qquickscalegrid_p_p.h"
#include <QtDeclarative/qdeclarative.h>
/*!
\internal
- \class QSGScaleGrid
- \brief The QSGScaleGrid class allows you to specify a 3x3 grid to use in scaling an image.
+ \class QQuickScaleGrid
+ \brief The QQuickScaleGrid class allows you to specify a 3x3 grid to use in scaling an image.
*/
-QSGScaleGrid::QSGScaleGrid(QObject *parent) : QObject(parent), _left(0), _top(0), _right(0), _bottom(0)
+QQuickScaleGrid::QQuickScaleGrid(QObject *parent) : QObject(parent), _left(0), _top(0), _right(0), _bottom(0)
{
}
-QSGScaleGrid::~QSGScaleGrid()
+QQuickScaleGrid::~QQuickScaleGrid()
{
}
-bool QSGScaleGrid::isNull() const
+bool QQuickScaleGrid::isNull() const
{
return !_left && !_top && !_right && !_bottom;
}
-void QSGScaleGrid::setLeft(int pos)
+void QQuickScaleGrid::setLeft(int pos)
{
if (_left != pos) {
_left = pos;
}
}
-void QSGScaleGrid::setTop(int pos)
+void QQuickScaleGrid::setTop(int pos)
{
if (_top != pos) {
_top = pos;
}
}
-void QSGScaleGrid::setRight(int pos)
+void QQuickScaleGrid::setRight(int pos)
{
if (_right != pos) {
_right = pos;
}
}
-void QSGScaleGrid::setBottom(int pos)
+void QQuickScaleGrid::setBottom(int pos)
{
if (_bottom != pos) {
_bottom = pos;
}
}
-QSGGridScaledImage::QSGGridScaledImage()
+QQuickGridScaledImage::QQuickGridScaledImage()
: _l(-1), _r(-1), _t(-1), _b(-1),
- _h(QSGBorderImage::Stretch), _v(QSGBorderImage::Stretch)
+ _h(QQuickBorderImage::Stretch), _v(QQuickBorderImage::Stretch)
{
}
-QSGGridScaledImage::QSGGridScaledImage(const QSGGridScaledImage &o)
+QQuickGridScaledImage::QQuickGridScaledImage(const QQuickGridScaledImage &o)
: _l(o._l), _r(o._r), _t(o._t), _b(o._b), _h(o._h), _v(o._v), _pix(o._pix)
{
}
-QSGGridScaledImage &QSGGridScaledImage::operator=(const QSGGridScaledImage &o)
+QQuickGridScaledImage &QQuickGridScaledImage::operator=(const QQuickGridScaledImage &o)
{
_l = o._l;
_r = o._r;
return *this;
}
-QSGGridScaledImage::QSGGridScaledImage(QIODevice *data)
-: _l(-1), _r(-1), _t(-1), _b(-1), _h(QSGBorderImage::Stretch), _v(QSGBorderImage::Stretch)
+QQuickGridScaledImage::QQuickGridScaledImage(QIODevice *data)
+: _l(-1), _r(-1), _t(-1), _b(-1), _h(QQuickBorderImage::Stretch), _v(QQuickBorderImage::Stretch)
{
int l = -1;
int r = -1;
_pix = _pix.mid(1, _pix.size() - 2); // remove leading/trailing quotes.
}
-QSGBorderImage::TileMode QSGGridScaledImage::stringToRule(const QString &s)
+QQuickBorderImage::TileMode QQuickGridScaledImage::stringToRule(const QString &s)
{
if (s == QLatin1String("Stretch"))
- return QSGBorderImage::Stretch;
+ return QQuickBorderImage::Stretch;
if (s == QLatin1String("Repeat"))
- return QSGBorderImage::Repeat;
+ return QQuickBorderImage::Repeat;
if (s == QLatin1String("Round"))
- return QSGBorderImage::Round;
+ return QQuickBorderImage::Round;
- qWarning("QSGGridScaledImage: Invalid tile rule specified. Using Stretch.");
- return QSGBorderImage::Stretch;
+ qWarning("QQuickGridScaledImage: Invalid tile rule specified. Using Stretch.");
+ return QQuickBorderImage::Stretch;
}
-bool QSGGridScaledImage::isValid() const
+bool QQuickGridScaledImage::isValid() const
{
return _l >= 0;
}
-int QSGGridScaledImage::gridLeft() const
+int QQuickGridScaledImage::gridLeft() const
{
return _l;
}
-int QSGGridScaledImage::gridRight() const
+int QQuickGridScaledImage::gridRight() const
{
return _r;
}
-int QSGGridScaledImage::gridTop() const
+int QQuickGridScaledImage::gridTop() const
{
return _t;
}
-int QSGGridScaledImage::gridBottom() const
+int QQuickGridScaledImage::gridBottom() const
{
return _b;
}
-QString QSGGridScaledImage::pixmapUrl() const
+QString QQuickGridScaledImage::pixmapUrl() const
{
return _pix;
}
**
****************************************************************************/
-#ifndef QSGSCALEGRID_P_P_H
-#define QSGSCALEGRID_P_P_H
+#ifndef QQUICKSCALEGRID_P_P_H
+#define QQUICKSCALEGRID_P_P_H
-#include "qsgborderimage_p.h"
+#include "qquickborderimage_p.h"
#include <QtDeclarative/qdeclarative.h>
#include <QtCore/qobject.h>
QT_MODULE(Declarative)
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGScaleGrid : public QObject
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickScaleGrid : public QObject
{
Q_OBJECT
Q_ENUMS(TileRule)
Q_PROPERTY(int bottom READ bottom WRITE setBottom NOTIFY borderChanged)
public:
- QSGScaleGrid(QObject *parent=0);
- ~QSGScaleGrid();
+ QQuickScaleGrid(QObject *parent=0);
+ ~QQuickScaleGrid();
bool isNull() const;
int _bottom;
};
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGGridScaledImage
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickGridScaledImage
{
public:
- QSGGridScaledImage();
- QSGGridScaledImage(const QSGGridScaledImage &);
- QSGGridScaledImage(QIODevice*);
- QSGGridScaledImage &operator=(const QSGGridScaledImage &);
+ QQuickGridScaledImage();
+ QQuickGridScaledImage(const QQuickGridScaledImage &);
+ QQuickGridScaledImage(QIODevice*);
+ QQuickGridScaledImage &operator=(const QQuickGridScaledImage &);
bool isValid() const;
int gridLeft() const;
int gridRight() const;
int gridTop() const;
int gridBottom() const;
- QSGBorderImage::TileMode horizontalTileRule() const { return _h; }
- QSGBorderImage::TileMode verticalTileRule() const { return _v; }
+ QQuickBorderImage::TileMode horizontalTileRule() const { return _h; }
+ QQuickBorderImage::TileMode verticalTileRule() const { return _v; }
QString pixmapUrl() const;
private:
- static QSGBorderImage::TileMode stringToRule(const QString &);
+ static QQuickBorderImage::TileMode stringToRule(const QString &);
private:
int _l;
int _r;
int _t;
int _b;
- QSGBorderImage::TileMode _h;
- QSGBorderImage::TileMode _v;
+ QQuickBorderImage::TileMode _h;
+ QQuickBorderImage::TileMode _v;
QString _pix;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGScaleGrid)
+QML_DECLARE_TYPE(QQuickScaleGrid)
QT_END_HEADER
-#endif // QSGSCALEGRID_P_P_H
+#endif // QQUICKSCALEGRID_P_P_H
**
****************************************************************************/
-#include <private/qsgshadereffect_p.h>
-#include <private/qsgshadereffectnode_p.h>
+#include <private/qquickshadereffect_p.h>
+#include <private/qquickshadereffectnode_p.h>
#include "qsgmaterial.h"
-#include "qsgitem_p.h"
+#include "qquickitem_p.h"
#include <private/qsgcontext_p.h>
#include <private/qsgtextureprovider_p.h>
-#include "qsgcanvas.h"
+#include "qquickcanvas.h"
-#include "qsgimage_p.h"
-#include "qsgshadereffectsource_p.h"
+#include "qquickimage_p.h"
+#include "qquickshadereffectsource_p.h"
#include <QtCore/qsignalmapper.h>
#include <QtGui/qopenglframebufferobject.h>
}
// TODO: Remove after grace period.
-QSGShaderEffectItem::QSGShaderEffectItem(QSGItem *parent)
- : QSGShaderEffect(parent)
+QQuickShaderEffectItem::QQuickShaderEffectItem(QQuickItem *parent)
+ : QQuickShaderEffect(parent)
{
qWarning("ShaderEffectItem has been deprecated. Use ShaderEffect instead.");
}
/*!
- \qmlclass ShaderEffect QSGShaderEffect
+ \qmlclass ShaderEffect QQuickShaderEffect
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The ShaderEffect element applies custom shaders to a rectangle.
bottom-left which is common in OpenGL.
*/
-QSGShaderEffect::QSGShaderEffect(QSGItem *parent)
- : QSGItem(parent)
+QQuickShaderEffect::QQuickShaderEffect(QQuickItem *parent)
+ : QQuickItem(parent)
, m_meshResolution(1, 1)
, m_mesh(0)
, m_cullMode(NoCulling)
, m_dirtyMesh(true)
, m_dirtyGeometry(true)
{
- setFlag(QSGItem::ItemHasContents);
+ setFlag(QQuickItem::ItemHasContents);
}
-QSGShaderEffect::~QSGShaderEffect()
+QQuickShaderEffect::~QQuickShaderEffect()
{
reset();
}
-void QSGShaderEffect::componentComplete()
+void QQuickShaderEffect::componentComplete()
{
updateProperties();
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
}
/*!
shader as "varying highp vec2 qt_TexCoord0".
*/
-void QSGShaderEffect::setFragmentShader(const QByteArray &code)
+void QQuickShaderEffect::setFragmentShader(const QByteArray &code)
{
if (m_source.fragmentCode.constData() == code.constData())
return;
sampler2D named "source".
*/
-void QSGShaderEffect::setVertexShader(const QByteArray &code)
+void QQuickShaderEffect::setVertexShader(const QByteArray &code)
{
if (m_source.vertexCode.constData() == code.constData())
return;
property to false when blending is not needed. The default value is true.
*/
-void QSGShaderEffect::setBlending(bool enable)
+void QQuickShaderEffect::setBlending(bool enable)
{
if (blending() == enable)
return;
\qmlproperty variant QtQuick2::ShaderEffect::mesh
This property defines the mesh used to draw the ShaderEffect. It can hold
- any mesh object deriving from \l QSGShaderEffectMesh, such as \l GridMesh.
+ any mesh object deriving from \l QQuickShaderEffectMesh, such as \l GridMesh.
If a size value is assigned to this property, the ShaderEffect implicitly
uses a \l GridMesh with the value as
\l{GridMesh::resolution}{mesh resolution}. By default, this property is
\sa GridMesh
*/
-QVariant QSGShaderEffect::mesh() const
+QVariant QQuickShaderEffect::mesh() const
{
return m_mesh ? qVariantFromValue(static_cast<QObject *>(m_mesh))
: qVariantFromValue(m_meshResolution);
}
-void QSGShaderEffect::setMesh(const QVariant &mesh)
+void QQuickShaderEffect::setMesh(const QVariant &mesh)
{
- QSGShaderEffectMesh *newMesh = qobject_cast<QSGShaderEffectMesh *>(qVariantValue<QObject *>(mesh));
+ QQuickShaderEffectMesh *newMesh = qobject_cast<QQuickShaderEffectMesh *>(qVariantValue<QObject *>(mesh));
if (newMesh && newMesh == m_mesh)
return;
if (m_mesh)
}
}
if (!ok)
- qWarning("ShaderEffect: mesh property must be size or object deriving from QSGShaderEffectMesh.");
+ qWarning("ShaderEffect: mesh property must be size or object deriving from QQuickShaderEffectMesh.");
}
m_defaultMesh.setResolution(m_meshResolution);
}
The default is NoCulling.
*/
-void QSGShaderEffect::setCullMode(CullMode face)
+void QQuickShaderEffect::setCullMode(CullMode face)
{
if (face == m_cullMode)
return;
emit cullModeChanged();
}
-void QSGShaderEffect::changeSource(int index)
+void QQuickShaderEffect::changeSource(int index)
{
Q_ASSERT(index >= 0 && index < m_sources.size());
QVariant v = property(m_sources.at(index).name.constData());
setSource(v, index);
}
-void QSGShaderEffect::updateData()
+void QQuickShaderEffect::updateData()
{
m_dirtyData = true;
update();
}
-void QSGShaderEffect::updateGeometry()
+void QQuickShaderEffect::updateGeometry()
{
m_dirtyGeometry = true;
update();
}
-void QSGShaderEffect::setSource(const QVariant &var, int index)
+void QQuickShaderEffect::setSource(const QVariant &var, int index)
{
Q_ASSERT(index >= 0 && index < m_sources.size());
}
QObject *obj = qVariantValue<QObject *>(var);
- QSGItem *item = qobject_cast<QSGItem *>(obj);
+ QQuickItem *item = qobject_cast<QQuickItem *>(obj);
if (!item || !item->isTextureProvider()) {
qWarning("ShaderEffect: source uniform [%s] is not assigned a valid texture provider: %s [%s]",
source.name.constData(), qPrintable(obj->objectName()), obj->metaObject()->className());
}
}
-void QSGShaderEffect::disconnectPropertySignals()
+void QQuickShaderEffect::disconnectPropertySignals()
{
disconnect(this, 0, this, SLOT(updateData()));
for (int i = 0; i < m_sources.size(); ++i) {
}
}
-void QSGShaderEffect::connectPropertySignals()
+void QQuickShaderEffect::connectPropertySignals()
{
QSet<QByteArray>::const_iterator it;
for (it = m_source.uniformNames.begin(); it != m_source.uniformNames.end(); ++it) {
if (pi >= 0) {
QMetaProperty mp = metaObject()->property(pi);
if (!mp.hasNotifySignal())
- qWarning("QSGShaderEffect: property '%s' does not have notification method!", it->constData());
+ qWarning("QQuickShaderEffect: property '%s' does not have notification method!", it->constData());
QByteArray signalName("2");
signalName.append(mp.notifySignal().signature());
connect(this, signalName, this, SLOT(updateData()));
} else {
- qWarning("QSGShaderEffect: '%s' does not have a matching property!", it->constData());
+ qWarning("QQuickShaderEffect: '%s' does not have a matching property!", it->constData());
}
}
for (int i = 0; i < m_sources.size(); ++i) {
source.mapper->setMapping(this, i);
connect(source.mapper, SIGNAL(mapped(int)), this, SLOT(changeSource(int)));
} else {
- qWarning("QSGShaderEffect: '%s' does not have a matching source!", source.name.constData());
+ qWarning("QQuickShaderEffect: '%s' does not have a matching source!", source.name.constData());
}
}
}
-void QSGShaderEffect::reset()
+void QQuickShaderEffect::reset()
{
disconnectPropertySignals();
for (int i = 0; i < m_sources.size(); ++i) {
const SourceData &source = m_sources.at(i);
delete source.mapper;
- QSGItem *item = qobject_cast<QSGItem *>(source.sourceObject);
+ QQuickItem *item = qobject_cast<QQuickItem *>(source.sourceObject);
if (item && item->parentItem() == this)
item->setParentItem(0);
}
m_dirtyMesh = true;
}
-void QSGShaderEffect::updateProperties()
+void QQuickShaderEffect::updateProperties()
{
QByteArray vertexCode = m_source.vertexCode;
QByteArray fragmentCode = m_source.fragmentCode;
lookThroughShaderCode(fragmentCode);
if (!m_mesh && !m_source.attributeNames.contains(qt_position_attribute_name))
- qWarning("QSGShaderEffect: Missing reference to \'%s\'.", qt_position_attribute_name);
+ qWarning("QQuickShaderEffect: Missing reference to \'%s\'.", qt_position_attribute_name);
if (!m_mesh && !m_source.attributeNames.contains(qt_texcoord_attribute_name))
- qWarning("QSGShaderEffect: Missing reference to \'%s\'.", qt_texcoord_attribute_name);
+ qWarning("QQuickShaderEffect: Missing reference to \'%s\'.", qt_texcoord_attribute_name);
if (!m_source.respectsMatrix)
- qWarning("QSGShaderEffect: Missing reference to \'qt_Matrix\'.");
+ qWarning("QQuickShaderEffect: Missing reference to \'qt_Matrix\'.");
if (!m_source.respectsOpacity)
- qWarning("QSGShaderEffect: Missing reference to \'qt_Opacity\'.");
+ qWarning("QQuickShaderEffect: Missing reference to \'qt_Opacity\'.");
for (int i = 0; i < m_sources.size(); ++i) {
QVariant v = property(m_sources.at(i).name);
connectPropertySignals();
}
-void QSGShaderEffect::lookThroughShaderCode(const QByteArray &code)
+void QQuickShaderEffect::lookThroughShaderCode(const QByteArray &code)
{
// Regexp for matching attributes and uniforms.
// In human readable form: attribute|uniform [lowp|mediump|highp] <type> <name>
}
}
-void QSGShaderEffect::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickShaderEffect::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
m_dirtyGeometry = true;
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
}
-QSGNode *QSGShaderEffect::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickShaderEffect::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
- QSGShaderEffectNode *node = static_cast<QSGShaderEffectNode *>(oldNode);
+ QQuickShaderEffectNode *node = static_cast<QQuickShaderEffectNode *>(oldNode);
// In the case of a bad vertex shader, don't try to create a node...
if (m_source.attributeNames.isEmpty()) {
}
if (!node) {
- node = new QSGShaderEffectNode;
+ node = new QQuickShaderEffectNode;
m_programDirty = true;
m_dirtyData = true;
m_dirtyGeometry = true;
}
- QSGShaderEffectMaterial *material = node->shaderMaterial();
+ QQuickShaderEffectMaterial *material = node->shaderMaterial();
if (m_dirtyMesh) {
node->setGeometry(0);
node->setFlag(QSGNode::OwnsGeometry, false);
QSGGeometry *geometry = node->geometry();
QRectF rect(0, 0, width(), height());
- QSGShaderEffectMesh *mesh = m_mesh ? m_mesh : &m_defaultMesh;
+ QQuickShaderEffectMesh *mesh = m_mesh ? m_mesh : &m_defaultMesh;
geometry = mesh->updateGeometry(geometry, m_source.attributeNames, rect);
if (!geometry) {
}
if (m_programDirty) {
- QSGShaderEffectProgram s = m_source;
+ QQuickShaderEffectProgram s = m_source;
if (s.fragmentCode.isEmpty())
s.fragmentCode = qt_default_fragment_code;
if (s.vertexCode.isEmpty())
}
if (int(material->cullMode()) != int(m_cullMode)) {
- material->setCullMode(QSGShaderEffectMaterial::CullMode(m_cullMode));
+ material->setCullMode(QQuickShaderEffectMaterial::CullMode(m_cullMode));
node->markDirty(QSGNode::DirtyMaterial);
}
**
****************************************************************************/
-#ifndef SHADEREFFECTITEM_H
-#define SHADEREFFECTITEM_H
+#ifndef QQUICKSHADEREFFECT_P_H
+#define QQUICKSHADEREFFECT_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include "qsgmaterial.h"
#include <private/qsgadaptationlayer_p.h>
-#include <private/qsgshadereffectnode_p.h>
-#include "qsgshadereffectmesh_p.h"
+#include <private/qquickshadereffectnode_p.h>
+#include "qquickshadereffectmesh_p.h"
#include <QtCore/qpointer.h>
class QSGContext;
class QSignalMapper;
-class QSGCustomMaterialShader;
+class QQuickCustomMaterialShader;
-class QSGShaderEffect : public QSGItem
+class QQuickShaderEffect : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QByteArray fragmentShader READ fragmentShader WRITE setFragmentShader NOTIFY fragmentShaderChanged)
public:
enum CullMode
{
- NoCulling = QSGShaderEffectMaterial::NoCulling,
- BackFaceCulling = QSGShaderEffectMaterial::BackFaceCulling,
- FrontFaceCulling = QSGShaderEffectMaterial::FrontFaceCulling
+ NoCulling = QQuickShaderEffectMaterial::NoCulling,
+ BackFaceCulling = QQuickShaderEffectMaterial::BackFaceCulling,
+ FrontFaceCulling = QQuickShaderEffectMaterial::FrontFaceCulling
};
- QSGShaderEffect(QSGItem *parent = 0);
- ~QSGShaderEffect();
+ QQuickShaderEffect(QQuickItem *parent = 0);
+ ~QQuickShaderEffect();
virtual void componentComplete();
void updateGeometry();
private:
- friend class QSGCustomMaterialShader;
- friend class QSGShaderEffectNode;
+ friend class QQuickCustomMaterialShader;
+ friend class QQuickShaderEffectNode;
void setSource(const QVariant &var, int index);
void disconnectPropertySignals();
void updateProperties();
void lookThroughShaderCode(const QByteArray &code);
- QSGShaderEffectProgram m_source;
+ QQuickShaderEffectProgram m_source;
QSize m_meshResolution;
- QSGShaderEffectMesh *m_mesh;
- QSGGridMesh m_defaultMesh;
+ QQuickShaderEffectMesh *m_mesh;
+ QQuickGridMesh m_defaultMesh;
CullMode m_cullMode;
struct SourceData
{
QSignalMapper *mapper;
- QPointer<QSGItem> sourceObject;
+ QPointer<QQuickItem> sourceObject;
QByteArray name;
};
QVector<SourceData> m_sources;
};
// TODO: Remove after grace period.
-class QSGShaderEffectItem : public QSGShaderEffect
+class QQuickShaderEffectItem : public QQuickShaderEffect
{
public:
- QSGShaderEffectItem(QSGItem *parent = 0);
+ QQuickShaderEffectItem(QQuickItem *parent = 0);
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // SHADEREFFECTITEM_H
+#endif // QQUICKSHADEREFFECT_P_H
**
****************************************************************************/
-#include "qsgshadereffectmesh_p.h"
+#include "qquickshadereffectmesh_p.h"
#include "qsggeometry.h"
-#include "qsgshadereffect_p.h"
+#include "qquickshadereffect_p.h"
QT_BEGIN_NAMESPACE
-QSGShaderEffectMesh::QSGShaderEffectMesh(QObject *parent)
+QQuickShaderEffectMesh::QQuickShaderEffectMesh(QObject *parent)
: QObject(parent)
{
}
/*!
- \qmlclass GridMesh QSGGridMesh
+ \qmlclass GridMesh QQuickGridMesh
\inqmlmodule QtQuick 2
\ingroup qml-utility-elements
\brief GridMesh defines a mesh with vertices arranged in a grid.
The grid resolution is specified with the \l resolution property.
*/
-QSGGridMesh::QSGGridMesh(QObject *parent)
- : QSGShaderEffectMesh(parent)
+QQuickGridMesh::QQuickGridMesh(QObject *parent)
+ : QQuickShaderEffectMesh(parent)
, m_resolution(1, 1)
{
connect(this, SIGNAL(resolutionChanged()), this, SIGNAL(geometryChanged()));
}
-QSGGeometry *QSGGridMesh::updateGeometry(QSGGeometry *geometry, const QVector<QByteArray> &attributes, const QRectF &dstRect) const
+QSGGeometry *QQuickGridMesh::updateGeometry(QSGGeometry *geometry, const QVector<QByteArray> &attributes, const QRectF &dstRect) const
{
int vmesh = m_resolution.height();
int hmesh = m_resolution.width();
bool error = true;
switch (attrCount) {
case 0:
- qWarning("QSGGridMesh:: No attributes specified.");
+ qWarning("QQuickGridMesh:: No attributes specified.");
break;
case 1:
if (attributes.at(0) == qtPositionAttributeName()) {
error = false;
break;
}
- qWarning("QSGGridMesh:: Missing \'%s\' attribute.",
+ qWarning("QQuickGridMesh:: Missing \'%s\' attribute.",
qtPositionAttributeName());
break;
case 2:
error = false;
break;
}
- qWarning("QSGGridMesh:: Missing \'%s\' or \'%s\' attribute.",
+ qWarning("QQuickGridMesh:: Missing \'%s\' or \'%s\' attribute.",
qtPositionAttributeName(), qtTexCoordAttributeName());
break;
default:
- qWarning("QSGGridMesh:: Too many attributes specified.");
+ qWarning("QQuickGridMesh:: Too many attributes specified.");
break;
}
\endrow
*/
-void QSGGridMesh::setResolution(const QSize &res)
+void QQuickGridMesh::setResolution(const QSize &res)
{
if (res == m_resolution)
return;
emit resolutionChanged();
}
-QSize QSGGridMesh::resolution() const
+QSize QQuickGridMesh::resolution() const
{
return m_resolution;
}
#include <QtCore/qvariant.h>
#include <QtGui/qopenglfunctions.h>
-#ifndef SHADEREFFECTMESH_H
-#define SHADEREFFECTMESH_H
+#ifndef QQUICKSHADEREFFECTMESH_P_H
+#define QQUICKSHADEREFFECTMESH_P_H
QT_BEGIN_HEADER
class QSGGeometry;
class QRectF;
-class Q_DECLARATIVE_EXPORT QSGShaderEffectMesh : public QObject
+class Q_DECLARATIVE_EXPORT QQuickShaderEffectMesh : public QObject
{
Q_OBJECT
public:
- QSGShaderEffectMesh(QObject *parent = 0);
+ QQuickShaderEffectMesh(QObject *parent = 0);
// If 'geometry' != 0, 'attributes' is the same as last time the function was called.
virtual QSGGeometry *updateGeometry(QSGGeometry *geometry, const QVector<QByteArray> &attributes, const QRectF &rect) const = 0;
void geometryChanged();
};
-class QSGGridMesh : public QSGShaderEffectMesh
+class QQuickGridMesh : public QQuickShaderEffectMesh
{
Q_OBJECT
Q_PROPERTY(QSize resolution READ resolution WRITE setResolution NOTIFY resolutionChanged)
public:
- QSGGridMesh(QObject *parent = 0);
+ QQuickGridMesh(QObject *parent = 0);
virtual QSGGeometry *updateGeometry(QSGGeometry *geometry, const QVector<QByteArray> &attributes, const QRectF &rect) const;
void setResolution(const QSize &res);
QT_END_HEADER
-#endif // SHADEREFFECTITEM_H
+#endif // QQUICKSHADEREFFECTMESH_P_H
**
****************************************************************************/
-#include <private/qsgshadereffectnode_p.h>
+#include <private/qquickshadereffectnode_p.h>
-#include "qsgshadereffectmesh_p.h"
+#include "qquickshadereffectmesh_p.h"
#include <private/qsgtextureprovider_p.h>
#include <private/qsgrenderer_p.h>
QT_BEGIN_NAMESPACE
-class QSGCustomMaterialShader : public QSGMaterialShader
+class QQuickCustomMaterialShader : public QSGMaterialShader
{
public:
- QSGCustomMaterialShader(const QSGShaderEffectMaterialKey &key, const QVector<QByteArray> &attributes);
+ QQuickCustomMaterialShader(const QQuickShaderEffectMaterialKey &key, const QVector<QByteArray> &attributes);
virtual void deactivate();
virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
virtual char const *const *attributeNames() const;
protected:
- friend class QSGShaderEffectNode;
+ friend class QQuickShaderEffectNode;
virtual void initialize();
virtual const char *vertexShader() const;
virtual const char *fragmentShader() const;
- const QSGShaderEffectMaterialKey m_key;
+ const QQuickShaderEffectMaterialKey m_key;
QVector<const char *> m_attributeNames;
const QVector<QByteArray> m_attributes;
uint m_textureIndicesSet;
};
-QSGCustomMaterialShader::QSGCustomMaterialShader(const QSGShaderEffectMaterialKey &key, const QVector<QByteArray> &attributes)
+QQuickCustomMaterialShader::QQuickCustomMaterialShader(const QQuickShaderEffectMaterialKey &key, const QVector<QByteArray> &attributes)
: m_key(key)
, m_attributes(attributes)
, m_textureIndicesSet(false)
m_attributeNames.append(0);
}
-void QSGCustomMaterialShader::deactivate()
+void QQuickCustomMaterialShader::deactivate()
{
QSGMaterialShader::deactivate();
glDisable(GL_CULL_FACE);
}
-void QSGCustomMaterialShader::updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
+void QQuickCustomMaterialShader::updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
{
Q_ASSERT(newEffect != 0);
- const QSGShaderEffectMaterial *material = static_cast<const QSGShaderEffectMaterial *>(newEffect);
+ const QQuickShaderEffectMaterial *material = static_cast<const QQuickShaderEffectMaterial *>(newEffect);
if (!m_textureIndicesSet) {
for (int i = 0; i < material->m_textures.size(); ++i)
}
}
- const QSGShaderEffectMaterial *oldMaterial = static_cast<const QSGShaderEffectMaterial *>(oldEffect);
+ const QQuickShaderEffectMaterial *oldMaterial = static_cast<const QQuickShaderEffectMaterial *>(oldEffect);
if (oldEffect == 0 || material->cullMode() != oldMaterial->cullMode()) {
switch (material->cullMode()) {
- case QSGShaderEffectMaterial::FrontFaceCulling:
+ case QQuickShaderEffectMaterial::FrontFaceCulling:
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
break;
- case QSGShaderEffectMaterial::BackFaceCulling:
+ case QQuickShaderEffectMaterial::BackFaceCulling:
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
break;
program()->setUniformValue(m_matrixLoc, state.combinedMatrix());
}
-char const *const *QSGCustomMaterialShader::attributeNames() const
+char const *const *QQuickCustomMaterialShader::attributeNames() const
{
return m_attributeNames.constData();
}
-void QSGCustomMaterialShader::initialize()
+void QQuickCustomMaterialShader::initialize()
{
m_opacityLoc = program()->uniformLocation("qt_Opacity");
m_matrixLoc = program()->uniformLocation("qt_Matrix");
m_matrixLoc = program()->uniformLocation("qt_ModelViewProjectionMatrix");
}
-const char *QSGCustomMaterialShader::vertexShader() const
+const char *QQuickCustomMaterialShader::vertexShader() const
{
return m_key.vertexCode.constData();
}
-const char *QSGCustomMaterialShader::fragmentShader() const
+const char *QQuickCustomMaterialShader::fragmentShader() const
{
return m_key.fragmentCode.constData();
}
-bool QSGShaderEffectMaterialKey::operator == (const QSGShaderEffectMaterialKey &other) const
+bool QQuickShaderEffectMaterialKey::operator == (const QQuickShaderEffectMaterialKey &other) const
{
return vertexCode == other.vertexCode && fragmentCode == other.fragmentCode && className == other.className;
}
-uint qHash(const QSGShaderEffectMaterialKey &key)
+uint qHash(const QQuickShaderEffectMaterialKey &key)
{
return qHash(qMakePair(qMakePair(key.vertexCode, key.fragmentCode), key.className));
}
-QHash<QSGShaderEffectMaterialKey, QSharedPointer<QSGMaterialType> > QSGShaderEffectMaterial::materialMap;
+QHash<QQuickShaderEffectMaterialKey, QSharedPointer<QSGMaterialType> > QQuickShaderEffectMaterial::materialMap;
-QSGShaderEffectMaterial::QSGShaderEffectMaterial()
+QQuickShaderEffectMaterial::QQuickShaderEffectMaterial()
: m_cullMode(NoCulling)
{
setFlag(Blending, true);
}
-QSGMaterialType *QSGShaderEffectMaterial::type() const
+QSGMaterialType *QQuickShaderEffectMaterial::type() const
{
return m_type.data();
}
-QSGMaterialShader *QSGShaderEffectMaterial::createShader() const
+QSGMaterialShader *QQuickShaderEffectMaterial::createShader() const
{
- return new QSGCustomMaterialShader(m_source, m_source.attributeNames);
+ return new QQuickCustomMaterialShader(m_source, m_source.attributeNames);
}
-int QSGShaderEffectMaterial::compare(const QSGMaterial *other) const
+int QQuickShaderEffectMaterial::compare(const QSGMaterial *other) const
{
- return this - static_cast<const QSGShaderEffectMaterial *>(other);
+ return this - static_cast<const QQuickShaderEffectMaterial *>(other);
}
-void QSGShaderEffectMaterial::setCullMode(QSGShaderEffectMaterial::CullMode face)
+void QQuickShaderEffectMaterial::setCullMode(QQuickShaderEffectMaterial::CullMode face)
{
m_cullMode = face;
}
-QSGShaderEffectMaterial::CullMode QSGShaderEffectMaterial::cullMode() const
+QQuickShaderEffectMaterial::CullMode QQuickShaderEffectMaterial::cullMode() const
{
return m_cullMode;
}
-void QSGShaderEffectMaterial::setProgramSource(const QSGShaderEffectProgram &source)
+void QQuickShaderEffectMaterial::setProgramSource(const QQuickShaderEffectProgram &source)
{
m_source = source;
m_type = materialMap.value(m_source);
}
}
-void QSGShaderEffectMaterial::setUniforms(const QVector<QPair<QByteArray, QVariant> > &uniformValues)
+void QQuickShaderEffectMaterial::setUniforms(const QVector<QPair<QByteArray, QVariant> > &uniformValues)
{
m_uniformValues = uniformValues;
}
-void QSGShaderEffectMaterial::setTextureProviders(const QVector<QPair<QByteArray, QSGTextureProvider *> > &textures)
+void QQuickShaderEffectMaterial::setTextureProviders(const QVector<QPair<QByteArray, QSGTextureProvider *> > &textures)
{
m_textures = textures;
}
-const QVector<QPair<QByteArray, QSGTextureProvider *> > &QSGShaderEffectMaterial::textureProviders() const
+const QVector<QPair<QByteArray, QSGTextureProvider *> > &QQuickShaderEffectMaterial::textureProviders() const
{
return m_textures;
}
-void QSGShaderEffectMaterial::updateTextures() const
+void QQuickShaderEffectMaterial::updateTextures() const
{
for (int i = 0; i < m_textures.size(); ++i) {
if (QSGTextureProvider *provider = m_textures.at(i).second) {
}
-QSGShaderEffectNode::QSGShaderEffectNode()
+QQuickShaderEffectNode::QQuickShaderEffectNode()
{
QSGNode::setFlag(UsePreprocess, true);
setMaterial(&m_material);
}
-QSGShaderEffectNode::~QSGShaderEffectNode()
+QQuickShaderEffectNode::~QQuickShaderEffectNode()
{
}
-void QSGShaderEffectNode::markDirtyTexture()
+void QQuickShaderEffectNode::markDirtyTexture()
{
markDirty(DirtyMaterial);
}
-void QSGShaderEffectNode::preprocess()
+void QQuickShaderEffectNode::preprocess()
{
Q_ASSERT(material());
- static_cast<QSGShaderEffectMaterial *>(material())->updateTextures();
+ static_cast<QQuickShaderEffectMaterial *>(material())->updateTextures();
}
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef SHADEREFFECTNODE_H
-#define SHADEREFFECTNODE_H
+#ifndef QQUICKSHADEREFFECTNODE_P_H
+#define QQUICKSHADEREFFECTNODE_P_H
#include "qsgnode.h"
#include "qsgmaterial.h"
#include <private/qsgtextureprovider_p.h>
-#include <qsgitem.h>
+#include <qquickitem.h>
#include <QtCore/qsharedpointer.h>
#include <QtCore/qpointer.h>
QT_MODULE(Declarative)
-struct QSGShaderEffectMaterialKey {
+struct QQuickShaderEffectMaterialKey {
QByteArray vertexCode;
QByteArray fragmentCode;
const char *className;
- bool operator == (const QSGShaderEffectMaterialKey &other) const;
+ bool operator == (const QQuickShaderEffectMaterialKey &other) const;
};
-uint qHash(const QSGShaderEffectMaterialKey &key);
+uint qHash(const QQuickShaderEffectMaterialKey &key);
// TODO: Implement support for multisampling.
-struct QSGShaderEffectProgram : public QSGShaderEffectMaterialKey
+struct QQuickShaderEffectProgram : public QQuickShaderEffectMaterialKey
{
- QSGShaderEffectProgram() : respectsOpacity(false), respectsMatrix(false) {}
+ QQuickShaderEffectProgram() : respectsOpacity(false), respectsMatrix(false) {}
QVector<QByteArray> attributeNames;
QSet<QByteArray> uniformNames;
};
-class QSGCustomMaterialShader;
-class QSGShaderEffectMaterial : public QSGMaterial
+class QQuickCustomMaterialShader;
+class QQuickShaderEffectMaterial : public QSGMaterial
{
public:
enum CullMode
FrontFaceCulling
};
- QSGShaderEffectMaterial();
+ QQuickShaderEffectMaterial();
virtual QSGMaterialType *type() const;
virtual QSGMaterialShader *createShader() const;
virtual int compare(const QSGMaterial *other) const;
void setCullMode(CullMode face);
CullMode cullMode() const;
- void setProgramSource(const QSGShaderEffectProgram &);
+ void setProgramSource(const QQuickShaderEffectProgram &);
void setUniforms(const QVector<QPair<QByteArray, QVariant> > &uniformValues);
void setTextureProviders(const QVector<QPair<QByteArray, QSGTextureProvider *> > &textures);
const QVector<QPair<QByteArray, QSGTextureProvider *> > &textureProviders() const;
void updateTextures() const;
protected:
- friend class QSGShaderEffect;
- friend class QSGCustomMaterialShader;
+ friend class QQuickCustomMaterialShader;
// The type pointer needs to be unique. It is not safe to let the type object be part of the
- // QSGShaderEffectMaterial, since it can be deleted and a new one constructed on top of the old
- // one. The new QSGShaderEffectMaterial would then get the same type pointer as the old one, and
+ // QQuickShaderEffectMaterial, since it can be deleted and a new one constructed on top of the old
+ // one. The new QQuickShaderEffectMaterial would then get the same type pointer as the old one, and
// CustomMaterialShaders based on the old one would incorrectly be used together with the new
// one. To guarantee that the type pointer is unique, the type object must live as long as
// there are any CustomMaterialShaders of that type.
QSharedPointer<QSGMaterialType> m_type;
- QSGShaderEffectProgram m_source;
+ QQuickShaderEffectProgram m_source;
QVector<QPair<QByteArray, QVariant> > m_uniformValues;
QVector<QPair<QByteArray, QSGTextureProvider *> > m_textures;
CullMode m_cullMode;
- static QHash<QSGShaderEffectMaterialKey, QSharedPointer<QSGMaterialType> > materialMap;
+ static QHash<QQuickShaderEffectMaterialKey, QSharedPointer<QSGMaterialType> > materialMap;
};
class QSGShaderEffectMesh;
-class QSGShaderEffectNode : public QObject, public QSGGeometryNode
+class QQuickShaderEffectNode : public QObject, public QSGGeometryNode
{
Q_OBJECT
public:
- QSGShaderEffectNode();
- virtual ~QSGShaderEffectNode();
+ QQuickShaderEffectNode();
+ virtual ~QQuickShaderEffectNode();
virtual void preprocess();
- QSGShaderEffectMaterial *shaderMaterial() { return &m_material; }
+ QQuickShaderEffectMaterial *shaderMaterial() { return &m_material; }
private Q_SLOTS:
void markDirtyTexture();
private:
- QSGShaderEffectMaterial m_material;
+ QQuickShaderEffectMaterial m_material;
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // SHADEREFFECTNODE_H
+#endif // QQUICKSHADEREFFECTNODE_P_H
**
****************************************************************************/
-#include "qsgshadereffectsource_p.h"
+#include "qquickshadereffectsource_p.h"
-#include "qsgitem_p.h"
-#include "qsgcanvas_p.h"
+#include "qquickitem_p.h"
+#include "qquickcanvas_p.h"
#include <private/qsgadaptationlayer_p.h>
#include <private/qsgrenderer_p.h>
DEFINE_BOOL_CONFIG_OPTION(qmlFboOverlay, QML_FBO_OVERLAY)
-class QSGShaderEffectSourceTextureProvider : public QSGTextureProvider
+class QQuickShaderEffectSourceTextureProvider : public QSGTextureProvider
{
Q_OBJECT
public:
- QSGShaderEffectSourceTextureProvider()
+ QQuickShaderEffectSourceTextureProvider()
: sourceTexture(0)
{
}
return sourceTexture;
}
- QSGShaderEffectTexture *sourceTexture;
+ QQuickShaderEffectTexture *sourceTexture;
QSGTexture::Filtering mipmapFiltering;
QSGTexture::Filtering filtering;
QSGTexture::WrapMode horizontalWrap;
QSGTexture::WrapMode verticalWrap;
};
-#include "qsgshadereffectsource.moc"
+#include "qquickshadereffectsource.moc"
-QSGShaderEffectSourceNode::QSGShaderEffectSourceNode()
+QQuickShaderEffectSourceNode::QQuickShaderEffectSourceNode()
{
setFlag(UsePreprocess, true);
}
-void QSGShaderEffectSourceNode::markDirtyTexture()
+void QQuickShaderEffectSourceNode::markDirtyTexture()
{
markDirty(DirtyMaterial);
}
-QSGShaderEffectTexture::QSGShaderEffectTexture(QSGItem *shaderSource)
+QQuickShaderEffectTexture::QQuickShaderEffectTexture(QQuickItem *shaderSource)
: QSGDynamicTexture()
, m_item(0)
, m_format(GL_RGBA)
#ifdef QSG_DEBUG_FBO_OVERLAY
, m_debugOverlay(0)
#endif
- , m_context(QSGItemPrivate::get(shaderSource)->sceneGraphContext())
+ , m_context(QQuickItemPrivate::get(shaderSource)->sceneGraphContext())
, m_mipmap(false)
, m_live(true)
, m_recursive(false)
{
}
-QSGShaderEffectTexture::~QSGShaderEffectTexture()
+QQuickShaderEffectTexture::~QQuickShaderEffectTexture()
{
delete m_renderer;
delete m_fbo;
#endif
}
-int QSGShaderEffectTexture::textureId() const
+int QQuickShaderEffectTexture::textureId() const
{
return m_fbo ? m_fbo->texture() : 0;
}
-bool QSGShaderEffectTexture::hasAlphaChannel() const
+bool QQuickShaderEffectTexture::hasAlphaChannel() const
{
return m_format != GL_RGB;
}
-bool QSGShaderEffectTexture::hasMipmaps() const
+bool QQuickShaderEffectTexture::hasMipmaps() const
{
return m_mipmap;
}
-void QSGShaderEffectTexture::bind()
+void QQuickShaderEffectTexture::bind()
{
#ifndef QT_NO_DEBUG
if (!m_recursive && m_fbo && ((m_multisampling && m_secondaryFbo->isBound()) || m_fbo->isBound()))
updateBindOptions();
}
-bool QSGShaderEffectTexture::updateTexture()
+bool QQuickShaderEffectTexture::updateTexture()
{
if ((m_live || m_grab) && m_dirtyTexture) {
grab();
return false;
}
-void QSGShaderEffectTexture::setHasMipmaps(bool mipmap)
+void QQuickShaderEffectTexture::setHasMipmaps(bool mipmap)
{
if (mipmap == m_mipmap)
return;
}
-void QSGShaderEffectTexture::setItem(QSGNode *item)
+void QQuickShaderEffectTexture::setItem(QSGNode *item)
{
if (item == m_item)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setRect(const QRectF &rect)
+void QQuickShaderEffectTexture::setRect(const QRectF &rect)
{
if (rect == m_rect)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setSize(const QSize &size)
+void QQuickShaderEffectTexture::setSize(const QSize &size)
{
if (size == m_size)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setFormat(GLenum format)
+void QQuickShaderEffectTexture::setFormat(GLenum format)
{
if (format == m_format)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setLive(bool live)
+void QQuickShaderEffectTexture::setLive(bool live)
{
if (live == m_live)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::scheduleUpdate()
+void QQuickShaderEffectTexture::scheduleUpdate()
{
if (m_grab)
return;
emit textureChanged();
}
-void QSGShaderEffectTexture::setRecursive(bool recursive)
+void QQuickShaderEffectTexture::setRecursive(bool recursive)
{
m_recursive = recursive;
}
-void QSGShaderEffectTexture::markDirtyTexture()
+void QQuickShaderEffectTexture::markDirtyTexture()
{
m_dirtyTexture = true;
if (m_live || m_grab)
emit textureChanged();
}
-void QSGShaderEffectTexture::grab()
+void QQuickShaderEffectTexture::grab()
{
if (!m_item || m_size.isNull()) {
delete m_fbo;
markDirtyTexture(); // Continuously update if 'live' and 'recursive'.
}
-QImage QSGShaderEffectTexture::toImage() const
+QImage QQuickShaderEffectTexture::toImage() const
{
if (m_fbo)
return m_fbo->toImage();
}
/*!
- \qmlclass ShaderEffectSource QSGShaderEffectSource
+ \qmlclass ShaderEffectSource QQuickShaderEffectSource
\since 5.0
\ingroup qml-basic-visual-elements
\brief The ShaderEffectSource element renders a QML element into a texture
but not multisampled framebuffer objects.
*/
-QSGShaderEffectSource::QSGShaderEffectSource(QSGItem *parent)
- : QSGItem(parent)
+QQuickShaderEffectSource::QQuickShaderEffectSource(QQuickItem *parent)
+ : QQuickItem(parent)
, m_provider(0)
, m_texture(0)
, m_wrapMode(ClampToEdge)
setFlag(ItemHasContents);
}
-QSGShaderEffectSource::~QSGShaderEffectSource()
+QQuickShaderEffectSource::~QQuickShaderEffectSource()
{
if (m_texture)
m_texture->deleteLater();
m_provider->deleteLater();
if (m_sourceItem)
- QSGItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
}
-void QSGShaderEffectSource::ensureTexture()
+void QQuickShaderEffectSource::ensureTexture()
{
if (m_texture)
return;
- Q_ASSERT_X(QSGItemPrivate::get(this)->canvas
- && QSGItemPrivate::get(this)->sceneGraphContext()
- && QThread::currentThread() == QSGItemPrivate::get(this)->sceneGraphContext()->thread(),
- "QSGShaderEffectSource::ensureTexture",
+ Q_ASSERT_X(QQuickItemPrivate::get(this)->canvas
+ && QQuickItemPrivate::get(this)->sceneGraphContext()
+ && QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphContext()->thread(),
+ "QQuickShaderEffectSource::ensureTexture",
"Cannot be used outside the rendering thread");
- m_texture = new QSGShaderEffectTexture(this);
+ m_texture = new QQuickShaderEffectTexture(this);
connect(m_texture, SIGNAL(textureChanged()), this, SLOT(update()));
}
-QSGTextureProvider *QSGShaderEffectSource::textureProvider() const
+QSGTextureProvider *QQuickShaderEffectSource::textureProvider() const
{
if (!m_provider) {
// Make sure it gets thread affinity on the rendering thread so deletion works properly..
- Q_ASSERT_X(QSGItemPrivate::get(this)->canvas
- && QSGItemPrivate::get(this)->sceneGraphContext()
- && QThread::currentThread() == QSGItemPrivate::get(this)->sceneGraphContext()->thread(),
- "QSGShaderEffectSource::textureProvider",
+ Q_ASSERT_X(QQuickItemPrivate::get(this)->canvas
+ && QQuickItemPrivate::get(this)->sceneGraphContext()
+ && QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphContext()->thread(),
+ "QQuickShaderEffectSource::textureProvider",
"Cannot be used outside the rendering thread");
- const_cast<QSGShaderEffectSource *>(this)->m_provider = new QSGShaderEffectSourceTextureProvider();
+ const_cast<QQuickShaderEffectSource *>(this)->m_provider = new QQuickShaderEffectSourceTextureProvider();
- const_cast<QSGShaderEffectSource *>(this)->ensureTexture();
+ const_cast<QQuickShaderEffectSource *>(this)->ensureTexture();
connect(m_texture, SIGNAL(textureChanged()), m_provider, SIGNAL(textureChanged()), Qt::DirectConnection);
m_provider->sourceTexture = m_texture;
}
wrap mode with non-power-of-two textures.
*/
-QSGShaderEffectSource::WrapMode QSGShaderEffectSource::wrapMode() const
+QQuickShaderEffectSource::WrapMode QQuickShaderEffectSource::wrapMode() const
{
return m_wrapMode;
}
-void QSGShaderEffectSource::setWrapMode(WrapMode mode)
+void QQuickShaderEffectSource::setWrapMode(WrapMode mode)
{
if (mode == m_wrapMode)
return;
This property holds the element to be rendered into the texture.
*/
-QSGItem *QSGShaderEffectSource::sourceItem() const
+QQuickItem *QQuickShaderEffectSource::sourceItem() const
{
return m_sourceItem;
}
-void QSGShaderEffectSource::setSourceItem(QSGItem *item)
+void QQuickShaderEffectSource::setSourceItem(QQuickItem *item)
{
if (item == m_sourceItem)
return;
if (m_sourceItem)
- QSGItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
m_sourceItem = item;
if (m_sourceItem) {
// TODO: Find better solution.
m_sourceItem->setParentItem(this);
m_sourceItem->setVisible(false);
}
- QSGItemPrivate::get(m_sourceItem)->refFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->refFromEffectItem(m_hideSource);
}
update();
emit sourceItemChanged();
the whole \l sourceItem is rendered to texture.
*/
-QRectF QSGShaderEffectSource::sourceRect() const
+QRectF QQuickShaderEffectSource::sourceRect() const
{
return m_sourceRect;
}
-void QSGShaderEffectSource::setSourceRect(const QRectF &rect)
+void QQuickShaderEffectSource::setSourceRect(const QRectF &rect)
{
if (rect == m_sourceRect)
return;
size.
*/
-QSize QSGShaderEffectSource::textureSize() const
+QSize QQuickShaderEffectSource::textureSize() const
{
return m_textureSize;
}
-void QSGShaderEffectSource::setTextureSize(const QSize &size)
+void QQuickShaderEffectSource::setTextureSize(const QSize &size)
{
if (size == m_textureSize)
return;
\note Some OpenGL implementations do not support the GL_ALPHA format.
*/
-QSGShaderEffectSource::Format QSGShaderEffectSource::format() const
+QQuickShaderEffectSource::Format QQuickShaderEffectSource::format() const
{
return m_format;
}
-void QSGShaderEffectSource::setFormat(QSGShaderEffectSource::Format format)
+void QQuickShaderEffectSource::setFormat(QQuickShaderEffectSource::Format format)
{
if (format == m_format)
return;
\l sourceItem. The property is true by default.
*/
-bool QSGShaderEffectSource::live() const
+bool QQuickShaderEffectSource::live() const
{
return m_live;
}
-void QSGShaderEffectSource::setLive(bool live)
+void QQuickShaderEffectSource::setLive(bool live)
{
if (live == m_live)
return;
and meant to replace the \l sourceItem.
*/
-bool QSGShaderEffectSource::hideSource() const
+bool QQuickShaderEffectSource::hideSource() const
{
return m_hideSource;
}
-void QSGShaderEffectSource::setHideSource(bool hide)
+void QQuickShaderEffectSource::setHideSource(bool hide)
{
if (hide == m_hideSource)
return;
if (m_sourceItem) {
- QSGItemPrivate::get(m_sourceItem)->refFromEffectItem(hide);
- QSGItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->refFromEffectItem(hide);
+ QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
}
m_hideSource = hide;
update();
non-power-of-two textures.
*/
-bool QSGShaderEffectSource::mipmap() const
+bool QQuickShaderEffectSource::mipmap() const
{
return m_mipmap;
}
-void QSGShaderEffectSource::setMipmap(bool enabled)
+void QQuickShaderEffectSource::setMipmap(bool enabled)
{
if (enabled == m_mipmap)
return;
updating it means that it immediately becomes dirty again.
*/
-bool QSGShaderEffectSource::recursive() const
+bool QQuickShaderEffectSource::recursive() const
{
return m_recursive;
}
-void QSGShaderEffectSource::setRecursive(bool enabled)
+void QQuickShaderEffectSource::setRecursive(bool enabled)
{
if (enabled == m_recursive)
return;
Use this to update the texture when \l live is false.
*/
-void QSGShaderEffectSource::scheduleUpdate()
+void QQuickShaderEffectSource::scheduleUpdate()
{
if (m_grab)
return;
update();
}
-static void get_wrap_mode(QSGShaderEffectSource::WrapMode mode, QSGTexture::WrapMode *hWrap, QSGTexture::WrapMode *vWrap)
+static void get_wrap_mode(QQuickShaderEffectSource::WrapMode mode, QSGTexture::WrapMode *hWrap, QSGTexture::WrapMode *vWrap)
{
switch (mode) {
- case QSGShaderEffectSource::RepeatHorizontally:
+ case QQuickShaderEffectSource::RepeatHorizontally:
*hWrap = QSGTexture::Repeat;
*vWrap = QSGTexture::ClampToEdge;
break;
- case QSGShaderEffectSource::RepeatVertically:
+ case QQuickShaderEffectSource::RepeatVertically:
*vWrap = QSGTexture::Repeat;
*hWrap = QSGTexture::ClampToEdge;
break;
- case QSGShaderEffectSource::Repeat:
+ case QQuickShaderEffectSource::Repeat:
*hWrap = *vWrap = QSGTexture::Repeat;
break;
default:
- // QSGShaderEffectSource::ClampToEdge
+ // QQuickShaderEffectSource::ClampToEdge
*hWrap = *vWrap = QSGTexture::ClampToEdge;
break;
}
}
-QSGNode *QSGShaderEffectSource::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickShaderEffectSource::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
if (!m_sourceItem || m_sourceItem->width() == 0 || m_sourceItem->height() == 0) {
delete oldNode;
ensureTexture();
- QSGShaderEffectTexture *tex = qobject_cast<QSGShaderEffectTexture *>(m_texture);
+ QQuickShaderEffectTexture *tex = qobject_cast<QQuickShaderEffectTexture *>(m_texture);
tex->setLive(m_live);
- tex->setItem(QSGItemPrivate::get(m_sourceItem)->itemNode());
+ tex->setItem(QQuickItemPrivate::get(m_sourceItem)->itemNode());
QRectF sourceRect = m_sourceRect.width() == 0 || m_sourceRect.height() == 0
? QRectF(0, 0, m_sourceItem->width(), m_sourceItem->height())
: m_sourceRect;
? QSize(qCeil(qAbs(sourceRect.width())), qCeil(qAbs(sourceRect.height())))
: m_textureSize;
Q_ASSERT(!textureSize.isEmpty());
- QSGItemPrivate *d = static_cast<QSGItemPrivate *>(QObjectPrivate::get(this));
+ QQuickItemPrivate *d = static_cast<QQuickItemPrivate *>(QObjectPrivate::get(this));
const QSize minTextureSize = d->sceneGraphContext()->minimumFBOSize();
// Keep power-of-two by doubling the size.
while (textureSize.width() < minTextureSize.width())
tex->scheduleUpdate();
m_grab = false;
- QSGTexture::Filtering filtering = QSGItemPrivate::get(this)->smooth
+ QSGTexture::Filtering filtering = QQuickItemPrivate::get(this)->smooth
? QSGTexture::Linear
: QSGTexture::Nearest;
QSGTexture::Filtering mmFiltering = m_mipmap ? filtering : QSGTexture::None;
return 0;
}
- QSGShaderEffectSourceNode *node = static_cast<QSGShaderEffectSourceNode *>(oldNode);
+ QQuickShaderEffectSourceNode *node = static_cast<QQuickShaderEffectSourceNode *>(oldNode);
if (!node) {
- node = new QSGShaderEffectSourceNode;
+ node = new QQuickShaderEffectSourceNode;
node->setTexture(m_texture);
connect(m_texture, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()), Qt::DirectConnection);
}
**
****************************************************************************/
-#ifndef SHADEREFFECTSOURCE_H
-#define SHADEREFFECTSOURCE_H
+#ifndef QQUICKSHADEREFFECTSOURCE_P_H
+#define QQUICKSHADEREFFECTSOURCE_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <private/qsgtextureprovider_p.h>
#include <private/qsgadaptationlayer_p.h>
#include <private/qsgcontext_p.h>
class UpdatePaintNodeData;
class QOpenGLFramebufferObject;
-class QSGShaderEffectSourceTextureProvider;
+class QQuickShaderEffectSourceTextureProvider;
-class QSGShaderEffectSourceNode : public QObject, public QSGDefaultImageNode
+class QQuickShaderEffectSourceNode : public QObject, public QSGDefaultImageNode
{
Q_OBJECT
public:
- QSGShaderEffectSourceNode();
+ QQuickShaderEffectSourceNode();
private Q_SLOTS:
void markDirtyTexture();
};
-class Q_DECLARATIVE_EXPORT QSGShaderEffectTexture : public QSGDynamicTexture
+class Q_DECLARATIVE_EXPORT QQuickShaderEffectTexture : public QSGDynamicTexture
{
Q_OBJECT
public:
- QSGShaderEffectTexture(QSGItem *shaderSource);
- ~QSGShaderEffectTexture();
+ QQuickShaderEffectTexture(QQuickItem *shaderSource);
+ ~QQuickShaderEffectTexture();
virtual bool updateTexture();
QSize m_size;
GLenum m_format;
- QSGItem *m_shaderSource;
+ QQuickItem *m_shaderSource;
QSGRenderer *m_renderer;
QOpenGLFramebufferObject *m_fbo;
QOpenGLFramebufferObject *m_secondaryFbo;
uint m_grab : 1;
};
-class Q_DECLARATIVE_EXPORT QSGShaderEffectSource : public QSGItem
+class Q_DECLARATIVE_EXPORT QQuickShaderEffectSource : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(WrapMode wrapMode READ wrapMode WRITE setWrapMode NOTIFY wrapModeChanged)
- Q_PROPERTY(QSGItem *sourceItem READ sourceItem WRITE setSourceItem NOTIFY sourceItemChanged)
+ Q_PROPERTY(QQuickItem *sourceItem READ sourceItem WRITE setSourceItem NOTIFY sourceItemChanged)
Q_PROPERTY(QRectF sourceRect READ sourceRect WRITE setSourceRect NOTIFY sourceRectChanged)
Q_PROPERTY(QSize textureSize READ textureSize WRITE setTextureSize NOTIFY textureSizeChanged)
Q_PROPERTY(Format format READ format WRITE setFormat NOTIFY formatChanged)
RGBA = GL_RGBA
};
- QSGShaderEffectSource(QSGItem *parent = 0);
- ~QSGShaderEffectSource();
+ QQuickShaderEffectSource(QQuickItem *parent = 0);
+ ~QQuickShaderEffectSource();
WrapMode wrapMode() const;
void setWrapMode(WrapMode mode);
- QSGItem *sourceItem() const;
- void setSourceItem(QSGItem *item);
+ QQuickItem *sourceItem() const;
+ void setSourceItem(QQuickItem *item);
QRectF sourceRect() const;
void setSourceRect(const QRectF &rect);
private:
void ensureTexture();
- QSGShaderEffectSourceTextureProvider *m_provider;
- QSGShaderEffectTexture *m_texture;
+ QQuickShaderEffectSourceTextureProvider *m_provider;
+ QQuickShaderEffectTexture *m_texture;
WrapMode m_wrapMode;
- QPointer<QSGItem> m_sourceItem;
+ QPointer<QQuickItem> m_sourceItem;
QRectF m_sourceRect;
QSize m_textureSize;
Format m_format;
QT_END_HEADER
-#endif // SHADEREFFECTSOURCE_H
+#endif // QQUICKSHADEREFFECTSOURCE_P_H
**
****************************************************************************/
-#include "qsgsprite_p.h"
+#include "qquicksprite_p.h"
#include <QDebug>
QT_BEGIN_NAMESPACE
/*!
- \qmlclass Sprite QSGSprite
+ \qmlclass Sprite QQuickSprite
\inqmlmodule QtQuick 2
\brief The Sprite element represents a sprite animation
Q_PROPERTY(int frameHeight READ frameHeight WRITE setFrameHeight NOTIFY frameHeightChanged)
Q_PROPERTY(int frameWidth READ frameWidth WRITE setFrameWidth NOTIFY frameWidthChanged)
-QSGSprite::QSGSprite(QObject *parent) :
- QSGStochasticState(parent)
+QQuickSprite::QQuickSprite(QObject *parent) :
+ QQuickStochasticState(parent)
, m_generatedCount(0)
, m_framesPerRow(0)
, m_frameHeight(0)
**
****************************************************************************/
-#ifndef SPRITESTATE_H
-#define SPRITESTATE_H
+#ifndef QQUICKSPRITE_P_H
+#define QQUICKSPRITE_P_H
#include <QObject>
#include <QUrl>
#include <QVariantMap>
#include <QDeclarativeListProperty>
-#include "qsgspriteengine_p.h"
+#include "qquickspriteengine_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGSprite : public QSGStochasticState
+class QQuickSprite : public QQuickStochasticState
{
Q_OBJECT
Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
Q_PROPERTY(int frameWidth READ frameWidth WRITE setFrameWidth NOTIFY frameWidthChanged)
public:
- explicit QSGSprite(QObject *parent = 0);
+ explicit QQuickSprite(QObject *parent = 0);
QUrl source() const
{
private:
friend class QSGImageParticle;
- friend class QSGSpriteEngine;
- friend class QSGStochasticEngine;
+ friend class QQuickSpriteEngine;
+ friend class QQuickStochasticEngine;
int m_generatedCount;
int m_framesPerRow;
QUrl m_source;
QT_END_NAMESPACE
QT_END_HEADER
-#endif // SPRITESTATE_H
+#endif // QQUICKSPRITE_P_H
**
****************************************************************************/
-#include "qsgspriteengine_p.h"
-#include "qsgsprite_p.h"
+#include "qquickspriteengine_p.h"
+#include "qquicksprite_p.h"
#include <QDebug>
#include <QPainter>
#include <QSet>
Also solve the state data initialization/transfer issue so as to not need to make friends
*/
-QSGStochasticEngine::QSGStochasticEngine(QObject *parent) :
+QQuickStochasticEngine::QQuickStochasticEngine(QObject *parent) :
QObject(parent), m_timeOffset(0)
{
//Default size 1
m_advanceTime.start();
}
-QSGStochasticEngine::QSGStochasticEngine(QList<QSGStochasticState*> states, QObject *parent) :
+QQuickStochasticEngine::QQuickStochasticEngine(QList<QQuickStochasticState*> states, QObject *parent) :
QObject(parent), m_states(states), m_timeOffset(0)
{
//Default size 1
m_advanceTime.start();
}
-QSGStochasticEngine::~QSGStochasticEngine()
+QQuickStochasticEngine::~QQuickStochasticEngine()
{
}
-QSGSpriteEngine::QSGSpriteEngine(QObject *parent)
- : QSGStochasticEngine(parent)
+QQuickSpriteEngine::QQuickSpriteEngine(QObject *parent)
+ : QQuickStochasticEngine(parent)
{
}
-QSGSpriteEngine::QSGSpriteEngine(QList<QSGSprite*> sprites, QObject *parent)
- : QSGStochasticEngine(parent)
+QQuickSpriteEngine::QQuickSpriteEngine(QList<QQuickSprite*> sprites, QObject *parent)
+ : QQuickStochasticEngine(parent)
{
- foreach (QSGSprite* sprite, sprites)
- m_states << (QSGStochasticState*)sprite;
+ foreach (QQuickSprite* sprite, sprites)
+ m_states << (QQuickStochasticState*)sprite;
}
-QSGSpriteEngine::~QSGSpriteEngine()
+QQuickSpriteEngine::~QQuickSpriteEngine()
{
}
-int QSGSpriteEngine::maxFrames()
+int QQuickSpriteEngine::maxFrames()
{
return m_maxFrames;
}
TODO: All these calculations should be pre-calculated and cached during initialization for a significant performance boost
TODO: Above idea needs to have the varying duration offset added to it
*/
-int QSGSpriteEngine::spriteState(int sprite)
+int QQuickSpriteEngine::spriteState(int sprite)
{
int state = m_things[sprite];
if (!m_sprites[state]->m_generatedCount)
return state + extra;
}
-int QSGSpriteEngine::spriteStart(int sprite)
+int QQuickSpriteEngine::spriteStart(int sprite)
{
int state = m_things[sprite];
if (!m_sprites[state]->m_generatedCount)
return state + extra*rowDuration;
}
-int QSGSpriteEngine::spriteFrames(int sprite)
+int QQuickSpriteEngine::spriteFrames(int sprite)
{
int state = m_things[sprite];
if (!m_sprites[state]->m_generatedCount)
return m_sprites[state]->m_framesPerRow;
}
-int QSGSpriteEngine::spriteDuration(int sprite)
+int QQuickSpriteEngine::spriteDuration(int sprite)
{
int state = m_things[sprite];
if (!m_sprites[state]->m_generatedCount)
return rowDuration;
}
-int QSGSpriteEngine::spriteY(int sprite)
+int QQuickSpriteEngine::spriteY(int sprite)
{
int state = m_things[sprite];
if (!m_sprites[state]->m_generatedCount)
return m_sprites[state]->m_rowY + m_sprites[state]->m_frameHeight * extra;
}
-int QSGSpriteEngine::spriteWidth(int sprite)
+int QQuickSpriteEngine::spriteWidth(int sprite)
{
int state = m_things[sprite];
return m_sprites[state]->m_frameWidth;
}
-int QSGSpriteEngine::spriteHeight(int sprite)
+int QQuickSpriteEngine::spriteHeight(int sprite)
{
int state = m_things[sprite];
return m_sprites[state]->m_frameHeight;
}
-int QSGSpriteEngine::spriteCount()//TODO: Actually image state count, need to rename these things to make sense together
+int QQuickSpriteEngine::spriteCount()//TODO: Actually image state count, need to rename these things to make sense together
{
return m_imageStateCount;
}
-void QSGStochasticEngine::setGoal(int state, int sprite, bool jump)
+void QQuickStochasticEngine::setGoal(int state, int sprite, bool jump)
{
if (sprite >= m_things.count() || state >= m_states.count())
return;
return;
}
-QImage QSGSpriteEngine::assembledImage()
+QImage QQuickSpriteEngine::assembledImage()
{
int h = 0;
int w = 0;
int maxSize = 0;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
- foreach (QSGStochasticState* s, m_states){
- QSGSprite* sprite = qobject_cast<QSGSprite*>(s);
+ foreach (QQuickStochasticState* s, m_states){
+ QQuickSprite* sprite = qobject_cast<QQuickSprite*>(s);
if (sprite)
m_sprites << sprite;
else
- qDebug() << "Error: Non-sprite in QSGSpriteEngine";
+ qDebug() << "Error: Non-sprite in QQuickSpriteEngine";
}
- foreach (QSGSprite* state, m_sprites){
+ foreach (QQuickSprite* state, m_sprites){
if (state->frames() > m_maxFrames)
m_maxFrames = state->frames();
image.fill(0);
QPainter p(&image);
int y = 0;
- foreach (QSGSprite* state, m_sprites){
+ foreach (QQuickSprite* state, m_sprites){
QImage img(state->source().toLocalFile());
int frameWidth = state->m_frameWidth;
int frameHeight = state->m_frameHeight;
return image;
}
-void QSGStochasticEngine::setCount(int c)
+void QQuickStochasticEngine::setCount(int c)
{
m_things.resize(c);
m_goals.resize(c);
m_startTimes.resize(c);
}
-void QSGStochasticEngine::start(int index, int state)
+void QQuickStochasticEngine::start(int index, int state)
{
if (index >= m_things.count())
return;
restart(index);
}
-void QSGStochasticEngine::stop(int index)
+void QQuickStochasticEngine::stop(int index)
{
if (index >= m_things.count())
return;
m_stateUpdates[i].second.removeAll(index);
}
-void QSGStochasticEngine::restart(int index)
+void QQuickStochasticEngine::restart(int index)
{
m_startTimes[index] = m_timeOffset + m_advanceTime.elapsed();
int time = m_duration[index] * m_states[m_things[index]]->frames() + m_startTimes[index];
addToUpdateList(time, index);
}
-uint QSGStochasticEngine::updateSprites(uint time)//### would returning a list of changed idxs be faster than signals?
+uint QQuickStochasticEngine::updateSprites(uint time)//### would returning a list of changed idxs be faster than signals?
{
//Sprite State Update;
QSet<int> changedIndexes;
return m_stateUpdates.first().first;
}
-int QSGStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
+int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
{
QString goalName;
if (m_goals[spriteIdx] != -1)
return curIdx;
if (dist < 0)
dist = m_states.count();
- QSGStochasticState* curState = m_states[curIdx];
+ QQuickStochasticState* curState = m_states[curIdx];
for (QVariantMap::const_iterator iter = curState->m_to.constBegin();
iter!=curState->m_to.constEnd(); iter++){
if (iter.key() == goalName)
return -1;
}
-void QSGStochasticEngine::addToUpdateList(uint t, int idx)
+void QQuickStochasticEngine::addToUpdateList(uint t, int idx)
{
for (int i=0; i<m_stateUpdates.count(); i++){
if (m_stateUpdates[i].first==t){
**
****************************************************************************/
-#ifndef SPRITEENGINE_H
-#define SPRITEENGINE_H
+#ifndef QQUICKSPRITEENGINE_P_H
+#define QQUICKSPRITEENGINE_P_H
#include <QObject>
#include <QVector>
QT_MODULE(Declarative)
-class QSGSprite;
-class Q_AUTOTEST_EXPORT QSGStochasticState : public QObject //For internal use
+class QQuickSprite;
+class Q_AUTOTEST_EXPORT QQuickStochasticState : public QObject //For internal use
{
Q_OBJECT
Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
Q_PROPERTY(int frames READ frames WRITE setFrames NOTIFY framesChanged)
public:
- QSGStochasticState(QObject* parent = 0)
+ QQuickStochasticState(QObject* parent = 0)
: QObject(parent)
, m_frames(1)
, m_duration(1000)
qreal m_speedModifier;
int m_durationVariance;
- friend class QSGStochasticEngine;
+ friend class QQuickStochasticEngine;
};
-class Q_AUTOTEST_EXPORT QSGStochasticEngine : public QObject
+class Q_AUTOTEST_EXPORT QQuickStochasticEngine : public QObject
{
Q_OBJECT
//TODO: Optimize single state case?
Q_PROPERTY(QString globalGoal READ globalGoal WRITE setGlobalGoal NOTIFY globalGoalChanged)
- Q_PROPERTY(QDeclarativeListProperty<QSGStochasticState> states READ states)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickStochasticState> states READ states)
public:
- explicit QSGStochasticEngine(QObject *parent = 0);
- QSGStochasticEngine(QList<QSGStochasticState*> states, QObject *parent=0);
- ~QSGStochasticEngine();
+ explicit QQuickStochasticEngine(QObject *parent = 0);
+ QQuickStochasticEngine(QList<QQuickStochasticState*> states, QObject *parent=0);
+ ~QQuickStochasticEngine();
- QDeclarativeListProperty<QSGStochasticState> states()
+ QDeclarativeListProperty<QQuickStochasticState> states()
{
- return QDeclarativeListProperty<QSGStochasticState>(this, m_states);
+ return QDeclarativeListProperty<QQuickStochasticState>(this, m_states);
}
QString globalGoal() const
void stop(int index=0);
int curState(int index=0) {return m_things[index];}
- QSGStochasticState* state(int idx){return m_states[idx];}
- int stateIndex(QSGStochasticState* s){return m_states.indexOf(s);}
+ QQuickStochasticState* state(int idx){return m_states[idx];}
+ int stateIndex(QQuickStochasticState* s){return m_states.indexOf(s);}
int stateCount() {return m_states.count();}
private:
signals:
void restart(int index);
void addToUpdateList(uint t, int idx);
int goalSeek(int curState, int idx, int dist=-1);
- QList<QSGStochasticState*> m_states;
+ QList<QQuickStochasticState*> m_states;
//### Consider struct or class for the four data variables?
QVector<int> m_things;//int is the index in m_states of the current state
QVector<int> m_goals;
int m_imageStateCount;
};
-class QSGSpriteEngine : public QSGStochasticEngine
+class QQuickSpriteEngine : public QQuickStochasticEngine
{
Q_OBJECT
- Q_PROPERTY(QDeclarativeListProperty<QSGSprite> sprites READ sprites)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickSprite> sprites READ sprites)
public:
- explicit QSGSpriteEngine(QObject *parent = 0);
- QSGSpriteEngine(QList<QSGSprite*> sprites, QObject *parent=0);
- ~QSGSpriteEngine();
- QDeclarativeListProperty<QSGSprite> sprites()
+ explicit QQuickSpriteEngine(QObject *parent = 0);
+ QQuickSpriteEngine(QList<QQuickSprite*> sprites, QObject *parent=0);
+ ~QQuickSpriteEngine();
+ QDeclarativeListProperty<QQuickSprite> sprites()
{
- return QDeclarativeListProperty<QSGSprite>(this, m_sprites);
+ return QDeclarativeListProperty<QQuickSprite>(this, m_sprites);
}
int maxFrames();
QImage assembledImage();
private:
- QList<QSGSprite*> m_sprites;
+ QList<QQuickSprite*> m_sprites;
};
//Common use is to have your own list property which is transparently an engine
-inline void spriteAppend(QDeclarativeListProperty<QSGSprite> *p, QSGSprite* s)
+inline void spriteAppend(QDeclarativeListProperty<QQuickSprite> *p, QQuickSprite* s)
{
- reinterpret_cast<QList<QSGSprite *> *>(p->data)->append(s);
+ reinterpret_cast<QList<QQuickSprite *> *>(p->data)->append(s);
p->object->metaObject()->invokeMethod(p->object, "createEngine");
}
-inline QSGSprite* spriteAt(QDeclarativeListProperty<QSGSprite> *p, int idx)
+inline QQuickSprite* spriteAt(QDeclarativeListProperty<QQuickSprite> *p, int idx)
{
- return reinterpret_cast<QList<QSGSprite *> *>(p->data)->at(idx);
+ return reinterpret_cast<QList<QQuickSprite *> *>(p->data)->at(idx);
}
-inline void spriteClear(QDeclarativeListProperty<QSGSprite> *p)
+inline void spriteClear(QDeclarativeListProperty<QQuickSprite> *p)
{
- reinterpret_cast<QList<QSGSprite *> *>(p->data)->clear();
+ reinterpret_cast<QList<QQuickSprite *> *>(p->data)->clear();
p->object->metaObject()->invokeMethod(p->object, "createEngine");
}
-inline int spriteCount(QDeclarativeListProperty<QSGSprite> *p)
+inline int spriteCount(QDeclarativeListProperty<QQuickSprite> *p)
{
- return reinterpret_cast<QList<QSGSprite *> *>(p->data)->count();
+ return reinterpret_cast<QList<QQuickSprite *> *>(p->data)->count();
}
QT_END_NAMESPACE
QT_END_HEADER
-#endif // SPRITEENGINE_H
+#endif // QQUICKSPRITEENGINE_P_H
**
****************************************************************************/
-#include "qsgspriteimage_p.h"
-#include "qsgsprite_p.h"
-#include "qsgspriteengine_p.h"
+#include "qquickspriteimage_p.h"
+#include "qquicksprite_p.h"
+#include "qquickspriteengine_p.h"
#include <private/qsgcontext_p.h>
#include <private/qsgadaptationlayer_p.h>
#include <qsgnode.h>
" gl_FragColor = mix(texture2D(texture, fTexS.xy), texture2D(texture, fTexS.zw), progress) * qt_Opacity;\n"
"}\n";
-class QSGSpriteMaterial : public QSGMaterial
+class QQuickSpriteMaterial : public QSGMaterial
{
public:
- QSGSpriteMaterial();
- virtual ~QSGSpriteMaterial();
+ QQuickSpriteMaterial();
+ virtual ~QQuickSpriteMaterial();
virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
virtual QSGMaterialShader *createShader() const;
virtual int compare(const QSGMaterial *other) const
{
- return this - static_cast<const QSGSpriteMaterial *>(other);
+ return this - static_cast<const QQuickSpriteMaterial *>(other);
}
QSGTexture *texture;
float elementHeight;
};
-QSGSpriteMaterial::QSGSpriteMaterial()
+QQuickSpriteMaterial::QQuickSpriteMaterial()
: timestamp(0)
, interpolate(1.0f)
, frameDuration(1.0f)
setFlag(Blending, true);
}
-QSGSpriteMaterial::~QSGSpriteMaterial()
+QQuickSpriteMaterial::~QQuickSpriteMaterial()
{
delete texture;
}
virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
{
- QSGSpriteMaterial *m = static_cast<QSGSpriteMaterial *>(newEffect);
+ QQuickSpriteMaterial *m = static_cast<QQuickSpriteMaterial *>(newEffect);
m->texture->bind();
program()->setUniformValue(m_opacity_id, state.opacity());
float SpriteMaterialData::chunkOfBytes[1024];
-QSGMaterialShader *QSGSpriteMaterial::createShader() const
+QSGMaterialShader *QQuickSpriteMaterial::createShader() const
{
return new SpriteMaterialData;
}
};
/*!
- \qmlclass SpriteImage QSGSpriteImage
+ \qmlclass SpriteImage QQuickSpriteImage
\inqmlmodule QtQuick 2
\inherits Item
\brief The SpriteImage element draws a sprite animation
*/
//TODO: Implicitly size element to size of first sprite?
-QSGSpriteImage::QSGSpriteImage(QSGItem *parent) :
- QSGItem(parent)
+QQuickSpriteImage::QQuickSpriteImage(QQuickItem *parent) :
+ QQuickItem(parent)
, m_node(0)
, m_material(0)
, m_spriteEngine(0)
this, SLOT(update()));
}
-QDeclarativeListProperty<QSGSprite> QSGSpriteImage::sprites()
+QDeclarativeListProperty<QQuickSprite> QQuickSpriteImage::sprites()
{
- return QDeclarativeListProperty<QSGSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
+ return QDeclarativeListProperty<QQuickSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
}
-void QSGSpriteImage::createEngine()
+void QQuickSpriteImage::createEngine()
{
//TODO: delay until component complete
if (m_spriteEngine)
delete m_spriteEngine;
if (m_sprites.count())
- m_spriteEngine = new QSGSpriteEngine(m_sprites, this);
+ m_spriteEngine = new QQuickSpriteEngine(m_sprites, this);
else
m_spriteEngine = 0;
reset();
SpriteImage_Attributes
};
-QSGGeometryNode* QSGSpriteImage::buildNode()
+QSGGeometryNode* QQuickSpriteImage::buildNode()
{
if (!m_spriteEngine) {
qWarning() << "SpriteImage: No sprite engine...";
return 0;
}
- m_material = new QSGSpriteMaterial();
+ m_material = new QQuickSpriteMaterial();
QImage image = m_spriteEngine->assembledImage();
if (image.isNull())
return m_node;
}
-void QSGSpriteImage::reset()
+void QQuickSpriteImage::reset()
{
m_pleaseReset = true;
}
-QSGNode *QSGSpriteImage::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
+QSGNode *QQuickSpriteImage::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
{
if (m_pleaseReset) {
delete m_node;
return m_node;
}
-void QSGSpriteImage::prepareNextFrame()
+void QQuickSpriteImage::prepareNextFrame()
{
if (m_node == 0)
m_node = buildNode();
**
****************************************************************************/
-#ifndef SPRITEIMAGE_H
-#define SPRITEIMAGE_H
+#ifndef QQUICKSPRITEIMAGE_P_H
+#define QQUICKSPRITEIMAGE_P_H
-#include <QSGItem>
+#include <QQuickItem>
#include <QTime>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
class QSGContext;
-class QSGSprite;
-class QSGSpriteEngine;
+class QQuickSprite;
+class QQuickSpriteEngine;
class QSGGeometryNode;
-class QSGSpriteMaterial;
-class QSGSpriteImage : public QSGItem
+class QQuickSpriteMaterial;
+class QQuickSpriteImage : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)
Q_PROPERTY(bool interpolate READ interpolate WRITE setInterpolate NOTIFY interpolateChanged)
//###try to share similar spriteEngines for less overhead?
- Q_PROPERTY(QDeclarativeListProperty<QSGSprite> sprites READ sprites)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickSprite> sprites READ sprites)
Q_CLASSINFO("DefaultProperty", "sprites")
public:
- explicit QSGSpriteImage(QSGItem *parent = 0);
+ explicit QQuickSpriteImage(QQuickItem *parent = 0);
- QDeclarativeListProperty<QSGSprite> sprites();
+ QDeclarativeListProperty<QQuickSprite> sprites();
bool running() const
{
void prepareNextFrame();
QSGGeometryNode* buildNode();
QSGGeometryNode *m_node;
- QSGSpriteMaterial *m_material;
- QList<QSGSprite*> m_sprites;
- QSGSpriteEngine* m_spriteEngine;
+ QQuickSpriteMaterial *m_material;
+ QList<QQuickSprite*> m_sprites;
+ QQuickSpriteEngine* m_spriteEngine;
QTime m_timestamp;
int m_maxFrames;
bool m_pleaseReset;
QT_END_HEADER
-#endif // SPRITEIMAGE_H
+#endif // QQUICKSPRITEIMAGE_P_H
**
****************************************************************************/
-#include "qsgstateoperations_p.h"
-#include "qsgitem_p.h"
+#include "qquickstateoperations_p.h"
+#include "qquickitem_p.h"
#include <private/qdeclarativestate_p_p.h>
QT_BEGIN_NAMESPACE
-class QSGParentChangePrivate : public QDeclarativeStateOperationPrivate
+class QQuickParentChangePrivate : public QDeclarativeStateOperationPrivate
{
- Q_DECLARE_PUBLIC(QSGParentChange)
+ Q_DECLARE_PUBLIC(QQuickParentChange)
public:
- QSGParentChangePrivate() : target(0), parent(0), origParent(0), origStackBefore(0),
+ QQuickParentChangePrivate() : target(0), parent(0), origParent(0), origStackBefore(0),
rewindParent(0), rewindStackBefore(0) {}
- QSGItem *target;
- QDeclarativeGuard<QSGItem> parent;
- QDeclarativeGuard<QSGItem> origParent;
- QDeclarativeGuard<QSGItem> origStackBefore;
- QSGItem *rewindParent;
- QSGItem *rewindStackBefore;
+ QQuickItem *target;
+ QDeclarativeGuard<QQuickItem> parent;
+ QDeclarativeGuard<QQuickItem> origParent;
+ QDeclarativeGuard<QQuickItem> origStackBefore;
+ QQuickItem *rewindParent;
+ QQuickItem *rewindStackBefore;
QDeclarativeNullableValue<QDeclarativeScriptString> xString;
QDeclarativeNullableValue<QDeclarativeScriptString> yString;
QDeclarativeNullableValue<QDeclarativeScriptString> scaleString;
QDeclarativeNullableValue<QDeclarativeScriptString> rotationString;
- void doChange(QSGItem *targetParent, QSGItem *stackBefore = 0);
+ void doChange(QQuickItem *targetParent, QQuickItem *stackBefore = 0);
};
-void QSGParentChangePrivate::doChange(QSGItem *targetParent, QSGItem *stackBefore)
+void QQuickParentChangePrivate::doChange(QQuickItem *targetParent, QQuickItem *stackBefore)
{
if (targetParent && target && target->parentItem()) {
- Q_Q(QSGParentChange);
+ Q_Q(QQuickParentChange);
bool ok;
const QTransform &transform = target->parentItem()->itemTransform(targetParent, &ok);
if (transform.type() >= QTransform::TxShear || !ok) {
- qmlInfo(q) << QSGParentChange::tr("Unable to preserve appearance under complex transform");
+ qmlInfo(q) << QQuickParentChange::tr("Unable to preserve appearance under complex transform");
ok = false;
}
if (transform.m11() == transform.m22())
scale = transform.m11();
else {
- qmlInfo(q) << QSGParentChange::tr("Unable to preserve appearance under non-uniform scale");
+ qmlInfo(q) << QQuickParentChange::tr("Unable to preserve appearance under non-uniform scale");
ok = false;
}
} else if (ok && isRotate) {
if (transform.m11() == transform.m22())
scale = qSqrt(transform.m11()*transform.m11() + transform.m12()*transform.m12());
else {
- qmlInfo(q) << QSGParentChange::tr("Unable to preserve appearance under non-uniform scale");
+ qmlInfo(q) << QQuickParentChange::tr("Unable to preserve appearance under non-uniform scale");
ok = false;
}
if (scale != 0)
rotation = atan2(transform.m12()/scale, transform.m11()/scale) * 180/M_PI;
else {
- qmlInfo(q) << QSGParentChange::tr("Unable to preserve appearance under scale of 0");
+ qmlInfo(q) << QQuickParentChange::tr("Unable to preserve appearance under scale of 0");
ok = false;
}
}
// setParentItem will update the transformOriginPoint if needed
target->setParentItem(targetParent);
- if (ok && target->transformOrigin() != QSGItem::TopLeft) {
+ if (ok && target->transformOrigin() != QQuickItem::TopLeft) {
qreal tempxt = target->transformOriginPoint().x();
qreal tempyt = target->transformOriginPoint().y();
QTransform t;
target->stackBefore(stackBefore);
}
-QSGParentChange::QSGParentChange(QObject *parent)
- : QDeclarativeStateOperation(*(new QSGParentChangePrivate), parent)
+QQuickParentChange::QQuickParentChange(QObject *parent)
+ : QDeclarativeStateOperation(*(new QQuickParentChangePrivate), parent)
{
}
-QSGParentChange::~QSGParentChange()
+QQuickParentChange::~QQuickParentChange()
{
}
-QDeclarativeScriptString QSGParentChange::x() const
+QDeclarativeScriptString QQuickParentChange::x() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->xString.value;
}
-void QSGParentChange::setX(QDeclarativeScriptString x)
+void QQuickParentChange::setX(QDeclarativeScriptString x)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->xString = x;
}
-bool QSGParentChange::xIsSet() const
+bool QQuickParentChange::xIsSet() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->xString.isValid();
}
-QDeclarativeScriptString QSGParentChange::y() const
+QDeclarativeScriptString QQuickParentChange::y() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->yString.value;
}
-void QSGParentChange::setY(QDeclarativeScriptString y)
+void QQuickParentChange::setY(QDeclarativeScriptString y)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->yString = y;
}
-bool QSGParentChange::yIsSet() const
+bool QQuickParentChange::yIsSet() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->yString.isValid();
}
-QDeclarativeScriptString QSGParentChange::width() const
+QDeclarativeScriptString QQuickParentChange::width() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->widthString.value;
}
-void QSGParentChange::setWidth(QDeclarativeScriptString width)
+void QQuickParentChange::setWidth(QDeclarativeScriptString width)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->widthString = width;
}
-bool QSGParentChange::widthIsSet() const
+bool QQuickParentChange::widthIsSet() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->widthString.isValid();
}
-QDeclarativeScriptString QSGParentChange::height() const
+QDeclarativeScriptString QQuickParentChange::height() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->heightString.value;
}
-void QSGParentChange::setHeight(QDeclarativeScriptString height)
+void QQuickParentChange::setHeight(QDeclarativeScriptString height)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->heightString = height;
}
-bool QSGParentChange::heightIsSet() const
+bool QQuickParentChange::heightIsSet() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->heightString.isValid();
}
-QDeclarativeScriptString QSGParentChange::scale() const
+QDeclarativeScriptString QQuickParentChange::scale() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->scaleString.value;
}
-void QSGParentChange::setScale(QDeclarativeScriptString scale)
+void QQuickParentChange::setScale(QDeclarativeScriptString scale)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->scaleString = scale;
}
-bool QSGParentChange::scaleIsSet() const
+bool QQuickParentChange::scaleIsSet() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->scaleString.isValid();
}
-QDeclarativeScriptString QSGParentChange::rotation() const
+QDeclarativeScriptString QQuickParentChange::rotation() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->rotationString.value;
}
-void QSGParentChange::setRotation(QDeclarativeScriptString rotation)
+void QQuickParentChange::setRotation(QDeclarativeScriptString rotation)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->rotationString = rotation;
}
-bool QSGParentChange::rotationIsSet() const
+bool QQuickParentChange::rotationIsSet() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->rotationString.isValid();
}
-QSGItem *QSGParentChange::originalParent() const
+QQuickItem *QQuickParentChange::originalParent() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->origParent;
}
-QSGItem *QSGParentChange::object() const
+QQuickItem *QQuickParentChange::object() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->target;
}
-void QSGParentChange::setObject(QSGItem *target)
+void QQuickParentChange::setObject(QQuickItem *target)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->target = target;
}
-QSGItem *QSGParentChange::parent() const
+QQuickItem *QQuickParentChange::parent() const
{
- Q_D(const QSGParentChange);
+ Q_D(const QQuickParentChange);
return d->parent;
}
-void QSGParentChange::setParent(QSGItem *parent)
+void QQuickParentChange::setParent(QQuickItem *parent)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->parent = parent;
}
-QDeclarativeStateOperation::ActionList QSGParentChange::actions()
+QDeclarativeStateOperation::ActionList QQuickParentChange::actions()
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
if (!d->target || !d->parent)
return ActionList();
return actions;
}
-void QSGParentChange::saveOriginals()
+void QQuickParentChange::saveOriginals()
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
saveCurrentValues();
d->origParent = d->rewindParent;
d->origStackBefore = d->rewindStackBefore;
}
-/*void QSGParentChange::copyOriginals(QDeclarativeActionEvent *other)
+/*void QQuickParentChange::copyOriginals(QDeclarativeActionEvent *other)
{
- Q_D(QSGParentChange);
- QSGParentChange *pc = static_cast<QSGParentChange*>(other);
+ Q_D(QQuickParentChange);
+ QQuickParentChange *pc = static_cast<QQuickParentChange*>(other);
d->origParent = pc->d_func()->rewindParent;
d->origStackBefore = pc->d_func()->rewindStackBefore;
saveCurrentValues();
}*/
-void QSGParentChange::execute(Reason)
+void QQuickParentChange::execute(Reason)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->doChange(d->parent);
}
-bool QSGParentChange::isReversable()
+bool QQuickParentChange::isReversable()
{
return true;
}
-void QSGParentChange::reverse(Reason)
+void QQuickParentChange::reverse(Reason)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->doChange(d->origParent, d->origStackBefore);
}
-QString QSGParentChange::typeName() const
+QString QQuickParentChange::typeName() const
{
return QLatin1String("ParentChange");
}
-bool QSGParentChange::override(QDeclarativeActionEvent*other)
+bool QQuickParentChange::override(QDeclarativeActionEvent*other)
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
if (other->typeName() != QLatin1String("ParentChange"))
return false;
- if (QSGParentChange *otherPC = static_cast<QSGParentChange*>(other))
+ if (QQuickParentChange *otherPC = static_cast<QQuickParentChange*>(other))
return (d->target == otherPC->object());
return false;
}
-void QSGParentChange::saveCurrentValues()
+void QQuickParentChange::saveCurrentValues()
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
if (!d->target) {
d->rewindParent = 0;
d->rewindStackBefore = 0;
if (!d->rewindParent)
return;
- QList<QSGItem *> children = d->rewindParent->childItems();
+ QList<QQuickItem *> children = d->rewindParent->childItems();
for (int ii = 0; ii < children.count() - 1; ++ii) {
if (children.at(ii) == d->target) {
d->rewindStackBefore = children.at(ii + 1);
}
}
-void QSGParentChange::rewind()
+void QQuickParentChange::rewind()
{
- Q_D(QSGParentChange);
+ Q_D(QQuickParentChange);
d->doChange(d->rewindParent, d->rewindStackBefore);
}
-class QSGAnchorSetPrivate : public QObjectPrivate
+class QQuickAnchorSetPrivate : public QObjectPrivate
{
- Q_DECLARE_PUBLIC(QSGAnchorSet)
+ Q_DECLARE_PUBLIC(QQuickAnchorSet)
public:
- QSGAnchorSetPrivate()
+ QQuickAnchorSetPrivate()
: usedAnchors(0), resetAnchors(0), fill(0),
centerIn(0)/*, leftMargin(0), rightMargin(0), topMargin(0), bottomMargin(0),
margins(0), vCenterOffset(0), hCenterOffset(0), baselineOffset(0)*/
{
}
- QSGAnchors::Anchors usedAnchors;
- QSGAnchors::Anchors resetAnchors;
+ QQuickAnchors::Anchors usedAnchors;
+ QQuickAnchors::Anchors resetAnchors;
- QSGItem *fill;
- QSGItem *centerIn;
+ QQuickItem *fill;
+ QQuickItem *centerIn;
QDeclarativeScriptString leftScript;
QDeclarativeScriptString rightScript;
qreal baselineOffset;*/
};
-QSGAnchorSet::QSGAnchorSet(QObject *parent)
- : QObject(*new QSGAnchorSetPrivate, parent)
+QQuickAnchorSet::QQuickAnchorSet(QObject *parent)
+ : QObject(*new QQuickAnchorSetPrivate, parent)
{
}
-QSGAnchorSet::~QSGAnchorSet()
+QQuickAnchorSet::~QQuickAnchorSet()
{
}
-QDeclarativeScriptString QSGAnchorSet::top() const
+QDeclarativeScriptString QQuickAnchorSet::top() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->topScript;
}
-void QSGAnchorSet::setTop(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setTop(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::TopAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::TopAnchor;
d->topScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetTop();
}
-void QSGAnchorSet::resetTop()
+void QQuickAnchorSet::resetTop()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::TopAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::TopAnchor;
d->topScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::TopAnchor;
+ d->resetAnchors |= QQuickAnchors::TopAnchor;
}
-QDeclarativeScriptString QSGAnchorSet::bottom() const
+QDeclarativeScriptString QQuickAnchorSet::bottom() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->bottomScript;
}
-void QSGAnchorSet::setBottom(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setBottom(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::BottomAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::BottomAnchor;
d->bottomScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetBottom();
}
-void QSGAnchorSet::resetBottom()
+void QQuickAnchorSet::resetBottom()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::BottomAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::BottomAnchor;
d->bottomScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::BottomAnchor;
+ d->resetAnchors |= QQuickAnchors::BottomAnchor;
}
-QDeclarativeScriptString QSGAnchorSet::verticalCenter() const
+QDeclarativeScriptString QQuickAnchorSet::verticalCenter() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->vCenterScript;
}
-void QSGAnchorSet::setVerticalCenter(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setVerticalCenter(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::VCenterAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::VCenterAnchor;
d->vCenterScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetVerticalCenter();
}
-void QSGAnchorSet::resetVerticalCenter()
+void QQuickAnchorSet::resetVerticalCenter()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::VCenterAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::VCenterAnchor;
d->vCenterScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::VCenterAnchor;
+ d->resetAnchors |= QQuickAnchors::VCenterAnchor;
}
-QDeclarativeScriptString QSGAnchorSet::baseline() const
+QDeclarativeScriptString QQuickAnchorSet::baseline() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->baselineScript;
}
-void QSGAnchorSet::setBaseline(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setBaseline(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::BaselineAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::BaselineAnchor;
d->baselineScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetBaseline();
}
-void QSGAnchorSet::resetBaseline()
+void QQuickAnchorSet::resetBaseline()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::BaselineAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::BaselineAnchor;
d->baselineScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::BaselineAnchor;
+ d->resetAnchors |= QQuickAnchors::BaselineAnchor;
}
-QDeclarativeScriptString QSGAnchorSet::left() const
+QDeclarativeScriptString QQuickAnchorSet::left() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->leftScript;
}
-void QSGAnchorSet::setLeft(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setLeft(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::LeftAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::LeftAnchor;
d->leftScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetLeft();
}
-void QSGAnchorSet::resetLeft()
+void QQuickAnchorSet::resetLeft()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::LeftAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::LeftAnchor;
d->leftScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::LeftAnchor;
+ d->resetAnchors |= QQuickAnchors::LeftAnchor;
}
-QDeclarativeScriptString QSGAnchorSet::right() const
+QDeclarativeScriptString QQuickAnchorSet::right() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->rightScript;
}
-void QSGAnchorSet::setRight(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setRight(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::RightAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::RightAnchor;
d->rightScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetRight();
}
-void QSGAnchorSet::resetRight()
+void QQuickAnchorSet::resetRight()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::RightAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::RightAnchor;
d->rightScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::RightAnchor;
+ d->resetAnchors |= QQuickAnchors::RightAnchor;
}
-QDeclarativeScriptString QSGAnchorSet::horizontalCenter() const
+QDeclarativeScriptString QQuickAnchorSet::horizontalCenter() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->hCenterScript;
}
-void QSGAnchorSet::setHorizontalCenter(const QDeclarativeScriptString &edge)
+void QQuickAnchorSet::setHorizontalCenter(const QDeclarativeScriptString &edge)
{
- Q_D(QSGAnchorSet);
- d->usedAnchors |= QSGAnchors::HCenterAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors |= QQuickAnchors::HCenterAnchor;
d->hCenterScript = edge;
if (edge.script() == QLatin1String("undefined"))
resetHorizontalCenter();
}
-void QSGAnchorSet::resetHorizontalCenter()
+void QQuickAnchorSet::resetHorizontalCenter()
{
- Q_D(QSGAnchorSet);
- d->usedAnchors &= ~QSGAnchors::HCenterAnchor;
+ Q_D(QQuickAnchorSet);
+ d->usedAnchors &= ~QQuickAnchors::HCenterAnchor;
d->hCenterScript = QDeclarativeScriptString();
- d->resetAnchors |= QSGAnchors::HCenterAnchor;
+ d->resetAnchors |= QQuickAnchors::HCenterAnchor;
}
-QSGItem *QSGAnchorSet::fill() const
+QQuickItem *QQuickAnchorSet::fill() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->fill;
}
-void QSGAnchorSet::setFill(QSGItem *f)
+void QQuickAnchorSet::setFill(QQuickItem *f)
{
- Q_D(QSGAnchorSet);
+ Q_D(QQuickAnchorSet);
d->fill = f;
}
-void QSGAnchorSet::resetFill()
+void QQuickAnchorSet::resetFill()
{
setFill(0);
}
-QSGItem *QSGAnchorSet::centerIn() const
+QQuickItem *QQuickAnchorSet::centerIn() const
{
- Q_D(const QSGAnchorSet);
+ Q_D(const QQuickAnchorSet);
return d->centerIn;
}
-void QSGAnchorSet::setCenterIn(QSGItem* c)
+void QQuickAnchorSet::setCenterIn(QQuickItem* c)
{
- Q_D(QSGAnchorSet);
+ Q_D(QQuickAnchorSet);
d->centerIn = c;
}
-void QSGAnchorSet::resetCenterIn()
+void QQuickAnchorSet::resetCenterIn()
{
setCenterIn(0);
}
-class QSGAnchorChangesPrivate : public QDeclarativeStateOperationPrivate
+class QQuickAnchorChangesPrivate : public QDeclarativeStateOperationPrivate
{
public:
- QSGAnchorChangesPrivate()
- : target(0), anchorSet(new QSGAnchorSet),
+ QQuickAnchorChangesPrivate()
+ : target(0), anchorSet(new QQuickAnchorSet),
leftBinding(0), rightBinding(0), hCenterBinding(0),
topBinding(0), bottomBinding(0), vCenterBinding(0), baselineBinding(0),
origLeftBinding(0), origRightBinding(0), origHCenterBinding(0),
{
}
- ~QSGAnchorChangesPrivate() { delete anchorSet; }
+ ~QQuickAnchorChangesPrivate() { delete anchorSet; }
- QSGItem *target;
- QSGAnchorSet *anchorSet;
+ QQuickItem *target;
+ QQuickAnchorSet *anchorSet;
QDeclarativeBinding *leftBinding;
QDeclarativeBinding *rightBinding;
QDeclarativeAbstractBinding *origVCenterBinding;
QDeclarativeAbstractBinding *origBaselineBinding;
- QSGAnchorLine rewindLeft;
- QSGAnchorLine rewindRight;
- QSGAnchorLine rewindHCenter;
- QSGAnchorLine rewindTop;
- QSGAnchorLine rewindBottom;
- QSGAnchorLine rewindVCenter;
- QSGAnchorLine rewindBaseline;
+ QQuickAnchorLine rewindLeft;
+ QQuickAnchorLine rewindRight;
+ QQuickAnchorLine rewindHCenter;
+ QQuickAnchorLine rewindTop;
+ QQuickAnchorLine rewindBottom;
+ QQuickAnchorLine rewindVCenter;
+ QQuickAnchorLine rewindBaseline;
qreal fromX;
qreal fromY;
QDeclarativeProperty baselineProp;
};
-QSGAnchorChanges::QSGAnchorChanges(QObject *parent)
- : QDeclarativeStateOperation(*(new QSGAnchorChangesPrivate), parent)
+QQuickAnchorChanges::QQuickAnchorChanges(QObject *parent)
+ : QDeclarativeStateOperation(*(new QQuickAnchorChangesPrivate), parent)
{
}
-QSGAnchorChanges::~QSGAnchorChanges()
+QQuickAnchorChanges::~QQuickAnchorChanges()
{
}
-QSGAnchorChanges::ActionList QSGAnchorChanges::actions()
+QQuickAnchorChanges::ActionList QQuickAnchorChanges::actions()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
d->leftBinding = d->rightBinding = d->hCenterBinding = d->topBinding
= d->bottomBinding = d->vCenterBinding = d->baselineBinding = 0;
d->vCenterProp = QDeclarativeProperty(d->target, QLatin1String("anchors.verticalCenter"));
d->baselineProp = QDeclarativeProperty(d->target, QLatin1String("anchors.baseline"));
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::LeftAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::LeftAnchor) {
d->leftBinding = new QDeclarativeBinding(d->anchorSet->d_func()->leftScript.script(), d->target, qmlContext(this));
d->leftBinding->setTarget(d->leftProp);
}
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::RightAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::RightAnchor) {
d->rightBinding = new QDeclarativeBinding(d->anchorSet->d_func()->rightScript.script(), d->target, qmlContext(this));
d->rightBinding->setTarget(d->rightProp);
}
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::HCenterAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::HCenterAnchor) {
d->hCenterBinding = new QDeclarativeBinding(d->anchorSet->d_func()->hCenterScript.script(), d->target, qmlContext(this));
d->hCenterBinding->setTarget(d->hCenterProp);
}
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::TopAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::TopAnchor) {
d->topBinding = new QDeclarativeBinding(d->anchorSet->d_func()->topScript.script(), d->target, qmlContext(this));
d->topBinding->setTarget(d->topProp);
}
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::BottomAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::BottomAnchor) {
d->bottomBinding = new QDeclarativeBinding(d->anchorSet->d_func()->bottomScript.script(), d->target, qmlContext(this));
d->bottomBinding->setTarget(d->bottomProp);
}
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::VCenterAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::VCenterAnchor) {
d->vCenterBinding = new QDeclarativeBinding(d->anchorSet->d_func()->vCenterScript.script(), d->target, qmlContext(this));
d->vCenterBinding->setTarget(d->vCenterProp);
}
- if (d->anchorSet->d_func()->usedAnchors & QSGAnchors::BaselineAnchor) {
+ if (d->anchorSet->d_func()->usedAnchors & QQuickAnchors::BaselineAnchor) {
d->baselineBinding = new QDeclarativeBinding(d->anchorSet->d_func()->baselineScript.script(), d->target, qmlContext(this));
d->baselineBinding->setTarget(d->baselineProp);
}
return ActionList() << a;
}
-QSGAnchorSet *QSGAnchorChanges::anchors()
+QQuickAnchorSet *QQuickAnchorChanges::anchors()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
return d->anchorSet;
}
-QSGItem *QSGAnchorChanges::object() const
+QQuickItem *QQuickAnchorChanges::object() const
{
- Q_D(const QSGAnchorChanges);
+ Q_D(const QQuickAnchorChanges);
return d->target;
}
-void QSGAnchorChanges::setObject(QSGItem *target)
+void QQuickAnchorChanges::setObject(QQuickItem *target)
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
d->target = target;
}
-void QSGAnchorChanges::execute(Reason reason)
+void QQuickAnchorChanges::execute(Reason reason)
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(d->target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(d->target);
//incorporate any needed "reverts"
if (d->applyOrigLeft) {
if (!d->origLeftBinding)
}
//reset any anchors that have been specified as "undefined"
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::LeftAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::LeftAnchor) {
targetPrivate->anchors()->resetLeft();
QDeclarativePropertyPrivate::setBinding(d->leftProp, 0);
}
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::RightAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::RightAnchor) {
targetPrivate->anchors()->resetRight();
QDeclarativePropertyPrivate::setBinding(d->rightProp, 0);
}
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::HCenterAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::HCenterAnchor) {
targetPrivate->anchors()->resetHorizontalCenter();
QDeclarativePropertyPrivate::setBinding(d->hCenterProp, 0);
}
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::TopAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::TopAnchor) {
targetPrivate->anchors()->resetTop();
QDeclarativePropertyPrivate::setBinding(d->topProp, 0);
}
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::BottomAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::BottomAnchor) {
targetPrivate->anchors()->resetBottom();
QDeclarativePropertyPrivate::setBinding(d->bottomProp, 0);
}
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::VCenterAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::VCenterAnchor) {
targetPrivate->anchors()->resetVerticalCenter();
QDeclarativePropertyPrivate::setBinding(d->vCenterProp, 0);
}
- if (d->anchorSet->d_func()->resetAnchors & QSGAnchors::BaselineAnchor) {
+ if (d->anchorSet->d_func()->resetAnchors & QQuickAnchors::BaselineAnchor) {
targetPrivate->anchors()->resetBaseline();
QDeclarativePropertyPrivate::setBinding(d->baselineProp, 0);
}
QDeclarativePropertyPrivate::setBinding(d->baselineBinding->property(), d->baselineBinding);
}
-bool QSGAnchorChanges::isReversable()
+bool QQuickAnchorChanges::isReversable()
{
return true;
}
-void QSGAnchorChanges::reverse(Reason reason)
+void QQuickAnchorChanges::reverse(Reason reason)
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(d->target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(d->target);
//reset any anchors set by the state
if (d->leftBinding) {
targetPrivate->anchors()->resetLeft();
QDeclarativePropertyPrivate::setBinding(d->baselineProp, d->origBaselineBinding);
//restore any absolute geometry changed by the state's anchors
- QSGAnchors::Anchors stateVAnchors = d->anchorSet->d_func()->usedAnchors & QSGAnchors::Vertical_Mask;
- QSGAnchors::Anchors origVAnchors = targetPrivate->anchors()->usedAnchors() & QSGAnchors::Vertical_Mask;
- QSGAnchors::Anchors stateHAnchors = d->anchorSet->d_func()->usedAnchors & QSGAnchors::Horizontal_Mask;
- QSGAnchors::Anchors origHAnchors = targetPrivate->anchors()->usedAnchors() & QSGAnchors::Horizontal_Mask;
+ QQuickAnchors::Anchors stateVAnchors = d->anchorSet->d_func()->usedAnchors & QQuickAnchors::Vertical_Mask;
+ QQuickAnchors::Anchors origVAnchors = targetPrivate->anchors()->usedAnchors() & QQuickAnchors::Vertical_Mask;
+ QQuickAnchors::Anchors stateHAnchors = d->anchorSet->d_func()->usedAnchors & QQuickAnchors::Horizontal_Mask;
+ QQuickAnchors::Anchors origHAnchors = targetPrivate->anchors()->usedAnchors() & QQuickAnchors::Horizontal_Mask;
bool stateSetWidth = (stateHAnchors &&
- stateHAnchors != QSGAnchors::LeftAnchor &&
- stateHAnchors != QSGAnchors::RightAnchor &&
- stateHAnchors != QSGAnchors::HCenterAnchor);
+ stateHAnchors != QQuickAnchors::LeftAnchor &&
+ stateHAnchors != QQuickAnchors::RightAnchor &&
+ stateHAnchors != QQuickAnchors::HCenterAnchor);
bool origSetWidth = (origHAnchors &&
- origHAnchors != QSGAnchors::LeftAnchor &&
- origHAnchors != QSGAnchors::RightAnchor &&
- origHAnchors != QSGAnchors::HCenterAnchor);
+ origHAnchors != QQuickAnchors::LeftAnchor &&
+ origHAnchors != QQuickAnchors::RightAnchor &&
+ origHAnchors != QQuickAnchors::HCenterAnchor);
if (d->origWidth.isValid() && stateSetWidth && !origSetWidth)
d->target->setWidth(d->origWidth.value);
bool stateSetHeight = (stateVAnchors &&
- stateVAnchors != QSGAnchors::TopAnchor &&
- stateVAnchors != QSGAnchors::BottomAnchor &&
- stateVAnchors != QSGAnchors::VCenterAnchor &&
- stateVAnchors != QSGAnchors::BaselineAnchor);
+ stateVAnchors != QQuickAnchors::TopAnchor &&
+ stateVAnchors != QQuickAnchors::BottomAnchor &&
+ stateVAnchors != QQuickAnchors::VCenterAnchor &&
+ stateVAnchors != QQuickAnchors::BaselineAnchor);
bool origSetHeight = (origVAnchors &&
- origVAnchors != QSGAnchors::TopAnchor &&
- origVAnchors != QSGAnchors::BottomAnchor &&
- origVAnchors != QSGAnchors::VCenterAnchor &&
- origVAnchors != QSGAnchors::BaselineAnchor);
+ origVAnchors != QQuickAnchors::TopAnchor &&
+ origVAnchors != QQuickAnchors::BottomAnchor &&
+ origVAnchors != QQuickAnchors::VCenterAnchor &&
+ origVAnchors != QQuickAnchors::BaselineAnchor);
if (d->origHeight.isValid() && stateSetHeight && !origSetHeight)
d->target->setHeight(d->origHeight.value);
d->target->setY(d->origY);
}
-QString QSGAnchorChanges::typeName() const
+QString QQuickAnchorChanges::typeName() const
{
return QLatin1String("AnchorChanges");
}
-QList<QDeclarativeAction> QSGAnchorChanges::additionalActions()
+QList<QDeclarativeAction> QQuickAnchorChanges::additionalActions()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
QList<QDeclarativeAction> extra;
- QSGAnchors::Anchors combined = d->anchorSet->d_func()->usedAnchors | d->anchorSet->d_func()->resetAnchors;
- bool hChange = combined & QSGAnchors::Horizontal_Mask;
- bool vChange = combined & QSGAnchors::Vertical_Mask;
+ QQuickAnchors::Anchors combined = d->anchorSet->d_func()->usedAnchors | d->anchorSet->d_func()->resetAnchors;
+ bool hChange = combined & QQuickAnchors::Horizontal_Mask;
+ bool vChange = combined & QQuickAnchors::Vertical_Mask;
if (d->target) {
QDeclarativeAction a;
return extra;
}
-bool QSGAnchorChanges::changesBindings()
+bool QQuickAnchorChanges::changesBindings()
{
return true;
}
-void QSGAnchorChanges::saveOriginals()
+void QQuickAnchorChanges::saveOriginals()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
d->origVCenterBinding = QDeclarativePropertyPrivate::binding(d->vCenterProp);
d->origBaselineBinding = QDeclarativePropertyPrivate::binding(d->baselineProp);
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(d->target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(d->target);
if (targetPrivate->widthValid)
d->origWidth = d->target->width();
if (targetPrivate->heightValid)
saveCurrentValues();
}
-void QSGAnchorChanges::copyOriginals(QDeclarativeActionEvent *other)
+void QQuickAnchorChanges::copyOriginals(QDeclarativeActionEvent *other)
{
- Q_D(QSGAnchorChanges);
- QSGAnchorChanges *ac = static_cast<QSGAnchorChanges*>(other);
- QSGAnchorChangesPrivate *acp = ac->d_func();
+ Q_D(QQuickAnchorChanges);
+ QQuickAnchorChanges *ac = static_cast<QQuickAnchorChanges*>(other);
+ QQuickAnchorChangesPrivate *acp = ac->d_func();
- QSGAnchors::Anchors combined = acp->anchorSet->d_func()->usedAnchors |
+ QQuickAnchors::Anchors combined = acp->anchorSet->d_func()->usedAnchors |
acp->anchorSet->d_func()->resetAnchors;
//probably also need to revert some things
- d->applyOrigLeft = (combined & QSGAnchors::LeftAnchor);
- d->applyOrigRight = (combined & QSGAnchors::RightAnchor);
- d->applyOrigHCenter = (combined & QSGAnchors::HCenterAnchor);
- d->applyOrigTop = (combined & QSGAnchors::TopAnchor);
- d->applyOrigBottom = (combined & QSGAnchors::BottomAnchor);
- d->applyOrigVCenter = (combined & QSGAnchors::VCenterAnchor);
- d->applyOrigBaseline = (combined & QSGAnchors::BaselineAnchor);
+ d->applyOrigLeft = (combined & QQuickAnchors::LeftAnchor);
+ d->applyOrigRight = (combined & QQuickAnchors::RightAnchor);
+ d->applyOrigHCenter = (combined & QQuickAnchors::HCenterAnchor);
+ d->applyOrigTop = (combined & QQuickAnchors::TopAnchor);
+ d->applyOrigBottom = (combined & QQuickAnchors::BottomAnchor);
+ d->applyOrigVCenter = (combined & QQuickAnchors::VCenterAnchor);
+ d->applyOrigBaseline = (combined & QQuickAnchors::BaselineAnchor);
d->origLeftBinding = acp->origLeftBinding;
d->origRightBinding = acp->origRightBinding;
saveCurrentValues();
}
-void QSGAnchorChanges::clearBindings()
+void QQuickAnchorChanges::clearBindings()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
d->fromWidth = d->target->width();
d->fromHeight = d->target->height();
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(d->target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(d->target);
//reset any anchors with corresponding reverts
//reset any anchors that have been specified as "undefined"
//reset any anchors that we'll be setting in the state
- QSGAnchors::Anchors combined = d->anchorSet->d_func()->resetAnchors |
+ QQuickAnchors::Anchors combined = d->anchorSet->d_func()->resetAnchors |
d->anchorSet->d_func()->usedAnchors;
- if (d->applyOrigLeft || (combined & QSGAnchors::LeftAnchor)) {
+ if (d->applyOrigLeft || (combined & QQuickAnchors::LeftAnchor)) {
targetPrivate->anchors()->resetLeft();
QDeclarativePropertyPrivate::setBinding(d->leftProp, 0);
}
- if (d->applyOrigRight || (combined & QSGAnchors::RightAnchor)) {
+ if (d->applyOrigRight || (combined & QQuickAnchors::RightAnchor)) {
targetPrivate->anchors()->resetRight();
QDeclarativePropertyPrivate::setBinding(d->rightProp, 0);
}
- if (d->applyOrigHCenter || (combined & QSGAnchors::HCenterAnchor)) {
+ if (d->applyOrigHCenter || (combined & QQuickAnchors::HCenterAnchor)) {
targetPrivate->anchors()->resetHorizontalCenter();
QDeclarativePropertyPrivate::setBinding(d->hCenterProp, 0);
}
- if (d->applyOrigTop || (combined & QSGAnchors::TopAnchor)) {
+ if (d->applyOrigTop || (combined & QQuickAnchors::TopAnchor)) {
targetPrivate->anchors()->resetTop();
QDeclarativePropertyPrivate::setBinding(d->topProp, 0);
}
- if (d->applyOrigBottom || (combined & QSGAnchors::BottomAnchor)) {
+ if (d->applyOrigBottom || (combined & QQuickAnchors::BottomAnchor)) {
targetPrivate->anchors()->resetBottom();
QDeclarativePropertyPrivate::setBinding(d->bottomProp, 0);
}
- if (d->applyOrigVCenter || (combined & QSGAnchors::VCenterAnchor)) {
+ if (d->applyOrigVCenter || (combined & QQuickAnchors::VCenterAnchor)) {
targetPrivate->anchors()->resetVerticalCenter();
QDeclarativePropertyPrivate::setBinding(d->vCenterProp, 0);
}
- if (d->applyOrigBaseline || (combined & QSGAnchors::BaselineAnchor)) {
+ if (d->applyOrigBaseline || (combined & QQuickAnchors::BaselineAnchor)) {
targetPrivate->anchors()->resetBaseline();
QDeclarativePropertyPrivate::setBinding(d->baselineProp, 0);
}
}
-bool QSGAnchorChanges::override(QDeclarativeActionEvent*other)
+bool QQuickAnchorChanges::override(QDeclarativeActionEvent*other)
{
if (other->typeName() != QLatin1String("AnchorChanges"))
return false;
if (static_cast<QDeclarativeActionEvent*>(this) == other)
return true;
- if (static_cast<QSGAnchorChanges*>(other)->object() == object())
+ if (static_cast<QQuickAnchorChanges*>(other)->object() == object())
return true;
return false;
}
-void QSGAnchorChanges::rewind()
+void QQuickAnchorChanges::rewind()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(d->target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(d->target);
//restore previous values (but not previous bindings, i.e. anchors)
d->target->setX(d->rewindX);
}
}
-void QSGAnchorChanges::saveCurrentValues()
+void QQuickAnchorChanges::saveCurrentValues()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
- QSGItemPrivate *targetPrivate = QSGItemPrivate::get(d->target);
+ QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(d->target);
d->rewindLeft = targetPrivate->anchors()->left();
d->rewindRight = targetPrivate->anchors()->right();
d->rewindHCenter = targetPrivate->anchors()->horizontalCenter();
d->rewindHeight = d->target->height();
}
-void QSGAnchorChanges::saveTargetValues()
+void QQuickAnchorChanges::saveTargetValues()
{
- Q_D(QSGAnchorChanges);
+ Q_D(QQuickAnchorChanges);
if (!d->target)
return;
d->toHeight = d->target->height();
}
-#include <moc_qsgstateoperations_p.cpp>
+#include <moc_qquickstateoperations_p.cpp>
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGSTATEOPERATIONS_H
-#define QSGSTATEOPERATIONS_H
+#ifndef QQUICKSTATEOPERATIONS_P_H
+#define QQUICKSTATEOPERATIONS_P_H
-#include "qsgitem.h"
-#include "qsganchors_p.h"
+#include "qquickitem.h"
+#include "qquickanchors_p.h"
#include <private/qdeclarativestate_p.h>
QT_MODULE(Declarative)
-class QSGParentChangePrivate;
-class Q_AUTOTEST_EXPORT QSGParentChange : public QDeclarativeStateOperation, public QDeclarativeActionEvent
+class QQuickParentChangePrivate;
+class Q_AUTOTEST_EXPORT QQuickParentChange : public QDeclarativeStateOperation, public QDeclarativeActionEvent
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGParentChange)
+ Q_DECLARE_PRIVATE(QQuickParentChange)
- Q_PROPERTY(QSGItem *target READ object WRITE setObject)
- Q_PROPERTY(QSGItem *parent READ parent WRITE setParent)
+ Q_PROPERTY(QQuickItem *target READ object WRITE setObject)
+ Q_PROPERTY(QQuickItem *parent READ parent WRITE setParent)
Q_PROPERTY(QDeclarativeScriptString x READ x WRITE setX)
Q_PROPERTY(QDeclarativeScriptString y READ y WRITE setY)
Q_PROPERTY(QDeclarativeScriptString width READ width WRITE setWidth)
Q_PROPERTY(QDeclarativeScriptString scale READ scale WRITE setScale)
Q_PROPERTY(QDeclarativeScriptString rotation READ rotation WRITE setRotation)
public:
- QSGParentChange(QObject *parent=0);
- ~QSGParentChange();
+ QQuickParentChange(QObject *parent=0);
+ ~QQuickParentChange();
- QSGItem *object() const;
- void setObject(QSGItem *);
+ QQuickItem *object() const;
+ void setObject(QQuickItem *);
- QSGItem *parent() const;
- void setParent(QSGItem *);
+ QQuickItem *parent() const;
+ void setParent(QQuickItem *);
- QSGItem *originalParent() const;
+ QQuickItem *originalParent() const;
QDeclarativeScriptString x() const;
void setX(QDeclarativeScriptString x);
virtual void saveCurrentValues();
};
-class QSGAnchorChanges;
-class QSGAnchorSetPrivate;
-class Q_AUTOTEST_EXPORT QSGAnchorSet : public QObject
+class QQuickAnchorChanges;
+class QQuickAnchorSetPrivate;
+class Q_AUTOTEST_EXPORT QQuickAnchorSet : public QObject
{
Q_OBJECT
Q_PROPERTY(QDeclarativeScriptString bottom READ bottom WRITE setBottom RESET resetBottom)
Q_PROPERTY(QDeclarativeScriptString verticalCenter READ verticalCenter WRITE setVerticalCenter RESET resetVerticalCenter)
Q_PROPERTY(QDeclarativeScriptString baseline READ baseline WRITE setBaseline RESET resetBaseline)
- //Q_PROPERTY(QSGItem *fill READ fill WRITE setFill RESET resetFill)
- //Q_PROPERTY(QSGItem *centerIn READ centerIn WRITE setCenterIn RESET resetCenterIn)
+ //Q_PROPERTY(QQuickItem *fill READ fill WRITE setFill RESET resetFill)
+ //Q_PROPERTY(QQuickItem *centerIn READ centerIn WRITE setCenterIn RESET resetCenterIn)
/*Q_PROPERTY(qreal margins READ margins WRITE setMargins NOTIFY marginsChanged)
Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin NOTIFY leftMarginChanged)
Q_PROPERTY(qreal baselineOffset READ baselineOffset WRITE setBaselineOffset NOTIFY baselineOffsetChanged())*/
public:
- QSGAnchorSet(QObject *parent=0);
- virtual ~QSGAnchorSet();
+ QQuickAnchorSet(QObject *parent=0);
+ virtual ~QQuickAnchorSet();
QDeclarativeScriptString left() const;
void setLeft(const QDeclarativeScriptString &edge);
void setBaseline(const QDeclarativeScriptString &edge);
void resetBaseline();
- QSGItem *fill() const;
- void setFill(QSGItem *);
+ QQuickItem *fill() const;
+ void setFill(QQuickItem *);
void resetFill();
- QSGItem *centerIn() const;
- void setCenterIn(QSGItem *);
+ QQuickItem *centerIn() const;
+ void setCenterIn(QQuickItem *);
void resetCenterIn();
/*qreal leftMargin() const;
qreal baselineOffset() const;
void setBaselineOffset(qreal);*/
- QSGAnchors::Anchors usedAnchors() const;
+ QQuickAnchors::Anchors usedAnchors() const;
/*Q_SIGNALS:
void leftMarginChanged();
void baselineOffsetChanged();*/
private:
- friend class QSGAnchorChanges;
- Q_DISABLE_COPY(QSGAnchorSet)
- Q_DECLARE_PRIVATE(QSGAnchorSet)
+ friend class QQuickAnchorChanges;
+ Q_DISABLE_COPY(QQuickAnchorSet)
+ Q_DECLARE_PRIVATE(QQuickAnchorSet)
};
-class QSGAnchorChangesPrivate;
-class Q_AUTOTEST_EXPORT QSGAnchorChanges : public QDeclarativeStateOperation, public QDeclarativeActionEvent
+class QQuickAnchorChangesPrivate;
+class Q_AUTOTEST_EXPORT QQuickAnchorChanges : public QDeclarativeStateOperation, public QDeclarativeActionEvent
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGAnchorChanges)
+ Q_DECLARE_PRIVATE(QQuickAnchorChanges)
- Q_PROPERTY(QSGItem *target READ object WRITE setObject)
- Q_PROPERTY(QSGAnchorSet *anchors READ anchors CONSTANT)
+ Q_PROPERTY(QQuickItem *target READ object WRITE setObject)
+ Q_PROPERTY(QQuickAnchorSet *anchors READ anchors CONSTANT)
public:
- QSGAnchorChanges(QObject *parent=0);
- ~QSGAnchorChanges();
+ QQuickAnchorChanges(QObject *parent=0);
+ ~QQuickAnchorChanges();
virtual ActionList actions();
- QSGAnchorSet *anchors();
+ QQuickAnchorSet *anchors();
- QSGItem *object() const;
- void setObject(QSGItem *);
+ QQuickItem *object() const;
+ void setObject(QQuickItem *);
virtual void execute(Reason reason = ActualChange);
virtual bool isReversable();
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGParentChange)
-QML_DECLARE_TYPE(QSGAnchorSet)
-QML_DECLARE_TYPE(QSGAnchorChanges)
+QML_DECLARE_TYPE(QQuickParentChange)
+QML_DECLARE_TYPE(QQuickAnchorSet)
+QML_DECLARE_TYPE(QQuickAnchorChanges)
QT_END_HEADER
-#endif // QSGSTATEOPERATIONS_H
+#endif // QQUICKSTATEOPERATIONS_P_H
**
****************************************************************************/
-#include "qsgtext_p.h"
-#include "qsgtext_p_p.h"
+#include "qquicktext_p.h"
+#include "qquicktext_p_p.h"
#include <private/qsgdistancefieldglyphcache_p.h>
#include <private/qsgcontext_p.h>
#include <private/qsgadaptationlayer_p.h>
-#include "qsgtextnode_p.h"
-#include "qsgimage_p_p.h"
+#include "qquicktextnode_p.h"
+#include "qquickimage_p_p.h"
#include <private/qsgtexture_p.h>
#include <QtDeclarative/qdeclarativeinfo.h>
extern Q_GUI_EXPORT bool qt_applefontsmoothing_enabled;
-class QSGTextDocumentWithImageResources : public QTextDocument {
+class QQuickTextDocumentWithImageResources : public QTextDocument {
Q_OBJECT
public:
- QSGTextDocumentWithImageResources(QSGText *parent);
- virtual ~QSGTextDocumentWithImageResources();
+ QQuickTextDocumentWithImageResources(QQuickText *parent);
+ virtual ~QQuickTextDocumentWithImageResources();
void setText(const QString &);
int resourcesLoading() const { return outstanding; }
DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
DEFINE_BOOL_CONFIG_OPTION(enableImageCache, QML_ENABLE_TEXT_IMAGE_CACHE);
-QString QSGTextPrivate::elideChar = QString(0x2026);
+QString QQuickTextPrivate::elideChar = QString(0x2026);
-QSGTextPrivate::QSGTextPrivate()
-: color((QRgb)0), style(QSGText::Normal), hAlign(QSGText::AlignLeft),
- vAlign(QSGText::AlignTop), elideMode(QSGText::ElideNone),
- format(QSGText::AutoText), wrapMode(QSGText::NoWrap), lineHeight(1),
- lineHeightMode(QSGText::ProportionalHeight), lineCount(1), maximumLineCount(INT_MAX),
+QQuickTextPrivate::QQuickTextPrivate()
+: color((QRgb)0), style(QQuickText::Normal), hAlign(QQuickText::AlignLeft),
+ vAlign(QQuickText::AlignTop), elideMode(QQuickText::ElideNone),
+ format(QQuickText::AutoText), wrapMode(QQuickText::NoWrap), lineHeight(1),
+ lineHeightMode(QQuickText::ProportionalHeight), lineCount(1), maximumLineCount(INT_MAX),
maximumLineCountValid(false),
texture(0),
imageCacheDirty(false), updateOnComponentComplete(true),
cacheAllTextAsImage = enableImageCache();
}
-void QSGTextPrivate::init()
+void QQuickTextPrivate::init()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
q->setAcceptedMouseButtons(Qt::LeftButton);
- q->setFlag(QSGItem::ItemHasContents);
+ q->setFlag(QQuickItem::ItemHasContents);
}
-QSGTextDocumentWithImageResources::QSGTextDocumentWithImageResources(QSGText *parent)
+QQuickTextDocumentWithImageResources::QQuickTextDocumentWithImageResources(QQuickText *parent)
: QTextDocument(parent), outstanding(0)
{
setUndoRedoEnabled(false);
}
-QSGTextDocumentWithImageResources::~QSGTextDocumentWithImageResources()
+QQuickTextDocumentWithImageResources::~QQuickTextDocumentWithImageResources()
{
if (!m_resources.isEmpty())
qDeleteAll(m_resources);
}
-QVariant QSGTextDocumentWithImageResources::loadResource(int type, const QUrl &name)
+QVariant QQuickTextDocumentWithImageResources::loadResource(int type, const QUrl &name)
{
QDeclarativeContext *context = qmlContext(parent());
QUrl url = context->resolvedUrl(name);
return QTextDocument::loadResource(type,url); // The *resolved* URL
}
-void QSGTextDocumentWithImageResources::requestFinished()
+void QQuickTextDocumentWithImageResources::requestFinished()
{
outstanding--;
if (outstanding == 0) {
- QSGText *textItem = static_cast<QSGText*>(parent());
+ QQuickText *textItem = static_cast<QQuickText*>(parent());
QString text = textItem->text();
#ifndef QT_NO_TEXTHTMLPARSER
setHtml(text);
#else
setPlainText(text);
#endif
- QSGTextPrivate *d = QSGTextPrivate::get(textItem);
+ QQuickTextPrivate *d = QQuickTextPrivate::get(textItem);
d->updateLayout();
}
}
-void QSGTextDocumentWithImageResources::setText(const QString &text)
+void QQuickTextDocumentWithImageResources::setText(const QString &text)
{
if (!m_resources.isEmpty()) {
qDeleteAll(m_resources);
#endif
}
-QSet<QUrl> QSGTextDocumentWithImageResources::errors;
+QSet<QUrl> QQuickTextDocumentWithImageResources::errors;
-QSGTextPrivate::~QSGTextPrivate()
+QQuickTextPrivate::~QQuickTextPrivate()
{
delete textLine; textLine = 0;
}
-qreal QSGTextPrivate::getImplicitWidth() const
+qreal QQuickTextPrivate::getImplicitWidth() const
{
if (!requireImplicitWidth) {
// We don't calculate implicitWidth unless it is required.
// We need to force a size update now to ensure implicitWidth is calculated
- QSGTextPrivate *me = const_cast<QSGTextPrivate*>(this);
+ QQuickTextPrivate *me = const_cast<QQuickTextPrivate*>(this);
me->requireImplicitWidth = true;
me->updateSize();
}
return implicitWidth;
}
-void QSGTextPrivate::updateLayout()
+void QQuickTextPrivate::updateLayout()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
if (!q->isComponentComplete()) {
updateOnComponentComplete = true;
return;
QString tmp = text;
tmp.replace(QLatin1Char('\n'), QChar::LineSeparator);
singleline = !tmp.contains(QChar::LineSeparator);
- if (singleline && !maximumLineCountValid && elideMode != QSGText::ElideNone && q->widthValid()) {
+ if (singleline && !maximumLineCountValid && elideMode != QQuickText::ElideNone && q->widthValid()) {
QFontMetrics fm(font);
tmp = fm.elidedText(tmp,(Qt::TextElideMode)elideMode,q->width());
if (tmp != text) {
} else {
ensureDoc();
QTextBlockFormat::LineHeightTypes type;
- type = lineHeightMode == QSGText::FixedHeight ? QTextBlockFormat::FixedHeight : QTextBlockFormat::ProportionalHeight;
+ type = lineHeightMode == QQuickText::FixedHeight ? QTextBlockFormat::FixedHeight : QTextBlockFormat::ProportionalHeight;
QTextBlockFormat blockFormat;
- blockFormat.setLineHeight((lineHeightMode == QSGText::FixedHeight ? lineHeight : lineHeight * 100), type);
+ blockFormat.setLineHeight((lineHeightMode == QQuickText::FixedHeight ? lineHeight : lineHeight * 100), type);
for (QTextBlock it = doc->begin(); it != doc->end(); it = it.next()) {
QTextCursor cursor(it);
cursor.mergeBlockFormat(blockFormat);
updateSize();
}
-void QSGTextPrivate::updateSize()
+void QQuickTextPrivate::updateSize()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
if (!q->isComponentComplete()) {
updateOnComponentComplete = true;
singleline = false; // richtext can't elide or be optimized for single-line case
ensureDoc();
doc->setDefaultFont(font);
- QSGText::HAlignment horizontalAlignment = q->effectiveHAlign();
+ QQuickText::HAlignment horizontalAlignment = q->effectiveHAlign();
if (rightToLeftText) {
- if (horizontalAlignment == QSGText::AlignLeft)
- horizontalAlignment = QSGText::AlignRight;
- else if (horizontalAlignment == QSGText::AlignRight)
- horizontalAlignment = QSGText::AlignLeft;
+ if (horizontalAlignment == QQuickText::AlignLeft)
+ horizontalAlignment = QQuickText::AlignRight;
+ else if (horizontalAlignment == QQuickText::AlignRight)
+ horizontalAlignment = QQuickText::AlignLeft;
}
QTextOption option;
option.setAlignment((Qt::Alignment)int(horizontalAlignment | vAlign));
doc->setTextWidth(-1);
naturalWidth = doc->idealWidth();
}
- if (wrapMode != QSGText::NoWrap && q->widthValid())
+ if (wrapMode != QQuickText::NoWrap && q->widthValid())
doc->setTextWidth(q->width());
else
doc->setTextWidth(doc->idealWidth()); // ### Text does not align if width is not set (QTextDoc bug)
int yoff = 0;
if (q->heightValid()) {
- if (vAlign == QSGText::AlignBottom)
+ if (vAlign == QQuickText::AlignBottom)
yoff = dy;
- else if (vAlign == QSGText::AlignVCenter)
+ else if (vAlign == QQuickText::AlignVCenter)
yoff = dy/2;
}
q->setBaselineOffset(fm.ascent() + yoff);
q->update();
}
-QSGTextLine::QSGTextLine()
+QQuickTextLine::QQuickTextLine()
: QObject(), m_line(0), m_height(0)
{
}
-void QSGTextLine::setLine(QTextLine *line)
+void QQuickTextLine::setLine(QTextLine *line)
{
m_line = line;
}
-int QSGTextLine::number() const
+int QQuickTextLine::number() const
{
if (m_line)
return m_line->lineNumber();
return 0;
}
-qreal QSGTextLine::width() const
+qreal QQuickTextLine::width() const
{
if (m_line)
return m_line->width();
return 0;
}
-void QSGTextLine::setWidth(qreal width)
+void QQuickTextLine::setWidth(qreal width)
{
if (m_line)
m_line->setLineWidth(width);
}
-qreal QSGTextLine::height() const
+qreal QQuickTextLine::height() const
{
if (m_height)
return m_height;
return 0;
}
-void QSGTextLine::setHeight(qreal height)
+void QQuickTextLine::setHeight(qreal height)
{
if (m_line)
m_line->setPosition(QPointF(m_line->x(), m_line->y() - m_line->height() + height));
m_height = height;
}
-qreal QSGTextLine::x() const
+qreal QQuickTextLine::x() const
{
if (m_line)
return m_line->x();
return 0;
}
-void QSGTextLine::setX(qreal x)
+void QQuickTextLine::setX(qreal x)
{
if (m_line)
m_line->setPosition(QPointF(x, m_line->y()));
}
-qreal QSGTextLine::y() const
+qreal QQuickTextLine::y() const
{
if (m_line)
return m_line->y();
return 0;
}
-void QSGTextLine::setY(qreal y)
+void QQuickTextLine::setY(qreal y)
{
if (m_line)
m_line->setPosition(QPointF(m_line->x(), y));
}
-void QSGText::doLayout()
+void QQuickText::doLayout()
{
- Q_D(QSGText);
+ Q_D(QQuickText);
d->updateSize();
}
\endcode
*/
-bool QSGTextPrivate::isLineLaidOutConnected()
+bool QQuickTextPrivate::isLineLaidOutConnected()
{
- static int idx = this->signalIndex("lineLaidOut(QSGTextLine*)");
+ static int idx = this->signalIndex("lineLaidOut(QQuickTextLine*)");
return this->isSignalConnected(idx);
}
-void QSGTextPrivate::setupCustomLineGeometry(QTextLine &line, qreal &height, qreal elideWidth = 0)
+void QQuickTextPrivate::setupCustomLineGeometry(QTextLine &line, qreal &height, qreal elideWidth = 0)
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
#if defined(Q_OS_MAC)
if (QThread::currentThread() != paintingThread) {
linesRects.clear();
if (!textLine)
- textLine = new QSGTextLine;
+ textLine = new QQuickTextLine;
textLine->setLine(&line);
textLine->setY(height);
textLine->setHeight(0);
// use the text item's width by default if it has one and wrap is on
- if (q->widthValid() && q->wrapMode() != QSGText::NoWrap)
+ if (q->widthValid() && q->wrapMode() != QQuickText::NoWrap)
textLine->setWidth(q->width() - elideWidth);
else
textLine->setWidth(INT_MAX);
if (lineHeight != 1.0)
- textLine->setHeight((lineHeightMode == QSGText::FixedHeight) ? lineHeight : line.height() * lineHeight);
+ textLine->setHeight((lineHeightMode == QQuickText::FixedHeight) ? lineHeight : line.height() * lineHeight);
emit q->lineLaidOut(textLine);
}
/*!
- Lays out the QSGTextPrivate::layout QTextLayout in the constraints of the QSGText.
+ Lays out the QQuickTextPrivate::layout QTextLayout in the constraints of the QQuickText.
Returns the size of the final text. This can be used to position the text vertically (the text is
already absolutely positioned horizontally).
*/
-QRect QSGTextPrivate::setupTextLayout()
+QRect QQuickTextPrivate::setupTextLayout()
{
// ### text layout handling should be profiled and optimized as needed
// what about QStackTextEngine engine(tmp, d->font.font()); QTextLayout textLayout(&engine);
- Q_Q(QSGText);
+ Q_Q(QQuickText);
layout.setCacheEnabled(true);
qreal lineWidth = 0;
if (--linesLeft == 0) {
if (visibleTextLength < text.length()) {
truncate = true;
- if (elideMode == QSGText::ElideRight && q->widthValid()) {
+ if (elideMode == QQuickText::ElideRight && q->widthValid()) {
qreal elideWidth = fm.width(elideChar);
// Need to correct for alignment
if (customLayout)
br = br.united(QRectF(elidePos, QSizeF(fm.width(elideChar), fm.ascent())));
}
br = br.united(line.naturalTextRect());
- height += (lineHeightMode == QSGText::FixedHeight) ? lineHeight : line.height() * lineHeight;
+ height += (lineHeightMode == QQuickText::FixedHeight) ? lineHeight : line.height() * lineHeight;
}
if (!customLayout)
br.setHeight(height);
}
/*!
- Returns a painted version of the QSGTextPrivate::layout QTextLayout.
+ Returns a painted version of the QQuickTextPrivate::layout QTextLayout.
If \a drawStyle is true, the style color overrides all colors in the document.
*/
-QPixmap QSGTextPrivate::textLayoutImage(bool drawStyle)
+QPixmap QQuickTextPrivate::textLayoutImage(bool drawStyle)
{
QSize size = layedOutTextRect.size();
}
/*!
- Paints the QSGTextPrivate::layout QTextLayout into \a painter at \a pos. If
+ Paints the QQuickTextPrivate::layout QTextLayout into \a painter at \a pos. If
\a drawStyle is true, the style color overrides all colors in the document.
*/
-void QSGTextPrivate::drawTextLayout(QPainter *painter, const QPointF &pos, bool drawStyle)
+void QQuickTextPrivate::drawTextLayout(QPainter *painter, const QPointF &pos, bool drawStyle)
{
if (drawStyle)
painter->setPen(styleColor);
}
/*!
- Returns a painted version of the QSGTextPrivate::doc QTextDocument.
+ Returns a painted version of the QQuickTextPrivate::doc QTextDocument.
If \a drawStyle is true, the style color overrides all colors in the document.
*/
-QPixmap QSGTextPrivate::textDocumentImage(bool drawStyle)
+QPixmap QQuickTextPrivate::textDocumentImage(bool drawStyle)
{
QSize size = doc->size().toSize();
/*!
Mark the image cache as dirty.
*/
-void QSGTextPrivate::invalidateImageCache()
+void QQuickTextPrivate::invalidateImageCache()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
- if (richTextAsImage || cacheAllTextAsImage || (qmlDisableDistanceField() && style != QSGText::Normal)) { // If actually using the image cache
+ if (richTextAsImage || cacheAllTextAsImage || (qmlDisableDistanceField() && style != QQuickText::Normal)) { // If actually using the image cache
if (imageCacheDirty)
return;
/*!
Tests if the image cache is dirty, and repaints it if it is.
*/
-void QSGTextPrivate::checkImageCache()
+void QQuickTextPrivate::checkImageCache()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
if (!imageCacheDirty)
return;
if (richText) {
textImage = textDocumentImage(false);
- if (style != QSGText::Normal)
+ if (style != QQuickText::Normal)
styledImage = textDocumentImage(true); //### should use styleColor
} else {
textImage = textLayoutImage(false);
- if (style != QSGText::Normal)
+ if (style != QQuickText::Normal)
styledImage = textLayoutImage(true); //### should use styleColor
}
switch (style) {
- case QSGText::Outline:
+ case QQuickText::Outline:
imageCache = drawOutline(textImage, styledImage);
break;
- case QSGText::Sunken:
+ case QQuickText::Sunken:
imageCache = drawOutline(textImage, styledImage, -1);
break;
- case QSGText::Raised:
+ case QQuickText::Raised:
imageCache = drawOutline(textImage, styledImage, 1);
break;
default:
}
/*!
- Ensures the QSGTextPrivate::doc variable is set to a valid text document
+ Ensures the QQuickTextPrivate::doc variable is set to a valid text document
*/
-void QSGTextPrivate::ensureDoc()
+void QQuickTextPrivate::ensureDoc()
{
if (!doc) {
- Q_Q(QSGText);
- doc = new QSGTextDocumentWithImageResources(q);
+ Q_Q(QQuickText);
+ doc = new QQuickTextDocumentWithImageResources(q);
doc->setDocumentMargin(0);
}
}
/*!
Draw \a styleSource as an outline around \a source and return the new image.
*/
-QPixmap QSGTextPrivate::drawOutline(const QPixmap &source, const QPixmap &styleSource)
+QPixmap QQuickTextPrivate::drawOutline(const QPixmap &source, const QPixmap &styleSource)
{
QPixmap img = QPixmap(styleSource.width() + 2, styleSource.height() + 2);
img.fill(Qt::transparent);
/*!
Draw \a styleSource below \a source at \a yOffset and return the new image.
*/
-QPixmap QSGTextPrivate::drawOutline(const QPixmap &source, const QPixmap &styleSource, int yOffset)
+QPixmap QQuickTextPrivate::drawOutline(const QPixmap &source, const QPixmap &styleSource, int yOffset)
{
QPixmap img = QPixmap(styleSource.width() + 2, styleSource.height() + 2);
img.fill(Qt::transparent);
}
/*!
- \qmlclass Text QSGText
+ \qmlclass Text QQuickText
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The Text item allows you to add formatted text to a scene.
\sa {declarative/text/fonts}{Fonts example}
*/
-QSGText::QSGText(QSGItem *parent)
-: QSGImplicitSizeItem(*(new QSGTextPrivate), parent)
+QQuickText::QQuickText(QQuickItem *parent)
+: QQuickImplicitSizeItem(*(new QQuickTextPrivate), parent)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
d->init();
}
-QSGText::~QSGText()
+QQuickText::~QQuickText()
{
}
Text { text: "Hello"; font.capitalization: Font.AllLowercase }
\endqml
*/
-QFont QSGText::font() const
+QFont QQuickText::font() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->sourceFont;
}
-void QSGText::setFont(const QFont &font)
+void QQuickText::setFont(const QFont &font)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->sourceFont == font)
return;
The item will try to automatically determine whether the text should
be treated as styled text. This determination is made using Qt::mightBeRichText().
*/
-QString QSGText::text() const
+QString QQuickText::text() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->text;
}
-void QSGText::setText(const QString &n)
+void QQuickText::setText(const QString &n)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->text == n)
return;
}
\endqml
*/
-QColor QSGText::color() const
+QColor QQuickText::color() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->color;
}
-void QSGText::setColor(const QColor &color)
+void QQuickText::setColor(const QColor &color)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->color == color)
return;
\image declarative-textstyle.png
*/
-QSGText::TextStyle QSGText::style() const
+QQuickText::TextStyle QQuickText::style() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->style;
}
-void QSGText::setStyle(QSGText::TextStyle style)
+void QQuickText::setStyle(QQuickText::TextStyle style)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->style == style)
return;
\sa style
*/
-QColor QSGText::styleColor() const
+QColor QQuickText::styleColor() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->styleColor;
}
-void QSGText::setStyleColor(const QColor &color)
+void QQuickText::setStyleColor(const QColor &color)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->styleColor == color)
return;
\c horizontalAlignment will remain unchanged. To query the effective horizontal alignment
of Text, use the read-only property \c effectiveHorizontalAlignment.
*/
-QSGText::HAlignment QSGText::hAlign() const
+QQuickText::HAlignment QQuickText::hAlign() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->hAlign;
}
-void QSGText::setHAlign(HAlignment align)
+void QQuickText::setHAlign(HAlignment align)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
bool forceAlign = d->hAlignImplicit && d->effectiveLayoutMirror;
d->hAlignImplicit = false;
if (d->setHAlign(align, forceAlign) && isComponentComplete())
d->updateLayout();
}
-void QSGText::resetHAlign()
+void QQuickText::resetHAlign()
{
- Q_D(QSGText);
+ Q_D(QQuickText);
d->hAlignImplicit = true;
if (d->determineHorizontalAlignment() && isComponentComplete())
d->updateLayout();
}
-QSGText::HAlignment QSGText::effectiveHAlign() const
+QQuickText::HAlignment QQuickText::effectiveHAlign() const
{
- Q_D(const QSGText);
- QSGText::HAlignment effectiveAlignment = d->hAlign;
+ Q_D(const QQuickText);
+ QQuickText::HAlignment effectiveAlignment = d->hAlign;
if (!d->hAlignImplicit && d->effectiveLayoutMirror) {
switch (d->hAlign) {
- case QSGText::AlignLeft:
- effectiveAlignment = QSGText::AlignRight;
+ case QQuickText::AlignLeft:
+ effectiveAlignment = QQuickText::AlignRight;
break;
- case QSGText::AlignRight:
- effectiveAlignment = QSGText::AlignLeft;
+ case QQuickText::AlignRight:
+ effectiveAlignment = QQuickText::AlignLeft;
break;
default:
break;
return effectiveAlignment;
}
-bool QSGTextPrivate::setHAlign(QSGText::HAlignment alignment, bool forceAlign)
+bool QQuickTextPrivate::setHAlign(QQuickText::HAlignment alignment, bool forceAlign)
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
if (hAlign != alignment || forceAlign) {
- QSGText::HAlignment oldEffectiveHAlign = q->effectiveHAlign();
+ QQuickText::HAlignment oldEffectiveHAlign = q->effectiveHAlign();
hAlign = alignment;
emit q->horizontalAlignmentChanged(hAlign);
return false;
}
-bool QSGTextPrivate::determineHorizontalAlignment()
+bool QQuickTextPrivate::determineHorizontalAlignment()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
if (hAlignImplicit && q->isComponentComplete()) {
bool alignToRight = text.isEmpty() ? QGuiApplication::keyboardInputDirection() == Qt::RightToLeft : rightToLeftText;
- return setHAlign(alignToRight ? QSGText::AlignRight : QSGText::AlignLeft);
+ return setHAlign(alignToRight ? QQuickText::AlignRight : QQuickText::AlignLeft);
}
return false;
}
-void QSGTextPrivate::mirrorChange()
+void QQuickTextPrivate::mirrorChange()
{
- Q_Q(QSGText);
+ Q_Q(QQuickText);
if (q->isComponentComplete()) {
- if (!hAlignImplicit && (hAlign == QSGText::AlignRight || hAlign == QSGText::AlignLeft)) {
+ if (!hAlignImplicit && (hAlign == QQuickText::AlignRight || hAlign == QQuickText::AlignLeft)) {
updateLayout();
emit q->effectiveHorizontalAlignmentChanged();
}
}
}
-QTextDocument *QSGTextPrivate::textDocument()
+QTextDocument *QQuickTextPrivate::textDocument()
{
return doc;
}
-QSGText::VAlignment QSGText::vAlign() const
+QQuickText::VAlignment QQuickText::vAlign() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->vAlign;
}
-void QSGText::setVAlign(VAlignment align)
+void QQuickText::setVAlign(VAlignment align)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->vAlign == align)
return;
\o Text.Wrap - if possible, wrapping occurs at a word boundary; otherwise it will occur at the appropriate point on the line, even in the middle of a word.
\endlist
*/
-QSGText::WrapMode QSGText::wrapMode() const
+QQuickText::WrapMode QQuickText::wrapMode() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->wrapMode;
}
-void QSGText::setWrapMode(WrapMode mode)
+void QQuickText::setWrapMode(WrapMode mode)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (mode == d->wrapMode)
return;
\sa maximumLineCount
*/
-int QSGText::lineCount() const
+int QQuickText::lineCount() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->lineCount;
}
\sa maximumLineCount, elide
*/
-bool QSGText::truncated() const
+bool QQuickText::truncated() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->truncated;
}
\sa lineCount, elide
*/
-int QSGText::maximumLineCount() const
+int QQuickText::maximumLineCount() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->maximumLineCount;
}
-void QSGText::setMaximumLineCount(int lines)
+void QQuickText::setMaximumLineCount(int lines)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
d->maximumLineCountValid = lines==INT_MAX ? false : true;
if (d->maximumLineCount != lines) {
}
}
-void QSGText::resetMaximumLineCount()
+void QQuickText::resetMaximumLineCount()
{
- Q_D(QSGText);
+ Q_D(QQuickText);
setMaximumLineCount(INT_MAX);
d->elidePos = QPointF();
if (d->truncated != false) {
\o \image declarative-textformat.png
\endtable
*/
-QSGText::TextFormat QSGText::textFormat() const
+QQuickText::TextFormat QQuickText::textFormat() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->format;
}
-void QSGText::setTextFormat(TextFormat format)
+void QQuickText::setTextFormat(TextFormat format)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (format == d->format)
return;
d->format = format;
Multi-length strings are ordered from longest to shortest, separated by the
Unicode "String Terminator" character \c U009C (write this in QML with \c{"\u009C"} or \c{"\x9C"}).
*/
-QSGText::TextElideMode QSGText::elideMode() const
+QQuickText::TextElideMode QQuickText::elideMode() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->elideMode;
}
-void QSGText::setElideMode(QSGText::TextElideMode mode)
+void QQuickText::setElideMode(QQuickText::TextElideMode mode)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (mode == d->elideMode)
return;
}
/*! \internal */
-QRectF QSGText::boundingRect() const
+QRectF QQuickText::boundingRect() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
QRect rect = d->layedOutTextRect;
if (d->style != Normal)
}
/*! \internal */
-void QSGText::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickText::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if ((!d->internalWidthUpdate && newGeometry.width() != oldGeometry.width())
- && (d->wrapMode != QSGText::NoWrap
- || d->elideMode != QSGText::ElideNone
- || d->hAlign != QSGText::AlignLeft)) {
- if ((d->singleline || d->maximumLineCountValid) && d->elideMode != QSGText::ElideNone && widthValid()) {
+ && (d->wrapMode != QQuickText::NoWrap
+ || d->elideMode != QQuickText::ElideNone
+ || d->hAlign != QQuickText::AlignLeft)) {
+ if ((d->singleline || d->maximumLineCountValid) && d->elideMode != QQuickText::ElideNone && widthValid()) {
// We need to re-elide
d->updateLayout();
} else {
}
}
- QSGItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickItem::geometryChanged(newGeometry, oldGeometry);
}
-QSGNode *QSGText::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+QSGNode *QQuickText::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
Q_UNUSED(data);
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->text.isEmpty()) {
delete oldNode;
d->updateLayout();
#endif
- // XXX todo - some styled text can be done by the QSGTextNode
+ // XXX todo - some styled text can be done by the QQuickTextNode
if (d->richTextAsImage || d->cacheAllTextAsImage || (qmlDisableDistanceField() && d->style != Normal)) {
bool wasDirty = d->textureImageCacheDirty;
d->textureImageCacheDirty = false;
}
QSGImageNode *node = 0;
- if (!oldNode || d->nodeType != QSGTextPrivate::NodeIsTexture) {
+ if (!oldNode || d->nodeType != QQuickTextPrivate::NodeIsTexture) {
delete oldNode;
- node = QSGItemPrivate::get(this)->sceneGraphContext()->createImageNode();
+ node = QQuickItemPrivate::get(this)->sceneGraphContext()->createImageNode();
d->texture = new QSGPlainTexture();
wasDirty = true;
- d->nodeType = QSGTextPrivate::NodeIsTexture;
+ d->nodeType = QQuickTextPrivate::NodeIsTexture;
} else {
node = static_cast<QSGImageNode *>(oldNode);
Q_ASSERT(d->texture);
return node;
} else {
- QSGTextNode *node = 0;
- if (!oldNode || d->nodeType != QSGTextPrivate::NodeIsText) {
+ QQuickTextNode *node = 0;
+ if (!oldNode || d->nodeType != QQuickTextPrivate::NodeIsText) {
delete oldNode;
- node = new QSGTextNode(QSGItemPrivate::get(this)->sceneGraphContext());
- d->nodeType = QSGTextPrivate::NodeIsText;
+ node = new QQuickTextNode(QQuickItemPrivate::get(this)->sceneGraphContext());
+ d->nodeType = QQuickTextPrivate::NodeIsText;
} else {
- node = static_cast<QSGTextNode *>(oldNode);
+ node = static_cast<QQuickTextNode *>(oldNode);
}
node->deleteContent();
}
}
-bool QSGText::event(QEvent *e)
+bool QQuickText::event(QEvent *e)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (e->type() == QEvent::User) {
d->checkImageCache();
return true;
} else {
- return QSGImplicitSizeItem::event(e);
+ return QQuickImplicitSizeItem::event(e);
}
}
Returns the width of the text, including width past the width
which is covered due to insufficient wrapping if WrapMode is set.
*/
-qreal QSGText::paintedWidth() const
+qreal QQuickText::paintedWidth() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->paintedSize.width();
}
Returns the height of the text, including height past the height
which is covered due to there being more text than fits in the set height.
*/
-qreal QSGText::paintedHeight() const
+qreal QQuickText::paintedHeight() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->paintedSize.height();
}
The default value is a multiplier of 1.0.
The line height must be a positive value.
*/
-qreal QSGText::lineHeight() const
+qreal QQuickText::lineHeight() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->lineHeight;
}
-void QSGText::setLineHeight(qreal lineHeight)
+void QQuickText::setLineHeight(qreal lineHeight)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if ((d->lineHeight == lineHeight) || (lineHeight < 0.0))
return;
\o Text.FixedHeight - this sets the line height to a fixed line height (in pixels).
\endlist
*/
-QSGText::LineHeightMode QSGText::lineHeightMode() const
+QQuickText::LineHeightMode QQuickText::lineHeightMode() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->lineHeightMode;
}
-void QSGText::setLineHeightMode(LineHeightMode mode)
+void QQuickText::setLineHeightMode(LineHeightMode mode)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (mode == d->lineHeightMode)
return;
/*!
Returns the number of resources (images) that are being loaded asynchronously.
*/
-int QSGText::resourcesLoading() const
+int QQuickText::resourcesLoading() const
{
- Q_D(const QSGText);
+ Q_D(const QQuickText);
return d->doc ? d->doc->resourcesLoading() : 0;
}
/*! \internal */
-void QSGText::componentComplete()
+void QQuickText::componentComplete()
{
- Q_D(QSGText);
- QSGItem::componentComplete();
+ Q_D(QQuickText);
+ QQuickItem::componentComplete();
if (d->updateOnComponentComplete) {
d->updateOnComponentComplete = false;
if (d->richText) {
}
-QString QSGTextPrivate::anchorAt(const QPointF &mousePos)
+QString QQuickTextPrivate::anchorAt(const QPointF &mousePos)
{
if (styledText) {
for (int i = 0; i < layout.lineCount(); ++i) {
return QString();
}
-bool QSGTextPrivate::isLinkActivatedConnected()
+bool QQuickTextPrivate::isLinkActivatedConnected()
{
static int idx = this->signalIndex("linkActivated(QString)");
return this->isSignalConnected(idx);
}
/*! \internal */
-void QSGText::mousePressEvent(QMouseEvent *event)
+void QQuickText::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
if (d->isLinkActivatedConnected()) {
if (d->styledText)
// ### may malfunction if two of the same links are clicked & dragged onto each other)
if (!event->isAccepted())
- QSGItem::mousePressEvent(event);
+ QQuickItem::mousePressEvent(event);
}
/*! \internal */
-void QSGText::mouseReleaseEvent(QMouseEvent *event)
+void QQuickText::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGText);
+ Q_D(QQuickText);
// ### confirm the link, and send a signal out
event->setAccepted(false);
if (!event->isAccepted())
- QSGItem::mouseReleaseEvent(event);
+ QQuickItem::mouseReleaseEvent(event);
}
QT_END_NAMESPACE
-#include "qsgtext.moc"
+#include "qquicktext.moc"
**
****************************************************************************/
-#ifndef QSGTEXT_P_H
-#define QSGTEXT_P_H
+#ifndef QQUICKTEXT_P_H
+#define QQUICKTEXT_P_H
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p.h"
#include <private/qdeclarativeglobal_p.h>
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class QSGTextPrivate;
-class QSGTextLine;
-class Q_DECLARATIVE_PRIVATE_EXPORT QSGText : public QSGImplicitSizeItem
+class QQuickTextPrivate;
+class QQuickTextLine;
+class Q_DECLARATIVE_PRIVATE_EXPORT QQuickText : public QQuickImplicitSizeItem
{
Q_OBJECT
Q_ENUMS(HAlignment)
Q_PROPERTY(LineHeightMode lineHeightMode READ lineHeightMode WRITE setLineHeightMode NOTIFY lineHeightModeChanged)
public:
- QSGText(QSGItem *parent=0);
- ~QSGText();
+ QQuickText(QQuickItem *parent=0);
+ ~QQuickText();
enum HAlignment { AlignLeft = Qt::AlignLeft,
AlignRight = Qt::AlignRight,
void lineHeightChanged(qreal lineHeight);
void lineHeightModeChanged(LineHeightMode mode);
void effectiveHorizontalAlignmentChanged();
- void lineLaidOut(QSGTextLine *line);
+ void lineLaidOut(QQuickTextLine *line);
protected:
void mousePressEvent(QMouseEvent *event);
virtual bool event(QEvent *);
private:
- Q_DISABLE_COPY(QSGText)
- Q_DECLARE_PRIVATE(QSGText)
+ Q_DISABLE_COPY(QQuickText)
+ Q_DECLARE_PRIVATE(QQuickText)
};
class QTextLine;
-class Q_AUTOTEST_EXPORT QSGTextLine : public QObject
+class Q_AUTOTEST_EXPORT QQuickTextLine : public QObject
{
Q_OBJECT
Q_PROPERTY(int number READ number)
Q_PROPERTY(qreal y READ y WRITE setY)
public:
- QSGTextLine();
+ QQuickTextLine();
void setLine(QTextLine* line);
int number() const;
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGText)
-QML_DECLARE_TYPE(QSGTextLine)
+QML_DECLARE_TYPE(QQuickText)
+QML_DECLARE_TYPE(QQuickTextLine)
QT_END_HEADER
-#endif // QSGTEXT_P_H
+#endif // QQUICKTEXT_P_H
**
****************************************************************************/
-#ifndef QSGTEXT_P_P_H
-#define QSGTEXT_P_P_H
+#ifndef QQUICKTEXT_P_P_H
+#define QQUICKTEXT_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgitem.h"
-#include "qsgimplicitsizeitem_p_p.h"
+#include "qquickitem.h"
+#include "qquickimplicitsizeitem_p_p.h"
#include <QtDeclarative/qdeclarative.h>
#include <QtGui/qtextlayout.h>
QT_BEGIN_NAMESPACE
class QTextLayout;
-class QSGTextDocumentWithImageResources;
+class QQuickTextDocumentWithImageResources;
class QSGPlainTexture;
-class Q_AUTOTEST_EXPORT QSGTextPrivate : public QSGImplicitSizeItemPrivate
+class Q_AUTOTEST_EXPORT QQuickTextPrivate : public QQuickImplicitSizeItemPrivate
{
- Q_DECLARE_PUBLIC(QSGText)
+ Q_DECLARE_PUBLIC(QQuickText)
public:
- QSGTextPrivate();
- ~QSGTextPrivate();
+ QQuickTextPrivate();
+ ~QQuickTextPrivate();
void init();
void updateSize();
void updateLayout();
bool determineHorizontalAlignment();
- bool setHAlign(QSGText::HAlignment, bool forceAlign = false);
+ bool setHAlign(QQuickText::HAlignment, bool forceAlign = false);
void mirrorChange();
QTextDocument *textDocument();
bool isLineLaidOutConnected();
QFont font;
QFont sourceFont;
QColor color;
- QSGText::TextStyle style;
+ QQuickText::TextStyle style;
QColor styleColor;
QString activeLink;
- QSGText::HAlignment hAlign;
- QSGText::VAlignment vAlign;
- QSGText::TextElideMode elideMode;
- QSGText::TextFormat format;
- QSGText::WrapMode wrapMode;
+ QQuickText::HAlignment hAlign;
+ QQuickText::VAlignment vAlign;
+ QQuickText::TextElideMode elideMode;
+ QQuickText::TextFormat format;
+ QQuickText::WrapMode wrapMode;
qreal lineHeight;
- QSGText::LineHeightMode lineHeightMode;
+ QQuickText::LineHeightMode lineHeightMode;
int lineCount;
int maximumLineCount;
int maximumLineCountValid;
void ensureDoc();
QPixmap textDocumentImage(bool drawStyle);
- QSGTextDocumentWithImageResources *doc;
+ QQuickTextDocumentWithImageResources *doc;
QRect setupTextLayout();
void setupCustomLineGeometry(QTextLine &line, qreal &height, qreal elideWidth);
QString anchorAt(const QPointF &pos);
QTextLayout layout;
QList<QRectF> linesRects;
- QSGTextLine *textLine;
+ QQuickTextLine *textLine;
static QPixmap drawOutline(const QPixmap &source, const QPixmap &styleSource);
static QPixmap drawOutline(const QPixmap &source, const QPixmap &styleSource, int yOffset);
- static inline QSGTextPrivate *get(QSGText *t) {
+ static inline QQuickTextPrivate *get(QQuickText *t) {
return t->d_func();
}
QT_END_NAMESPACE
-#endif // QSGTEXT_P_P_H
+#endif // QQUICKTEXT_P_P_H
**
****************************************************************************/
-#include "qsgtextedit_p.h"
-#include "qsgtextedit_p_p.h"
-#include "qsgevents_p_p.h"
-#include "qsgcanvas.h"
-#include "qsgtextnode_p.h"
+#include "qquicktextedit_p.h"
+#include "qquicktextedit_p_p.h"
+#include "qquickevents_p_p.h"
+#include "qquickcanvas.h"
+#include "qquicktextnode_p.h"
#include "qsgsimplerectnode.h"
#include <QtDeclarative/qdeclarativeinfo.h>
DEFINE_BOOL_CONFIG_OPTION(qmlEnableImageCache, QML_ENABLE_TEXT_IMAGE_CACHE)
/*!
- \qmlclass TextEdit QSGTextEdit
+ \qmlclass TextEdit QQuickTextEdit
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The TextEdit item displays multiple lines of editable formatted text.
The link must be in rich text or HTML format and the
\a link string provides access to the particular link.
*/
-QSGTextEdit::QSGTextEdit(QSGItem *parent)
-: QSGImplicitSizeItem(*(new QSGTextEditPrivate), parent)
+QQuickTextEdit::QQuickTextEdit(QQuickItem *parent)
+: QQuickImplicitSizeItem(*(new QQuickTextEditPrivate), parent)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->init();
}
-QString QSGTextEdit::text() const
+QString QQuickTextEdit::text() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
#ifndef QT_NO_TEXTHTMLPARSER
if (d->richText)
automatically determine whether the text should be treated as
rich text. This determination is made using Qt::mightBeRichText().
*/
-void QSGTextEdit::setText(const QString &text)
+void QQuickTextEdit::setText(const QString &text)
{
- Q_D(QSGTextEdit);
- if (QSGTextEdit::text() == text)
+ Q_D(QQuickTextEdit);
+ if (QQuickTextEdit::text() == text)
return;
d->richText = d->format == RichText || (d->format == AutoText && Qt::mightBeRichText(text));
\o \image declarative-textformat.png
\endtable
*/
-QSGTextEdit::TextFormat QSGTextEdit::textFormat() const
+QQuickTextEdit::TextFormat QQuickTextEdit::textFormat() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->format;
}
-void QSGTextEdit::setTextFormat(TextFormat format)
+void QQuickTextEdit::setTextFormat(TextFormat format)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (format == d->format)
return;
bool wasRich = d->richText;
emit textFormatChanged(d->format);
}
-QFont QSGTextEdit::font() const
+QFont QQuickTextEdit::font() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->sourceFont;
}
-void QSGTextEdit::setFont(const QFont &font)
+void QQuickTextEdit::setFont(const QFont &font)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->sourceFont == font)
return;
TextEdit { color: "steelblue" }
\endqml
*/
-QColor QSGTextEdit::color() const
+QColor QQuickTextEdit::color() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->color;
}
-void QSGTextEdit::setColor(const QColor &color)
+void QQuickTextEdit::setColor(const QColor &color)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->color == color)
return;
The text highlight color, used behind selections.
*/
-QColor QSGTextEdit::selectionColor() const
+QColor QQuickTextEdit::selectionColor() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->selectionColor;
}
-void QSGTextEdit::setSelectionColor(const QColor &color)
+void QQuickTextEdit::setSelectionColor(const QColor &color)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->selectionColor == color)
return;
The selected text color, used in selections.
*/
-QColor QSGTextEdit::selectedTextColor() const
+QColor QQuickTextEdit::selectedTextColor() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->selectedTextColor;
}
-void QSGTextEdit::setSelectedTextColor(const QColor &color)
+void QQuickTextEdit::setSelectedTextColor(const QColor &color)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->selectedTextColor == color)
return;
\c horizontalAlignment will remain unchanged. To query the effective horizontal alignment
of TextEdit, use the read-only property \c effectiveHorizontalAlignment.
*/
-QSGTextEdit::HAlignment QSGTextEdit::hAlign() const
+QQuickTextEdit::HAlignment QQuickTextEdit::hAlign() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->hAlign;
}
-void QSGTextEdit::setHAlign(HAlignment align)
+void QQuickTextEdit::setHAlign(HAlignment align)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
bool forceAlign = d->hAlignImplicit && d->effectiveLayoutMirror;
d->hAlignImplicit = false;
if (d->setHAlign(align, forceAlign) && isComponentComplete()) {
}
}
-void QSGTextEdit::resetHAlign()
+void QQuickTextEdit::resetHAlign()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->hAlignImplicit = true;
if (d->determineHorizontalAlignment() && isComponentComplete()) {
d->updateDefaultTextOption();
}
}
-QSGTextEdit::HAlignment QSGTextEdit::effectiveHAlign() const
+QQuickTextEdit::HAlignment QQuickTextEdit::effectiveHAlign() const
{
- Q_D(const QSGTextEdit);
- QSGTextEdit::HAlignment effectiveAlignment = d->hAlign;
+ Q_D(const QQuickTextEdit);
+ QQuickTextEdit::HAlignment effectiveAlignment = d->hAlign;
if (!d->hAlignImplicit && d->effectiveLayoutMirror) {
switch (d->hAlign) {
- case QSGTextEdit::AlignLeft:
- effectiveAlignment = QSGTextEdit::AlignRight;
+ case QQuickTextEdit::AlignLeft:
+ effectiveAlignment = QQuickTextEdit::AlignRight;
break;
- case QSGTextEdit::AlignRight:
- effectiveAlignment = QSGTextEdit::AlignLeft;
+ case QQuickTextEdit::AlignRight:
+ effectiveAlignment = QQuickTextEdit::AlignLeft;
break;
default:
break;
return effectiveAlignment;
}
-bool QSGTextEditPrivate::setHAlign(QSGTextEdit::HAlignment alignment, bool forceAlign)
+bool QQuickTextEditPrivate::setHAlign(QQuickTextEdit::HAlignment alignment, bool forceAlign)
{
- Q_Q(QSGTextEdit);
+ Q_Q(QQuickTextEdit);
if (hAlign != alignment || forceAlign) {
- QSGTextEdit::HAlignment oldEffectiveHAlign = q->effectiveHAlign();
+ QQuickTextEdit::HAlignment oldEffectiveHAlign = q->effectiveHAlign();
hAlign = alignment;
emit q->horizontalAlignmentChanged(alignment);
if (oldEffectiveHAlign != q->effectiveHAlign())
return false;
}
-bool QSGTextEditPrivate::determineHorizontalAlignment()
+bool QQuickTextEditPrivate::determineHorizontalAlignment()
{
- Q_Q(QSGTextEdit);
+ Q_Q(QQuickTextEdit);
if (hAlignImplicit && q->isComponentComplete()) {
bool alignToRight = text.isEmpty() ? QGuiApplication::keyboardInputDirection() == Qt::RightToLeft : rightToLeftText;
- return setHAlign(alignToRight ? QSGTextEdit::AlignRight : QSGTextEdit::AlignLeft);
+ return setHAlign(alignToRight ? QQuickTextEdit::AlignRight : QQuickTextEdit::AlignLeft);
}
return false;
}
-void QSGTextEditPrivate::mirrorChange()
+void QQuickTextEditPrivate::mirrorChange()
{
- Q_Q(QSGTextEdit);
+ Q_Q(QQuickTextEdit);
if (q->isComponentComplete()) {
- if (!hAlignImplicit && (hAlign == QSGTextEdit::AlignRight || hAlign == QSGTextEdit::AlignLeft)) {
+ if (!hAlignImplicit && (hAlign == QQuickTextEdit::AlignRight || hAlign == QQuickTextEdit::AlignLeft)) {
updateDefaultTextOption();
q->updateSize();
emit q->effectiveHorizontalAlignmentChanged();
}
}
-QSGTextEdit::VAlignment QSGTextEdit::vAlign() const
+QQuickTextEdit::VAlignment QQuickTextEdit::vAlign() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->vAlign;
}
-void QSGTextEdit::setVAlign(QSGTextEdit::VAlignment alignment)
+void QQuickTextEdit::setVAlign(QQuickTextEdit::VAlignment alignment)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (alignment == d->vAlign)
return;
d->vAlign = alignment;
The default is TextEdit.NoWrap. If you set a width, consider using TextEdit.Wrap.
*/
-QSGTextEdit::WrapMode QSGTextEdit::wrapMode() const
+QQuickTextEdit::WrapMode QQuickTextEdit::wrapMode() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->wrapMode;
}
-void QSGTextEdit::setWrapMode(WrapMode mode)
+void QQuickTextEdit::setWrapMode(WrapMode mode)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (mode == d->wrapMode)
return;
d->wrapMode = mode;
Returns the total number of lines in the textEdit item.
*/
-int QSGTextEdit::lineCount() const
+int QQuickTextEdit::lineCount() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->lineCount;
}
Returns the width of the text, including the width past the width
which is covered due to insufficient wrapping if \l wrapMode is set.
*/
-qreal QSGTextEdit::paintedWidth() const
+qreal QQuickTextEdit::paintedWidth() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->paintedSize.width();
}
Returns the height of the text, including the height past the height
that is covered if the text does not fit within the set height.
*/
-qreal QSGTextEdit::paintedHeight() const
+qreal QQuickTextEdit::paintedHeight() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->paintedSize.height();
}
and height properties correspond to the cursor that would describe
that position.
*/
-QRectF QSGTextEdit::positionToRectangle(int pos) const
+QRectF QQuickTextEdit::positionToRectangle(int pos) const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
QTextCursor c(d->document);
c.setPosition(pos);
return d->control->cursorRect(c);
Position 0 is before the first character, position 1 is after the first character
but before the second, and so on until position \l {text}.length, which is after all characters.
*/
-int QSGTextEdit::positionAt(int x, int y) const
+int QQuickTextEdit::positionAt(int x, int y) const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
int r = d->document->documentLayout()->hitTest(QPoint(x,y-d->yoff), Qt::FuzzyHit);
QTextCursor cursor = d->control->textCursor();
if (r > cursor.position()) {
The same sequence with TextEdit.SelectWords will extend the selection start to a word boundary
before or on position 5 and extend the selection end to a word boundary on or past position 9.
*/
-void QSGTextEdit::moveCursorSelection(int pos)
+void QQuickTextEdit::moveCursorSelection(int pos)
{
//Note that this is the same as setCursorPosition but with the KeepAnchor flag set
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
QTextCursor cursor = d->control->textCursor();
if (cursor.position() == pos)
return;
d->control->setTextCursor(cursor);
}
-void QSGTextEdit::moveCursorSelection(int pos, SelectionMode mode)
+void QQuickTextEdit::moveCursorSelection(int pos, SelectionMode mode)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
QTextCursor cursor = d->control->textCursor();
if (cursor.position() == pos)
return;
This property is set and unset when the text edit gets active focus, but it can also
be set directly (useful, for example, if a KeyProxy might forward keys to it).
*/
-bool QSGTextEdit::isCursorVisible() const
+bool QQuickTextEdit::isCursorVisible() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->cursorVisible;
}
-void QSGTextEdit::setCursorVisible(bool on)
+void QQuickTextEdit::setCursorVisible(bool on)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->cursorVisible == on)
return;
d->cursorVisible = on;
\qmlproperty int QtQuick2::TextEdit::cursorPosition
The position of the cursor in the TextEdit.
*/
-int QSGTextEdit::cursorPosition() const
+int QQuickTextEdit::cursorPosition() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->control->textCursor().position();
}
-void QSGTextEdit::setCursorPosition(int pos)
+void QQuickTextEdit::setCursorPosition(int pos)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (pos < 0 || pos > d->text.length())
return;
QTextCursor cursor = d->control->textCursor();
Note that the root item of the delegate component must be a QDeclarativeItem or
QDeclarativeItem derived item.
*/
-QDeclarativeComponent* QSGTextEdit::cursorDelegate() const
+QDeclarativeComponent* QQuickTextEdit::cursorDelegate() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->cursorComponent;
}
-void QSGTextEdit::setCursorDelegate(QDeclarativeComponent* c)
+void QQuickTextEdit::setCursorDelegate(QDeclarativeComponent* c)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->cursorComponent) {
if (d->cursor) {
d->control->setCursorWidth(-1);
emit cursorDelegateChanged();
}
-void QSGTextEdit::loadCursorDelegate()
+void QQuickTextEdit::loadCursorDelegate()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->cursorComponent->isLoading())
return;
QDeclarativeContext *creationContext = d->cursorComponent->creationContext();
QObject *object = d->cursorComponent->create(creationContext ? creationContext : qmlContext(this));
- d->cursor = qobject_cast<QSGItem*>(object);
+ d->cursor = qobject_cast<QQuickItem*>(object);
if (d->cursor) {
d->control->setCursorWidth(0);
updateCursor();
\sa selectionEnd, cursorPosition, selectedText
*/
-int QSGTextEdit::selectionStart() const
+int QQuickTextEdit::selectionStart() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->control->textCursor().selectionStart();
}
\sa selectionStart, cursorPosition, selectedText
*/
-int QSGTextEdit::selectionEnd() const
+int QQuickTextEdit::selectionEnd() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->control->textCursor().selectionEnd();
}
myTextEdit.selectionEnd);
\endcode
*/
-QString QSGTextEdit::selectedText() const
+QString QQuickTextEdit::selectedText() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->control->textCursor().selectedText();
}
Whether the TextEdit should gain active focus on a mouse press. By default this is
set to true.
*/
-bool QSGTextEdit::focusOnPress() const
+bool QQuickTextEdit::focusOnPress() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->focusOnPress;
}
-void QSGTextEdit::setFocusOnPress(bool on)
+void QQuickTextEdit::setFocusOnPress(bool on)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->focusOnPress == on)
return;
d->focusOnPress = on;
Whether the TextEdit should keep the selection visible when it loses active focus to another
item in the scene. By default this is set to true;
*/
-bool QSGTextEdit::persistentSelection() const
+bool QQuickTextEdit::persistentSelection() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->persistentSelection;
}
-void QSGTextEdit::setPersistentSelection(bool on)
+void QQuickTextEdit::setPersistentSelection(bool on)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->persistentSelection == on)
return;
d->persistentSelection = on;
The margin, in pixels, around the text in the TextEdit.
*/
-qreal QSGTextEdit::textMargin() const
+qreal QQuickTextEdit::textMargin() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->textMargin;
}
-void QSGTextEdit::setTextMargin(qreal margin)
+void QQuickTextEdit::setTextMargin(qreal margin)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->textMargin == margin)
return;
d->textMargin = margin;
emit textMarginChanged(d->textMargin);
}
-void QSGTextEdit::geometryChanged(const QRectF &newGeometry,
+void QQuickTextEdit::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
if (newGeometry.width() != oldGeometry.width())
updateSize();
- QSGImplicitSizeItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickImplicitSizeItem::geometryChanged(newGeometry, oldGeometry);
}
/*!
Ensures any delayed caching or data loading the class
needs to performed is complete.
*/
-void QSGTextEdit::componentComplete()
+void QQuickTextEdit::componentComplete()
{
- Q_D(QSGTextEdit);
- QSGImplicitSizeItem::componentComplete();
+ Q_D(QQuickTextEdit);
+ QQuickImplicitSizeItem::componentComplete();
if (d->richText)
d->useImageFallback = qmlEnableImageCache();
not be an appropriate interaction (eg. may conflict with how
the text needs to behave inside a Flickable.
*/
-bool QSGTextEdit::selectByMouse() const
+bool QQuickTextEdit::selectByMouse() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->selectByMouse;
}
-void QSGTextEdit::setSelectByMouse(bool on)
+void QQuickTextEdit::setSelectByMouse(bool on)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->selectByMouse != on) {
d->selectByMouse = on;
setKeepMouseGrab(on);
This property only applies when \l selectByMouse is true.
*/
-QSGTextEdit::SelectionMode QSGTextEdit::mouseSelectionMode() const
+QQuickTextEdit::SelectionMode QQuickTextEdit::mouseSelectionMode() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->mouseSelectionMode;
}
-void QSGTextEdit::setMouseSelectionMode(SelectionMode mode)
+void QQuickTextEdit::setMouseSelectionMode(SelectionMode mode)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->mouseSelectionMode != mode) {
d->mouseSelectionMode = mode;
d->control->setWordSelectionEnabled(mode == SelectWords);
By default this property is false.
*/
-void QSGTextEdit::setReadOnly(bool r)
+void QQuickTextEdit::setReadOnly(bool r)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (r == isReadOnly())
return;
- setFlag(QSGItem::ItemAcceptsInputMethod, !r);
+ setFlag(QQuickItem::ItemAcceptsInputMethod, !r);
Qt::TextInteractionFlags flags = Qt::LinksAccessibleByMouse;
if (d->selectByMouse)
flags = flags | Qt::TextSelectableByMouse;
emit readOnlyChanged(r);
}
-bool QSGTextEdit::isReadOnly() const
+bool QQuickTextEdit::isReadOnly() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return !(d->control->textInteractionFlags() & Qt::TextEditable);
}
Sets how the text edit should interact with user input to the given
\a flags.
*/
-void QSGTextEdit::setTextInteractionFlags(Qt::TextInteractionFlags flags)
+void QQuickTextEdit::setTextInteractionFlags(Qt::TextInteractionFlags flags)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->setTextInteractionFlags(flags);
}
Returns the flags specifying how the text edit should interact
with user input.
*/
-Qt::TextInteractionFlags QSGTextEdit::textInteractionFlags() const
+Qt::TextInteractionFlags QQuickTextEdit::textInteractionFlags() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->control->textInteractionFlags();
}
The rectangle where the text cursor is rendered
within the text edit. Read-only.
*/
-QRect QSGTextEdit::cursorRectangle() const
+QRect QQuickTextEdit::cursorRectangle() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->control->cursorRect().toRect().translated(0,d->yoff);
}
-bool QSGTextEdit::event(QEvent *event)
+bool QQuickTextEdit::event(QEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (event->type() == QEvent::ShortcutOverride) {
d->control->processEvent(event, QPointF(0, -d->yoff));
return event->isAccepted();
}
- return QSGImplicitSizeItem::event(event);
+ return QQuickImplicitSizeItem::event(event);
}
/*!
\overload
Handles the given key \a event.
*/
-void QSGTextEdit::keyPressEvent(QKeyEvent *event)
+void QQuickTextEdit::keyPressEvent(QKeyEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->processEvent(event, QPointF(0, -d->yoff));
if (!event->isAccepted())
- QSGImplicitSizeItem::keyPressEvent(event);
+ QQuickImplicitSizeItem::keyPressEvent(event);
}
/*!
\overload
Handles the given key \a event.
*/
-void QSGTextEdit::keyReleaseEvent(QKeyEvent *event)
+void QQuickTextEdit::keyReleaseEvent(QKeyEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->processEvent(event, QPointF(0, -d->yoff));
if (!event->isAccepted())
- QSGImplicitSizeItem::keyReleaseEvent(event);
+ QQuickImplicitSizeItem::keyReleaseEvent(event);
}
/*!
Removes active text selection.
*/
-void QSGTextEdit::deselect()
+void QQuickTextEdit::deselect()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
QTextCursor c = d->control->textCursor();
c.clearSelection();
d->control->setTextCursor(c);
Causes all text to be selected.
*/
-void QSGTextEdit::selectAll()
+void QQuickTextEdit::selectAll()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->selectAll();
}
Causes the word closest to the current cursor position to be selected.
*/
-void QSGTextEdit::selectWord()
+void QQuickTextEdit::selectWord()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
QTextCursor c = d->control->textCursor();
c.select(QTextCursor::WordUnderCursor);
d->control->setTextCursor(c);
\sa selectionStart, selectionEnd
*/
-void QSGTextEdit::select(int start, int end)
+void QQuickTextEdit::select(int start, int end)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (start < 0 || end < 0 || start > d->text.length() || end > d->text.length())
return;
QTextCursor cursor = d->control->textCursor();
Returns true if the natural reading direction of the editor text
found between positions \a start and \a end is right to left.
*/
-bool QSGTextEdit::isRightToLeft(int start, int end)
+bool QQuickTextEdit::isRightToLeft(int start, int end)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (start > end) {
qmlInfo(this) << "isRightToLeft(start, end) called with the end property being smaller than the start.";
return false;
Moves the currently selected text to the system clipboard.
*/
-void QSGTextEdit::cut()
+void QQuickTextEdit::cut()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->cut();
}
Copies the currently selected text to the system clipboard.
*/
-void QSGTextEdit::copy()
+void QQuickTextEdit::copy()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->copy();
}
Replaces the currently selected text by the contents of the system clipboard.
*/
-void QSGTextEdit::paste()
+void QQuickTextEdit::paste()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->paste();
}
#endif // QT_NO_CLIPBOARD
\overload
Handles the given mouse \a event.
*/
-void QSGTextEdit::mousePressEvent(QMouseEvent *event)
+void QQuickTextEdit::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->focusOnPress){
bool hadActiveFocus = hasActiveFocus();
forceActiveFocus();
}
d->control->processEvent(event, QPointF(0, -d->yoff));
if (!event->isAccepted())
- QSGImplicitSizeItem::mousePressEvent(event);
+ QQuickImplicitSizeItem::mousePressEvent(event);
}
/*!
\overload
Handles the given mouse \a event.
*/
-void QSGTextEdit::mouseReleaseEvent(QMouseEvent *event)
+void QQuickTextEdit::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->processEvent(event, QPointF(0, -d->yoff));
if (!event->isAccepted())
- QSGImplicitSizeItem::mouseReleaseEvent(event);
+ QQuickImplicitSizeItem::mouseReleaseEvent(event);
}
/*!
\overload
Handles the given mouse \a event.
*/
-void QSGTextEdit::mouseDoubleClickEvent(QMouseEvent *event)
+void QQuickTextEdit::mouseDoubleClickEvent(QMouseEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->processEvent(event, QPointF(0, -d->yoff));
if (!event->isAccepted())
- QSGImplicitSizeItem::mouseDoubleClickEvent(event);
+ QQuickImplicitSizeItem::mouseDoubleClickEvent(event);
}
/*!
\overload
Handles the given mouse \a event.
*/
-void QSGTextEdit::mouseMoveEvent(QMouseEvent *event)
+void QQuickTextEdit::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->control->processEvent(event, QPointF(0, -d->yoff));
if (!event->isAccepted())
- QSGImplicitSizeItem::mouseMoveEvent(event);
+ QQuickImplicitSizeItem::mouseMoveEvent(event);
}
/*!
\overload
Handles the given input method \a event.
*/
-void QSGTextEdit::inputMethodEvent(QInputMethodEvent *event)
+void QQuickTextEdit::inputMethodEvent(QInputMethodEvent *event)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
const bool wasComposing = isInputMethodComposing();
d->control->processEvent(event, QPointF(0, -d->yoff));
if (wasComposing != isInputMethodComposing())
emit inputMethodComposingChanged();
}
-void QSGTextEdit::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickTextEdit::itemChange(ItemChange change, const ItemChangeData &value)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (change == ItemActiveFocusHasChanged) {
setCursorVisible(value.boolValue); // ### refactor: focus handling && d->canvas && d->canvas->hasFocus());
}
- QSGItem::itemChange(change, value);
+ QQuickItem::itemChange(change, value);
}
/*!
\overload
Returns the value of the given \a property.
*/
-QVariant QSGTextEdit::inputMethodQuery(Qt::InputMethodQuery property) const
+QVariant QQuickTextEdit::inputMethodQuery(Qt::InputMethodQuery property) const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
QVariant v;
switch (property) {
}
-void QSGTextEdit::updateImageCache(const QRectF &)
+void QQuickTextEdit::updateImageCache(const QRectF &)
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
// Do we really need the image cache?
if (!d->richText || !d->useImageFallback) {
}
-QSGNode *QSGTextEdit::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
+QSGNode *QQuickTextEdit::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
{
Q_UNUSED(updatePaintNodeData);
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
QSGNode *currentNode = oldNode;
if (d->richText && d->useImageFallback) {
QSGImageNode *node = 0;
- if (oldNode == 0 || d->nodeType != QSGTextEditPrivate::NodeIsTexture) {
+ if (oldNode == 0 || d->nodeType != QQuickTextEditPrivate::NodeIsTexture) {
delete oldNode;
- node = QSGItemPrivate::get(this)->sceneGraphContext()->createImageNode();
+ node = QQuickItemPrivate::get(this)->sceneGraphContext()->createImageNode();
d->texture = new QSGPlainTexture();
- d->nodeType = QSGTextEditPrivate::NodeIsTexture;
+ d->nodeType = QQuickTextEditPrivate::NodeIsTexture;
currentNode = node;
} else {
node = static_cast<QSGImageNode *>(oldNode);
d->document->markContentsDirty(0, d->document->characterCount());
#endif
- QSGTextNode *node = 0;
- if (oldNode == 0 || d->nodeType != QSGTextEditPrivate::NodeIsText) {
+ QQuickTextNode *node = 0;
+ if (oldNode == 0 || d->nodeType != QQuickTextEditPrivate::NodeIsText) {
delete oldNode;
- node = new QSGTextNode(QSGItemPrivate::get(this)->sceneGraphContext());
- d->nodeType = QSGTextEditPrivate::NodeIsText;
+ node = new QQuickTextNode(QQuickItemPrivate::get(this)->sceneGraphContext());
+ d->nodeType = QQuickTextEditPrivate::NodeIsText;
currentNode = node;
} else {
- node = static_cast<QSGTextNode *>(oldNode);
+ node = static_cast<QQuickTextNode *>(oldNode);
}
node->deleteContent();
QColor selectionColor = d->control->palette().color(QPalette::Highlight);
QColor selectedTextColor = d->control->palette().color(QPalette::HighlightedText);
- node->addTextDocument(bounds.topLeft(), d->document, d->color, QSGText::Normal, QColor(),
+ node->addTextDocument(bounds.topLeft(), d->document, d->color, QQuickText::Normal, QColor(),
selectionColor, selectedTextColor, selectionStart(),
selectionEnd() - 1); // selectionEnd() returns first char after
// selection
#endif
}
- if (d->nodeType == QSGTextEditPrivate::NodeIsText && d->cursorComponent == 0 && !isReadOnly()) {
- QSGTextNode *node = static_cast<QSGTextNode *>(currentNode);
+ if (d->nodeType == QQuickTextEditPrivate::NodeIsText && d->cursorComponent == 0 && !isReadOnly()) {
+ QQuickTextNode *node = static_cast<QQuickTextNode *>(currentNode);
QColor color = (!d->cursorVisible || !d->control->cursorOn())
? QColor(0, 0, 0, 0)
Returns true if the TextEdit is writable and the content of the clipboard is
suitable for pasting into the TextEdit.
*/
-bool QSGTextEdit::canPaste() const
+bool QQuickTextEdit::canPaste() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
return d->canPaste;
}
to determine when to disable events handlers that may interfere with the
correct operation of an input method.
*/
-bool QSGTextEdit::isInputMethodComposing() const
+bool QQuickTextEdit::isInputMethodComposing() const
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
if (QTextLayout *layout = d->control->textCursor().block().layout())
return layout->preeditAreaText().length() > 0;
return false;
}
-void QSGTextEditPrivate::init()
+void QQuickTextEditPrivate::init()
{
- Q_Q(QSGTextEdit);
+ Q_Q(QQuickTextEdit);
q->setSmooth(smooth);
q->setAcceptedMouseButtons(Qt::LeftButton);
- q->setFlag(QSGItem::ItemAcceptsInputMethod);
- q->setFlag(QSGItem::ItemHasContents);
+ q->setFlag(QQuickItem::ItemAcceptsInputMethod);
+ q->setFlag(QQuickItem::ItemHasContents);
control = new QTextControl(q);
control->setIgnoreUnusedNavigationEvents(true);
// cursor blinks.
if (!QObject::disconnect(control, SIGNAL(updateCursorRequest(QRectF)),
control, SIGNAL(updateRequest(QRectF)))) {
- qWarning("QSGTextEditPrivate::init: Failed to disconnect updateCursorRequest and updateRequest");
+ qWarning("QQuickTextEditPrivate::init: Failed to disconnect updateCursorRequest and updateRequest");
}
// QTextControl follows the default text color
updateDefaultTextOption();
}
-void QSGTextEdit::q_textChanged()
+void QQuickTextEdit::q_textChanged()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->text = text();
d->rightToLeftText = d->document->begin().layout()->engine()->isRightToLeft();
d->determineHorizontalAlignment();
emit textChanged(d->text);
}
-void QSGTextEdit::moveCursorDelegate()
+void QQuickTextEdit::moveCursorDelegate()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->determineHorizontalAlignment();
updateMicroFocus();
emit cursorRectangleChanged();
d->cursor->setY(cursorRect.y());
}
-void QSGTextEditPrivate::updateSelection()
+void QQuickTextEditPrivate::updateSelection()
{
- Q_Q(QSGTextEdit);
+ Q_Q(QQuickTextEdit);
QTextCursor cursor = control->textCursor();
bool startChange = (lastSelectionStart != cursor.selectionStart());
bool endChange = (lastSelectionEnd != cursor.selectionEnd());
q->selectionEndChanged();
}
-void QSGTextEdit::updateSelectionMarkers()
+void QQuickTextEdit::updateSelectionMarkers()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (d->lastSelectionStart != d->control->textCursor().selectionStart()) {
d->lastSelectionStart = d->control->textCursor().selectionStart();
emit selectionStartChanged();
}
}
-QRectF QSGTextEdit::boundingRect() const
+QRectF QQuickTextEdit::boundingRect() const
{
- Q_D(const QSGTextEdit);
- QRectF r = QSGImplicitSizeItem::boundingRect();
+ Q_D(const QQuickTextEdit);
+ QRectF r = QQuickImplicitSizeItem::boundingRect();
int cursorWidth = 1;
if (d->cursor)
cursorWidth = d->cursor->width();
return r.translated(0,d->yoff);
}
-qreal QSGTextEditPrivate::getImplicitWidth() const
+qreal QQuickTextEditPrivate::getImplicitWidth() const
{
- Q_Q(const QSGTextEdit);
+ Q_Q(const QQuickTextEdit);
if (!requireImplicitWidth) {
// We don't calculate implicitWidth unless it is required.
// We need to force a size update now to ensure implicitWidth is calculated
- const_cast<QSGTextEditPrivate*>(this)->requireImplicitWidth = true;
- const_cast<QSGTextEdit*>(q)->updateSize();
+ const_cast<QQuickTextEditPrivate*>(this)->requireImplicitWidth = true;
+ const_cast<QQuickTextEdit*>(q)->updateSize();
}
return implicitWidth;
}
//### we should perhaps be a bit smarter here -- depending on what has changed, we shouldn't
// need to do all the calculations each time
-void QSGTextEdit::updateSize()
+void QQuickTextEdit::updateSize()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (isComponentComplete()) {
qreal naturalWidth = d->implicitWidth;
// ### assumes that if the width is set, the text will fill to edges
updateDocument();
}
-void QSGTextEdit::updateDocument()
+void QQuickTextEdit::updateDocument()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
d->documentDirty = true;
if (isComponentComplete()) {
}
}
-void QSGTextEdit::updateCursor()
+void QQuickTextEdit::updateCursor()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
if (isComponentComplete()) {
updateImageCache(d->control->cursorRect());
update();
}
}
-void QSGTextEdit::updateTotalLines()
+void QQuickTextEdit::updateTotalLines()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
int subLines = 0;
}
}
-void QSGTextEditPrivate::updateDefaultTextOption()
+void QQuickTextEditPrivate::updateDefaultTextOption()
{
- Q_Q(QSGTextEdit);
+ Q_Q(QQuickTextEdit);
QTextOption opt = document->defaultTextOption();
int oldAlignment = opt.alignment();
- QSGTextEdit::HAlignment horizontalAlignment = q->effectiveHAlign();
+ QQuickTextEdit::HAlignment horizontalAlignment = q->effectiveHAlign();
if (rightToLeftText) {
- if (horizontalAlignment == QSGTextEdit::AlignLeft)
- horizontalAlignment = QSGTextEdit::AlignRight;
- else if (horizontalAlignment == QSGTextEdit::AlignRight)
- horizontalAlignment = QSGTextEdit::AlignLeft;
+ if (horizontalAlignment == QQuickTextEdit::AlignLeft)
+ horizontalAlignment = QQuickTextEdit::AlignRight;
+ else if (horizontalAlignment == QQuickTextEdit::AlignRight)
+ horizontalAlignment = QQuickTextEdit::AlignLeft;
}
opt.setAlignment((Qt::Alignment)(int)(horizontalAlignment | vAlign));
}
\endcode
*/
-void QSGTextEdit::openSoftwareInputPanel()
+void QQuickTextEdit::openSoftwareInputPanel()
{
if (qGuiApp)
qGuiApp->inputPanel()->show();
}
\endcode
*/
-void QSGTextEdit::closeSoftwareInputPanel()
+void QQuickTextEdit::closeSoftwareInputPanel()
{
if (qGuiApp)
qGuiApp->inputPanel()->hide();
}
-void QSGTextEdit::focusInEvent(QFocusEvent *event)
+void QQuickTextEdit::focusInEvent(QFocusEvent *event)
{
- Q_D(const QSGTextEdit);
+ Q_D(const QQuickTextEdit);
if (d->focusOnPress && !isReadOnly())
openSoftwareInputPanel();
- QSGImplicitSizeItem::focusInEvent(event);
+ QQuickImplicitSizeItem::focusInEvent(event);
}
-void QSGTextEdit::q_canPasteChanged()
+void QQuickTextEdit::q_canPasteChanged()
{
- Q_D(QSGTextEdit);
+ Q_D(QQuickTextEdit);
bool old = d->canPaste;
d->canPaste = d->control->canPaste();
if (old!=d->canPaste)
**
****************************************************************************/
-#ifndef QSGTEXTEDIT_P_H
-#define QSGTEXTEDIT_P_H
+#ifndef QQUICKTEXTEDIT_P_H
+#define QQUICKTEXTEDIT_P_H
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p.h"
#include <QtGui/qtextoption.h>
QT_MODULE(Declarative)
-class QSGTextEditPrivate;
-class Q_AUTOTEST_EXPORT QSGTextEdit : public QSGImplicitSizeItem
+class QQuickTextEditPrivate;
+class Q_AUTOTEST_EXPORT QQuickTextEdit : public QQuickImplicitSizeItem
{
Q_OBJECT
Q_ENUMS(VAlignment)
Q_PROPERTY(bool inputMethodComposing READ isInputMethodComposing NOTIFY inputMethodComposingChanged)
public:
- QSGTextEdit(QSGItem *parent=0);
+ QQuickTextEdit(QQuickItem *parent=0);
enum HAlignment {
AlignLeft = Qt::AlignLeft,
QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData);
private:
- Q_DISABLE_COPY(QSGTextEdit)
- Q_DECLARE_PRIVATE(QSGTextEdit)
+ Q_DISABLE_COPY(QQuickTextEdit)
+ Q_DECLARE_PRIVATE(QQuickTextEdit)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGTextEdit)
+QML_DECLARE_TYPE(QQuickTextEdit)
QT_END_HEADER
-#endif // QSGTEXTEDIT_P_H
+#endif // QQUICKTEXTEDIT_P_H
**
****************************************************************************/
-#ifndef QSGTEXTEDIT_P_P_H
-#define QSGTEXTEDIT_P_P_H
+#ifndef QQUICKTEXTEDIT_P_P_H
+#define QQUICKTEXTEDIT_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qsgtextedit_p.h"
-#include "qsgimplicitsizeitem_p_p.h"
+#include "qquicktextedit_p.h"
+#include "qquickimplicitsizeitem_p_p.h"
#include <QtDeclarative/qdeclarative.h>
#include <QtGui/qpixmap.h>
class QTextLayout;
class QTextDocument;
class QTextControl;
-class QSGTextEditPrivate : public QSGImplicitSizeItemPrivate
+class QQuickTextEditPrivate : public QQuickImplicitSizeItemPrivate
{
- Q_DECLARE_PUBLIC(QSGTextEdit)
+ Q_DECLARE_PUBLIC(QQuickTextEdit)
public:
- QSGTextEditPrivate()
- : color("black"), hAlign(QSGTextEdit::AlignLeft), vAlign(QSGTextEdit::AlignTop),
+ QQuickTextEditPrivate()
+ : color("black"), hAlign(QQuickTextEdit::AlignLeft), vAlign(QQuickTextEdit::AlignTop),
documentDirty(true), dirty(false), richText(false), cursorVisible(false), focusOnPress(true),
persistentSelection(true), requireImplicitWidth(false), selectByMouse(false), canPaste(false),
hAlignImplicit(true), rightToLeftText(false), useImageFallback(false),
textMargin(0.0), lastSelectionStart(0), lastSelectionEnd(0), cursorComponent(0), cursor(0),
- format(QSGTextEdit::AutoText), document(0), wrapMode(QSGTextEdit::NoWrap),
- mouseSelectionMode(QSGTextEdit::SelectCharacters),
+ format(QQuickTextEdit::AutoText), document(0), wrapMode(QQuickTextEdit::NoWrap),
+ mouseSelectionMode(QQuickTextEdit::SelectCharacters),
lineCount(0), yoff(0), nodeType(NodeIsNull), texture(0)
{
}
void relayoutDocument();
void updateSelection();
bool determineHorizontalAlignment();
- bool setHAlign(QSGTextEdit::HAlignment, bool forceAlign = false);
+ bool setHAlign(QQuickTextEdit::HAlignment, bool forceAlign = false);
void mirrorChange();
qreal getImplicitWidth() const;
QColor selectedTextColor;
QString style;
QColor styleColor;
- QSGTextEdit::HAlignment hAlign;
- QSGTextEdit::VAlignment vAlign;
+ QQuickTextEdit::HAlignment hAlign;
+ QQuickTextEdit::VAlignment vAlign;
bool documentDirty : 1;
bool dirty : 1;
int lastSelectionStart;
int lastSelectionEnd;
QDeclarativeComponent* cursorComponent;
- QSGItem* cursor;
- QSGTextEdit::TextFormat format;
+ QQuickItem* cursor;
+ QQuickTextEdit::TextFormat format;
QTextDocument *document;
QTextControl *control;
- QSGTextEdit::WrapMode wrapMode;
- QSGTextEdit::SelectionMode mouseSelectionMode;
+ QQuickTextEdit::WrapMode wrapMode;
+ QQuickTextEdit::SelectionMode mouseSelectionMode;
int lineCount;
int yoff;
QSize paintedSize;
QT_END_NAMESPACE
-#endif // QSGTEXTEDIT_P_P_H
+#endif // QQUICKTEXTEDIT_P_P_H
**
****************************************************************************/
-#include "qsgtextinput_p.h"
-#include "qsgtextinput_p_p.h"
-#include "qsgcanvas.h"
+#include "qquicktextinput_p.h"
+#include "qquicktextinput_p_p.h"
+#include "qquickcanvas.h"
#include <private/qdeclarativeglobal_p.h>
#include <private/qsgdistancefieldglyphcache_p.h>
#include <QtDeclarative/qdeclarativeinfo.h>
#include <QtGui/qevent.h>
#include <QTextBoundaryFinder>
-#include "qsgtextnode_p.h"
+#include "qquicktextnode_p.h"
#include <qsgsimplerectnode.h>
#include <QtGui/qstylehints.h>
DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
/*!
- \qmlclass TextInput QSGTextInput
+ \qmlclass TextInput QQuickTextInput
\inqmlmodule QtQuick 2
\ingroup qml-basic-visual-elements
\brief The TextInput item displays an editable line of text.
\sa TextEdit, Text, {declarative/text/textselection}{Text Selection example}
*/
-QSGTextInput::QSGTextInput(QSGItem* parent)
-: QSGImplicitSizeItem(*(new QSGTextInputPrivate), parent)
+QQuickTextInput::QQuickTextInput(QQuickItem* parent)
+: QQuickImplicitSizeItem(*(new QQuickTextInputPrivate), parent)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->init();
}
-QSGTextInput::~QSGTextInput()
+QQuickTextInput::~QQuickTextInput()
{
}
The text in the TextInput.
*/
-QString QSGTextInput::text() const
+QString QQuickTextInput::text() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->text();
}
-void QSGTextInput::setText(const QString &s)
+void QQuickTextInput::setText(const QString &s)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (s == text())
return;
d->control->setText(s);
\endqml
*/
-QFont QSGTextInput::font() const
+QFont QQuickTextInput::font() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->sourceFont;
}
-void QSGTextInput::setFont(const QFont &font)
+void QQuickTextInput::setFont(const QFont &font)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->sourceFont == font)
return;
The text color.
*/
-QColor QSGTextInput::color() const
+QColor QQuickTextInput::color() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->color;
}
-void QSGTextInput::setColor(const QColor &c)
+void QQuickTextInput::setColor(const QColor &c)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (c != d->color) {
d->color = c;
update();
The text highlight color, used behind selections.
*/
-QColor QSGTextInput::selectionColor() const
+QColor QQuickTextInput::selectionColor() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->selectionColor;
}
-void QSGTextInput::setSelectionColor(const QColor &color)
+void QQuickTextInput::setSelectionColor(const QColor &color)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->selectionColor == color)
return;
The highlighted text color, used in selections.
*/
-QColor QSGTextInput::selectedTextColor() const
+QColor QQuickTextInput::selectedTextColor() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->selectedTextColor;
}
-void QSGTextInput::setSelectedTextColor(const QColor &color)
+void QQuickTextInput::setSelectedTextColor(const QColor &color)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->selectedTextColor == color)
return;
\c horizontalAlignment will remain unchanged. To query the effective horizontal alignment
of TextInput, use the read-only property \c effectiveHorizontalAlignment.
*/
-QSGTextInput::HAlignment QSGTextInput::hAlign() const
+QQuickTextInput::HAlignment QQuickTextInput::hAlign() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->hAlign;
}
-void QSGTextInput::setHAlign(HAlignment align)
+void QQuickTextInput::setHAlign(HAlignment align)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
bool forceAlign = d->hAlignImplicit && d->effectiveLayoutMirror;
d->hAlignImplicit = false;
if (d->setHAlign(align, forceAlign) && isComponentComplete()) {
}
}
-void QSGTextInput::resetHAlign()
+void QQuickTextInput::resetHAlign()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->hAlignImplicit = true;
if (d->determineHorizontalAlignment() && isComponentComplete()) {
updateCursorRectangle();
}
}
-QSGTextInput::HAlignment QSGTextInput::effectiveHAlign() const
+QQuickTextInput::HAlignment QQuickTextInput::effectiveHAlign() const
{
- Q_D(const QSGTextInput);
- QSGTextInput::HAlignment effectiveAlignment = d->hAlign;
+ Q_D(const QQuickTextInput);
+ QQuickTextInput::HAlignment effectiveAlignment = d->hAlign;
if (!d->hAlignImplicit && d->effectiveLayoutMirror) {
switch (d->hAlign) {
- case QSGTextInput::AlignLeft:
- effectiveAlignment = QSGTextInput::AlignRight;
+ case QQuickTextInput::AlignLeft:
+ effectiveAlignment = QQuickTextInput::AlignRight;
break;
- case QSGTextInput::AlignRight:
- effectiveAlignment = QSGTextInput::AlignLeft;
+ case QQuickTextInput::AlignRight:
+ effectiveAlignment = QQuickTextInput::AlignLeft;
break;
default:
break;
return effectiveAlignment;
}
-bool QSGTextInputPrivate::setHAlign(QSGTextInput::HAlignment alignment, bool forceAlign)
+bool QQuickTextInputPrivate::setHAlign(QQuickTextInput::HAlignment alignment, bool forceAlign)
{
- Q_Q(QSGTextInput);
- if ((hAlign != alignment || forceAlign) && alignment <= QSGTextInput::AlignHCenter) { // justify not supported
- QSGTextInput::HAlignment oldEffectiveHAlign = q->effectiveHAlign();
+ Q_Q(QQuickTextInput);
+ if ((hAlign != alignment || forceAlign) && alignment <= QQuickTextInput::AlignHCenter) { // justify not supported
+ QQuickTextInput::HAlignment oldEffectiveHAlign = q->effectiveHAlign();
hAlign = alignment;
emit q->horizontalAlignmentChanged(alignment);
if (oldEffectiveHAlign != q->effectiveHAlign())
return false;
}
-bool QSGTextInputPrivate::determineHorizontalAlignment()
+bool QQuickTextInputPrivate::determineHorizontalAlignment()
{
if (hAlignImplicit) {
// if no explicit alignment has been set, follow the natural layout direction of the text
if (text.isEmpty())
text = control->preeditAreaText();
bool isRightToLeft = text.isEmpty() ? QGuiApplication::keyboardInputDirection() == Qt::RightToLeft : text.isRightToLeft();
- return setHAlign(isRightToLeft ? QSGTextInput::AlignRight : QSGTextInput::AlignLeft);
+ return setHAlign(isRightToLeft ? QQuickTextInput::AlignRight : QQuickTextInput::AlignLeft);
}
return false;
}
-void QSGTextInputPrivate::mirrorChange()
+void QQuickTextInputPrivate::mirrorChange()
{
- Q_Q(QSGTextInput);
+ Q_Q(QQuickTextInput);
if (q->isComponentComplete()) {
- if (!hAlignImplicit && (hAlign == QSGTextInput::AlignRight || hAlign == QSGTextInput::AlignLeft)) {
+ if (!hAlignImplicit && (hAlign == QQuickTextInput::AlignRight || hAlign == QQuickTextInput::AlignLeft)) {
q->updateCursorRectangle();
emit q->effectiveHorizontalAlignmentChanged();
}
property. Any bindings or attempts to set the text property will still
work.
*/
-bool QSGTextInput::isReadOnly() const
+bool QQuickTextInput::isReadOnly() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->isReadOnly();
}
-void QSGTextInput::setReadOnly(bool ro)
+void QQuickTextInput::setReadOnly(bool ro)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->control->isReadOnly() == ro)
return;
- setFlag(QSGItem::ItemAcceptsInputMethod, !ro);
+ setFlag(QQuickItem::ItemAcceptsInputMethod, !ro);
d->control->setReadOnly(ro);
if (!ro)
d->control->setCursorPosition(d->control->end());
By default, this property contains a value of 32767.
*/
-int QSGTextInput::maxLength() const
+int QQuickTextInput::maxLength() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->maxLength();
}
-void QSGTextInput::setMaxLength(int ml)
+void QQuickTextInput::setMaxLength(int ml)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->control->maxLength() == ml)
return;
In the above snippet the cursor will still become visible when the
TextInput gains active focus.
*/
-bool QSGTextInput::isCursorVisible() const
+bool QQuickTextInput::isCursorVisible() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->cursorVisible;
}
-void QSGTextInput::setCursorVisible(bool on)
+void QQuickTextInput::setCursorVisible(bool on)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->cursorVisible == on)
return;
d->cursorVisible = on;
\qmlproperty int QtQuick2::TextInput::cursorPosition
The position of the cursor in the TextInput.
*/
-int QSGTextInput::cursorPosition() const
+int QQuickTextInput::cursorPosition() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->cursor();
}
-void QSGTextInput::setCursorPosition(int cp)
+void QQuickTextInput::setCursorPosition(int cp)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (cp < 0 || cp > d->control->text().length())
return;
d->control->moveCursor(cp);
Returns a Rect which encompasses the cursor, but which may be larger than is
required. Ignores custom cursor delegates.
*/
-QRect QSGTextInput::cursorRectangle() const
+QRect QQuickTextInput::cursorRectangle() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
QRect r = d->control->cursorRect();
// Scroll and make consistent with TextEdit
// QLineControl inexplicably adds 1 to the height and horizontal padding
\sa selectionEnd, cursorPosition, selectedText
*/
-int QSGTextInput::selectionStart() const
+int QQuickTextInput::selectionStart() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->lastSelectionStart;
}
/*!
\sa selectionStart, cursorPosition, selectedText
*/
-int QSGTextInput::selectionEnd() const
+int QQuickTextInput::selectionEnd() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->lastSelectionEnd;
}
/*!
\sa selectionStart, selectionEnd
*/
-void QSGTextInput::select(int start, int end)
+void QQuickTextInput::select(int start, int end)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (start < 0 || end < 0 || start > d->control->text().length() || end > d->control->text().length())
return;
d->control->setSelection(start, end-start);
myTextInput.selectionEnd);
\endjs
*/
-QString QSGTextInput::selectedText() const
+QString QQuickTextInput::selectedText() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->selectedText();
}
Whether the TextInput should gain active focus on a mouse press. By default this is
set to true.
*/
-bool QSGTextInput::focusOnPress() const
+bool QQuickTextInput::focusOnPress() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->focusOnPress;
}
-void QSGTextInput::setFocusOnPress(bool b)
+void QQuickTextInput::setFocusOnPress(bool b)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->focusOnPress == b)
return;
Whether the TextInput should scroll when the text is longer than the width. By default this is
set to true.
*/
-bool QSGTextInput::autoScroll() const
+bool QQuickTextInput::autoScroll() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->autoScroll;
}
-void QSGTextInput::setAutoScroll(bool b)
+void QQuickTextInput::setAutoScroll(bool b)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->autoScroll == b)
return;
\sa acceptableInput, inputMask
*/
-QValidator* QSGTextInput::validator() const
+QValidator* QQuickTextInput::validator() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
//###const cast isn't good, but needed for property system?
return const_cast<QValidator*>(d->control->validator());
}
-void QSGTextInput::setValidator(QValidator* v)
+void QQuickTextInput::setValidator(QValidator* v)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->control->validator() == v)
return;
\sa acceptableInput, validator
*/
-QString QSGTextInput::inputMask() const
+QString QQuickTextInput::inputMask() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->inputMask();
}
-void QSGTextInput::setInputMask(const QString &im)
+void QQuickTextInput::setInputMask(const QString &im)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->control->inputMask() == im)
return;
if the current text is acceptable to the validator or input mask as a final
string (not as an intermediate string).
*/
-bool QSGTextInput::hasAcceptableInput() const
+bool QQuickTextInput::hasAcceptableInput() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->hasAcceptableInput();
}
state.
*/
-void QSGTextInputPrivate::updateInputMethodHints()
+void QQuickTextInputPrivate::updateInputMethodHints()
{
- Q_Q(QSGTextInput);
+ Q_Q(QQuickTextInput);
Qt::InputMethodHints hints = inputMethodHints;
uint echo = control->echoMode();
- if (echo == QSGTextInput::Password || echo == QSGTextInput::NoEcho)
+ if (echo == QQuickTextInput::Password || echo == QQuickTextInput::NoEcho)
hints |= Qt::ImhHiddenText;
- else if (echo == QSGTextInput::PasswordEchoOnEdit)
+ else if (echo == QQuickTextInput::PasswordEchoOnEdit)
hints &= ~Qt::ImhHiddenText;
- if (echo != QSGTextInput::Normal)
+ if (echo != QQuickTextInput::Normal)
hints |= (Qt::ImhNoAutoUppercase | Qt::ImhNoPredictiveText);
q->setInputMethodHints(hints);
}
while editing, otherwise displays asterisks.
\endlist
*/
-QSGTextInput::EchoMode QSGTextInput::echoMode() const
+QQuickTextInput::EchoMode QQuickTextInput::echoMode() const
{
- Q_D(const QSGTextInput);
- return (QSGTextInput::EchoMode)d->control->echoMode();
+ Q_D(const QQuickTextInput);
+ return (QQuickTextInput::EchoMode)d->control->echoMode();
}
-void QSGTextInput::setEchoMode(QSGTextInput::EchoMode echo)
+void QQuickTextInput::setEchoMode(QQuickTextInput::EchoMode echo)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (echoMode() == echo)
return;
d->control->setEchoMode((QLineControl::EchoMode)echo);
emit echoModeChanged(echoMode());
}
-Qt::InputMethodHints QSGTextInput::imHints() const
+Qt::InputMethodHints QQuickTextInput::imHints() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->inputMethodHints;
}
-void QSGTextInput::setIMHints(Qt::InputMethodHints hints)
+void QQuickTextInput::setIMHints(Qt::InputMethodHints hints)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->inputMethodHints == hints)
return;
d->inputMethodHints = hints;
Note that the root item of the delegate component must be a QDeclarativeItem or
QDeclarativeItem derived item.
*/
-QDeclarativeComponent* QSGTextInput::cursorDelegate() const
+QDeclarativeComponent* QQuickTextInput::cursorDelegate() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->cursorComponent;
}
-void QSGTextInput::setCursorDelegate(QDeclarativeComponent* c)
+void QQuickTextInput::setCursorDelegate(QDeclarativeComponent* c)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->cursorComponent == c)
return;
emit cursorDelegateChanged();
}
-void QSGTextInputPrivate::startCreatingCursor()
+void QQuickTextInputPrivate::startCreatingCursor()
{
- Q_Q(QSGTextInput);
+ Q_Q(QQuickTextInput);
if (cursorComponent->isReady()) {
q->createCursor();
} else if (cursorComponent->isLoading()) {
q->connect(cursorComponent, SIGNAL(statusChanged(int)),
q, SLOT(createCursor()));
} else { // isError
- qmlInfo(q, cursorComponent->errors()) << QSGTextInput::tr("Could not load cursor delegate");
+ qmlInfo(q, cursorComponent->errors()) << QQuickTextInput::tr("Could not load cursor delegate");
}
}
-void QSGTextInput::createCursor()
+void QQuickTextInput::createCursor()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->cursorComponent->isError()) {
qmlInfo(this, d->cursorComponent->errors()) << tr("Could not load cursor delegate");
return;
delete d->cursorItem;
QDeclarativeContext *creationContext = d->cursorComponent->creationContext();
QObject *object = d->cursorComponent->create(creationContext ? creationContext : qmlContext(this));
- d->cursorItem = qobject_cast<QSGItem*>(object);
+ d->cursorItem = qobject_cast<QQuickItem*>(object);
if (!d->cursorItem) {
delete object;
qmlInfo(this, d->cursorComponent->errors()) << tr("Could not instantiate cursor delegate");
This is similar to setting the cursorPosition, and then querying the cursor
rectangle, but the cursorPosition is not changed.
*/
-QRectF QSGTextInput::positionToRectangle(int pos) const
+QRectF QQuickTextInput::positionToRectangle(int pos) const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
if (pos > d->control->cursorPosition())
pos += d->control->preeditAreaText().length();
return QRectF(d->control->cursorToX(pos)-d->hscroll,
\o TextInput.CursorOnCharacter - Returns the position before the character that is nearest x.
\endlist
*/
-int QSGTextInput::positionAt(int x) const
+int QQuickTextInput::positionAt(int x) const
{
return positionAt(x, CursorBetweenCharacters);
}
-int QSGTextInput::positionAt(int x, CursorPosition position) const
+int QQuickTextInput::positionAt(int x, CursorPosition position) const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
int pos = d->control->xToPos(x + d->hscroll, QTextLine::CursorPosition(position));
const int cursor = d->control->cursor();
if (pos > cursor) {
return pos;
}
-void QSGTextInput::keyPressEvent(QKeyEvent* ev)
+void QQuickTextInput::keyPressEvent(QKeyEvent* ev)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
// Don't allow MacOSX up/down support, and we don't allow a completer.
bool ignore = (ev->key() == Qt::Key_Up || ev->key() == Qt::Key_Down) && ev->modifiers() == Qt::NoModifier;
if (!ignore && (d->lastSelectionStart == d->lastSelectionEnd) && (ev->key() == Qt::Key_Right || ev->key() == Qt::Key_Left)) {
d->control->processKeyEvent(ev);
}
if (!ev->isAccepted())
- QSGImplicitSizeItem::keyPressEvent(ev);
+ QQuickImplicitSizeItem::keyPressEvent(ev);
}
-void QSGTextInput::inputMethodEvent(QInputMethodEvent *ev)
+void QQuickTextInput::inputMethodEvent(QInputMethodEvent *ev)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
const bool wasComposing = d->control->preeditAreaText().length() > 0;
if (d->control->isReadOnly()) {
ev->ignore();
d->control->processInputMethodEvent(ev);
}
if (!ev->isAccepted())
- QSGImplicitSizeItem::inputMethodEvent(ev);
+ QQuickImplicitSizeItem::inputMethodEvent(ev);
if (wasComposing != (d->control->preeditAreaText().length() > 0))
emit inputMethodComposingChanged();
}
-void QSGTextInput::mouseDoubleClickEvent(QMouseEvent *event)
+void QQuickTextInput::mouseDoubleClickEvent(QMouseEvent *event)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->sendMouseEventToInputContext(event))
return;
if (d->selectByMouse) {
d->tripleClickTimer.start();
}
} else {
- QSGImplicitSizeItem::mouseDoubleClickEvent(event);
+ QQuickImplicitSizeItem::mouseDoubleClickEvent(event);
}
}
-void QSGTextInput::mousePressEvent(QMouseEvent *event)
+void QQuickTextInput::mousePressEvent(QMouseEvent *event)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->sendMouseEventToInputContext(event))
return;
if (d->focusOnPress) {
event->setAccepted(true);
}
-void QSGTextInput::mouseMoveEvent(QMouseEvent *event)
+void QQuickTextInput::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->sendMouseEventToInputContext(event))
return;
if (d->selectPressed) {
moveCursorSelection(d->xToPos(event->localPos().x()), d->mouseSelectionMode);
event->setAccepted(true);
} else {
- QSGImplicitSizeItem::mouseMoveEvent(event);
+ QQuickImplicitSizeItem::mouseMoveEvent(event);
}
}
-void QSGTextInput::mouseReleaseEvent(QMouseEvent *event)
+void QQuickTextInput::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->sendMouseEventToInputContext(event))
return;
if (d->selectPressed) {
}
d->control->processEvent(event);
if (!event->isAccepted())
- QSGImplicitSizeItem::mouseReleaseEvent(event);
+ QQuickImplicitSizeItem::mouseReleaseEvent(event);
}
-bool QSGTextInputPrivate::sendMouseEventToInputContext(QMouseEvent *event)
+bool QQuickTextInputPrivate::sendMouseEventToInputContext(QMouseEvent *event)
{
#if !defined QT_NO_IM
if (control->composeMode() && event->type() == QEvent::KeyRelease) {
return false;
}
-void QSGTextInput::mouseUngrabEvent()
+void QQuickTextInput::mouseUngrabEvent()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->selectPressed = false;
setKeepMouseGrab(false);
}
-bool QSGTextInput::event(QEvent* ev)
+bool QQuickTextInput::event(QEvent* ev)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
//Anything we don't deal with ourselves, pass to the control
bool handled = false;
switch (ev->type()) {
handled = d->control->processEvent(ev);
}
if (!handled)
- handled = QSGImplicitSizeItem::event(ev);
+ handled = QQuickImplicitSizeItem::event(ev);
return handled;
}
-void QSGTextInput::geometryChanged(const QRectF &newGeometry,
+void QQuickTextInput::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
if (newGeometry.width() != oldGeometry.width()) {
updateSize();
updateCursorRectangle();
}
- QSGImplicitSizeItem::geometryChanged(newGeometry, oldGeometry);
+ QQuickImplicitSizeItem::geometryChanged(newGeometry, oldGeometry);
}
-int QSGTextInputPrivate::calculateTextWidth()
+int QQuickTextInputPrivate::calculateTextWidth()
{
return qRound(control->naturalTextWidth());
}
-void QSGTextInputPrivate::updateHorizontalScroll()
+void QQuickTextInputPrivate::updateHorizontalScroll()
{
- Q_Q(QSGTextInput);
+ Q_Q(QQuickTextInput);
const int preeditLength = control->preeditAreaText().length();
const int width = q->width();
int widthUsed = calculateTextWidth();
if (!autoScroll || widthUsed <= width) {
- QSGTextInput::HAlignment effectiveHAlign = q->effectiveHAlign();
+ QQuickTextInput::HAlignment effectiveHAlign = q->effectiveHAlign();
// text fits in br; use hscroll for alignment
switch (effectiveHAlign & ~(Qt::AlignAbsolute|Qt::AlignVertical_Mask)) {
case Qt::AlignRight:
}
}
-QSGNode *QSGTextInput::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+QSGNode *QQuickTextInput::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
Q_UNUSED(data);
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
- QSGTextNode *node = static_cast<QSGTextNode *>(oldNode);
+ QQuickTextNode *node = static_cast<QQuickTextNode *>(oldNode);
if (node == 0)
- node = new QSGTextNode(QSGItemPrivate::get(this)->sceneGraphContext());
+ node = new QQuickTextNode(QQuickItemPrivate::get(this)->sceneGraphContext());
d->textNode = node;
if (!d->textLayoutDirty) {
QTextLayout *textLayout = d->control->textLayout();
if (!textLayout->text().isEmpty()) {
node->addTextLayout(offset, textLayout, d->color,
- QSGText::Normal, QColor(),
+ QQuickText::Normal, QColor(),
d->selectionColor, d->selectedTextColor,
d->control->selectionStart(),
d->control->selectionEnd() - 1); // selectionEnd() returns first char after
return node;
}
-QVariant QSGTextInput::inputMethodQuery(Qt::InputMethodQuery property) const
+QVariant QQuickTextInput::inputMethodQuery(Qt::InputMethodQuery property) const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
switch (property) {
case Qt::ImEnabled:
return QVariant((bool)(flags() & ItemAcceptsInputMethod));
Removes active text selection.
*/
-void QSGTextInput::deselect()
+void QQuickTextInput::deselect()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->control->deselect();
}
Causes all text to be selected.
*/
-void QSGTextInput::selectAll()
+void QQuickTextInput::selectAll()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->control->setSelection(0, d->control->text().length());
}
Returns true if the natural reading direction of the editor text
found between positions \a start and \a end is right to left.
*/
-bool QSGTextInput::isRightToLeft(int start, int end)
+bool QQuickTextInput::isRightToLeft(int start, int end)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (start > end) {
qmlInfo(this) << "isRightToLeft(start, end) called with the end property being smaller than the start.";
return false;
Moves the currently selected text to the system clipboard.
*/
-void QSGTextInput::cut()
+void QQuickTextInput::cut()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->control->copy();
d->control->del();
}
Copies the currently selected text to the system clipboard.
*/
-void QSGTextInput::copy()
+void QQuickTextInput::copy()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->control->copy();
}
Replaces the currently selected text by the contents of the system clipboard.
*/
-void QSGTextInput::paste()
+void QQuickTextInput::paste()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (!d->control->isReadOnly())
d->control->paste();
}
Causes the word closest to the current cursor position to be selected.
*/
-void QSGTextInput::selectWord()
+void QQuickTextInput::selectWord()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->control->selectWordAtPos(d->control->cursor());
}
the first character is used. If the string is empty, the value
is ignored and the property is not set.
*/
-QString QSGTextInput::passwordCharacter() const
+QString QQuickTextInput::passwordCharacter() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return QString(d->control->passwordCharacter());
}
-void QSGTextInput::setPasswordCharacter(const QString &str)
+void QQuickTextInput::setPasswordCharacter(const QString &str)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (str.length() < 1)
return;
d->control->setPasswordCharacter(str.constData()[0]);
this property holds the text visible to the user, while
the \l text property holds the actual entered text.
*/
-QString QSGTextInput::displayText() const
+QString QQuickTextInput::displayText() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->displayText();
}
not be an appropriate interaction (eg. may conflict with how
the text needs to behave inside a Flickable.
*/
-bool QSGTextInput::selectByMouse() const
+bool QQuickTextInput::selectByMouse() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->selectByMouse;
}
-void QSGTextInput::setSelectByMouse(bool on)
+void QQuickTextInput::setSelectByMouse(bool on)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->selectByMouse != on) {
d->selectByMouse = on;
emit selectByMouseChanged(on);
This property only applies when \l selectByMouse is true.
*/
-QSGTextInput::SelectionMode QSGTextInput::mouseSelectionMode() const
+QQuickTextInput::SelectionMode QQuickTextInput::mouseSelectionMode() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->mouseSelectionMode;
}
-void QSGTextInput::setMouseSelectionMode(SelectionMode mode)
+void QQuickTextInput::setMouseSelectionMode(SelectionMode mode)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (d->mouseSelectionMode != mode) {
d->mouseSelectionMode = mode;
emit mouseSelectionModeChanged(mode);
Returns true if the TextInput is writable and the content of the clipboard is
suitable for pasting into the TextEdit.
*/
-bool QSGTextInput::canPaste() const
+bool QQuickTextInput::canPaste() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->canPaste;
}
-void QSGTextInput::moveCursorSelection(int position)
+void QQuickTextInput::moveCursorSelection(int position)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->control->moveCursor(position, true);
}
The same sequence with TextInput.SelectWords will extend the selection start to a word boundary
before or on position 5 and extend the selection end to a word boundary on or past position 9.
*/
-void QSGTextInput::moveCursorSelection(int pos, SelectionMode mode)
+void QQuickTextInput::moveCursorSelection(int pos, SelectionMode mode)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (mode == SelectCharacters) {
d->control->moveCursor(pos, true);
}
\endqml
*/
-void QSGTextInput::openSoftwareInputPanel()
+void QQuickTextInput::openSoftwareInputPanel()
{
if (qGuiApp)
qGuiApp->inputPanel()->show();
}
\endqml
*/
-void QSGTextInput::closeSoftwareInputPanel()
+void QQuickTextInput::closeSoftwareInputPanel()
{
if (qGuiApp)
qGuiApp->inputPanel()->hide();
}
-void QSGTextInput::focusInEvent(QFocusEvent *event)
+void QQuickTextInput::focusInEvent(QFocusEvent *event)
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
if (d->focusOnPress && !isReadOnly())
openSoftwareInputPanel();
- QSGImplicitSizeItem::focusInEvent(event);
+ QQuickImplicitSizeItem::focusInEvent(event);
}
-void QSGTextInput::itemChange(ItemChange change, const ItemChangeData &value)
+void QQuickTextInput::itemChange(ItemChange change, const ItemChangeData &value)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (change == ItemActiveFocusHasChanged) {
bool hasFocus = value.boolValue;
d->focused = hasFocus;
setCursorVisible(hasFocus); // ### refactor: && d->canvas && d->canvas->hasFocus()
- if (echoMode() == QSGTextInput::PasswordEchoOnEdit && !hasFocus)
+ if (echoMode() == QQuickTextInput::PasswordEchoOnEdit && !hasFocus)
d->control->updatePasswordEchoEditing(false);//QLineControl sets it on key events, but doesn't deal with focus events
if (!hasFocus)
d->control->deselect();
}
- QSGItem::itemChange(change, value);
+ QQuickItem::itemChange(change, value);
}
/*!
used to determine when to disable events handlers that may interfere with
the correct operation of an input method.
*/
-bool QSGTextInput::isInputMethodComposing() const
+bool QQuickTextInput::isInputMethodComposing() const
{
- Q_D(const QSGTextInput);
+ Q_D(const QQuickTextInput);
return d->control->preeditAreaText().length() > 0;
}
-void QSGTextInputPrivate::init()
+void QQuickTextInputPrivate::init()
{
- Q_Q(QSGTextInput);
+ Q_Q(QQuickTextInput);
#if defined(Q_WS_MAC)
control->setThreadChecks(true);
#endif
control->setPasswordCharacter(QLatin1Char('*'));
q->setSmooth(smooth);
q->setAcceptedMouseButtons(Qt::LeftButton);
- q->setFlag(QSGItem::ItemAcceptsInputMethod);
- q->setFlag(QSGItem::ItemHasContents);
+ q->setFlag(QQuickItem::ItemAcceptsInputMethod);
+ q->setFlag(QQuickItem::ItemHasContents);
q->connect(control, SIGNAL(cursorPositionChanged(int,int)),
q, SLOT(cursorPosChanged()));
q->connect(control, SIGNAL(selectionChanged()),
}
}
-void QSGTextInput::cursorPosChanged()
+void QQuickTextInput::cursorPosChanged()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
updateCursorRectangle();
emit cursorPositionChanged();
// XXX todo - not in 4.8?
}
}
-void QSGTextInput::updateCursorRectangle()
+void QQuickTextInput::updateCursorRectangle()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
d->determineHorizontalAlignment();
d->updateHorizontalScroll();
updateRect();//TODO: Only update rect between pos's
d->cursorItem->setX(d->control->cursorToX() - d->hscroll);
}
-void QSGTextInput::selectionChanged()
+void QQuickTextInput::selectionChanged()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
updateRect();//TODO: Only update rect in selection
emit selectedTextChanged();
}
}
-void QSGTextInput::q_textChanged()
+void QQuickTextInput::q_textChanged()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
emit textChanged();
emit displayTextChanged();
updateSize();
}
}
-void QSGTextInputPrivate::showCursor()
+void QQuickTextInputPrivate::showCursor()
{
if (textNode != 0 && textNode->cursorNode() != 0)
textNode->cursorNode()->setColor(color);
}
-void QSGTextInputPrivate::hideCursor()
+void QQuickTextInputPrivate::hideCursor()
{
if (textNode != 0 && textNode->cursorNode() != 0)
textNode->cursorNode()->setColor(QColor(0, 0, 0, 0));
}
-void QSGTextInput::updateRect(const QRect &r)
+void QQuickTextInput::updateRect(const QRect &r)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
if (!isComponentComplete())
return;
update();
}
-QRectF QSGTextInput::boundingRect() const
+QRectF QQuickTextInput::boundingRect() const
{
- Q_D(const QSGTextInput);
- QRectF r = QSGImplicitSizeItem::boundingRect();
+ Q_D(const QQuickTextInput);
+ QRectF r = QQuickImplicitSizeItem::boundingRect();
int cursorWidth = d->cursorItem ? d->cursorItem->width() : d->control->cursorWidth();
return r;
}
-void QSGTextInput::updateSize(bool needsRedraw)
+void QQuickTextInput::updateSize(bool needsRedraw)
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
int w = width();
int h = height();
setImplicitHeight(d->control->height()-1); // -1 to counter QLineControl's +1 which is not consistent with Text.
update();
}
-void QSGTextInput::q_canPasteChanged()
+void QQuickTextInput::q_canPasteChanged()
{
- Q_D(QSGTextInput);
+ Q_D(QQuickTextInput);
bool old = d->canPaste;
#ifndef QT_NO_CLIPBOARD
d->canPaste = !d->control->isReadOnly() && QGuiApplication::clipboard()->text().length() != 0;
**
****************************************************************************/
-#ifndef QSGTEXTINPUT_P_H
-#define QSGTEXTINPUT_P_H
+#ifndef QQUICKTEXTINPUT_P_H
+#define QQUICKTEXTINPUT_P_H
-#include "qsgimplicitsizeitem_p.h"
+#include "qquickimplicitsizeitem_p.h"
#include <QtGui/qvalidator.h>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class QSGTextInputPrivate;
+class QQuickTextInputPrivate;
class QValidator;
-class Q_AUTOTEST_EXPORT QSGTextInput : public QSGImplicitSizeItem
+class Q_AUTOTEST_EXPORT QQuickTextInput : public QQuickImplicitSizeItem
{
Q_OBJECT
Q_ENUMS(HAlignment)
Q_PROPERTY(bool inputMethodComposing READ isInputMethodComposing NOTIFY inputMethodComposingChanged)
public:
- QSGTextInput(QSGItem * parent=0);
- ~QSGTextInput();
+ QQuickTextInput(QQuickItem * parent=0);
+ ~QQuickTextInput();
enum EchoMode {//To match QLineEdit::EchoMode
Normal,
void q_canPasteChanged();
private:
- Q_DECLARE_PRIVATE(QSGTextInput)
+ Q_DECLARE_PRIVATE(QQuickTextInput)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGTextInput)
+QML_DECLARE_TYPE(QQuickTextInput)
#ifndef QT_NO_VALIDATOR
QML_DECLARE_TYPE(QValidator)
QML_DECLARE_TYPE(QIntValidator)
QT_END_HEADER
-#endif // QSGTEXTINPUT_P_H
+#endif // QQUICKTEXTINPUT_P_H
**
****************************************************************************/
-#ifndef QSGTEXTINPUT_P_P_H
-#define QSGTEXTINPUT_P_P_H
+#ifndef QQUICKTEXTINPUT_P_P_H
+#define QQUICKTEXTINPUT_P_P_H
-#include "qsgtextinput_p.h"
-#include "qsgtext_p.h"
-#include "qsgimplicitsizeitem_p_p.h"
+#include "qquicktextinput_p.h"
+#include "qquicktext_p.h"
+#include "qquickimplicitsizeitem_p_p.h"
#include <private/qlinecontrol_p.h>
QT_BEGIN_NAMESPACE
-class QSGTextNode;
+class QQuickTextNode;
-class Q_AUTOTEST_EXPORT QSGTextInputPrivate : public QSGImplicitSizeItemPrivate
+class Q_AUTOTEST_EXPORT QQuickTextInputPrivate : public QQuickImplicitSizeItemPrivate
{
- Q_DECLARE_PUBLIC(QSGTextInput)
+ Q_DECLARE_PUBLIC(QQuickTextInput)
public:
- QSGTextInputPrivate()
+ QQuickTextInputPrivate()
: control(new QLineControl(QString()))
, color((QRgb)0)
- , style(QSGText::Normal)
+ , style(QQuickText::Normal)
, styleColor((QRgb)0)
- , hAlign(QSGTextInput::AlignLeft)
- , mouseSelectionMode(QSGTextInput::SelectCharacters)
+ , hAlign(QQuickTextInput::AlignLeft)
+ , mouseSelectionMode(QQuickTextInput::SelectCharacters)
, inputMethodHints(Qt::ImhNone)
, textNode(0)
, hscroll(0)
{
}
- ~QSGTextInputPrivate()
+ ~QQuickTextInputPrivate()
{
}
int xToPos(int x, QTextLine::CursorPosition betweenOrOn = QTextLine::CursorBetweenCharacters) const
{
- Q_Q(const QSGTextInput);
+ Q_Q(const QQuickTextInput);
QRect cr = q->boundingRect().toRect();
x-= cr.x() - hscroll;
return control->xToPos(x, betweenOrOn);
void startCreatingCursor();
void updateHorizontalScroll();
bool determineHorizontalAlignment();
- bool setHAlign(QSGTextInput::HAlignment, bool forceAlign = false);
+ bool setHAlign(QQuickTextInput::HAlignment, bool forceAlign = false);
void mirrorChange();
int calculateTextWidth();
bool sendMouseEventToInputContext(QMouseEvent *event);
QColor color;
QColor selectionColor;
QColor selectedTextColor;
- QSGText::TextStyle style;
+ QQuickText::TextStyle style;
QColor styleColor;
- QSGTextInput::HAlignment hAlign;
- QSGTextInput::SelectionMode mouseSelectionMode;
+ QQuickTextInput::HAlignment hAlign;
+ QQuickTextInput::SelectionMode mouseSelectionMode;
Qt::InputMethodHints inputMethodHints;
QPointer<QDeclarativeComponent> cursorComponent;
- QPointer<QSGItem> cursorItem;
+ QPointer<QQuickItem> cursorItem;
QPointF pressPos;
- QSGTextNode *textNode;
+ QQuickTextNode *textNode;
QElapsedTimer tripleClickTimer;
QPoint tripleClickStartPoint;
bool selectPressed:1;
bool textLayoutDirty:1;
- static inline QSGTextInputPrivate *get(QSGTextInput *t) {
+ static inline QQuickTextInputPrivate *get(QQuickTextInput *t) {
return t->d_func();
}
bool hasPendingTripleClick() const {
QT_END_NAMESPACE
-#endif // QSGTEXTINPUT_P_P_H
+#endif // QQUICKTEXTINPUT_P_P_H
**
****************************************************************************/
-#include "qsgtextnode_p.h"
+#include "qquicktextnode_p.h"
#include "qsgsimplerectnode.h"
#include <private/qsgadaptationlayer_p.h>
#include <private/qsgdistancefieldglyphcache_p.h>
QT_BEGIN_NAMESPACE
/*!
- Creates an empty QSGTextNode
+ Creates an empty QQuickTextNode
*/
-QSGTextNode::QSGTextNode(QSGContext *context)
+QQuickTextNode::QQuickTextNode(QSGContext *context)
: m_context(context), m_cursorNode(0)
{
#if defined(QML_RUNTIME_TESTING)
#endif
}
-QSGTextNode::~QSGTextNode()
+QQuickTextNode::~QQuickTextNode()
{
qDeleteAll(m_textures);
}
#if 0
-void QSGTextNode::setColor(const QColor &color)
+void QQuickTextNode::setColor(const QColor &color)
{
if (m_usePixmapCache) {
setUpdateFlag(UpdateNodes);
m_color = color;
}
-void QSGTextNode::setStyleColor(const QColor &styleColor)
+void QQuickTextNode::setStyleColor(const QColor &styleColor)
{
- if (m_textStyle != QSGTextNode::NormalTextStyle) {
+ if (m_textStyle != QQuickTextNode::NormalTextStyle) {
if (m_usePixmapCache) {
setUpdateFlag(UpdateNodes);
} else {
}
#endif
-QSGGlyphNode *QSGTextNode::addGlyphs(const QPointF &position, const QGlyphRun &glyphs, const QColor &color,
- QSGText::TextStyle style, const QColor &styleColor,
+QSGGlyphNode *QQuickTextNode::addGlyphs(const QPointF &position, const QGlyphRun &glyphs, const QColor &color,
+ QQuickText::TextStyle style, const QColor &styleColor,
QSGNode *parentNode)
{
QSGGlyphNode *node = m_context->createGlyphNode();
return node;
}
-void QSGTextNode::setCursor(const QRectF &rect, const QColor &color)
+void QQuickTextNode::setCursor(const QRectF &rect, const QColor &color)
{
if (m_cursorNode != 0)
delete m_cursorNode;
BinaryTreeNode()
: selectionState(Unselected)
, clipNode(0)
- , decorations(QSGTextNode::NoDecoration)
+ , decorations(QQuickTextNode::NoDecoration)
, ascent(0.0)
, leftChildIndex(-1)
, rightChildIndex(-1)
: boundingRect(brect)
, selectionState(selState)
, clipNode(0)
- , decorations(QSGTextNode::NoDecoration)
+ , decorations(QQuickTextNode::NoDecoration)
, image(i)
, ascent(a)
, leftChildIndex(-1)
}
BinaryTreeNode(const QGlyphRun &g, SelectionState selState, const QRectF &brect,
- const QSGTextNode::Decorations &decs, const QColor &c, const QColor &bc,
+ const QQuickTextNode::Decorations &decs, const QColor &c, const QColor &bc,
const QPointF &pos, qreal a)
: glyphRun(g)
, boundingRect(brect)
QRectF boundingRect;
SelectionState selectionState;
QSGClipNode *clipNode;
- QSGTextNode::Decorations decorations;
+ QQuickTextNode::Decorations decorations;
QColor color;
QColor backgroundColor;
QPointF position;
if (qFuzzyIsNull(searchRect.width()) || qFuzzyIsNull(searchRect.height()))
return;
- QSGTextNode::Decorations decorations = QSGTextNode::NoDecoration;
- decorations |= (glyphRun.underline() ? QSGTextNode::Underline : QSGTextNode::NoDecoration);
- decorations |= (glyphRun.overline() ? QSGTextNode::Overline : QSGTextNode::NoDecoration);
- decorations |= (glyphRun.strikeOut() ? QSGTextNode::StrikeOut : QSGTextNode::NoDecoration);
- decorations |= (backgroundColor.isValid() ? QSGTextNode::Background : QSGTextNode::NoDecoration);
+ QQuickTextNode::Decorations decorations = QQuickTextNode::NoDecoration;
+ decorations |= (glyphRun.underline() ? QQuickTextNode::Underline : QQuickTextNode::NoDecoration);
+ decorations |= (glyphRun.overline() ? QQuickTextNode::Overline : QQuickTextNode::NoDecoration);
+ decorations |= (glyphRun.strikeOut() ? QQuickTextNode::StrikeOut : QQuickTextNode::NoDecoration);
+ decorations |= (backgroundColor.isValid() ? QQuickTextNode::Background : QQuickTextNode::NoDecoration);
qreal ascent = glyphRun.rawFont().ascent();
insert(binaryTree, BinaryTreeNode(glyphRun, selectionState, searchRect, decorations,
int start, int end,
int selectionStart, int selectionEnd);
- void addToSceneGraph(QSGTextNode *parent,
- QSGText::TextStyle style = QSGText::Normal,
+ void addToSceneGraph(QQuickTextNode *parent,
+ QQuickText::TextStyle style = QQuickText::Normal,
const QColor &styleColor = QColor());
void setSelectionColor(const QColor &selectionColor)
BinaryTreeNode::SelectionState currentSelectionState = BinaryTreeNode::Unselected;
QRectF currentRect;
- QSGTextNode::Decorations currentDecorations = QSGTextNode::NoDecoration;
+ QQuickTextNode::Decorations currentDecorations = QQuickTextNode::NoDecoration;
qreal underlineOffset = 0.0;
qreal underlineThickness = 0.0;
currentSelectionState = node->selectionState;
// Update decorations
- if (currentDecorations != QSGTextNode::NoDecoration) {
+ if (currentDecorations != QQuickTextNode::NoDecoration) {
decorationRect.setY(m_position.y() + m_currentLine.y());
decorationRect.setHeight(m_currentLine.height());
decorationRect.setRight(node->boundingRect.left());
TextDecoration textDecoration(currentSelectionState, decorationRect, lastColor);
- if (currentDecorations & QSGTextNode::Underline)
+ if (currentDecorations & QQuickTextNode::Underline)
pendingUnderlines.append(textDecoration);
- if (currentDecorations & QSGTextNode::Overline)
+ if (currentDecorations & QQuickTextNode::Overline)
pendingOverlines.append(textDecoration);
- if (currentDecorations & QSGTextNode::StrikeOut)
+ if (currentDecorations & QQuickTextNode::StrikeOut)
pendingStrikeOuts.append(textDecoration);
- if (currentDecorations & QSGTextNode::Background)
+ if (currentDecorations & QQuickTextNode::Background)
m_backgrounds.append(qMakePair(decorationRect, lastBackgroundColor));
}
// If previous item(s) had underline and current does not, then we add the
// pending lines to the lists and likewise for overlines and strikeouts
if (!pendingUnderlines.isEmpty()
- && !(node->decorations & QSGTextNode::Underline)) {
+ && !(node->decorations & QQuickTextNode::Underline)) {
addTextDecorations(pendingUnderlines, underlineOffset, underlineThickness);
pendingUnderlines.clear();
// Merge current values with previous. Prefer greatest thickness
QRawFont rawFont = node->glyphRun.rawFont();
- if (node->decorations & QSGTextNode::Underline) {
+ if (node->decorations & QQuickTextNode::Underline) {
if (rawFont.lineThickness() > underlineThickness) {
underlineThickness = rawFont.lineThickness();
underlineOffset = rawFont.underlinePosition();
}
}
- if (node->decorations & QSGTextNode::Overline) {
+ if (node->decorations & QQuickTextNode::Overline) {
overlineOffset = -rawFont.ascent();
overlineThickness = rawFont.lineThickness();
}
- if (node->decorations & QSGTextNode::StrikeOut) {
+ if (node->decorations & QQuickTextNode::StrikeOut) {
strikeOutThickness = rawFont.lineThickness();
strikeOutOffset = rawFont.ascent() / -3.0;
}
}
}
- void SelectionEngine::addToSceneGraph(QSGTextNode *parentNode,
- QSGText::TextStyle style,
+ void SelectionEngine::addToSceneGraph(QQuickTextNode *parentNode,
+ QQuickText::TextStyle style,
const QColor &styleColor)
{
if (m_currentLine.isValid())
}
}
-void QSGTextNode::mergeFormats(QTextLayout *textLayout,
+void QQuickTextNode::mergeFormats(QTextLayout *textLayout,
QVarLengthArray<QTextLayout::FormatRange> *mergedFormats)
{
Q_ASSERT(mergedFormats != 0);
}
-void QSGTextNode::addImage(const QRectF &rect, const QImage &image)
+void QQuickTextNode::addImage(const QRectF &rect, const QImage &image)
{
QSGImageNode *node = m_context->createImageNode();
QSGTexture *texture = m_context->createTexture(image);
node->update();
}
-void QSGTextNode::addTextDocument(const QPointF &, QTextDocument *textDocument,
+void QQuickTextNode::addTextDocument(const QPointF &, QTextDocument *textDocument,
const QColor &textColor,
- QSGText::TextStyle style, const QColor &styleColor,
+ QQuickText::TextStyle style, const QColor &styleColor,
const QColor &selectionColor, const QColor &selectedTextColor,
int selectionStart, int selectionEnd)
{
engine.addToSceneGraph(this, style, styleColor);
}
-void QSGTextNode::addTextLayout(const QPointF &position, QTextLayout *textLayout, const QColor &color,
- QSGText::TextStyle style, const QColor &styleColor,
+void QQuickTextNode::addTextLayout(const QPointF &position, QTextLayout *textLayout, const QColor &color,
+ QQuickText::TextStyle style, const QColor &styleColor,
const QColor &selectionColor, const QColor &selectedTextColor,
int selectionStart, int selectionEnd)
{
engine.addToSceneGraph(this, style, styleColor);
}
-void QSGTextNode::deleteContent()
+void QQuickTextNode::deleteContent()
{
while (firstChild() != 0)
delete firstChild();
}
#if 0
-void QSGTextNode::updateNodes()
+void QQuickTextNode::updateNodes()
{
return;
deleteContent();
**
****************************************************************************/
-#ifndef QSGTEXTNODE_P_H
-#define QSGTEXTNODE_P_H
+#ifndef QQUICKTEXTNODE_P_H
+#define QQUICKTEXTNODE_P_H
#include <qsgnode.h>
-#include "qsgtext_p.h"
+#include "qquicktext_p.h"
#include <qglyphrun.h>
#include <QtGui/qcolor.h>
class QSGClipNode;
class QSGTexture;
-class QSGTextNode : public QSGTransformNode
+class QQuickTextNode : public QSGTransformNode
{
public:
enum Decoration {
};
Q_DECLARE_FLAGS(Decorations, Decoration)
- QSGTextNode(QSGContext *);
- ~QSGTextNode();
+ QQuickTextNode(QSGContext *);
+ ~QQuickTextNode();
static bool isComplexRichText(QTextDocument *);
void deleteContent();
void addTextLayout(const QPointF &position, QTextLayout *textLayout, const QColor &color = QColor(),
- QSGText::TextStyle style = QSGText::Normal, const QColor &styleColor = QColor(),
+ QQuickText::TextStyle style = QQuickText::Normal, const QColor &styleColor = QColor(),
const QColor &selectionColor = QColor(), const QColor &selectedTextColor = QColor(),
int selectionStart = -1, int selectionEnd = -1);
void addTextDocument(const QPointF &position, QTextDocument *textDocument, const QColor &color = QColor(),
- QSGText::TextStyle style = QSGText::Normal, const QColor &styleColor = QColor(),
+ QQuickText::TextStyle style = QQuickText::Normal, const QColor &styleColor = QColor(),
const QColor &selectionColor = QColor(), const QColor &selectedTextColor = QColor(),
int selectionStart = -1, int selectionEnd = -1);
QSGSimpleRectNode *cursorNode() const { return m_cursorNode; }
QSGGlyphNode *addGlyphs(const QPointF &position, const QGlyphRun &glyphs, const QColor &color,
- QSGText::TextStyle style = QSGText::Normal, const QColor &styleColor = QColor(),
+ QQuickText::TextStyle style = QQuickText::Normal, const QColor &styleColor = QColor(),
QSGNode *parentNode = 0);
void addImage(const QRectF &rect, const QImage &image);
QT_END_NAMESPACE
-#endif // QSGTEXTNODE_P_H
+#endif // QQUICKTEXTNODE_P_H
**
****************************************************************************/
-#include "qsgtranslate_p.h"
-#include "qsgitem_p.h"
+#include "qquicktranslate_p.h"
+#include "qquickitem_p.h"
#include <QtCore/qmath.h>
QT_BEGIN_NAMESPACE
-class QSGTranslatePrivate : public QSGTransformPrivate
+class QQuickTranslatePrivate : public QQuickTransformPrivate
{
public:
- QSGTranslatePrivate()
+ QQuickTranslatePrivate()
: x(0), y(0) {}
qreal x;
};
/*!
- Constructs an empty QSGTranslate object with the given \a parent.
+ Constructs an empty QQuickTranslate object with the given \a parent.
*/
-QSGTranslate::QSGTranslate(QObject *parent)
-: QSGTransform(*new QSGTranslatePrivate, parent)
+QQuickTranslate::QQuickTranslate(QObject *parent)
+: QQuickTransform(*new QQuickTranslatePrivate, parent)
{
}
/*!
Destroys the graphics scale.
*/
-QSGTranslate::~QSGTranslate()
+QQuickTranslate::~QQuickTranslate()
{
}
/*!
- \property QSGTranslate::x
+ \property QQuickTranslate::x
\brief the horizontal translation.
The translation can be any real number; the default value is 0.0.
\sa y
*/
-qreal QSGTranslate::x() const
+qreal QQuickTranslate::x() const
{
- Q_D(const QSGTranslate);
+ Q_D(const QQuickTranslate);
return d->x;
}
-void QSGTranslate::setX(qreal x)
+void QQuickTranslate::setX(qreal x)
{
- Q_D(QSGTranslate);
+ Q_D(QQuickTranslate);
if (d->x == x)
return;
d->x = x;
}
/*!
- \property QSGTranslate::y
+ \property QQuickTranslate::y
\brief the vertical translation.
The translation can be any real number; the default value is 0.0.
\sa x
*/
-qreal QSGTranslate::y() const
+qreal QQuickTranslate::y() const
{
- Q_D(const QSGTranslate);
+ Q_D(const QQuickTranslate);
return d->y;
}
-void QSGTranslate::setY(qreal y)
+void QQuickTranslate::setY(qreal y)
{
- Q_D(QSGTranslate);
+ Q_D(QQuickTranslate);
if (d->y == y)
return;
d->y = y;
emit yChanged();
}
-void QSGTranslate::applyTo(QMatrix4x4 *matrix) const
+void QQuickTranslate::applyTo(QMatrix4x4 *matrix) const
{
- Q_D(const QSGTranslate);
+ Q_D(const QQuickTranslate);
matrix->translate(d->x, d->y, 0);
}
-class QSGScalePrivate : public QSGTransformPrivate
+class QQuickScalePrivate : public QQuickTransformPrivate
{
public:
- QSGScalePrivate()
+ QQuickScalePrivate()
: xScale(1), yScale(1), zScale(1) {}
QVector3D origin;
qreal xScale;
qreal zScale;
};
-QSGScale::QSGScale(QObject *parent)
- : QSGTransform(*new QSGScalePrivate, parent)
+QQuickScale::QQuickScale(QObject *parent)
+ : QQuickTransform(*new QQuickScalePrivate, parent)
{
}
-QSGScale::~QSGScale()
+QQuickScale::~QQuickScale()
{
}
-QVector3D QSGScale::origin() const
+QVector3D QQuickScale::origin() const
{
- Q_D(const QSGScale);
+ Q_D(const QQuickScale);
return d->origin;
}
-void QSGScale::setOrigin(const QVector3D &point)
+void QQuickScale::setOrigin(const QVector3D &point)
{
- Q_D(QSGScale);
+ Q_D(QQuickScale);
if (d->origin == point)
return;
d->origin = point;
emit originChanged();
}
-qreal QSGScale::xScale() const
+qreal QQuickScale::xScale() const
{
- Q_D(const QSGScale);
+ Q_D(const QQuickScale);
return d->xScale;
}
-void QSGScale::setXScale(qreal scale)
+void QQuickScale::setXScale(qreal scale)
{
- Q_D(QSGScale);
+ Q_D(QQuickScale);
if (d->xScale == scale)
return;
d->xScale = scale;
emit scaleChanged();
}
-qreal QSGScale::yScale() const
+qreal QQuickScale::yScale() const
{
- Q_D(const QSGScale);
+ Q_D(const QQuickScale);
return d->yScale;
}
-void QSGScale::setYScale(qreal scale)
+void QQuickScale::setYScale(qreal scale)
{
- Q_D(QSGScale);
+ Q_D(QQuickScale);
if (d->yScale == scale)
return;
d->yScale = scale;
emit scaleChanged();
}
-qreal QSGScale::zScale() const
+qreal QQuickScale::zScale() const
{
- Q_D(const QSGScale);
+ Q_D(const QQuickScale);
return d->zScale;
}
-void QSGScale::setZScale(qreal scale)
+void QQuickScale::setZScale(qreal scale)
{
- Q_D(QSGScale);
+ Q_D(QQuickScale);
if (d->zScale == scale)
return;
d->zScale = scale;
emit scaleChanged();
}
-void QSGScale::applyTo(QMatrix4x4 *matrix) const
+void QQuickScale::applyTo(QMatrix4x4 *matrix) const
{
- Q_D(const QSGScale);
+ Q_D(const QQuickScale);
matrix->translate(d->origin);
matrix->scale(d->xScale, d->yScale, d->zScale);
matrix->translate(-d->origin);
}
-class QSGRotationPrivate : public QSGTransformPrivate
+class QQuickRotationPrivate : public QQuickTransformPrivate
{
public:
- QSGRotationPrivate()
+ QQuickRotationPrivate()
: angle(0), axis(0, 0, 1) {}
QVector3D origin;
qreal angle;
QVector3D axis;
};
-QSGRotation::QSGRotation(QObject *parent)
- : QSGTransform(*new QSGRotationPrivate, parent)
+QQuickRotation::QQuickRotation(QObject *parent)
+ : QQuickTransform(*new QQuickRotationPrivate, parent)
{
}
-QSGRotation::~QSGRotation()
+QQuickRotation::~QQuickRotation()
{
}
-QVector3D QSGRotation::origin() const
+QVector3D QQuickRotation::origin() const
{
- Q_D(const QSGRotation);
+ Q_D(const QQuickRotation);
return d->origin;
}
-void QSGRotation::setOrigin(const QVector3D &point)
+void QQuickRotation::setOrigin(const QVector3D &point)
{
- Q_D(QSGRotation);
+ Q_D(QQuickRotation);
if (d->origin == point)
return;
d->origin = point;
emit originChanged();
}
-qreal QSGRotation::angle() const
+qreal QQuickRotation::angle() const
{
- Q_D(const QSGRotation);
+ Q_D(const QQuickRotation);
return d->angle;
}
-void QSGRotation::setAngle(qreal angle)
+void QQuickRotation::setAngle(qreal angle)
{
- Q_D(QSGRotation);
+ Q_D(QQuickRotation);
if (d->angle == angle)
return;
d->angle = angle;
emit angleChanged();
}
-QVector3D QSGRotation::axis() const
+QVector3D QQuickRotation::axis() const
{
- Q_D(const QSGRotation);
+ Q_D(const QQuickRotation);
return d->axis;
}
-void QSGRotation::setAxis(const QVector3D &axis)
+void QQuickRotation::setAxis(const QVector3D &axis)
{
- Q_D(QSGRotation);
+ Q_D(QQuickRotation);
if (d->axis == axis)
return;
d->axis = axis;
emit axisChanged();
}
-void QSGRotation::setAxis(Qt::Axis axis)
+void QQuickRotation::setAxis(Qt::Axis axis)
{
switch (axis)
{
}
};
-void QSGRotation::applyTo(QMatrix4x4 *matrix) const
+void QQuickRotation::applyTo(QMatrix4x4 *matrix) const
{
- Q_D(const QSGRotation);
+ Q_D(const QQuickRotation);
if (d->angle == 0. || d->axis.isNull())
return;
**
****************************************************************************/
-#ifndef QSGTRANSLATE_P_H
-#define QSGTRANSLATE_P_H
+#ifndef QQUICKTRANSLATE_P_H
+#define QQUICKTRANSLATE_P_H
-#include "qsgitem.h"
+#include "qquickitem.h"
#include <QtGui/qmatrix4x4.h>
QT_MODULE(Declarative)
-class QSGTranslatePrivate;
-class Q_AUTOTEST_EXPORT QSGTranslate : public QSGTransform
+class QQuickTranslatePrivate;
+class Q_AUTOTEST_EXPORT QQuickTranslate : public QQuickTransform
{
Q_OBJECT
Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
public:
- QSGTranslate(QObject *parent = 0);
- ~QSGTranslate();
+ QQuickTranslate(QObject *parent = 0);
+ ~QQuickTranslate();
qreal x() const;
void setX(qreal);
void yChanged();
private:
- Q_DECLARE_PRIVATE(QSGTranslate)
- Q_DISABLE_COPY(QSGTranslate)
+ Q_DECLARE_PRIVATE(QQuickTranslate)
+ Q_DISABLE_COPY(QQuickTranslate)
};
-class QSGScalePrivate;
-class Q_AUTOTEST_EXPORT QSGScale : public QSGTransform
+class QQuickScalePrivate;
+class Q_AUTOTEST_EXPORT QQuickScale : public QQuickTransform
{
Q_OBJECT
Q_PROPERTY(qreal yScale READ yScale WRITE setYScale NOTIFY yScaleChanged)
Q_PROPERTY(qreal zScale READ zScale WRITE setZScale NOTIFY zScaleChanged)
public:
- QSGScale(QObject *parent = 0);
- ~QSGScale();
+ QQuickScale(QObject *parent = 0);
+ ~QQuickScale();
QVector3D origin() const;
void setOrigin(const QVector3D &point);
void scaleChanged();
private:
- Q_DECLARE_PRIVATE(QSGScale)
+ Q_DECLARE_PRIVATE(QQuickScale)
};
-class QSGRotationPrivate;
-class Q_AUTOTEST_EXPORT QSGRotation : public QSGTransform
+class QQuickRotationPrivate;
+class Q_AUTOTEST_EXPORT QQuickRotation : public QQuickTransform
{
Q_OBJECT
Q_PROPERTY(qreal angle READ angle WRITE setAngle NOTIFY angleChanged)
Q_PROPERTY(QVector3D axis READ axis WRITE setAxis NOTIFY axisChanged)
public:
- QSGRotation(QObject *parent = 0);
- ~QSGRotation();
+ QQuickRotation(QObject *parent = 0);
+ ~QQuickRotation();
QVector3D origin() const;
void setOrigin(const QVector3D &point);
void axisChanged();
private:
- Q_DECLARE_PRIVATE(QSGRotation)
+ Q_DECLARE_PRIVATE(QQuickRotation)
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGTranslate)
+QML_DECLARE_TYPE(QQuickTranslate)
QT_END_HEADER
**
****************************************************************************/
-#include "qsgview.h"
-#include "qsgview_p.h"
+#include "qquickview.h"
+#include "qquickview_p.h"
-#include "qsgcanvas_p.h"
-#include "qsgitem_p.h"
-#include "qsgitemchangelistener_p.h"
+#include "qquickcanvas_p.h"
+#include "qquickitem_p.h"
+#include "qquickitemchangelistener_p.h"
#include <private/qdeclarativedebugtrace_p.h>
#include <private/qdeclarativeinspectorservice_p.h>
DEFINE_BOOL_CONFIG_OPTION(frameRateDebug, QML_SHOW_FRAMERATE)
-void QSGViewPrivate::init()
+void QQuickViewPrivate::init()
{
- Q_Q(QSGView);
+ Q_Q(QQuickView);
- QDeclarativeEnginePrivate::get(&engine)->sgContext = QSGCanvasPrivate::context;
+ QDeclarativeEnginePrivate::get(&engine)->sgContext = QQuickCanvasPrivate::context;
engine.setIncubationController(q->incubationController());
QDeclarativeInspectorService::instance()->addView(q);
}
-QSGViewPrivate::QSGViewPrivate()
- : root(0), component(0), resizeMode(QSGView::SizeViewToRootObject), initialSize(0,0), resized(false)
+QQuickViewPrivate::QQuickViewPrivate()
+ : root(0), component(0), resizeMode(QQuickView::SizeViewToRootObject), initialSize(0,0), resized(false)
{
}
-QSGViewPrivate::~QSGViewPrivate()
+QQuickViewPrivate::~QQuickViewPrivate()
{
if (QDeclarativeDebugService::isDebuggingEnabled())
QDeclarativeInspectorService::instance()->removeView(q_func());
delete root;
}
-void QSGViewPrivate::execute()
+void QQuickViewPrivate::execute()
{
- Q_Q(QSGView);
+ Q_Q(QQuickView);
if (root) {
delete root;
root = 0;
}
}
-void QSGViewPrivate::itemGeometryChanged(QSGItem *resizeItem, const QRectF &newGeometry, const QRectF &oldGeometry)
+void QQuickViewPrivate::itemGeometryChanged(QQuickItem *resizeItem, const QRectF &newGeometry, const QRectF &oldGeometry)
{
- Q_Q(QSGView);
- if (resizeItem == root && resizeMode == QSGView::SizeViewToRootObject) {
+ Q_Q(QQuickView);
+ if (resizeItem == root && resizeMode == QQuickView::SizeViewToRootObject) {
// wait for both width and height to be changed
resizetimer.start(0,q);
}
- QSGItemChangeListener::itemGeometryChanged(resizeItem, newGeometry, oldGeometry);
+ QQuickItemChangeListener::itemGeometryChanged(resizeItem, newGeometry, oldGeometry);
}
-QSGView::QSGView(QWindow *parent, Qt::WindowFlags f)
-: QSGCanvas(*(new QSGViewPrivate), parent)
+QQuickView::QQuickView(QWindow *parent, Qt::WindowFlags f)
+: QQuickCanvas(*(new QQuickViewPrivate), parent)
{
setWindowFlags(f);
d_func()->init();
}
-QSGView::QSGView(const QUrl &source, QWindow *parent, Qt::WindowFlags f)
-: QSGCanvas(*(new QSGViewPrivate), parent)
+QQuickView::QQuickView(const QUrl &source, QWindow *parent, Qt::WindowFlags f)
+: QQuickCanvas(*(new QQuickViewPrivate), parent)
{
setWindowFlags(f);
d_func()->init();
setSource(source);
}
-QSGView::~QSGView()
+QQuickView::~QQuickView()
{
}
-void QSGView::setSource(const QUrl& url)
+void QQuickView::setSource(const QUrl& url)
{
- Q_D(QSGView);
+ Q_D(QQuickView);
d->source = url;
d->execute();
}
-QUrl QSGView::source() const
+QUrl QQuickView::source() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
return d->source;
}
-QDeclarativeEngine* QSGView::engine() const
+QDeclarativeEngine* QQuickView::engine() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
return const_cast<QDeclarativeEngine *>(&d->engine);
}
-QDeclarativeContext* QSGView::rootContext() const
+QDeclarativeContext* QQuickView::rootContext() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
return d->engine.rootContext();
}
-QSGView::Status QSGView::status() const
+QQuickView::Status QQuickView::status() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
if (!d->component)
- return QSGView::Null;
+ return QQuickView::Null;
- return QSGView::Status(d->component->status());
+ return QQuickView::Status(d->component->status());
}
-QList<QDeclarativeError> QSGView::errors() const
+QList<QDeclarativeError> QQuickView::errors() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
if (d->component)
return d->component->errors();
return QList<QDeclarativeError>();
}
-void QSGView::setResizeMode(ResizeMode mode)
+void QQuickView::setResizeMode(ResizeMode mode)
{
- Q_D(QSGView);
+ Q_D(QQuickView);
if (d->resizeMode == mode)
return;
if (d->root) {
if (d->resizeMode == SizeViewToRootObject) {
- QSGItemPrivate *p = QSGItemPrivate::get(d->root);
- p->removeItemChangeListener(d, QSGItemPrivate::Geometry);
+ QQuickItemPrivate *p = QQuickItemPrivate::get(d->root);
+ p->removeItemChangeListener(d, QQuickItemPrivate::Geometry);
}
}
}
}
-void QSGViewPrivate::initResize()
+void QQuickViewPrivate::initResize()
{
if (root) {
- if (resizeMode == QSGView::SizeViewToRootObject) {
- QSGItemPrivate *p = QSGItemPrivate::get(root);
- p->addItemChangeListener(this, QSGItemPrivate::Geometry);
+ if (resizeMode == QQuickView::SizeViewToRootObject) {
+ QQuickItemPrivate *p = QQuickItemPrivate::get(root);
+ p->addItemChangeListener(this, QQuickItemPrivate::Geometry);
}
}
updateSize();
}
-void QSGViewPrivate::updateSize()
+void QQuickViewPrivate::updateSize()
{
- Q_Q(QSGView);
+ Q_Q(QQuickView);
if (!root)
return;
- if (resizeMode == QSGView::SizeViewToRootObject) {
+ if (resizeMode == QQuickView::SizeViewToRootObject) {
QSize newSize = QSize(root->width(), root->height());
if (newSize.isValid() && newSize != q->size()) {
q->resize(newSize);
}
- } else if (resizeMode == QSGView::SizeRootObjectToView) {
+ } else if (resizeMode == QQuickView::SizeRootObjectToView) {
if (!qFuzzyCompare(q->width(), root->width()))
root->setWidth(q->width());
if (!qFuzzyCompare(q->height(), root->height()))
}
}
-QSize QSGViewPrivate::rootObjectSize() const
+QSize QQuickViewPrivate::rootObjectSize() const
{
QSize rootObjectSize(0,0);
int widthCandidate = -1;
return rootObjectSize;
}
-QSGView::ResizeMode QSGView::resizeMode() const
+QQuickView::ResizeMode QQuickView::resizeMode() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
return d->resizeMode;
}
/*!
\internal
*/
-void QSGView::continueExecute()
+void QQuickView::continueExecute()
{
- Q_D(QSGView);
+ Q_D(QQuickView);
disconnect(d->component, SIGNAL(statusChanged(QDeclarativeComponent::Status)), this, SLOT(continueExecute()));
if (d->component->isError()) {
/*!
\internal
*/
-void QSGViewPrivate::setRootObject(QObject *obj)
+void QQuickViewPrivate::setRootObject(QObject *obj)
{
- Q_Q(QSGView);
+ Q_Q(QQuickView);
if (root == obj)
return;
- if (QSGItem *sgItem = qobject_cast<QSGItem *>(obj)) {
+ if (QQuickItem *sgItem = qobject_cast<QQuickItem *>(obj)) {
root = sgItem;
- sgItem->setParentItem(q->QSGCanvas::rootItem());
+ sgItem->setParentItem(q->QQuickCanvas::rootItem());
} else {
- qWarning() << "QSGView only supports loading of root objects that derive from QSGItem." << endl
+ qWarning() << "QQuickView only supports loading of root objects that derive from QQuickItem." << endl
<< endl
<< "If your example is using QML 2, (such as qmlscene) and the .qml file you" << endl
<< "loaded has 'import QtQuick 1.0' or 'import Qt 4.7', this error will occur." << endl
}
if (root) {
initialSize = rootObjectSize();
- if ((resizeMode == QSGView::SizeViewToRootObject || !resized) // ### refactor: || !q->testAttribute(Qt::WA_Resized)
+ if ((resizeMode == QQuickView::SizeViewToRootObject || !resized) // ### refactor: || !q->testAttribute(Qt::WA_Resized)
&& initialSize != q->size()) {
q->resize(initialSize);
If the \l {QTimerEvent} {timer event} \a e is this
view's resize timer, sceneResized() is emitted.
*/
-void QSGView::timerEvent(QTimerEvent* e)
+void QQuickView::timerEvent(QTimerEvent* e)
{
- Q_D(QSGView);
+ Q_D(QQuickView);
if (!e || e->timerId() == d->resizetimer.timerId()) {
d->updateSize();
d->resizetimer.stop();
\internal
Preferred size follows the root object geometry.
*/
-QSize QSGView::sizeHint() const
+QSize QQuickView::sizeHint() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
QSize rootObjectSize = d->rootObjectSize();
if (rootObjectSize.isEmpty()) {
return size();
}
}
-QSize QSGView::initialSize() const
+QSize QQuickView::initialSize() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
return d->initialSize;
}
-QSGItem *QSGView::rootObject() const
+QQuickItem *QQuickView::rootObject() const
{
- Q_D(const QSGView);
+ Q_D(const QQuickView);
return d->root;
}
This function handles the \l {QResizeEvent} {resize event}
\a e.
*/
-void QSGView::resizeEvent(QResizeEvent *e)
+void QQuickView::resizeEvent(QResizeEvent *e)
{
- Q_D(QSGView);
+ Q_D(QQuickView);
if (d->resizeMode == SizeRootObjectToView)
d->updateSize();
- QSGCanvas::resizeEvent(e);
+ QQuickCanvas::resizeEvent(e);
}
-void QSGView::keyPressEvent(QKeyEvent *e)
+void QQuickView::keyPressEvent(QKeyEvent *e)
{
QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Key);
- QSGCanvas::keyPressEvent(e);
+ QQuickCanvas::keyPressEvent(e);
}
-void QSGView::keyReleaseEvent(QKeyEvent *e)
+void QQuickView::keyReleaseEvent(QKeyEvent *e)
{
QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Key);
- QSGCanvas::keyReleaseEvent(e);
+ QQuickCanvas::keyReleaseEvent(e);
}
-void QSGView::mouseMoveEvent(QMouseEvent *e)
+void QQuickView::mouseMoveEvent(QMouseEvent *e)
{
QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Mouse);
- QSGCanvas::mouseMoveEvent(e);
+ QQuickCanvas::mouseMoveEvent(e);
}
-void QSGView::mousePressEvent(QMouseEvent *e)
+void QQuickView::mousePressEvent(QMouseEvent *e)
{
QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Mouse);
- QSGCanvas::mousePressEvent(e);
+ QQuickCanvas::mousePressEvent(e);
}
-void QSGView::mouseReleaseEvent(QMouseEvent *e)
+void QQuickView::mouseReleaseEvent(QMouseEvent *e)
{
QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Mouse);
- QSGCanvas::mouseReleaseEvent(e);
+ QQuickCanvas::mouseReleaseEvent(e);
}
**
****************************************************************************/
-#ifndef QSGVIEW_H
-#define QSGVIEW_H
+#ifndef QQUICKVIEW_H
+#define QQUICKVIEW_H
-#include <qsgcanvas.h>
+#include <qquickcanvas.h>
#include <QtCore/qurl.h>
#include <QtDeclarative/qdeclarativedebug.h>
class QDeclarativeEngine;
class QDeclarativeContext;
class QDeclarativeError;
-class QSGItem;
+class QQuickItem;
-class QSGViewPrivate;
-class Q_DECLARATIVE_EXPORT QSGView : public QSGCanvas
+class QQuickViewPrivate;
+class Q_DECLARATIVE_EXPORT QQuickView : public QQuickCanvas
{
Q_OBJECT
Q_PROPERTY(ResizeMode resizeMode READ resizeMode WRITE setResizeMode)
Q_PROPERTY(QUrl source READ source WRITE setSource DESIGNABLE true)
Q_ENUMS(ResizeMode Status)
public:
- explicit QSGView(QWindow *parent = 0, Qt::WindowFlags f = 0);
- QSGView(const QUrl &source, QWindow *parent = 0, Qt::WindowFlags f = 0);
- virtual ~QSGView();
+ explicit QQuickView(QWindow *parent = 0, Qt::WindowFlags f = 0);
+ QQuickView(const QUrl &source, QWindow *parent = 0, Qt::WindowFlags f = 0);
+ virtual ~QQuickView();
QUrl source() const;
QDeclarativeEngine* engine() const;
QDeclarativeContext* rootContext() const;
- QSGItem *rootObject() const;
+ QQuickItem *rootObject() const;
enum ResizeMode { SizeViewToRootObject, SizeRootObjectToView };
ResizeMode resizeMode() const;
void setSource(const QUrl&);
Q_SIGNALS:
- void statusChanged(QSGView::Status);
+ void statusChanged(QQuickView::Status);
private Q_SLOTS:
void continueExecute();
virtual void mouseReleaseEvent(QMouseEvent *);
virtual void mouseMoveEvent(QMouseEvent *);
private:
- Q_DISABLE_COPY(QSGView)
- Q_DECLARE_PRIVATE(QSGView)
+ Q_DISABLE_COPY(QQuickView)
+ Q_DECLARE_PRIVATE(QQuickView)
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // QSGVIEW_H
+#endif // QQUICKVIEW_H
**
****************************************************************************/
-#ifndef QSGVIEW_P_H
-#define QSGVIEW_P_H
+#ifndef QQUICKVIEW_P_H
+#define QQUICKVIEW_P_H
-#include "qsgview.h"
+#include "qquickview.h"
#include <QtCore/qurl.h>
#include <QtCore/qelapsedtimer.h>
#include <QtCore/qtimer.h>
#include <QtCore/qpointer.h>
#include <QtDeclarative/qdeclarativeengine.h>
-#include "qsgcanvas_p.h"
+#include "qquickcanvas_p.h"
-#include "qsgitemchangelistener_p.h"
+#include "qquickitemchangelistener_p.h"
QT_BEGIN_HEADER
class QDeclarativeContext;
class QDeclarativeError;
-class QSGItem;
+class QQuickItem;
class QDeclarativeComponent;
-class QSGViewPrivate : public QSGCanvasPrivate,
- public QSGItemChangeListener
+class QQuickViewPrivate : public QQuickCanvasPrivate,
+ public QQuickItemChangeListener
{
- Q_DECLARE_PUBLIC(QSGView)
+ Q_DECLARE_PUBLIC(QQuickView)
public:
- static QSGViewPrivate* get(QSGView *view) { return view->d_func(); }
- static const QSGViewPrivate* get(const QSGView *view) { return view->d_func(); }
+ static QQuickViewPrivate* get(QQuickView *view) { return view->d_func(); }
+ static const QQuickViewPrivate* get(const QQuickView *view) { return view->d_func(); }
- QSGViewPrivate();
- ~QSGViewPrivate();
+ QQuickViewPrivate();
+ ~QQuickViewPrivate();
void execute();
- void itemGeometryChanged(QSGItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+ void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
void initResize();
void updateSize();
void setRootObject(QObject *);
QSize rootObjectSize() const;
- QPointer<QSGItem> root;
+ QPointer<QQuickItem> root;
QUrl source;
QDeclarativeComponent *component;
QBasicTimer resizetimer;
- QSGView::ResizeMode resizeMode;
+ QQuickView::ResizeMode resizeMode;
QSize initialSize;
QElapsedTimer frameTimer;
QT_END_HEADER
-#endif // QSGVIEW_P_H
+#endif // QQUICKVIEW_P_H
**
****************************************************************************/
-#include "qsgvisualadaptormodel_p.h"
-#include "qsgitem.h"
+#include "qquickvisualadaptormodel_p.h"
+#include "qquickitem.h"
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeengine.h>
QMetaObjectBuilder builder;
};
-class QSGVisualAdaptorModelData : public QObject
+class QQuickVisualAdaptorModelData : public QObject
{
Q_OBJECT
Q_PROPERTY(int index READ index NOTIFY indexChanged)
public:
- QSGVisualAdaptorModelData(int index, QSGVisualAdaptorModel *model);
- ~QSGVisualAdaptorModelData();
+ QQuickVisualAdaptorModelData(int index, QQuickVisualAdaptorModel *model);
+ ~QQuickVisualAdaptorModelData();
int index() const;
void setIndex(int index);
public:
int m_index;
- QDeclarativeGuard<QSGVisualAdaptorModel> m_model;
+ QDeclarativeGuard<QQuickVisualAdaptorModel> m_model;
QIntrusiveListNode m_cacheNode;
};
-typedef QIntrusiveList<QSGVisualAdaptorModelData, &QSGVisualAdaptorModelData::m_cacheNode> QSGVisualAdaptorModelDataCache;
+typedef QIntrusiveList<QQuickVisualAdaptorModelData, &QQuickVisualAdaptorModelData::m_cacheNode> QQuickVisualAdaptorModelDataCache;
-class QSGVisualAdaptorModelDataMetaObject;
-class QSGVisualAdaptorModelPrivate : public QObjectPrivate
+class QQuickVisualAdaptorModelDataMetaObject;
+class QQuickVisualAdaptorModelPrivate : public QObjectPrivate
{
- Q_DECLARE_PUBLIC(QSGVisualAdaptorModel)
+ Q_DECLARE_PUBLIC(QQuickVisualAdaptorModel)
public:
- QSGVisualAdaptorModelPrivate()
+ QQuickVisualAdaptorModelPrivate()
: m_engine(0)
, m_listAccessor(0)
, m_delegateDataType(0)
}
- static QSGVisualAdaptorModelPrivate *get(QSGVisualAdaptorModel *m) {
- return static_cast<QSGVisualAdaptorModelPrivate *>(QObjectPrivate::get(m));
+ static QQuickVisualAdaptorModelPrivate *get(QQuickVisualAdaptorModel *m) {
+ return static_cast<QQuickVisualAdaptorModelPrivate *>(QObjectPrivate::get(m));
}
void addProperty(int role, int propertyId, const char *propertyName, const char *propertyType, bool isModelData = false);
m_delegateDataType->propertyOffset = T::staticMetaObject.propertyCount();
m_delegateDataType->signalOffset = T::staticMetaObject.methodCount();
}
- QSGVisualAdaptorModelData *createMetaObject(int index, QSGVisualAdaptorModel *model);
+ QQuickVisualAdaptorModelData *createMetaObject(int index, QQuickVisualAdaptorModel *model);
- static QSGVisualAdaptorModelData *initializeModelData(int index, QSGVisualAdaptorModel *model) {
+ static QQuickVisualAdaptorModelData *initializeModelData(int index, QQuickVisualAdaptorModel *model) {
return get(model)->createMetaObject(index, model);
}
- typedef QSGVisualAdaptorModelData *(*CreateModelData)(int index, QSGVisualAdaptorModel *model);
+ typedef QQuickVisualAdaptorModelData *(*CreateModelData)(int index, QQuickVisualAdaptorModel *model);
struct PropertyData {
int role;
int m_ref;
int m_count;
- QSGVisualAdaptorModel::Flags m_flags;
+ QQuickVisualAdaptorModel::Flags m_flags;
bool m_objectList : 1;
QVariant m_modelVariant;
QList<QByteArray> watchedRoles;
QHash<QByteArray,int> m_roleNames;
QVector<PropertyData> m_propertyData;
- QSGVisualAdaptorModelDataCache m_cache;
+ QQuickVisualAdaptorModelDataCache m_cache;
};
-class QSGVisualAdaptorModelDataMetaObject : public QAbstractDynamicMetaObject
+class QQuickVisualAdaptorModelDataMetaObject : public QAbstractDynamicMetaObject
{
public:
- QSGVisualAdaptorModelDataMetaObject(QSGVisualAdaptorModelData *data, VDMDelegateDataType *type)
+ QQuickVisualAdaptorModelDataMetaObject(QQuickVisualAdaptorModelData *data, VDMDelegateDataType *type)
: m_data(data)
, m_type(type)
{
m_type->addref();
}
- ~QSGVisualAdaptorModelDataMetaObject() { m_type->release(); }
+ ~QQuickVisualAdaptorModelDataMetaObject() { m_type->release(); }
- QSGVisualAdaptorModelData *m_data;
+ QQuickVisualAdaptorModelData *m_data;
VDMDelegateDataType *m_type;
};
-class QSGVDMAbstractItemModelDataMetaObject : public QSGVisualAdaptorModelDataMetaObject
+class QQuickVDMAbstractItemModelDataMetaObject : public QQuickVisualAdaptorModelDataMetaObject
{
public:
- QSGVDMAbstractItemModelDataMetaObject(QSGVisualAdaptorModelData *object, VDMDelegateDataType *type)
- : QSGVisualAdaptorModelDataMetaObject(object, type) {}
+ QQuickVDMAbstractItemModelDataMetaObject(QQuickVisualAdaptorModelData *object, VDMDelegateDataType *type)
+ : QQuickVisualAdaptorModelDataMetaObject(object, type) {}
int metaCall(QMetaObject::Call call, int id, void **arguments)
{
if (call == QMetaObject::ReadProperty && id >= m_type->propertyOffset) {
- QSGVisualAdaptorModelPrivate *model = QSGVisualAdaptorModelPrivate::get(m_data->m_model);
+ QQuickVisualAdaptorModelPrivate *model = QQuickVisualAdaptorModelPrivate::get(m_data->m_model);
if (m_data->m_index == -1 || !model->m_abstractItemModel)
return -1;
*static_cast<QVariant *>(arguments[0]) = model->m_abstractItemModel->index(
}
};
-class QSGVDMAbstractItemModelData : public QSGVisualAdaptorModelData
+class QQuickVDMAbstractItemModelData : public QQuickVisualAdaptorModelData
{
Q_OBJECT
Q_PROPERTY(bool hasModelChildren READ hasModelChildren CONSTANT)
public:
bool hasModelChildren() const
{
- QSGVisualAdaptorModelPrivate *model = QSGVisualAdaptorModelPrivate::get(m_model);
+ QQuickVisualAdaptorModelPrivate *model = QQuickVisualAdaptorModelPrivate::get(m_model);
return model->m_abstractItemModel->hasChildren(model->m_abstractItemModel->index(m_index, 0, model->m_root));
}
- static QSGVisualAdaptorModelData *create(int index, QSGVisualAdaptorModel *model) {
- return new QSGVDMAbstractItemModelData(index, model); }
+ static QQuickVisualAdaptorModelData *create(int index, QQuickVisualAdaptorModel *model) {
+ return new QQuickVDMAbstractItemModelData(index, model); }
private:
- QSGVDMAbstractItemModelData(int index, QSGVisualAdaptorModel *model)
- : QSGVisualAdaptorModelData(index, model)
+ QQuickVDMAbstractItemModelData(int index, QQuickVisualAdaptorModel *model)
+ : QQuickVisualAdaptorModelData(index, model)
{
- new QSGVDMAbstractItemModelDataMetaObject(
- this, QSGVisualAdaptorModelPrivate::get(m_model)->m_delegateDataType);
+ new QQuickVDMAbstractItemModelDataMetaObject(
+ this, QQuickVisualAdaptorModelPrivate::get(m_model)->m_delegateDataType);
}
};
-class QSGVDMListModelInterfaceDataMetaObject : public QSGVisualAdaptorModelDataMetaObject
+class QQuickVDMListModelInterfaceDataMetaObject : public QQuickVisualAdaptorModelDataMetaObject
{
public:
- QSGVDMListModelInterfaceDataMetaObject(QSGVisualAdaptorModelData *object, VDMDelegateDataType *type)
- : QSGVisualAdaptorModelDataMetaObject(object, type) {}
+ QQuickVDMListModelInterfaceDataMetaObject(QQuickVisualAdaptorModelData *object, VDMDelegateDataType *type)
+ : QQuickVisualAdaptorModelDataMetaObject(object, type) {}
int metaCall(QMetaObject::Call call, int id, void **arguments)
{
if (call == QMetaObject::ReadProperty && id >= m_type->propertyOffset) {
- QSGVisualAdaptorModelPrivate *model = QSGVisualAdaptorModelPrivate::get(m_data->m_model);
+ QQuickVisualAdaptorModelPrivate *model = QQuickVisualAdaptorModelPrivate::get(m_data->m_model);
if (m_data->m_index == -1 || !model->m_listModelInterface)
return -1;
*static_cast<QVariant *>(arguments[0]) = model->m_listModelInterface->data(
}
};
-class QSGVDMListModelInterfaceData : public QSGVisualAdaptorModelData
+class QQuickVDMListModelInterfaceData : public QQuickVisualAdaptorModelData
{
public:
- static QSGVisualAdaptorModelData *create(int index, QSGVisualAdaptorModel *model) {
- return new QSGVDMListModelInterfaceData(index, model); }
+ static QQuickVisualAdaptorModelData *create(int index, QQuickVisualAdaptorModel *model) {
+ return new QQuickVDMListModelInterfaceData(index, model); }
private:
- QSGVDMListModelInterfaceData(int index, QSGVisualAdaptorModel *model)
- : QSGVisualAdaptorModelData(index, model)
+ QQuickVDMListModelInterfaceData(int index, QQuickVisualAdaptorModel *model)
+ : QQuickVisualAdaptorModelData(index, model)
{
- new QSGVDMListModelInterfaceDataMetaObject(
- this, QSGVisualAdaptorModelPrivate::get(m_model)->m_delegateDataType);
+ new QQuickVDMListModelInterfaceDataMetaObject(
+ this, QQuickVisualAdaptorModelPrivate::get(m_model)->m_delegateDataType);
}
};
-class QSGVDMListAccessorData : public QSGVisualAdaptorModelData
+class QQuickVDMListAccessorData : public QQuickVisualAdaptorModelData
{
Q_OBJECT
Q_PROPERTY(QVariant modelData READ modelData CONSTANT)
public:
QVariant modelData() const {
- return QSGVisualAdaptorModelPrivate::get(m_model)->m_listAccessor->at(m_index); }
+ return QQuickVisualAdaptorModelPrivate::get(m_model)->m_listAccessor->at(m_index); }
- static QSGVisualAdaptorModelData *create(int index, QSGVisualAdaptorModel *model) {
- return new QSGVDMListAccessorData(index, model); }
+ static QQuickVisualAdaptorModelData *create(int index, QQuickVisualAdaptorModel *model) {
+ return new QQuickVDMListAccessorData(index, model); }
private:
- QSGVDMListAccessorData(int index, QSGVisualAdaptorModel *model)
- : QSGVisualAdaptorModelData(index, model)
+ QQuickVDMListAccessorData(int index, QQuickVisualAdaptorModel *model)
+ : QQuickVisualAdaptorModelData(index, model)
{
}
};
-class QSGVDMObjectDataMetaObject : public QSGVisualAdaptorModelDataMetaObject
+class QQuickVDMObjectDataMetaObject : public QQuickVisualAdaptorModelDataMetaObject
{
public:
- QSGVDMObjectDataMetaObject(QSGVisualAdaptorModelData *data, VDMDelegateDataType *type)
- : QSGVisualAdaptorModelDataMetaObject(data, type)
- , m_object(QSGVisualAdaptorModelPrivate::get(data->m_model)->m_listAccessor->at(data->m_index).value<QObject *>())
+ QQuickVDMObjectDataMetaObject(QQuickVisualAdaptorModelData *data, VDMDelegateDataType *type)
+ : QQuickVisualAdaptorModelDataMetaObject(data, type)
+ , m_object(QQuickVisualAdaptorModelPrivate::get(data->m_model)->m_listAccessor->at(data->m_index).value<QObject *>())
{}
int metaCall(QMetaObject::Call call, int id, void **arguments)
QDeclarativeGuard<QObject> m_object;
};
-class QSGVDMObjectData : public QSGVisualAdaptorModelData, public QSGVisualAdaptorModelProxyInterface
+class QQuickVDMObjectData : public QQuickVisualAdaptorModelData, public QQuickVisualAdaptorModelProxyInterface
{
Q_OBJECT
Q_PROPERTY(QObject *modelData READ modelData CONSTANT)
- Q_INTERFACES(QSGVisualAdaptorModelProxyInterface)
+ Q_INTERFACES(QQuickVisualAdaptorModelProxyInterface)
public:
QObject *modelData() const { return m_metaObject->m_object; }
QObject *proxiedObject() { return m_metaObject->m_object; }
- static QSGVisualAdaptorModelData *create(int index, QSGVisualAdaptorModel *model) {
- return new QSGVDMObjectData(index, model); }
+ static QQuickVisualAdaptorModelData *create(int index, QQuickVisualAdaptorModel *model) {
+ return new QQuickVDMObjectData(index, model); }
private:
- QSGVDMObjectData(int index, QSGVisualAdaptorModel *model)
- : QSGVisualAdaptorModelData(index, model)
- , m_metaObject(new QSGVDMObjectDataMetaObject(this, QSGVisualAdaptorModelPrivate::get(m_model)->m_delegateDataType))
+ QQuickVDMObjectData(int index, QQuickVisualAdaptorModel *model)
+ : QQuickVisualAdaptorModelData(index, model)
+ , m_metaObject(new QQuickVDMObjectDataMetaObject(this, QQuickVisualAdaptorModelPrivate::get(m_model)->m_delegateDataType))
{
}
- QSGVDMObjectDataMetaObject *m_metaObject;
+ QQuickVDMObjectDataMetaObject *m_metaObject;
};
-void QSGVisualAdaptorModelPrivate::addProperty(
+void QQuickVisualAdaptorModelPrivate::addProperty(
int role, int propertyId, const char *propertyName, const char *propertyType, bool isModelData)
{
PropertyData propertyData;
m_propertyData.append(propertyData);
}
-QSGVisualAdaptorModelData *QSGVisualAdaptorModelPrivate::createMetaObject(int index, QSGVisualAdaptorModel *model)
+QQuickVisualAdaptorModelData *QQuickVisualAdaptorModelPrivate::createMetaObject(int index, QQuickVisualAdaptorModel *model)
{
Q_ASSERT(!m_delegateDataType);
if (m_listAccessor
&& m_listAccessor->type() != QDeclarativeListAccessor::ListProperty
&& m_listAccessor->type() != QDeclarativeListAccessor::Instance) {
- createModelData = &QSGVDMListAccessorData::create;
- m_flags = QSGVisualAdaptorModel::MetaObjectCacheable;
- return QSGVDMListAccessorData::create(index, model);
+ createModelData = &QQuickVDMListAccessorData::create;
+ m_flags = QQuickVisualAdaptorModel::MetaObjectCacheable;
+ return QQuickVDMListAccessorData::create(index, model);
}
m_delegateDataType = new VDMDelegateDataType;
if (m_listModelInterface) {
- setModelDataType<QSGVDMListModelInterfaceData>();
+ setModelDataType<QQuickVDMListModelInterfaceData>();
QList<int> roles = m_listModelInterface->roles();
for (int propertyId = 0; propertyId < roles.count(); ++propertyId) {
const int role = roles.at(propertyId);
}
if (m_propertyData.count() == 1)
addProperty(roles.first(), 1, "modelData", "QVariant", true);
- m_flags = QSGVisualAdaptorModel::MetaObjectCacheable;
+ m_flags = QQuickVisualAdaptorModel::MetaObjectCacheable;
} else if (m_abstractItemModel) {
- setModelDataType<QSGVDMAbstractItemModelData>();
+ setModelDataType<QQuickVDMAbstractItemModelData>();
QHash<int, QByteArray> roleNames = m_abstractItemModel->roleNames();
for (QHash<int, QByteArray>::const_iterator it = roleNames.begin(); it != roleNames.end(); ++it) {
addProperty(it.key(), m_propertyData.count(), it.value(), "QVariant");
}
if (m_propertyData.count() == 1)
addProperty(roleNames.begin().key(), 1, "modelData", "QVariant", true);
- m_flags = QSGVisualAdaptorModel::MetaObjectCacheable;
+ m_flags = QQuickVisualAdaptorModel::MetaObjectCacheable;
} else if (m_listAccessor) {
- setModelDataType<QSGVDMObjectData>();
+ setModelDataType<QQuickVDMObjectData>();
m_objectList = true;
- m_flags = QSGVisualAdaptorModel::ProxiedObject;
+ m_flags = QQuickVisualAdaptorModel::ProxiedObject;
} else {
Q_ASSERT(!"No model set on VisualDataModel");
return 0;
return createModelData(index, model);
}
-QSGVisualAdaptorModelData::QSGVisualAdaptorModelData(int index, QSGVisualAdaptorModel *model)
+QQuickVisualAdaptorModelData::QQuickVisualAdaptorModelData(int index, QQuickVisualAdaptorModel *model)
: m_index(index)
, m_model(model)
{
}
-QSGVisualAdaptorModelData::~QSGVisualAdaptorModelData()
+QQuickVisualAdaptorModelData::~QQuickVisualAdaptorModelData()
{
}
-int QSGVisualAdaptorModelData::index() const
+int QQuickVisualAdaptorModelData::index() const
{
return m_index;
}
// This is internal only - it should not be set from qml
-void QSGVisualAdaptorModelData::setIndex(int index)
+void QQuickVisualAdaptorModelData::setIndex(int index)
{
m_index = index;
emit indexChanged();
//---------------------------------------------------------------------------
-QSGVisualAdaptorModel::QSGVisualAdaptorModel(QObject *parent)
- : QObject(*(new QSGVisualAdaptorModelPrivate), parent)
+QQuickVisualAdaptorModel::QQuickVisualAdaptorModel(QObject *parent)
+ : QObject(*(new QQuickVisualAdaptorModelPrivate), parent)
{
}
-QSGVisualAdaptorModel::~QSGVisualAdaptorModel()
+QQuickVisualAdaptorModel::~QQuickVisualAdaptorModel()
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (d->m_listAccessor)
delete d->m_listAccessor;
if (d->m_delegateDataType)
d->m_delegateDataType->release();
}
-QSGVisualAdaptorModel::Flags QSGVisualAdaptorModel::flags() const
+QQuickVisualAdaptorModel::Flags QQuickVisualAdaptorModel::flags() const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
return d->m_flags;
}
-QVariant QSGVisualAdaptorModel::model() const
+QVariant QQuickVisualAdaptorModel::model() const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
return d->m_modelVariant;
}
-void QSGVisualAdaptorModel::setModel(const QVariant &model, QDeclarativeEngine *engine)
+void QQuickVisualAdaptorModel::setModel(const QVariant &model, QDeclarativeEngine *engine)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
delete d->m_listAccessor;
d->m_engine = engine;
d->m_listAccessor = 0;
d->m_roles.clear();
d->m_roleNames.clear();
- d->m_flags = QSGVisualAdaptorModel::Flags();
+ d->m_flags = QQuickVisualAdaptorModel::Flags();
if (d->m_delegateDataType)
d->m_delegateDataType->release();
d->m_delegateDataType = 0;
- d->createModelData = &QSGVisualAdaptorModelPrivate::initializeModelData;
+ d->createModelData = &QQuickVisualAdaptorModelPrivate::initializeModelData;
if (d->m_count)
emit itemsRemoved(0, d->m_count);
emit itemsInserted(0, d->m_count);
}
-QVariant QSGVisualAdaptorModel::rootIndex() const
+QVariant QQuickVisualAdaptorModel::rootIndex() const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
return QVariant::fromValue(d->m_root);
}
-void QSGVisualAdaptorModel::setRootIndex(const QVariant &root)
+void QQuickVisualAdaptorModel::setRootIndex(const QVariant &root)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
QModelIndex modelIndex = qvariant_cast<QModelIndex>(root);
if (d->m_root != modelIndex) {
int oldCount = d->modelCount();
}
}
-QVariant QSGVisualAdaptorModel::modelIndex(int idx) const
+QVariant QQuickVisualAdaptorModel::modelIndex(int idx) const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
if (d->m_abstractItemModel)
return QVariant::fromValue(d->m_abstractItemModel->index(idx, 0, d->m_root));
return QVariant::fromValue(QModelIndex());
}
-QVariant QSGVisualAdaptorModel::parentModelIndex() const
+QVariant QQuickVisualAdaptorModel::parentModelIndex() const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
if (d->m_abstractItemModel)
return QVariant::fromValue(d->m_abstractItemModel->parent(d->m_root));
return QVariant::fromValue(QModelIndex());
}
-int QSGVisualAdaptorModel::count() const
+int QQuickVisualAdaptorModel::count() const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
return d->modelCount();
}
-QObject *QSGVisualAdaptorModel::data(int index)
+QObject *QQuickVisualAdaptorModel::data(int index)
{
- Q_D(QSGVisualAdaptorModel);
- QSGVisualAdaptorModelData *data = d->createModelData(index, this);
+ Q_D(QQuickVisualAdaptorModel);
+ QQuickVisualAdaptorModelData *data = d->createModelData(index, this);
d->m_cache.insert(data);
return data;
}
-QString QSGVisualAdaptorModel::stringValue(int index, const QString &name)
+QString QQuickVisualAdaptorModel::stringValue(int index, const QString &name)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if ((!d->m_listModelInterface || !d->m_abstractItemModel) && d->m_listAccessor) {
if (QObject *object = d->m_listAccessor->at(index).value<QObject*>())
return object->property(name.toUtf8()).toString();
}
QString val;
- QSGVisualAdaptorModelData *data = d->createModelData(index, this);
+ QQuickVisualAdaptorModelData *data = d->createModelData(index, this);
QDeclarativeData *ddata = QDeclarativeData::get(data);
if (ddata && ddata->propertyCache) {
return val;
}
-int QSGVisualAdaptorModel::indexOf(QObject *object) const
+int QQuickVisualAdaptorModel::indexOf(QObject *object) const
{
- if (QSGVisualAdaptorModelData *data = qobject_cast<QSGVisualAdaptorModelData *>(object))
+ if (QQuickVisualAdaptorModelData *data = qobject_cast<QQuickVisualAdaptorModelData *>(object))
return data->index();
return -1;
}
-bool QSGVisualAdaptorModel::canFetchMore() const
+bool QQuickVisualAdaptorModel::canFetchMore() const
{
- Q_D(const QSGVisualAdaptorModel);
+ Q_D(const QQuickVisualAdaptorModel);
return d->m_abstractItemModel && d->m_abstractItemModel->canFetchMore(d->m_root);
}
-void QSGVisualAdaptorModel::fetchMore()
+void QQuickVisualAdaptorModel::fetchMore()
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (d->m_abstractItemModel)
d->m_abstractItemModel->fetchMore(d->m_root);
}
-void QSGVisualAdaptorModel::replaceWatchedRoles(const QList<QByteArray> &oldRoles, const QList<QByteArray> &newRoles)
+void QQuickVisualAdaptorModel::replaceWatchedRoles(const QList<QByteArray> &oldRoles, const QList<QByteArray> &newRoles)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
d->watchedRoleIds.clear();
foreach (const QByteArray &oldRole, oldRoles)
d->watchedRoles.removeOne(oldRole);
d->watchedRoles += newRoles;
}
-void QSGVisualAdaptorModel::_q_itemsChanged(int index, int count, const QList<int> &roles)
+void QQuickVisualAdaptorModel::_q_itemsChanged(int index, int count, const QList<int> &roles)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
bool changed = roles.isEmpty();
if (!d->watchedRoles.isEmpty() && d->watchedRoleIds.isEmpty()) {
foreach (QByteArray r, d->watchedRoles) {
signalIndexes.append(propertyId + d->m_delegateDataType->signalOffset);
}
- typedef QSGVisualAdaptorModelDataCache::iterator iterator;
+ typedef QQuickVisualAdaptorModelDataCache::iterator iterator;
for (iterator it = d->m_cache.begin(); it != d->m_cache.end(); ++it) {
const int idx = it->index();
if (idx >= index && idx < index + count) {
- QSGVisualAdaptorModelData *data = *it;
+ QQuickVisualAdaptorModelData *data = *it;
for (int i = 0; i < signalIndexes.count(); ++i)
QMetaObject::activate(data, signalIndexes.at(i), 0);
}
emit itemsChanged(index, count);
}
-void QSGVisualAdaptorModel::_q_itemsInserted(int index, int count)
+void QQuickVisualAdaptorModel::_q_itemsInserted(int index, int count)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (count <= 0)
return;
d->m_count += count;
- typedef QSGVisualAdaptorModelDataCache::iterator iterator;
+ typedef QQuickVisualAdaptorModelDataCache::iterator iterator;
for (iterator it = d->m_cache.begin(); it != d->m_cache.end(); ++it) {
if (it->index() >= index)
it->setIndex(it->index() + count);
emit itemsInserted(index, count);
}
-void QSGVisualAdaptorModel::_q_itemsRemoved(int index, int count)
+void QQuickVisualAdaptorModel::_q_itemsRemoved(int index, int count)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (count <= 0)
return;
d->m_count -= count;
- typedef QSGVisualAdaptorModelDataCache::iterator iterator;
+ typedef QQuickVisualAdaptorModelDataCache::iterator iterator;
for (iterator it = d->m_cache.begin(); it != d->m_cache.end(); ++it) {
if (it->index() >= index + count)
it->setIndex(it->index() - count);
emit itemsRemoved(index, count);
}
-void QSGVisualAdaptorModel::_q_itemsMoved(int from, int to, int count)
+void QQuickVisualAdaptorModel::_q_itemsMoved(int from, int to, int count)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
const int minimum = qMin(from, to);
const int maximum = qMax(from, to) + count;
const int difference = from > to ? count : -count;
- typedef QSGVisualAdaptorModelDataCache::iterator iterator;
+ typedef QQuickVisualAdaptorModelDataCache::iterator iterator;
for (iterator it = d->m_cache.begin(); it != d->m_cache.end(); ++it) {
if (it->index() >= from && it->index() < from + count)
it->setIndex(it->index() - from + to);
emit itemsMoved(from, to, count);
}
-void QSGVisualAdaptorModel::_q_rowsInserted(const QModelIndex &parent, int begin, int end)
+void QQuickVisualAdaptorModel::_q_rowsInserted(const QModelIndex &parent, int begin, int end)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (parent == d->m_root)
_q_itemsInserted(begin, end - begin + 1);
}
-void QSGVisualAdaptorModel::_q_rowsRemoved(const QModelIndex &parent, int begin, int end)
+void QQuickVisualAdaptorModel::_q_rowsRemoved(const QModelIndex &parent, int begin, int end)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (parent == d->m_root)
_q_itemsRemoved(begin, end - begin + 1);
}
-void QSGVisualAdaptorModel::_q_rowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)
+void QQuickVisualAdaptorModel::_q_rowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
const int count = sourceEnd - sourceStart + 1;
if (destinationParent == d->m_root && sourceParent == d->m_root) {
_q_itemsMoved(sourceStart, sourceStart > destinationRow ? destinationRow : destinationRow-count, count);
}
}
-void QSGVisualAdaptorModel::_q_dataChanged(const QModelIndex &begin, const QModelIndex &end)
+void QQuickVisualAdaptorModel::_q_dataChanged(const QModelIndex &begin, const QModelIndex &end)
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
if (begin.parent() == d->m_root)
_q_itemsChanged(begin.row(), end.row() - begin.row() + 1, d->m_roles);
}
-void QSGVisualAdaptorModel::_q_layoutChanged()
+void QQuickVisualAdaptorModel::_q_layoutChanged()
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
_q_itemsChanged(0, count(), d->m_roles);
}
-void QSGVisualAdaptorModel::_q_modelReset()
+void QQuickVisualAdaptorModel::_q_modelReset()
{
- Q_D(QSGVisualAdaptorModel);
+ Q_D(QQuickVisualAdaptorModel);
int oldCount = d->m_count;
d->m_root = QModelIndex();
d->m_count = d->modelCount();
QML_DECLARE_TYPE(QListModelInterface)
-#include <qsgvisualadaptormodel.moc>
+#include <qquickvisualadaptormodel.moc>
**
****************************************************************************/
-#ifndef QSGVISUALADAPTORMODEL_P_H
-#define QSGVISUALADAPTORMODEL_P_H
+#ifndef QQUICKVISUALADAPTORMODEL_P_H
+#define QQUICKVISUALADAPTORMODEL_P_H
#include <QtCore/qobject.h>
#include <QtCore/qabstractitemmodel.h>
class QDeclarativeEngine;
-class QSGVisualAdaptorModelPrivate;
-class QSGVisualAdaptorModel : public QObject
+class QQuickVisualAdaptorModelPrivate;
+class QQuickVisualAdaptorModel : public QObject
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGVisualAdaptorModel)
+ Q_DECLARE_PRIVATE(QQuickVisualAdaptorModel)
public:
enum Flag
{
};
Q_DECLARE_FLAGS(Flags, Flag)
- QSGVisualAdaptorModel(QObject *parent = 0);
- virtual ~QSGVisualAdaptorModel();
+ QQuickVisualAdaptorModel(QObject *parent = 0);
+ virtual ~QQuickVisualAdaptorModel();
Flags flags() const;
void _q_modelReset();
private:
- Q_DISABLE_COPY(QSGVisualAdaptorModel)
+ Q_DISABLE_COPY(QQuickVisualAdaptorModel)
};
-class QSGVisualAdaptorModelProxyInterface
+class QQuickVisualAdaptorModelProxyInterface
{
public:
- virtual ~QSGVisualAdaptorModelProxyInterface() {}
+ virtual ~QQuickVisualAdaptorModelProxyInterface() {}
virtual QObject *proxiedObject() = 0;
};
-Q_DECLARE_INTERFACE(QSGVisualAdaptorModelProxyInterface, "com.trolltech.qml.QSGVisualAdaptorModelProxyInterface")
+Q_DECLARE_INTERFACE(QQuickVisualAdaptorModelProxyInterface, "com.trolltech.qml.QQuickVisualAdaptorModelProxyInterface")
QT_END_NAMESPACE
**
****************************************************************************/
-#include "qsgvisualdatamodel_p.h"
-#include "qsgitem.h"
+#include "qquickvisualdatamodel_p.h"
+#include "qquickitem.h"
#include <QtCore/qcoreapplication.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <private/qdeclarativeglobal_p.h>
#include <private/qmetaobjectbuilder_p.h>
#include <private/qdeclarativeproperty_p.h>
-#include <private/qsgvisualadaptormodel_p.h>
+#include <private/qquickvisualadaptormodel_p.h>
#include <private/qdeclarativechangeset_p.h>
#include <private/qdeclarativelistcompositor_p.h>
#include <private/qdeclarativeengine_p.h>
typedef QDeclarativeListCompositor Compositor;
-class QSGVisualDataGroupEmitter
+class QQuickVisualDataGroupEmitter
{
public:
virtual void emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset) = 0;
QIntrusiveListNode emitterNode;
};
-typedef QIntrusiveList<QSGVisualDataGroupEmitter, &QSGVisualDataGroupEmitter::emitterNode> QSGVisualDataGroupEmitterList;
+typedef QIntrusiveList<QQuickVisualDataGroupEmitter, &QQuickVisualDataGroupEmitter::emitterNode> QQuickVisualDataGroupEmitterList;
//---------------------------------------------------------------------------
-class QSGVisualDataGroupPrivate : public QObjectPrivate
+class QQuickVisualDataGroupPrivate : public QObjectPrivate
{
public:
- Q_DECLARE_PUBLIC(QSGVisualDataGroup)
+ Q_DECLARE_PUBLIC(QQuickVisualDataGroup)
- QSGVisualDataGroupPrivate() : group(Compositor::Cache), defaultInclude(false) {}
+ QQuickVisualDataGroupPrivate() : group(Compositor::Cache), defaultInclude(false) {}
- static QSGVisualDataGroupPrivate *get(QSGVisualDataGroup *group) {
- return static_cast<QSGVisualDataGroupPrivate *>(QObjectPrivate::get(group)); }
+ static QQuickVisualDataGroupPrivate *get(QQuickVisualDataGroup *group) {
+ return static_cast<QQuickVisualDataGroupPrivate *>(QObjectPrivate::get(group)); }
- void setModel(QSGVisualDataModel *model, Compositor::Group group);
+ void setModel(QQuickVisualDataModel *model, Compositor::Group group);
void emitChanges(QV8Engine *engine);
void emitModelUpdated(bool reset);
bool parseGroupArgs(QDeclarativeV8Function *args, int *index, int *count, int *groups) const;
Compositor::Group group;
- QDeclarativeGuard<QSGVisualDataModel> model;
- QSGVisualDataGroupEmitterList emitters;
+ QDeclarativeGuard<QQuickVisualDataModel> model;
+ QQuickVisualDataGroupEmitterList emitters;
QDeclarativeChangeSet changeSet;
QString name;
bool defaultInclude;
//---------------------------------------------------------------------------
-class QSGVisualDataModelCacheItem;
-class QSGVisualDataModelCacheMetaType;
-class QSGVisualDataModelParts;
+class QQuickVisualDataModelCacheItem;
+class QQuickVisualDataModelCacheMetaType;
+class QQuickVisualDataModelParts;
-class QSGVisualDataModelPrivate : public QObjectPrivate, public QSGVisualDataGroupEmitter
+class QQuickVisualDataModelPrivate : public QObjectPrivate, public QQuickVisualDataGroupEmitter
{
- Q_DECLARE_PUBLIC(QSGVisualDataModel)
+ Q_DECLARE_PUBLIC(QQuickVisualDataModel)
public:
- QSGVisualDataModelPrivate(QDeclarativeContext *);
+ QQuickVisualDataModelPrivate(QDeclarativeContext *);
- static QSGVisualDataModelPrivate *get(QSGVisualDataModel *m) {
- return static_cast<QSGVisualDataModelPrivate *>(QObjectPrivate::get(m));
+ static QQuickVisualDataModelPrivate *get(QQuickVisualDataModel *m) {
+ return static_cast<QQuickVisualDataModelPrivate *>(QObjectPrivate::get(m));
}
void init();
- void connectModel(QSGVisualAdaptorModel *model);
+ void connectModel(QQuickVisualAdaptorModel *model);
QObject *object(Compositor::Group group, int index, bool complete, bool reference);
void destroy(QObject *object);
- QSGVisualDataModel::ReleaseFlags release(QObject *object);
+ QQuickVisualDataModel::ReleaseFlags release(QObject *object);
QString stringValue(Compositor::Group group, int index, const QString &name);
int cacheIndexOf(QObject *object) const;
void emitCreatedPackage(Compositor::iterator at, QDeclarativePackage *package);
- void emitCreatedItem(Compositor::iterator at, QSGItem *item) {
+ void emitCreatedItem(Compositor::iterator at, QQuickItem *item) {
emit q_func()->createdItem(at.index[m_compositorGroup], item); }
void emitDestroyingPackage(QDeclarativePackage *package);
- void emitDestroyingItem(QSGItem *item) { emit q_func()->destroyingItem(item); }
+ void emitDestroyingItem(QQuickItem *item) { emit q_func()->destroyingItem(item); }
void updateFilterGroup();
void itemsInserted(
const QVector<Compositor::Insert> &inserts,
QVarLengthArray<QVector<QDeclarativeChangeSet::Insert>, Compositor::MaximumGroupCount> *translatedInserts,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems = 0);
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems = 0);
void itemsInserted(const QVector<Compositor::Insert> &inserts);
void itemsRemoved(
const QVector<Compositor::Remove> &removes,
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> *translatedRemoves,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems = 0);
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems = 0);
void itemsRemoved(const QVector<Compositor::Remove> &removes);
void itemsMoved(
const QVector<Compositor::Remove> &removes, const QVector<Compositor::Insert> &inserts);
void emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
- static void group_append(QDeclarativeListProperty<QSGVisualDataGroup> *property, QSGVisualDataGroup *group);
- static int group_count(QDeclarativeListProperty<QSGVisualDataGroup> *property);
- static QSGVisualDataGroup *group_at(QDeclarativeListProperty<QSGVisualDataGroup> *property, int index);
+ static void group_append(QDeclarativeListProperty<QQuickVisualDataGroup> *property, QQuickVisualDataGroup *group);
+ static int group_count(QDeclarativeListProperty<QQuickVisualDataGroup> *property);
+ static QQuickVisualDataGroup *group_at(QDeclarativeListProperty<QQuickVisualDataGroup> *property, int index);
- QSGVisualAdaptorModel *m_adaptorModel;
+ QQuickVisualAdaptorModel *m_adaptorModel;
QDeclarativeComponent *m_delegate;
- QSGVisualDataModelCacheMetaType *m_cacheMetaType;
+ QQuickVisualDataModelCacheMetaType *m_cacheMetaType;
QDeclarativeGuard<QDeclarativeContext> m_context;
- QList<QSGVisualDataModelCacheItem *> m_cache;
- QSGVisualDataModelParts *m_parts;
- QSGVisualDataGroupEmitterList m_pendingParts;
+ QList<QQuickVisualDataModelCacheItem *> m_cache;
+ QQuickVisualDataModelParts *m_parts;
+ QQuickVisualDataGroupEmitterList m_pendingParts;
QDeclarativeListCompositor m_compositor;
QDeclarativeListCompositor::Group m_compositorGroup;
union {
struct {
- QSGVisualDataGroup *m_cacheItems;
- QSGVisualDataGroup *m_items;
- QSGVisualDataGroup *m_persistedItems;
+ QQuickVisualDataGroup *m_cacheItems;
+ QQuickVisualDataGroup *m_items;
+ QQuickVisualDataGroup *m_persistedItems;
};
- QSGVisualDataGroup *m_groups[Compositor::MaximumGroupCount];
+ QQuickVisualDataGroup *m_groups[Compositor::MaximumGroupCount];
};
int m_groupCount;
};
//---------------------------------------------------------------------------
-class QSGVisualPartsModel : public QSGVisualModel, public QSGVisualDataGroupEmitter
+class QQuickVisualPartsModel : public QQuickVisualModel, public QQuickVisualDataGroupEmitter
{
Q_OBJECT
Q_PROPERTY(QString filterOnGroup READ filterGroup WRITE setFilterGroup NOTIFY filterGroupChanged RESET resetFilterGroup)
public:
- QSGVisualPartsModel(QSGVisualDataModel *model, const QString &part, QObject *parent = 0);
- ~QSGVisualPartsModel();
+ QQuickVisualPartsModel(QQuickVisualDataModel *model, const QString &part, QObject *parent = 0);
+ ~QQuickVisualPartsModel();
QString filterGroup() const;
void setFilterGroup(const QString &group);
int count() const;
bool isValid() const;
- QSGItem *item(int index, bool complete=true);
- ReleaseFlags release(QSGItem *item);
+ QQuickItem *item(int index, bool complete=true);
+ ReleaseFlags release(QQuickItem *item);
bool completePending() const;
void completeItem();
QString stringValue(int index, const QString &role);
void setWatchedRoles(QList<QByteArray> roles);
- int indexOf(QSGItem *item, QObject *objectContext) const;
+ int indexOf(QQuickItem *item, QObject *objectContext) const;
void emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
void filterGroupChanged();
private:
- QSGVisualDataModel *m_model;
+ QQuickVisualDataModel *m_model;
QHash<QObject *, QDeclarativePackage *> m_packaged;
QString m_part;
QString m_filterGroup;
bool m_inheritGroup;
};
-class QSGVisualDataModelPartsMetaObject : public QDeclarativeOpenMetaObject
+class QQuickVisualDataModelPartsMetaObject : public QDeclarativeOpenMetaObject
{
public:
- QSGVisualDataModelPartsMetaObject(QObject *parent)
+ QQuickVisualDataModelPartsMetaObject(QObject *parent)
: QDeclarativeOpenMetaObject(parent) {}
virtual void propertyCreated(int, QMetaPropertyBuilder &);
virtual QVariant initialValue(int);
};
-class QSGVisualDataModelParts : public QObject
+class QQuickVisualDataModelParts : public QObject
{
Q_OBJECT
public:
- QSGVisualDataModelParts(QSGVisualDataModel *parent);
+ QQuickVisualDataModelParts(QQuickVisualDataModel *parent);
- QSGVisualDataModel *model;
- QList<QSGVisualPartsModel *> models;
+ QQuickVisualDataModel *model;
+ QList<QQuickVisualPartsModel *> models;
};
-void QSGVisualDataModelPartsMetaObject::propertyCreated(int, QMetaPropertyBuilder &prop)
+void QQuickVisualDataModelPartsMetaObject::propertyCreated(int, QMetaPropertyBuilder &prop)
{
prop.setWritable(false);
}
-QVariant QSGVisualDataModelPartsMetaObject::initialValue(int id)
+QVariant QQuickVisualDataModelPartsMetaObject::initialValue(int id)
{
- QSGVisualDataModelParts *parts = static_cast<QSGVisualDataModelParts *>(object());
- QSGVisualPartsModel *m = new QSGVisualPartsModel(
+ QQuickVisualDataModelParts *parts = static_cast<QQuickVisualDataModelParts *>(object());
+ QQuickVisualPartsModel *m = new QQuickVisualPartsModel(
parts->model, QString::fromUtf8(name(id)), parts);
parts->models.append(m);
return QVariant::fromValue(static_cast<QObject *>(m));
}
-QSGVisualDataModelParts::QSGVisualDataModelParts(QSGVisualDataModel *parent)
+QQuickVisualDataModelParts::QQuickVisualDataModelParts(QQuickVisualDataModel *parent)
: QObject(parent), model(parent)
{
- new QSGVisualDataModelPartsMetaObject(this);
+ new QQuickVisualDataModelPartsMetaObject(this);
}
//---------------------------------------------------------------------------
-class QSGVisualDataModelCacheMetaType : public QDeclarativeRefCount
+class QQuickVisualDataModelCacheMetaType : public QDeclarativeRefCount
{
public:
- QSGVisualDataModelCacheMetaType(QV8Engine *engine, QSGVisualDataModel *model, const QStringList &groupNames);
- ~QSGVisualDataModelCacheMetaType();
+ QQuickVisualDataModelCacheMetaType(QV8Engine *engine, QQuickVisualDataModel *model, const QStringList &groupNames);
+ ~QQuickVisualDataModelCacheMetaType();
int parseGroups(const QStringList &groupNames) const;
int parseGroups(QV8Engine *engine, const v8::Local<v8::Value> &groupNames) const;
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
static v8::Handle<v8::Value> get_index(v8::Local<v8::String>, const v8::AccessorInfo &info);
- QDeclarativeGuard<QSGVisualDataModel> model;
+ QDeclarativeGuard<QQuickVisualDataModel> model;
const int groupCount;
const int memberPropertyOffset;
const int indexPropertyOffset;
v8::Persistent<v8::Function> constructor;
};
-class QSGVisualDataModelCacheItem : public QV8ObjectResource
+class QQuickVisualDataModelCacheItem : public QV8ObjectResource
{
V8_RESOURCE_TYPE(VisualDataItemType)
public:
- QSGVisualDataModelCacheItem(QSGVisualDataModelCacheMetaType *metaType)
+ QQuickVisualDataModelCacheItem(QQuickVisualDataModelCacheMetaType *metaType)
: QV8ObjectResource(metaType->v8Engine)
, metaType(metaType)
, object(0)
metaType->addref();
}
- ~QSGVisualDataModelCacheItem()
+ ~QQuickVisualDataModelCacheItem()
{
Q_ASSERT(scriptRef == 0);
Q_ASSERT(objectRef == 0);
void Dispose();
- QSGVisualDataModelCacheMetaType * const metaType;
+ QQuickVisualDataModelCacheMetaType * const metaType;
QDeclarativeGuard<QObject> object;
- QSGVisualDataModelAttached *attached;
+ QQuickVisualDataModelAttached *attached;
int objectRef;
int scriptRef;
int groups;
int index[Compositor::MaximumGroupCount];
};
-class QSGVisualDataModelAttachedMetaObject : public QAbstractDynamicMetaObject
+class QQuickVisualDataModelAttachedMetaObject : public QAbstractDynamicMetaObject
{
public:
- QSGVisualDataModelAttachedMetaObject(
- QSGVisualDataModelAttached *attached, QSGVisualDataModelCacheMetaType *metaType);
- ~QSGVisualDataModelAttachedMetaObject();
+ QQuickVisualDataModelAttachedMetaObject(
+ QQuickVisualDataModelAttached *attached, QQuickVisualDataModelCacheMetaType *metaType);
+ ~QQuickVisualDataModelAttachedMetaObject();
int metaCall(QMetaObject::Call, int _id, void **);
private:
- QSGVisualDataModelAttached *attached;
- QSGVisualDataModelCacheMetaType *metaType;
+ QQuickVisualDataModelAttached *attached;
+ QQuickVisualDataModelCacheMetaType *metaType;
};
//---------------------------------------------------------------------------
-QHash<QObject*, QSGVisualDataModelAttached*> QSGVisualDataModelAttached::attachedProperties;
+QHash<QObject*, QQuickVisualDataModelAttached*> QQuickVisualDataModelAttached::attachedProperties;
/*!
- \qmlclass VisualDataModel QSGVisualDataModel
+ \qmlclass VisualDataModel QQuickVisualDataModel
\inqmlmodule QtQuick 2
\ingroup qml-working-with-data
\brief The VisualDataModel encapsulates a model and delegate
\snippet doc/src/snippets/declarative/visualdatamodel.qml 0
*/
-QSGVisualDataModelPrivate::QSGVisualDataModelPrivate(QDeclarativeContext *ctxt)
+QQuickVisualDataModelPrivate::QQuickVisualDataModelPrivate(QDeclarativeContext *ctxt)
: m_adaptorModel(0)
, m_delegate(0)
, m_cacheMetaType(0)
{
}
-void QSGVisualDataModelPrivate::connectModel(QSGVisualAdaptorModel *model)
+void QQuickVisualDataModelPrivate::connectModel(QQuickVisualAdaptorModel *model)
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
QObject::connect(model, SIGNAL(itemsInserted(int,int)), q, SLOT(_q_itemsInserted(int,int)));
QObject::connect(model, SIGNAL(itemsRemoved(int,int)), q, SLOT(_q_itemsRemoved(int,int)));
QObject::connect(model, SIGNAL(modelReset(int,int)), q, SLOT(_q_modelReset(int,int)));
}
-void QSGVisualDataModelPrivate::init()
+void QQuickVisualDataModelPrivate::init()
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
m_compositor.setRemoveGroups(Compositor::GroupMask & ~Compositor::PersistedFlag);
- m_adaptorModel = new QSGVisualAdaptorModel;
+ m_adaptorModel = new QQuickVisualAdaptorModel;
QObject::connect(m_adaptorModel, SIGNAL(rootIndexChanged()), q, SIGNAL(rootIndexChanged()));
- m_items = new QSGVisualDataGroup(QStringLiteral("items"), q, Compositor::Default, q);
+ m_items = new QQuickVisualDataGroup(QStringLiteral("items"), q, Compositor::Default, q);
m_items->setDefaultInclude(true);
- m_persistedItems = new QSGVisualDataGroup(QStringLiteral("persistedItems"), q, Compositor::Persisted, q);
- QSGVisualDataGroupPrivate::get(m_items)->emitters.insert(this);
+ m_persistedItems = new QQuickVisualDataGroup(QStringLiteral("persistedItems"), q, Compositor::Persisted, q);
+ QQuickVisualDataGroupPrivate::get(m_items)->emitters.insert(this);
}
-QSGVisualDataModel::QSGVisualDataModel()
-: QSGVisualModel(*(new QSGVisualDataModelPrivate(0)))
+QQuickVisualDataModel::QQuickVisualDataModel()
+: QQuickVisualModel(*(new QQuickVisualDataModelPrivate(0)))
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->init();
}
-QSGVisualDataModel::QSGVisualDataModel(QDeclarativeContext *ctxt, QObject *parent)
-: QSGVisualModel(*(new QSGVisualDataModelPrivate(ctxt)), parent)
+QQuickVisualDataModel::QQuickVisualDataModel(QDeclarativeContext *ctxt, QObject *parent)
+: QQuickVisualModel(*(new QQuickVisualDataModelPrivate(ctxt)), parent)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->init();
}
-QSGVisualDataModel::~QSGVisualDataModel()
+QQuickVisualDataModel::~QQuickVisualDataModel()
{
- Q_D(QSGVisualDataModel);
- foreach (QSGVisualDataModelCacheItem *cacheItem, d->m_cache) {
+ Q_D(QQuickVisualDataModel);
+ foreach (QQuickVisualDataModelCacheItem *cacheItem, d->m_cache) {
cacheItem->object = 0;
cacheItem->objectRef = 0;
if (!cacheItem->isReferenced())
}
-void QSGVisualDataModel::classBegin()
+void QQuickVisualDataModel::classBegin()
{
}
-void QSGVisualDataModel::componentComplete()
+void QQuickVisualDataModel::componentComplete()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_complete = true;
int defaultGroups = 0;
QStringList groupNames;
groupNames.append(QStringLiteral("items"));
groupNames.append(QStringLiteral("persistedItems"));
- if (QSGVisualDataGroupPrivate::get(d->m_items)->defaultInclude)
+ if (QQuickVisualDataGroupPrivate::get(d->m_items)->defaultInclude)
defaultGroups |= Compositor::DefaultFlag;
- if (QSGVisualDataGroupPrivate::get(d->m_persistedItems)->defaultInclude)
+ if (QQuickVisualDataGroupPrivate::get(d->m_persistedItems)->defaultInclude)
defaultGroups |= Compositor::PersistedFlag;
for (int i = 3; i < d->m_groupCount; ++i) {
QString name = d->m_groups[i]->name();
--d->m_groupCount;
--i;
} else if (name.at(0).isUpper()) {
- qmlInfo(d->m_groups[i]) << QSGVisualDataGroup::tr("Group names must start with a lower case letter");
+ qmlInfo(d->m_groups[i]) << QQuickVisualDataGroup::tr("Group names must start with a lower case letter");
d->m_groups[i] = d->m_groups[d->m_groupCount - 1];
--d->m_groupCount;
--i;
} else {
groupNames.append(name);
- QSGVisualDataGroupPrivate *group = QSGVisualDataGroupPrivate::get(d->m_groups[i]);
+ QQuickVisualDataGroupPrivate *group = QQuickVisualDataGroupPrivate::get(d->m_groups[i]);
group->setModel(this, Compositor::Group(i));
if (group->defaultInclude)
defaultGroups |= (1 << i);
if (!d->m_context)
d->m_context = qmlContext(this);
- d->m_cacheMetaType = new QSGVisualDataModelCacheMetaType(
+ d->m_cacheMetaType = new QQuickVisualDataModelCacheMetaType(
QDeclarativeEnginePrivate::getV8Engine(d->m_context->engine()), this, groupNames);
d->m_compositor.setGroupCount(d->m_groupCount);
d->updateFilterGroup();
while (!d->m_pendingParts.isEmpty())
- static_cast<QSGVisualPartsModel *>(d->m_pendingParts.first())->updateFilterGroup();
+ static_cast<QQuickVisualPartsModel *>(d->m_pendingParts.first())->updateFilterGroup();
d->connectModel(d->m_adaptorModel);
QVector<Compositor::Insert> inserts;
\sa {qmlmodels}{Data Models}
*/
-QVariant QSGVisualDataModel::model() const
+QVariant QQuickVisualDataModel::model() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->model();
}
-void QSGVisualDataModel::setModel(const QVariant &model)
+void QQuickVisualDataModel::setModel(const QVariant &model)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_adaptorModel->setModel(model, d->m_context ? d->m_context->engine() : qmlEngine(this));
if (d->m_complete && d->m_adaptorModel->canFetchMore())
QCoreApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
The index is exposed as an accessible \c index property. Properties of the
model are also available depending upon the type of \l {qmlmodels}{Data Model}.
*/
-QDeclarativeComponent *QSGVisualDataModel::delegate() const
+QDeclarativeComponent *QQuickVisualDataModel::delegate() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_delegate;
}
-void QSGVisualDataModel::setDelegate(QDeclarativeComponent *delegate)
+void QQuickVisualDataModel::setDelegate(QDeclarativeComponent *delegate)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (d->m_transaction) {
qmlInfo(this) << tr("The delegate of a VisualDataModel cannot be changed within onUpdated.");
return;
d->m_delegateValidated = false;
if (wasValid && d->m_complete) {
for (int i = 1; i < d->m_groupCount; ++i) {
- QSGVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.remove(
+ QQuickVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.remove(
0, d->m_compositor.count(Compositor::Group(i)));
}
}
if (d->m_complete && d->m_delegate) {
for (int i = 1; i < d->m_groupCount; ++i) {
- QSGVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.insert(
+ QQuickVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.insert(
0, d->m_compositor.count(Compositor::Group(i)));
}
}
\sa modelIndex(), parentModelIndex()
*/
-QVariant QSGVisualDataModel::rootIndex() const
+QVariant QQuickVisualDataModel::rootIndex() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->rootIndex();
}
-void QSGVisualDataModel::setRootIndex(const QVariant &root)
+void QQuickVisualDataModel::setRootIndex(const QVariant &root)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_adaptorModel->setRootIndex(root);
}
\sa rootIndex
*/
-QVariant QSGVisualDataModel::modelIndex(int idx) const
+QVariant QQuickVisualDataModel::modelIndex(int idx) const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->modelIndex(idx);
}
\sa rootIndex
*/
-QVariant QSGVisualDataModel::parentModelIndex() const
+QVariant QQuickVisualDataModel::parentModelIndex() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->parentModelIndex();
}
\qmlproperty int QtQuick2::VisualDataModel::count
*/
-int QSGVisualDataModel::count() const
+int QQuickVisualDataModel::count() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
if (!d->m_delegate)
return 0;
return d->m_compositor.count(d->m_compositorGroup);
}
-void QSGVisualDataModelPrivate::destroy(QObject *object)
+void QQuickVisualDataModelPrivate::destroy(QObject *object)
{
QObjectPrivate *p = QObjectPrivate::get(object);
Q_ASSERT(p->declarativeData);
object->deleteLater();
}
-QSGVisualDataModel::ReleaseFlags QSGVisualDataModelPrivate::release(QObject *object)
+QQuickVisualDataModel::ReleaseFlags QQuickVisualDataModelPrivate::release(QObject *object)
{
- QSGVisualDataModel::ReleaseFlags stat = 0;
+ QQuickVisualDataModel::ReleaseFlags stat = 0;
if (!object)
return stat;
int cacheIndex = cacheIndexOf(object);
if (cacheIndex != -1) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (cacheItem->releaseObject()) {
destroy(object);
cacheItem->object = 0;
- stat |= QSGVisualModel::Destroyed;
+ stat |= QQuickVisualModel::Destroyed;
if (!cacheItem->isReferenced()) {
m_compositor.clearFlags(Compositor::Cache, cacheIndex, 1, Compositor::CacheFlag);
m_cache.removeAt(cacheIndex);
Q_ASSERT(m_cache.count() == m_compositor.count(Compositor::Cache));
}
} else {
- stat |= QSGVisualDataModel::Referenced;
+ stat |= QQuickVisualDataModel::Referenced;
}
}
return stat;
Returns ReleaseStatus flags.
*/
-QSGVisualDataModel::ReleaseFlags QSGVisualDataModel::release(QSGItem *item)
+QQuickVisualDataModel::ReleaseFlags QQuickVisualDataModel::release(QQuickItem *item)
{
- Q_D(QSGVisualDataModel);
- QSGVisualModel::ReleaseFlags stat = d->release(item);
+ Q_D(QQuickVisualDataModel);
+ QQuickVisualModel::ReleaseFlags stat = d->release(item);
if (stat & Destroyed)
item->setParentItem(0);
return stat;
}
-void QSGVisualDataModelPrivate::group_append(
- QDeclarativeListProperty<QSGVisualDataGroup> *property, QSGVisualDataGroup *group)
+void QQuickVisualDataModelPrivate::group_append(
+ QDeclarativeListProperty<QQuickVisualDataGroup> *property, QQuickVisualDataGroup *group)
{
- QSGVisualDataModelPrivate *d = static_cast<QSGVisualDataModelPrivate *>(property->data);
+ QQuickVisualDataModelPrivate *d = static_cast<QQuickVisualDataModelPrivate *>(property->data);
if (d->m_complete)
return;
if (d->m_groupCount == 11) {
- qmlInfo(d->q_func()) << QSGVisualDataModel::tr("The maximum number of supported VisualDataGroups is 8");
+ qmlInfo(d->q_func()) << QQuickVisualDataModel::tr("The maximum number of supported VisualDataGroups is 8");
return;
}
d->m_groups[d->m_groupCount] = group;
d->m_groupCount += 1;
}
-int QSGVisualDataModelPrivate::group_count(
- QDeclarativeListProperty<QSGVisualDataGroup> *property)
+int QQuickVisualDataModelPrivate::group_count(
+ QDeclarativeListProperty<QQuickVisualDataGroup> *property)
{
- QSGVisualDataModelPrivate *d = static_cast<QSGVisualDataModelPrivate *>(property->data);
+ QQuickVisualDataModelPrivate *d = static_cast<QQuickVisualDataModelPrivate *>(property->data);
return d->m_groupCount - 1;
}
-QSGVisualDataGroup *QSGVisualDataModelPrivate::group_at(
- QDeclarativeListProperty<QSGVisualDataGroup> *property, int index)
+QQuickVisualDataGroup *QQuickVisualDataModelPrivate::group_at(
+ QDeclarativeListProperty<QQuickVisualDataGroup> *property, int index)
{
- QSGVisualDataModelPrivate *d = static_cast<QSGVisualDataModelPrivate *>(property->data);
+ QQuickVisualDataModelPrivate *d = static_cast<QQuickVisualDataModelPrivate *>(property->data);
return index >= 0 && index < d->m_groupCount - 1
? d->m_groups[index - 1]
: 0;
\snippet doc/src/snippets/declarative/visualdatagroup.qml 0
*/
-QDeclarativeListProperty<QSGVisualDataGroup> QSGVisualDataModel::groups()
+QDeclarativeListProperty<QQuickVisualDataGroup> QQuickVisualDataModel::groups()
{
- Q_D(QSGVisualDataModel);
- return QDeclarativeListProperty<QSGVisualDataGroup>(
+ Q_D(QQuickVisualDataModel);
+ return QDeclarativeListProperty<QQuickVisualDataGroup>(
this,
d,
- QSGVisualDataModelPrivate::group_append,
- QSGVisualDataModelPrivate::group_count,
- QSGVisualDataModelPrivate::group_at);
+ QQuickVisualDataModelPrivate::group_append,
+ QQuickVisualDataModelPrivate::group_count,
+ QQuickVisualDataModelPrivate::group_at);
}
/*!
This property holds visual data model's default group to which all new items are added.
*/
-QSGVisualDataGroup *QSGVisualDataModel::items()
+QQuickVisualDataGroup *QQuickVisualDataModel::items()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
return d->m_items;
}
to this group.
*/
-QSGVisualDataGroup *QSGVisualDataModel::persistedItems()
+QQuickVisualDataGroup *QQuickVisualDataModel::persistedItems()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
return d->m_persistedItems;
}
By default this is the \l items group.
*/
-QString QSGVisualDataModel::filterGroup() const
+QString QQuickVisualDataModel::filterGroup() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_filterGroup;
}
-void QSGVisualDataModel::setFilterGroup(const QString &group)
+void QQuickVisualDataModel::setFilterGroup(const QString &group)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (d->m_transaction) {
qmlInfo(this) << tr("The group of a VisualDataModel cannot be changed within onChanged");
}
}
-void QSGVisualDataModel::resetFilterGroup()
+void QQuickVisualDataModel::resetFilterGroup()
{
setFilterGroup(QStringLiteral("items"));
}
-void QSGVisualDataModelPrivate::updateFilterGroup()
+void QQuickVisualDataModelPrivate::updateFilterGroup()
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
if (!m_cacheMetaType)
return;
}
}
- QSGVisualDataGroupPrivate::get(m_groups[m_compositorGroup])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(m_groups[m_compositorGroup])->emitters.insert(this);
if (m_compositorGroup != previousGroup) {
QVector<QDeclarativeChangeSet::Remove> removes;
QVector<QDeclarativeChangeSet::Insert> inserts;
emit q->countChanged();
if (m_parts) {
- foreach (QSGVisualPartsModel *model, m_parts->models)
+ foreach (QQuickVisualPartsModel *model, m_parts->models)
model->updateFilterGroup(m_compositorGroup, changeSet);
}
}
\sa Package
*/
-QObject *QSGVisualDataModel::parts()
+QObject *QQuickVisualDataModel::parts()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (!d->m_parts)
- d->m_parts = new QSGVisualDataModelParts(this);
+ d->m_parts = new QQuickVisualDataModelParts(this);
return d->m_parts;
}
-void QSGVisualDataModelPrivate::emitCreatedPackage(Compositor::iterator at, QDeclarativePackage *package)
+void QQuickVisualDataModelPrivate::emitCreatedPackage(Compositor::iterator at, QDeclarativePackage *package)
{
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->createdPackage(at.index[i], package);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->createdPackage(at.index[i], package);
}
-void QSGVisualDataModelPrivate::emitDestroyingPackage(QDeclarativePackage *package)
+void QQuickVisualDataModelPrivate::emitDestroyingPackage(QDeclarativePackage *package)
{
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->destroyingPackage(package);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->destroyingPackage(package);
}
-QObject *QSGVisualDataModelPrivate::object(Compositor::Group group, int index, bool complete, bool reference)
+QObject *QQuickVisualDataModelPrivate::object(Compositor::Group group, int index, bool complete, bool reference)
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
Compositor::iterator it = m_compositor.find(group, index);
- QSGVisualDataModelCacheItem *cacheItem = it->inCache() ? m_cache.at(it.cacheIndex) : 0;
+ QQuickVisualDataModelCacheItem *cacheItem = it->inCache() ? m_cache.at(it.cacheIndex) : 0;
if (!cacheItem) {
- cacheItem = new QSGVisualDataModelCacheItem(m_cacheMetaType);
+ cacheItem = new QQuickVisualDataModelCacheItem(m_cacheMetaType);
for (int i = 0; i < m_groupCount; ++i)
cacheItem->index[i] = it.index[i];
cacheItem->groups = it->flags & Compositor::GroupMask;
QDeclarativeContext *rootContext = new QDeclarativeContext(
creationContext ? creationContext : m_context.data());
QDeclarativeContext *ctxt = rootContext;
- if (m_adaptorModel->flags() & QSGVisualAdaptorModel::ProxiedObject) {
- if (QSGVisualAdaptorModelProxyInterface *proxy = qobject_cast<QSGVisualAdaptorModelProxyInterface *>(data)) {
+ if (m_adaptorModel->flags() & QQuickVisualAdaptorModel::ProxiedObject) {
+ if (QQuickVisualAdaptorModelProxyInterface *proxy = qobject_cast<QQuickVisualAdaptorModelProxyInterface *>(data)) {
ctxt->setContextObject(proxy->proxiedObject());
ctxt = new QDeclarativeContext(ctxt, ctxt);
}
Q_ASSERT(m_cache.count() == m_compositor.count(Compositor::Cache));
}
- cacheItem->attached = QSGVisualDataModelAttached::properties(cacheItem->object);
+ cacheItem->attached = QQuickVisualDataModelAttached::properties(cacheItem->object);
cacheItem->attached->m_cacheItem = cacheItem;
- new QSGVisualDataModelAttachedMetaObject(cacheItem->attached, m_cacheMetaType);
+ new QQuickVisualDataModelAttachedMetaObject(cacheItem->attached, m_cacheMetaType);
cacheItem->attached->emitChanges();
if (QDeclarativePackage *package = qobject_cast<QDeclarativePackage *>(cacheItem->object)) {
emitCreatedPackage(it, package);
} else if (!reference) {
- if (QSGItem *item = qobject_cast<QSGItem *>(cacheItem->object))
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(cacheItem->object))
emitCreatedItem(it, item);
}
return cacheItem->object;
}
-QSGItem *QSGVisualDataModel::item(int index, bool complete)
+QQuickItem *QQuickVisualDataModel::item(int index, bool complete)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (!d->m_delegate || index < 0 || index >= d->m_compositor.count(d->m_compositorGroup)) {
qWarning() << "VisualDataModel::item: index out range" << index << d->m_compositor.count(d->m_compositorGroup);
return 0;
}
QObject *object = d->object(d->m_compositorGroup, index, complete, true);
- if (QSGItem *item = qobject_cast<QSGItem *>(object))
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(object))
return item;
if (d->m_completePending)
completeItem();
d->release(object);
if (!d->m_delegateValidated) {
if (object)
- qmlInfo(d->m_delegate) << QSGVisualDataModel::tr("Delegate component must be Item type.");
+ qmlInfo(d->m_delegate) << QQuickVisualDataModel::tr("Delegate component must be Item type.");
d->m_delegateValidated = true;
}
return 0;
}
-bool QSGVisualDataModel::completePending() const
+bool QQuickVisualDataModel::completePending() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_completePending;
}
-void QSGVisualDataModel::completeItem()
+void QQuickVisualDataModel::completeItem()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_delegate->completeCreate();
d->m_completePending = false;
}
-QString QSGVisualDataModelPrivate::stringValue(Compositor::Group group, int index, const QString &name)
+QString QQuickVisualDataModelPrivate::stringValue(Compositor::Group group, int index, const QString &name)
{
Compositor::iterator it = m_compositor.find(group, index);
- if (QSGVisualAdaptorModel *model = it.list<QSGVisualAdaptorModel>()) {
+ if (QQuickVisualAdaptorModel *model = it.list<QQuickVisualAdaptorModel>()) {
return model->stringValue(it.modelIndex(), name);
}
return QString();
}
-QString QSGVisualDataModel::stringValue(int index, const QString &name)
+QString QQuickVisualDataModel::stringValue(int index, const QString &name)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
return d->stringValue(d->m_compositorGroup, index, name);
}
-int QSGVisualDataModelPrivate::cacheIndexOf(QObject *object) const
+int QQuickVisualDataModelPrivate::cacheIndexOf(QObject *object) const
{
for (int cacheIndex = 0; cacheIndex < m_cache.count(); ++cacheIndex) {
if (m_cache.at(cacheIndex)->object == object)
return -1;
}
-int QSGVisualDataModel::indexOf(QSGItem *item, QObject *) const
+int QQuickVisualDataModel::indexOf(QQuickItem *item, QObject *) const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
const int cacheIndex = d->cacheIndexOf(item);
return cacheIndex != -1
? d->m_cache.at(cacheIndex)->index[d->m_compositorGroup]
: -1;
}
-void QSGVisualDataModel::setWatchedRoles(QList<QByteArray> roles)
+void QQuickVisualDataModel::setWatchedRoles(QList<QByteArray> roles)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_adaptorModel->replaceWatchedRoles(d->watchedRoles, roles);
d->watchedRoles = roles;
}
-void QSGVisualDataModelPrivate::addGroups(Compositor::Group group, int index, int count, int groupFlags)
+void QQuickVisualDataModelPrivate::addGroups(Compositor::Group group, int index, int count, int groupFlags)
{
QVector<Compositor::Insert> inserts;
m_compositor.setFlags(group, index, count, groupFlags, &inserts);
emitChanges();
}
-void QSGVisualDataModelPrivate::removeGroups(Compositor::Group group, int index, int count, int groupFlags)
+void QQuickVisualDataModelPrivate::removeGroups(Compositor::Group group, int index, int count, int groupFlags)
{
QVector<Compositor::Remove> removes;
m_compositor.clearFlags(group, index, count, groupFlags, &removes);
emitChanges();
}
-void QSGVisualDataModelPrivate::setGroups(Compositor::Group group, int index, int count, int groupFlags)
+void QQuickVisualDataModelPrivate::setGroups(Compositor::Group group, int index, int count, int groupFlags)
{
QVector<Compositor::Insert> inserts;
m_compositor.setFlags(group, index, count, groupFlags, &inserts);
emitChanges();
}
-bool QSGVisualDataModel::event(QEvent *e)
+bool QQuickVisualDataModel::event(QEvent *e)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (e->type() == QEvent::UpdateRequest)
d->m_adaptorModel->fetchMore();
- return QSGVisualModel::event(e);
+ return QQuickVisualModel::event(e);
}
-void QSGVisualDataModelPrivate::itemsChanged(const QVector<Compositor::Change> &changes)
+void QQuickVisualDataModelPrivate::itemsChanged(const QVector<Compositor::Change> &changes)
{
if (!m_delegate)
return;
}
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedChanges.at(i));
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedChanges.at(i));
}
-void QSGVisualDataModel::_q_itemsChanged(int index, int count)
+void QQuickVisualDataModel::_q_itemsChanged(int index, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
QVector<Compositor::Change> changes;
d->emitChanges();
}
-void QSGVisualDataModelPrivate::itemsInserted(
+void QQuickVisualDataModelPrivate::itemsInserted(
const QVector<Compositor::Insert> &inserts,
QVarLengthArray<QVector<QDeclarativeChangeSet::Insert>, Compositor::MaximumGroupCount> *translatedInserts,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems)
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems)
{
int cacheIndex = 0;
foreach (const Compositor::Insert &insert, inserts) {
for (; cacheIndex < insert.cacheIndex; ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
continue;
if (movedItems && insert.isMove()) {
- QList<QSGVisualDataModelCacheItem *> items = movedItems->take(insert.moveId);
+ QList<QQuickVisualDataModelCacheItem *> items = movedItems->take(insert.moveId);
Q_ASSERT(items.count() == insert.count);
m_cache = m_cache.mid(0, insert.cacheIndex) + items + m_cache.mid(insert.cacheIndex);
}
if (insert.inGroup()) {
for (int offset = 0; cacheIndex < insert.cacheIndex + insert.count; ++cacheIndex, ++offset) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
cacheItem->groups |= insert.flags & Compositor::GroupMask;
for (int i = 1; i < m_groupCount; ++i) {
cacheItem->index[i] = cacheItem->groups & (1 << i)
}
}
for (; cacheIndex < m_cache.count(); ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
}
}
-void QSGVisualDataModelPrivate::itemsInserted(const QVector<Compositor::Insert> &inserts)
+void QQuickVisualDataModelPrivate::itemsInserted(const QVector<Compositor::Insert> &inserts)
{
QVarLengthArray<QVector<QDeclarativeChangeSet::Insert>, Compositor::MaximumGroupCount> translatedInserts(m_groupCount);
itemsInserted(inserts, &translatedInserts);
return;
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedInserts.at(i));
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedInserts.at(i));
}
-void QSGVisualDataModel::_q_itemsInserted(int index, int count)
+void QQuickVisualDataModel::_q_itemsInserted(int index, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
QVector<Compositor::Insert> inserts;
d->emitChanges();
}
-void QSGVisualDataModelPrivate::itemsRemoved(
+void QQuickVisualDataModelPrivate::itemsRemoved(
const QVector<Compositor::Remove> &removes,
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> *translatedRemoves,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems)
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems)
{
int cacheIndex = 0;
int removedCache = 0;
foreach (const Compositor::Remove &remove, removes) {
for (; cacheIndex < remove.cacheIndex; ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
if (movedItems && remove.isMove()) {
movedItems->insert(remove.moveId, m_cache.mid(remove.cacheIndex, remove.count));
- QList<QSGVisualDataModelCacheItem *>::iterator begin = m_cache.begin() + remove.cacheIndex;
- QList<QSGVisualDataModelCacheItem *>::iterator end = begin + remove.count;
+ QList<QQuickVisualDataModelCacheItem *>::iterator begin = m_cache.begin() + remove.cacheIndex;
+ QList<QQuickVisualDataModelCacheItem *>::iterator end = begin + remove.count;
m_cache.erase(begin, end);
} else {
for (; cacheIndex < remove.cacheIndex + remove.count - removedCache; ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (remove.inGroup(Compositor::Persisted) && cacheItem->objectRef == 0) {
destroy(cacheItem->object);
if (QDeclarativePackage *package = qobject_cast<QDeclarativePackage *>(cacheItem->object))
emitDestroyingPackage(package);
- else if (QSGItem *item = qobject_cast<QSGItem *>(cacheItem->object))
+ else if (QQuickItem *item = qobject_cast<QQuickItem *>(cacheItem->object))
emitDestroyingItem(item);
cacheItem->object = 0;
}
}
for (; cacheIndex < m_cache.count(); ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
}
}
-void QSGVisualDataModelPrivate::itemsRemoved(const QVector<Compositor::Remove> &removes)
+void QQuickVisualDataModelPrivate::itemsRemoved(const QVector<Compositor::Remove> &removes)
{
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> translatedRemoves(m_groupCount);
itemsRemoved(removes, &translatedRemoves);
return;
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedRemoves.at(i));
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedRemoves.at(i));
}
-void QSGVisualDataModel::_q_itemsRemoved(int index, int count)
+void QQuickVisualDataModel::_q_itemsRemoved(int index, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
d->emitChanges();
}
-void QSGVisualDataModelPrivate::itemsMoved(
+void QQuickVisualDataModelPrivate::itemsMoved(
const QVector<Compositor::Remove> &removes, const QVector<Compositor::Insert> &inserts)
{
- QHash<int, QList<QSGVisualDataModelCacheItem *> > movedItems;
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > movedItems;
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> translatedRemoves(m_groupCount);
itemsRemoved(removes, &translatedRemoves, &movedItems);
return;
for (int i = 1; i < m_groupCount; ++i) {
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(
translatedRemoves.at(i),
translatedInserts.at(i));
}
}
-void QSGVisualDataModel::_q_itemsMoved(int from, int to, int count)
+void QQuickVisualDataModel::_q_itemsMoved(int from, int to, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
}
template <typename T> v8::Local<v8::Array>
-QSGVisualDataModelPrivate::buildChangeList(const QVector<T> &changes)
+QQuickVisualDataModelPrivate::buildChangeList(const QVector<T> &changes)
{
v8::Local<v8::Array> indexes = v8::Array::New(changes.count());
v8::Local<v8::String> indexKey = v8::String::New("index");
return indexes;
}
-void QSGVisualDataModelPrivate::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickVisualDataModelPrivate::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
emit q->modelUpdated(changeSet, reset);
if (changeSet.difference() != 0)
emit q->countChanged();
}
-void QSGVisualDataModelPrivate::emitChanges()
+void QQuickVisualDataModelPrivate::emitChanges()
{
if (m_transaction || !m_complete)
return;
m_transaction = true;
QV8Engine *engine = QDeclarativeEnginePrivate::getV8Engine(m_context->engine());
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->emitChanges(engine);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->emitChanges(engine);
m_transaction = false;
const bool reset = m_reset;
m_reset = false;
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->emitModelUpdated(reset);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->emitModelUpdated(reset);
- foreach (QSGVisualDataModelCacheItem *cacheItem, m_cache) {
+ foreach (QQuickVisualDataModelCacheItem *cacheItem, m_cache) {
if (cacheItem->object)
cacheItem->attached->emitChanges();
}
}
-void QSGVisualDataModel::_q_modelReset(int oldCount, int newCount)
+void QQuickVisualDataModel::_q_modelReset(int oldCount, int newCount)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (!d->m_delegate)
return;
d->emitChanges();
}
-QSGVisualDataModelAttached *QSGVisualDataModel::qmlAttachedProperties(QObject *obj)
+QQuickVisualDataModelAttached *QQuickVisualDataModel::qmlAttachedProperties(QObject *obj)
{
- return QSGVisualDataModelAttached::properties(obj);
+ return QQuickVisualDataModelAttached::properties(obj);
}
//============================================================================
-QSGVisualDataModelCacheMetaType::QSGVisualDataModelCacheMetaType(
- QV8Engine *engine, QSGVisualDataModel *model, const QStringList &groupNames)
+QQuickVisualDataModelCacheMetaType::QQuickVisualDataModelCacheMetaType(
+ QV8Engine *engine, QQuickVisualDataModel *model, const QStringList &groupNames)
: model(model)
, groupCount(groupNames.count() + 1)
- , memberPropertyOffset(QSGVisualDataModelAttached::staticMetaObject.propertyCount())
- , indexPropertyOffset(QSGVisualDataModelAttached::staticMetaObject.propertyCount() + groupNames.count())
+ , memberPropertyOffset(QQuickVisualDataModelAttached::staticMetaObject.propertyCount())
+ , indexPropertyOffset(QQuickVisualDataModelAttached::staticMetaObject.propertyCount() + groupNames.count())
, v8Engine(engine)
, metaObject(0)
, groupNames(groupNames)
{
QMetaObjectBuilder builder;
builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
- builder.setClassName(QSGVisualDataModelAttached::staticMetaObject.className());
- builder.setSuperClass(&QSGVisualDataModelAttached::staticMetaObject);
+ builder.setClassName(QQuickVisualDataModelAttached::staticMetaObject.className());
+ builder.setSuperClass(&QQuickVisualDataModelAttached::staticMetaObject);
v8::HandleScope handleScope;
v8::Context::Scope contextScope(engine->context());
constructor = qPersistentNew<v8::Function>(ft->GetFunction());
}
-QSGVisualDataModelCacheMetaType::~QSGVisualDataModelCacheMetaType()
+QQuickVisualDataModelCacheMetaType::~QQuickVisualDataModelCacheMetaType()
{
qFree(metaObject);
qPersistentDispose(constructor);
}
-int QSGVisualDataModelCacheMetaType::parseGroups(const QStringList &groups) const
+int QQuickVisualDataModelCacheMetaType::parseGroups(const QStringList &groups) const
{
int groupFlags = 0;
foreach (const QString &groupName, groups) {
return groupFlags;
}
-int QSGVisualDataModelCacheMetaType::parseGroups(QV8Engine *engine, const v8::Local<v8::Value> &groups) const
+int QQuickVisualDataModelCacheMetaType::parseGroups(QV8Engine *engine, const v8::Local<v8::Value> &groups) const
{
int groupFlags = 0;
if (groups->IsString()) {
return groupFlags;
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_model(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_model(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
if (!cacheItem->metaType->model)
return v8::Undefined();
QObject *data = 0;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(cacheItem->metaType->model);
for (int i = 1; i < cacheItem->metaType->groupCount; ++i) {
if (cacheItem->groups & (1 << i)) {
Compositor::iterator it = model->m_compositor.find(
Compositor::Group(i), cacheItem->index[i]);
- if (QSGVisualAdaptorModel *list = it.list<QSGVisualAdaptorModel>())
+ if (QQuickVisualAdaptorModel *list = it.list<QQuickVisualAdaptorModel>())
data = list->data(it.modelIndex());
break;
}
return cacheItem->engine->newQObject(data);
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_groups(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_groups(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
return cacheItem->engine->fromVariant(groups);
}
-void QSGVisualDataModelCacheMetaType::set_groups(
+void QQuickVisualDataModelCacheMetaType::set_groups(
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR_SETTER("Not a valid VisualData object");
if (!cacheItem->metaType->model)
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(cacheItem->metaType->model);
const int groupFlags = model->m_cacheMetaType->parseGroups(cacheItem->engine, value);
for (int i = 1; i < cacheItem->metaType->groupCount; ++i) {
}
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_member(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_member(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
return v8::Boolean::New(cacheItem->groups & (1 << info.Data()->Int32Value()));
}
-void QSGVisualDataModelCacheMetaType::set_member(
+void QQuickVisualDataModelCacheMetaType::set_member(
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR_SETTER("Not a valid VisualData object");
if (!cacheItem->metaType->model)
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(cacheItem->metaType->model);
Compositor::Group group = Compositor::Group(info.Data()->Int32Value());
const bool member = value->BooleanValue();
}
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_index(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_index(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
//---------------------------------------------------------------------------
-void QSGVisualDataModelCacheItem::Dispose()
+void QQuickVisualDataModelCacheItem::Dispose()
{
--scriptRef;
if (isReferenced())
return;
if (metaType->model) {
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(metaType->model);
const int cacheIndex = model->m_cache.indexOf(this);
if (cacheIndex != -1) {
model->m_compositor.clearFlags(Compositor::Cache, cacheIndex, 1, Compositor::CacheFlag);
//---------------------------------------------------------------------------
-QSGVisualDataModelAttachedMetaObject::QSGVisualDataModelAttachedMetaObject(
- QSGVisualDataModelAttached *attached, QSGVisualDataModelCacheMetaType *metaType)
+QQuickVisualDataModelAttachedMetaObject::QQuickVisualDataModelAttachedMetaObject(
+ QQuickVisualDataModelAttached *attached, QQuickVisualDataModelCacheMetaType *metaType)
: attached(attached)
, metaType(metaType)
{
QObjectPrivate::get(attached)->metaObject = this;
}
-QSGVisualDataModelAttachedMetaObject::~QSGVisualDataModelAttachedMetaObject()
+QQuickVisualDataModelAttachedMetaObject::~QQuickVisualDataModelAttachedMetaObject()
{
metaType->release();
}
-int QSGVisualDataModelAttachedMetaObject::metaCall(QMetaObject::Call call, int _id, void **arguments)
+int QQuickVisualDataModelAttachedMetaObject::metaCall(QMetaObject::Call call, int _id, void **arguments)
{
if (call == QMetaObject::ReadProperty) {
if (_id >= metaType->indexPropertyOffset) {
Compositor::Group group = Compositor::Group(_id - metaType->memberPropertyOffset + 1);
const bool member = attached->m_cacheItem->groups & (1 << group);
if (member != *static_cast<bool *>(arguments[0])) {
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(metaType->model);
const int cacheIndex = model->m_cache.indexOf(attached->m_cacheItem);
if (member)
model->removeGroups(Compositor::Cache, cacheIndex, 1, (1 << group));
It is attached to each instance of the delegate.
*/
-QSGVisualDataModel *QSGVisualDataModelAttached::model() const
+QQuickVisualDataModel *QQuickVisualDataModelAttached::model() const
{
return m_cacheItem ? m_cacheItem->metaType->model : 0;
}
It is attached to each instance of the delegate.
*/
-QStringList QSGVisualDataModelAttached::groups() const
+QStringList QQuickVisualDataModelAttached::groups() const
{
QStringList groups;
return groups;
}
-void QSGVisualDataModelAttached::setGroups(const QStringList &groups)
+void QQuickVisualDataModelAttached::setGroups(const QStringList &groups)
{
if (!m_cacheItem)
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_cacheItem->metaType->model);
const int cacheIndex = model->m_cache.indexOf(m_cacheItem);
const int groupFlags = model->m_cacheMetaType->parseGroups(groups);
It is attached to each instance of the delegate.
*/
-void QSGVisualDataModelAttached::emitChanges()
+void QQuickVisualDataModelAttached::emitChanges()
{
if (m_modelChanged) {
m_modelChanged = false;
//============================================================================
-void QSGVisualDataGroupPrivate::setModel(QSGVisualDataModel *m, Compositor::Group g)
+void QQuickVisualDataGroupPrivate::setModel(QQuickVisualDataModel *m, Compositor::Group g)
{
Q_ASSERT(!model);
model = m;
group = g;
}
-void QSGVisualDataGroupPrivate::emitChanges(QV8Engine *engine)
+void QQuickVisualDataGroupPrivate::emitChanges(QV8Engine *engine)
{
- Q_Q(QSGVisualDataGroup);
+ Q_Q(QQuickVisualDataGroup);
static int idx = signalIndex("changed(QDeclarativeV8Handle,QDeclarativeV8Handle)");
if (isSignalConnected(idx)) {
v8::HandleScope handleScope;
v8::Context::Scope contextScope(engine->context());
- v8::Local<v8::Array> removed = QSGVisualDataModelPrivate::buildChangeList(changeSet.removes());
- v8::Local<v8::Array> inserted = QSGVisualDataModelPrivate::buildChangeList(changeSet.inserts());
+ v8::Local<v8::Array> removed = QQuickVisualDataModelPrivate::buildChangeList(changeSet.removes());
+ v8::Local<v8::Array> inserted = QQuickVisualDataModelPrivate::buildChangeList(changeSet.inserts());
emit q->changed(
QDeclarativeV8Handle::fromHandle(removed), QDeclarativeV8Handle::fromHandle(inserted));
}
emit q->countChanged();
}
-void QSGVisualDataGroupPrivate::emitModelUpdated(bool reset)
+void QQuickVisualDataGroupPrivate::emitModelUpdated(bool reset)
{
- for (QSGVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
+ for (QQuickVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
it->emitModelUpdated(changeSet, reset);
changeSet.clear();
}
-void QSGVisualDataGroupPrivate::createdPackage(int index, QDeclarativePackage *package)
+void QQuickVisualDataGroupPrivate::createdPackage(int index, QDeclarativePackage *package)
{
- for (QSGVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
+ for (QQuickVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
it->createdPackage(index, package);
}
-void QSGVisualDataGroupPrivate::destroyingPackage(QDeclarativePackage *package)
+void QQuickVisualDataGroupPrivate::destroyingPackage(QDeclarativePackage *package)
{
- for (QSGVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
+ for (QQuickVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
it->destroyingPackage(package);
}
/*!
- \qmlclass VisualDataGroup QSGVisualDataGroup
+ \qmlclass VisualDataGroup QQuickVisualDataGroup
\inqmlmodule QtQuick 2
\ingroup qml-working-with-data
\brief The VisualDataGroup encapsulates a filtered set of visual data items.
*/
-QSGVisualDataGroup::QSGVisualDataGroup(QObject *parent)
- : QObject(*new QSGVisualDataGroupPrivate, parent)
+QQuickVisualDataGroup::QQuickVisualDataGroup(QObject *parent)
+ : QObject(*new QQuickVisualDataGroupPrivate, parent)
{
}
-QSGVisualDataGroup::QSGVisualDataGroup(
- const QString &name, QSGVisualDataModel *model, int index, QObject *parent)
- : QObject(*new QSGVisualDataGroupPrivate, parent)
+QQuickVisualDataGroup::QQuickVisualDataGroup(
+ const QString &name, QQuickVisualDataModel *model, int index, QObject *parent)
+ : QObject(*new QQuickVisualDataGroupPrivate, parent)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
d->name = name;
d->setModel(model, Compositor::Group(index));
}
-QSGVisualDataGroup::~QSGVisualDataGroup()
+QQuickVisualDataGroup::~QQuickVisualDataGroup()
{
}
Each group in a model must have a unique name starting with a lower case letter.
*/
-QString QSGVisualDataGroup::name() const
+QString QQuickVisualDataGroup::name() const
{
- Q_D(const QSGVisualDataGroup);
+ Q_D(const QQuickVisualDataGroup);
return d->name;
}
-void QSGVisualDataGroup::setName(const QString &name)
+void QQuickVisualDataGroup::setName(const QString &name)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (d->model)
return;
if (d->name != name) {
This property holds the number of items in the group.
*/
-int QSGVisualDataGroup::count() const
+int QQuickVisualDataGroup::count() const
{
- Q_D(const QSGVisualDataGroup);
+ Q_D(const QQuickVisualDataGroup);
if (!d->model)
return 0;
- return QSGVisualDataModelPrivate::get(d->model)->m_compositor.count(d->group);
+ return QQuickVisualDataModelPrivate::get(d->model)->m_compositor.count(d->group);
}
/*!
This property holds whether new items are assigned to this group by default.
*/
-bool QSGVisualDataGroup::defaultInclude() const
+bool QQuickVisualDataGroup::defaultInclude() const
{
- Q_D(const QSGVisualDataGroup);
+ Q_D(const QQuickVisualDataGroup);
return d->defaultInclude;
}
-void QSGVisualDataGroup::setDefaultInclude(bool include)
+void QQuickVisualDataGroup::setDefaultInclude(bool include)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (d->defaultInclude != include) {
d->defaultInclude = include;
if (d->model) {
if (include)
- QSGVisualDataModelPrivate::get(d->model)->m_compositor.setDefaultGroup(d->group);
+ QQuickVisualDataModelPrivate::get(d->model)->m_compositor.setDefaultGroup(d->group);
else
- QSGVisualDataModelPrivate::get(d->model)->m_compositor.clearDefaultGroup(d->group);
+ QQuickVisualDataModelPrivate::get(d->model)->m_compositor.clearDefaultGroup(d->group);
}
emit defaultIncludeChanged();
}
\endlist
*/
-QDeclarativeV8Handle QSGVisualDataGroup::get(int index)
+QDeclarativeV8Handle QQuickVisualDataGroup::get(int index)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (!d->model)
return QDeclarativeV8Handle::fromHandle(v8::Undefined());;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (index < 0 || index >= model->m_compositor.count(d->group)) {
qmlInfo(this) << tr("get: index out of range");
return QDeclarativeV8Handle::fromHandle(v8::Undefined());
}
Compositor::iterator it = model->m_compositor.find(d->group, index);
- QSGVisualDataModelCacheItem *cacheItem = it->inCache()
+ QQuickVisualDataModelCacheItem *cacheItem = it->inCache()
? model->m_cache.at(it.cacheIndex)
: 0;
if (!cacheItem) {
- cacheItem = new QSGVisualDataModelCacheItem(model->m_cacheMetaType);
+ cacheItem = new QQuickVisualDataModelCacheItem(model->m_cacheMetaType);
for (int i = 0; i < model->m_groupCount; ++i)
cacheItem->index[i] = it.index[i];
cacheItem->groups = it->flags & Compositor::GroupMask;
group remain instantiated when not referenced by any view.
*/
-QObject *QSGVisualDataGroup::create(int index)
+QObject *QQuickVisualDataGroup::create(int index)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (!d->model)
return 0;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (index < 0 || index >= model->m_compositor.count(d->group)) {
qmlInfo(this) << tr("create: index out of range");
return 0;
Removes \a count items starting at \a index from the group.
*/
-void QSGVisualDataGroup::remove(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::remove(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (!d->model)
return;
int index = -1;
count = v->Int32Value();
}
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("remove: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
}
}
-bool QSGVisualDataGroupPrivate::parseGroupArgs(
+bool QQuickVisualDataGroupPrivate::parseGroupArgs(
QDeclarativeV8Function *args, int *index, int *count, int *groups) const
{
if (!model)
v = (*args)[i];
}
- *groups = QSGVisualDataModelPrivate::get(model)->m_cacheMetaType->parseGroups(args->engine(), v);
+ *groups = QQuickVisualDataModelPrivate::get(model)->m_cacheMetaType->parseGroups(args->engine(), v);
return true;
}
Adds \a count items starting at \a index to \a groups.
*/
-void QSGVisualDataGroup::addGroups(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::addGroups(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
int index = -1;
int count = 1;
int groups = 0;
if (!d->parseGroupArgs(args, &index, &count, &groups))
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("addGroups: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
Removes \a count items starting at \a index from \a groups.
*/
-void QSGVisualDataGroup::removeGroups(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::removeGroups(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
int index = -1;
int count = 1;
int groups = 0;
if (!d->parseGroupArgs(args, &index, &count, &groups))
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("removeGroups: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
Sets the \a groups \a count items starting at \a index belong to.
*/
-void QSGVisualDataGroup::setGroups(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::setGroups(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
int index = -1;
int count = 1;
int groups = 0;
if (!d->parseGroupArgs(args, &index, &count, &groups))
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("setGroups: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
Moves \a count at \a from in a group \a to a new position.
*/
-void QSGVisualDataGroup::move(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::move(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (args->Length() < 2)
return;
int i = 0;
v8::Local<v8::Value> v = (*args)[i];
- if (QSGVisualDataGroup *group = qobject_cast<QSGVisualDataGroup *>(args->engine()->toQObject(v))) {
- QSGVisualDataGroupPrivate *g_d = QSGVisualDataGroupPrivate::get(group);
+ if (QQuickVisualDataGroup *group = qobject_cast<QQuickVisualDataGroup *>(args->engine()->toQObject(v))) {
+ QQuickVisualDataGroupPrivate *g_d = QQuickVisualDataGroupPrivate::get(group);
if (g_d->model != d->model)
return;
fromGroup = g_d->group;
return;
v = (*args)[i];
- if (QSGVisualDataGroup *group = qobject_cast<QSGVisualDataGroup *>(args->engine()->toQObject(v))) {
- QSGVisualDataGroupPrivate *g_d = QSGVisualDataGroupPrivate::get(group);
+ if (QQuickVisualDataGroup *group = qobject_cast<QQuickVisualDataGroup *>(args->engine()->toQObject(v))) {
+ QQuickVisualDataGroupPrivate *g_d = QQuickVisualDataGroupPrivate::get(group);
if (g_d->model != d->model)
return;
toGroup = g_d->group;
count = v->Int32Value();
}
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("move: invalid count");
//============================================================================
-QSGVisualPartsModel::QSGVisualPartsModel(QSGVisualDataModel *model, const QString &part, QObject *parent)
- : QSGVisualModel(*new QObjectPrivate, parent)
+QQuickVisualPartsModel::QQuickVisualPartsModel(QQuickVisualDataModel *model, const QString &part, QObject *parent)
+ : QQuickVisualModel(*new QObjectPrivate, parent)
, m_model(model)
, m_part(part)
, m_compositorGroup(Compositor::Cache)
, m_inheritGroup(true)
{
- QSGVisualDataModelPrivate *d = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *d = QQuickVisualDataModelPrivate::get(m_model);
if (d->m_cacheMetaType) {
- QSGVisualDataGroupPrivate::get(d->m_groups[1])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(d->m_groups[1])->emitters.insert(this);
m_compositorGroup = Compositor::Default;
} else {
d->m_pendingParts.insert(this);
}
}
-QSGVisualPartsModel::~QSGVisualPartsModel()
+QQuickVisualPartsModel::~QQuickVisualPartsModel()
{
}
-QString QSGVisualPartsModel::filterGroup() const
+QString QQuickVisualPartsModel::filterGroup() const
{
if (m_inheritGroup)
return m_model->filterGroup();
return m_filterGroup;
}
-void QSGVisualPartsModel::setFilterGroup(const QString &group)
+void QQuickVisualPartsModel::setFilterGroup(const QString &group)
{
- if (QSGVisualDataModelPrivate::get(m_model)->m_transaction) {
+ if (QQuickVisualDataModelPrivate::get(m_model)->m_transaction) {
qmlInfo(this) << tr("The group of a VisualDataModel cannot be changed within onChanged");
return;
}
}
}
-void QSGVisualPartsModel::resetFilterGroup()
+void QQuickVisualPartsModel::resetFilterGroup()
{
if (!m_inheritGroup) {
m_inheritGroup = true;
}
}
-void QSGVisualPartsModel::updateFilterGroup()
+void QQuickVisualPartsModel::updateFilterGroup()
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
if (!model->m_cacheMetaType)
return;
QDeclarativeListCompositor::Group previousGroup = model->m_compositorGroup;
m_compositorGroup = Compositor::Default;
- QSGVisualDataGroupPrivate::get(model->m_groups[Compositor::Default])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(model->m_groups[Compositor::Default])->emitters.insert(this);
for (int i = 1; i < model->m_groupCount; ++i) {
if (m_filterGroup == model->m_cacheMetaType->groupNames.at(i - 1)) {
m_compositorGroup = Compositor::Group(i);
}
}
- QSGVisualDataGroupPrivate::get(model->m_groups[m_compositorGroup])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(model->m_groups[m_compositorGroup])->emitters.insert(this);
if (m_compositorGroup != previousGroup) {
QVector<QDeclarativeChangeSet::Remove> removes;
QVector<QDeclarativeChangeSet::Insert> inserts;
}
}
-void QSGVisualPartsModel::updateFilterGroup(
+void QQuickVisualPartsModel::updateFilterGroup(
Compositor::Group group, const QDeclarativeChangeSet &changeSet)
{
if (!m_inheritGroup)
return;
m_compositorGroup = group;
- QSGVisualDataGroupPrivate::get(QSGVisualDataModelPrivate::get(m_model)->m_groups[m_compositorGroup])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(QQuickVisualDataModelPrivate::get(m_model)->m_groups[m_compositorGroup])->emitters.insert(this);
if (!changeSet.isEmpty())
emit modelUpdated(changeSet, false);
emit filterGroupChanged();
}
-int QSGVisualPartsModel::count() const
+int QQuickVisualPartsModel::count() const
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
return model->m_delegate
? model->m_compositor.count(m_compositorGroup)
: 0;
}
-bool QSGVisualPartsModel::isValid() const
+bool QQuickVisualPartsModel::isValid() const
{
return m_model->isValid();
}
-QSGItem *QSGVisualPartsModel::item(int index, bool complete)
+QQuickItem *QQuickVisualPartsModel::item(int index, bool complete)
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
if (!model->m_delegate || index < 0 || index >= model->m_compositor.count(m_compositorGroup)) {
qWarning() << "VisualDataModel::item: index out range" << index << model->m_compositor.count(m_compositorGroup);
QObject *part = package->part(m_part);
if (!part)
return 0;
- if (QSGItem *item = qobject_cast<QSGItem *>(part)) {
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(part)) {
m_packaged.insertMulti(item, package);
return item;
}
return 0;
}
-QSGVisualModel::ReleaseFlags QSGVisualPartsModel::release(QSGItem *item)
+QQuickVisualModel::ReleaseFlags QQuickVisualPartsModel::release(QQuickItem *item)
{
- QSGVisualModel::ReleaseFlags flags = 0;
+ QQuickVisualModel::ReleaseFlags flags = 0;
QHash<QObject *, QDeclarativePackage *>::iterator it = m_packaged.find(item);
if (it != m_packaged.end()) {
QDeclarativePackage *package = *it;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
flags = model->release(package);
m_packaged.erase(it);
if (!m_packaged.contains(item))
flags &= ~Referenced;
if (flags & Destroyed)
- QSGVisualDataModelPrivate::get(m_model)->emitDestroyingPackage(package);
+ QQuickVisualDataModelPrivate::get(m_model)->emitDestroyingPackage(package);
}
return flags;
}
-bool QSGVisualPartsModel::completePending() const
+bool QQuickVisualPartsModel::completePending() const
{
return m_model->completePending();
}
-void QSGVisualPartsModel::completeItem()
+void QQuickVisualPartsModel::completeItem()
{
m_model->completeItem();
}
-QString QSGVisualPartsModel::stringValue(int index, const QString &role)
+QString QQuickVisualPartsModel::stringValue(int index, const QString &role)
{
- return QSGVisualDataModelPrivate::get(m_model)->stringValue(m_compositorGroup, index, role);
+ return QQuickVisualDataModelPrivate::get(m_model)->stringValue(m_compositorGroup, index, role);
}
-void QSGVisualPartsModel::setWatchedRoles(QList<QByteArray> roles)
+void QQuickVisualPartsModel::setWatchedRoles(QList<QByteArray> roles)
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
model->m_adaptorModel->replaceWatchedRoles(m_watchedRoles, roles);
m_watchedRoles = roles;
}
-int QSGVisualPartsModel::indexOf(QSGItem *item, QObject *) const
+int QQuickVisualPartsModel::indexOf(QQuickItem *item, QObject *) const
{
QHash<QObject *, QDeclarativePackage *>::const_iterator it = m_packaged.find(item);
if (it != m_packaged.end()) {
- const QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ const QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
const int cacheIndex = model->cacheIndexOf(*it);
return cacheIndex != -1
? model->m_cache.at(cacheIndex)->index[m_compositorGroup]
return -1;
}
-void QSGVisualPartsModel::createdPackage(int index, QDeclarativePackage *package)
+void QQuickVisualPartsModel::createdPackage(int index, QDeclarativePackage *package)
{
- if (QSGItem *item = qobject_cast<QSGItem *>(package->part(m_part)))
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(package->part(m_part)))
emit createdItem(index, item);
}
-void QSGVisualPartsModel::destroyingPackage(QDeclarativePackage *package)
+void QQuickVisualPartsModel::destroyingPackage(QDeclarativePackage *package)
{
- if (QSGItem *item = qobject_cast<QSGItem *>(package->part(m_part))) {
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(package->part(m_part))) {
Q_ASSERT(!m_packaged.contains(item));
emit destroyingItem(item);
}
}
-void QSGVisualPartsModel::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickVisualPartsModel::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
emit modelUpdated(changeSet, reset);
if (changeSet.difference() != 0)
QT_END_NAMESPACE
-#include <qsgvisualdatamodel.moc>
+#include <qquickvisualdatamodel.moc>
**
****************************************************************************/
-#ifndef QSGVISUALDATAMODEL_P_H
-#define QSGVISUALDATAMODEL_P_H
+#ifndef QQUICKVISUALDATAMODEL_P_H
+#define QQUICKVISUALDATAMODEL_P_H
#include <private/qdeclarativelistcompositor_p.h>
-#include <private/qsgvisualitemmodel_p.h>
+#include <private/qquickvisualitemmodel_p.h>
#include <QtCore/qabstractitemmodel.h>
class QDeclarativeComponent;
class QDeclarativePackage;
class QDeclarativeV8Function;
-class QSGVisualDataGroup;
-class QSGVisualDataModelAttached;
-class QSGVisualDataModelPrivate;
+class QQuickVisualDataGroup;
+class QQuickVisualDataModelAttached;
+class QQuickVisualDataModelPrivate;
-class Q_DECLARATIVE_EXPORT QSGVisualDataModel : public QSGVisualModel, public QDeclarativeParserStatus
+class Q_DECLARATIVE_EXPORT QQuickVisualDataModel : public QQuickVisualModel, public QDeclarativeParserStatus
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGVisualDataModel)
+ Q_DECLARE_PRIVATE(QQuickVisualDataModel)
Q_PROPERTY(QVariant model READ model WRITE setModel)
Q_PROPERTY(QDeclarativeComponent *delegate READ delegate WRITE setDelegate)
Q_PROPERTY(QString filterOnGroup READ filterGroup WRITE setFilterGroup NOTIFY filterGroupChanged RESET resetFilterGroup)
- Q_PROPERTY(QSGVisualDataGroup *items READ items CONSTANT)
- Q_PROPERTY(QSGVisualDataGroup *persistedItems READ persistedItems CONSTANT)
- Q_PROPERTY(QDeclarativeListProperty<QSGVisualDataGroup> groups READ groups CONSTANT)
+ Q_PROPERTY(QQuickVisualDataGroup *items READ items CONSTANT)
+ Q_PROPERTY(QQuickVisualDataGroup *persistedItems READ persistedItems CONSTANT)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickVisualDataGroup> groups READ groups CONSTANT)
Q_PROPERTY(QObject *parts READ parts CONSTANT)
Q_PROPERTY(QVariant rootIndex READ rootIndex WRITE setRootIndex NOTIFY rootIndexChanged)
Q_CLASSINFO("DefaultProperty", "delegate")
Q_INTERFACES(QDeclarativeParserStatus)
public:
- QSGVisualDataModel();
- QSGVisualDataModel(QDeclarativeContext *, QObject *parent=0);
- virtual ~QSGVisualDataModel();
+ QQuickVisualDataModel();
+ QQuickVisualDataModel(QDeclarativeContext *, QObject *parent=0);
+ virtual ~QQuickVisualDataModel();
void classBegin();
void componentComplete();
int count() const;
bool isValid() const { return delegate() != 0; }
- QSGItem *item(int index, bool complete=true);
- ReleaseFlags release(QSGItem *item);
+ QQuickItem *item(int index, bool complete=true);
+ ReleaseFlags release(QQuickItem *item);
bool completePending() const;
void completeItem();
virtual QString stringValue(int index, const QString &role);
virtual void setWatchedRoles(QList<QByteArray> roles);
- int indexOf(QSGItem *item, QObject *objectContext) const;
+ int indexOf(QQuickItem *item, QObject *objectContext) const;
QString filterGroup() const;
void setFilterGroup(const QString &group);
void resetFilterGroup();
- QSGVisualDataGroup *items();
- QSGVisualDataGroup *persistedItems();
- QDeclarativeListProperty<QSGVisualDataGroup> groups();
+ QQuickVisualDataGroup *items();
+ QQuickVisualDataGroup *persistedItems();
+ QDeclarativeListProperty<QQuickVisualDataGroup> groups();
QObject *parts();
bool event(QEvent *);
- static QSGVisualDataModelAttached *qmlAttachedProperties(QObject *obj);
+ static QQuickVisualDataModelAttached *qmlAttachedProperties(QObject *obj);
Q_SIGNALS:
void filterGroupChanged();
void _q_itemsMoved(int from, int to, int count);
void _q_modelReset(int oldCount, int newCount);
private:
- Q_DISABLE_COPY(QSGVisualDataModel)
+ Q_DISABLE_COPY(QQuickVisualDataModel)
};
-class QSGVisualDataGroupPrivate;
-class Q_AUTOTEST_EXPORT QSGVisualDataGroup : public QObject
+class QQuickVisualDataGroupPrivate;
+class Q_AUTOTEST_EXPORT QQuickVisualDataGroup : public QObject
{
Q_OBJECT
Q_PROPERTY(int count READ count NOTIFY countChanged)
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(bool includeByDefault READ defaultInclude WRITE setDefaultInclude NOTIFY defaultIncludeChanged)
public:
- QSGVisualDataGroup(QObject *parent = 0);
- QSGVisualDataGroup(const QString &name, QSGVisualDataModel *model, int compositorType, QObject *parent = 0);
- ~QSGVisualDataGroup();
+ QQuickVisualDataGroup(QObject *parent = 0);
+ QQuickVisualDataGroup(const QString &name, QQuickVisualDataModel *model, int compositorType, QObject *parent = 0);
+ ~QQuickVisualDataGroup();
QString name() const;
void setName(const QString &name);
void defaultIncludeChanged();
void changed(const QDeclarativeV8Handle &removed, const QDeclarativeV8Handle &inserted);
private:
- Q_DECLARE_PRIVATE(QSGVisualDataGroup)
+ Q_DECLARE_PRIVATE(QQuickVisualDataGroup)
};
-class QSGVisualDataModelCacheItem;
-class QSGVisualDataModelAttachedMetaObject;
-class QSGVisualDataModelAttached : public QObject
+class QQuickVisualDataModelCacheItem;
+class QQuickVisualDataModelAttachedMetaObject;
+class QQuickVisualDataModelAttached : public QObject
{
Q_OBJECT
- Q_PROPERTY(QSGVisualDataModel *model READ model NOTIFY modelChanged)
+ Q_PROPERTY(QQuickVisualDataModel *model READ model NOTIFY modelChanged)
Q_PROPERTY(QStringList groups READ groups WRITE setGroups NOTIFY groupsChanged)
public:
- QSGVisualDataModelAttached(QObject *parent)
+ QQuickVisualDataModelAttached(QObject *parent)
: QObject(parent)
, m_cacheItem(0)
, m_previousGroups(0)
, m_modelChanged(false)
{}
- ~QSGVisualDataModelAttached() { attachedProperties.remove(parent()); }
+ ~QQuickVisualDataModelAttached() { attachedProperties.remove(parent()); }
- QSGVisualDataModel *model() const;
+ QQuickVisualDataModel *model() const;
QStringList groups() const;
void setGroups(const QStringList &groups);
void emitChanges();
- static QSGVisualDataModelAttached *properties(QObject *obj)
+ static QQuickVisualDataModelAttached *properties(QObject *obj)
{
- QSGVisualDataModelAttached *rv = attachedProperties.value(obj);
+ QQuickVisualDataModelAttached *rv = attachedProperties.value(obj);
if (!rv) {
- rv = new QSGVisualDataModelAttached(obj);
+ rv = new QQuickVisualDataModelAttached(obj);
attachedProperties.insert(obj, rv);
}
return rv;
void groupsChanged();
public:
- QSGVisualDataModelCacheItem *m_cacheItem;
+ QQuickVisualDataModelCacheItem *m_cacheItem;
int m_previousGroups;
int m_previousIndex[QDeclarativeListCompositor::MaximumGroupCount];
bool m_modelChanged;
- static QHash<QObject*, QSGVisualDataModelAttached*> attachedProperties;
+ static QHash<QObject*, QQuickVisualDataModelAttached*> attachedProperties;
- friend class QSGVisualDataModelAttachedMetaObject;
+ friend class QQuickVisualDataModelAttachedMetaObject;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGVisualDataModel)
-QML_DECLARE_TYPEINFO(QSGVisualDataModel, QML_HAS_ATTACHED_PROPERTIES)
-QML_DECLARE_TYPE(QSGVisualDataGroup)
+QML_DECLARE_TYPE(QQuickVisualDataModel)
+QML_DECLARE_TYPEINFO(QQuickVisualDataModel, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickVisualDataGroup)
QT_END_HEADER
-#endif // QSGVISUALDATAMODEL_P_H
+#endif // QQUICKVISUALDATAMODEL_P_H
**
****************************************************************************/
-#include "qsgvisualitemmodel_p.h"
-#include "qsgitem.h"
+#include "qquickvisualitemmodel_p.h"
+#include "qquickitem.h"
#include <QtCore/qcoreapplication.h>
#include <QtDeclarative/qdeclarativecontext.h>
QT_BEGIN_NAMESPACE
-QHash<QObject*, QSGVisualItemModelAttached*> QSGVisualItemModelAttached::attachedProperties;
+QHash<QObject*, QQuickVisualItemModelAttached*> QQuickVisualItemModelAttached::attachedProperties;
-class QSGVisualItemModelPrivate : public QObjectPrivate
+class QQuickVisualItemModelPrivate : public QObjectPrivate
{
- Q_DECLARE_PUBLIC(QSGVisualItemModel)
+ Q_DECLARE_PUBLIC(QQuickVisualItemModel)
public:
- QSGVisualItemModelPrivate() : QObjectPrivate() {}
+ QQuickVisualItemModelPrivate() : QObjectPrivate() {}
- static void children_append(QDeclarativeListProperty<QSGItem> *prop, QSGItem *item) {
+ static void children_append(QDeclarativeListProperty<QQuickItem> *prop, QQuickItem *item) {
QDeclarative_setParent_noEvent(item, prop->object);
- static_cast<QSGVisualItemModelPrivate *>(prop->data)->children.append(Item(item));
- static_cast<QSGVisualItemModelPrivate *>(prop->data)->itemAppended();
- static_cast<QSGVisualItemModelPrivate *>(prop->data)->emitChildrenChanged();
+ static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.append(Item(item));
+ static_cast<QQuickVisualItemModelPrivate *>(prop->data)->itemAppended();
+ static_cast<QQuickVisualItemModelPrivate *>(prop->data)->emitChildrenChanged();
}
- static int children_count(QDeclarativeListProperty<QSGItem> *prop) {
- return static_cast<QSGVisualItemModelPrivate *>(prop->data)->children.count();
+ static int children_count(QDeclarativeListProperty<QQuickItem> *prop) {
+ return static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.count();
}
- static QSGItem *children_at(QDeclarativeListProperty<QSGItem> *prop, int index) {
- return static_cast<QSGVisualItemModelPrivate *>(prop->data)->children.at(index).item;
+ static QQuickItem *children_at(QDeclarativeListProperty<QQuickItem> *prop, int index) {
+ return static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.at(index).item;
}
void itemAppended() {
- Q_Q(QSGVisualItemModel);
- QSGVisualItemModelAttached *attached = QSGVisualItemModelAttached::properties(children.last().item);
+ Q_Q(QQuickVisualItemModel);
+ QQuickVisualItemModelAttached *attached = QQuickVisualItemModelAttached::properties(children.last().item);
attached->setIndex(children.count()-1);
QDeclarativeChangeSet changeSet;
changeSet.insert(children.count() - 1, 1);
}
void emitChildrenChanged() {
- Q_Q(QSGVisualItemModel);
+ Q_Q(QQuickVisualItemModel);
emit q->childrenChanged();
}
- int indexOf(QSGItem *item) const {
+ int indexOf(QQuickItem *item) const {
for (int i = 0; i < children.count(); ++i)
if (children.at(i).item == item)
return i;
class Item {
public:
- Item(QSGItem *i) : item(i), ref(0) {}
+ Item(QQuickItem *i) : item(i), ref(0) {}
void addRef() { ++ref; }
bool deref() { return --ref == 0; }
- QSGItem *item;
+ QQuickItem *item;
int ref;
};
/*!
- \qmlclass VisualItemModel QSGVisualItemModel
+ \qmlclass VisualItemModel QQuickVisualItemModel
\inqmlmodule QtQuick 2
\ingroup qml-working-with-data
\brief The VisualItemModel allows items to be provided to a view.
\sa {declarative/modelviews/visualitemmodel}{VisualItemModel example}
*/
-QSGVisualItemModel::QSGVisualItemModel(QObject *parent)
- : QSGVisualModel(*(new QSGVisualItemModelPrivate), parent)
+QQuickVisualItemModel::QQuickVisualItemModel(QObject *parent)
+ : QQuickVisualModel(*(new QQuickVisualItemModelPrivate), parent)
{
}
It is attached to each instance of the delegate.
*/
-QDeclarativeListProperty<QSGItem> QSGVisualItemModel::children()
+QDeclarativeListProperty<QQuickItem> QQuickVisualItemModel::children()
{
- Q_D(QSGVisualItemModel);
- return QDeclarativeListProperty<QSGItem>(this, d, d->children_append,
+ Q_D(QQuickVisualItemModel);
+ return QDeclarativeListProperty<QQuickItem>(this, d, d->children_append,
d->children_count, d->children_at);
}
The number of items in the model. This property is readonly.
*/
-int QSGVisualItemModel::count() const
+int QQuickVisualItemModel::count() const
{
- Q_D(const QSGVisualItemModel);
+ Q_D(const QQuickVisualItemModel);
return d->children.count();
}
-bool QSGVisualItemModel::isValid() const
+bool QQuickVisualItemModel::isValid() const
{
return true;
}
-QSGItem *QSGVisualItemModel::item(int index, bool)
+QQuickItem *QQuickVisualItemModel::item(int index, bool)
{
- Q_D(QSGVisualItemModel);
- QSGVisualItemModelPrivate::Item &item = d->children[index];
+ Q_D(QQuickVisualItemModel);
+ QQuickVisualItemModelPrivate::Item &item = d->children[index];
item.addRef();
return item.item;
}
-QSGVisualModel::ReleaseFlags QSGVisualItemModel::release(QSGItem *item)
+QQuickVisualModel::ReleaseFlags QQuickVisualItemModel::release(QQuickItem *item)
{
- Q_D(QSGVisualItemModel);
+ Q_D(QQuickVisualItemModel);
int idx = d->indexOf(item);
if (idx >= 0) {
if (d->children[idx].deref()) {
return 0;
}
-bool QSGVisualItemModel::completePending() const
+bool QQuickVisualItemModel::completePending() const
{
return false;
}
-void QSGVisualItemModel::completeItem()
+void QQuickVisualItemModel::completeItem()
{
// Nothing to do
}
-QString QSGVisualItemModel::stringValue(int index, const QString &name)
+QString QQuickVisualItemModel::stringValue(int index, const QString &name)
{
- Q_D(QSGVisualItemModel);
+ Q_D(QQuickVisualItemModel);
if (index < 0 || index >= d->children.count())
return QString();
return QDeclarativeEngine::contextForObject(d->children.at(index).item)->contextProperty(name).toString();
}
-int QSGVisualItemModel::indexOf(QSGItem *item, QObject *) const
+int QQuickVisualItemModel::indexOf(QQuickItem *item, QObject *) const
{
- Q_D(const QSGVisualItemModel);
+ Q_D(const QQuickVisualItemModel);
return d->indexOf(item);
}
-QSGVisualItemModelAttached *QSGVisualItemModel::qmlAttachedProperties(QObject *obj)
+QQuickVisualItemModelAttached *QQuickVisualItemModel::qmlAttachedProperties(QObject *obj)
{
- return QSGVisualItemModelAttached::properties(obj);
+ return QQuickVisualItemModelAttached::properties(obj);
}
QT_END_NAMESPACE
**
****************************************************************************/
-#ifndef QSGVISUALITEMMODEL_P_H
-#define QSGVISUALITEMMODEL_P_H
+#ifndef QQUICKVISUALITEMMODEL_P_H
+#define QQUICKVISUALITEMMODEL_P_H
#include <QtDeclarative/qdeclarative.h>
#include <QtCore/qobject.h>
QT_MODULE(Declarative)
-class QSGItem;
+class QQuickItem;
class QDeclarativeChangeSet;
-class Q_DECLARATIVE_EXPORT QSGVisualModel : public QObject
+class Q_DECLARATIVE_EXPORT QQuickVisualModel : public QObject
{
Q_OBJECT
Q_PROPERTY(int count READ count NOTIFY countChanged)
public:
- virtual ~QSGVisualModel() {}
+ virtual ~QQuickVisualModel() {}
enum ReleaseFlag { Referenced = 0x01, Destroyed = 0x02 };
Q_DECLARE_FLAGS(ReleaseFlags, ReleaseFlag)
virtual int count() const = 0;
virtual bool isValid() const = 0;
- virtual QSGItem *item(int index, bool complete=true) = 0;
- virtual ReleaseFlags release(QSGItem *item) = 0;
+ virtual QQuickItem *item(int index, bool complete=true) = 0;
+ virtual ReleaseFlags release(QQuickItem *item) = 0;
virtual bool completePending() const = 0;
virtual void completeItem() = 0;
virtual QString stringValue(int, const QString &) = 0;
virtual void setWatchedRoles(QList<QByteArray> roles) = 0;
- virtual int indexOf(QSGItem *item, QObject *objectContext) const = 0;
+ virtual int indexOf(QQuickItem *item, QObject *objectContext) const = 0;
Q_SIGNALS:
void countChanged();
void modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
- void createdItem(int index, QSGItem *item);
- void destroyingItem(QSGItem *item);
+ void createdItem(int index, QQuickItem *item);
+ void destroyingItem(QQuickItem *item);
protected:
- QSGVisualModel(QObjectPrivate &dd, QObject *parent = 0)
+ QQuickVisualModel(QObjectPrivate &dd, QObject *parent = 0)
: QObject(dd, parent) {}
private:
- Q_DISABLE_COPY(QSGVisualModel)
+ Q_DISABLE_COPY(QQuickVisualModel)
};
-class QSGVisualItemModelAttached;
-class QSGVisualItemModelPrivate;
-class Q_DECLARATIVE_EXPORT QSGVisualItemModel : public QSGVisualModel
+class QQuickVisualItemModelAttached;
+class QQuickVisualItemModelPrivate;
+class Q_DECLARATIVE_EXPORT QQuickVisualItemModel : public QQuickVisualModel
{
Q_OBJECT
- Q_DECLARE_PRIVATE(QSGVisualItemModel)
+ Q_DECLARE_PRIVATE(QQuickVisualItemModel)
- Q_PROPERTY(QDeclarativeListProperty<QSGItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
Q_CLASSINFO("DefaultProperty", "children")
public:
- QSGVisualItemModel(QObject *parent=0);
- virtual ~QSGVisualItemModel() {}
+ QQuickVisualItemModel(QObject *parent=0);
+ virtual ~QQuickVisualItemModel() {}
virtual int count() const;
virtual bool isValid() const;
- virtual QSGItem *item(int index, bool complete=true);
- virtual ReleaseFlags release(QSGItem *item);
+ virtual QQuickItem *item(int index, bool complete=true);
+ virtual ReleaseFlags release(QQuickItem *item);
virtual bool completePending() const;
virtual void completeItem();
virtual QString stringValue(int index, const QString &role);
virtual void setWatchedRoles(QList<QByteArray>) {}
- virtual int indexOf(QSGItem *item, QObject *objectContext) const;
+ virtual int indexOf(QQuickItem *item, QObject *objectContext) const;
- QDeclarativeListProperty<QSGItem> children();
+ QDeclarativeListProperty<QQuickItem> children();
- static QSGVisualItemModelAttached *qmlAttachedProperties(QObject *obj);
+ static QQuickVisualItemModelAttached *qmlAttachedProperties(QObject *obj);
Q_SIGNALS:
void childrenChanged();
private:
- Q_DISABLE_COPY(QSGVisualItemModel)
+ Q_DISABLE_COPY(QQuickVisualItemModel)
};
-class QSGVisualItemModelAttached : public QObject
+class QQuickVisualItemModelAttached : public QObject
{
Q_OBJECT
public:
- QSGVisualItemModelAttached(QObject *parent)
+ QQuickVisualItemModelAttached(QObject *parent)
: QObject(parent), m_index(0) {}
- ~QSGVisualItemModelAttached() {
+ ~QQuickVisualItemModelAttached() {
attachedProperties.remove(parent());
}
}
}
- static QSGVisualItemModelAttached *properties(QObject *obj) {
- QSGVisualItemModelAttached *rv = attachedProperties.value(obj);
+ static QQuickVisualItemModelAttached *properties(QObject *obj) {
+ QQuickVisualItemModelAttached *rv = attachedProperties.value(obj);
if (!rv) {
- rv = new QSGVisualItemModelAttached(obj);
+ rv = new QQuickVisualItemModelAttached(obj);
attachedProperties.insert(obj, rv);
}
return rv;
public:
int m_index;
- static QHash<QObject*, QSGVisualItemModelAttached*> attachedProperties;
+ static QHash<QObject*, QQuickVisualItemModelAttached*> attachedProperties;
};
QT_END_NAMESPACE
-QML_DECLARE_TYPE(QSGVisualModel)
-QML_DECLARE_TYPE(QSGVisualItemModel)
-QML_DECLARE_TYPEINFO(QSGVisualItemModel, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickVisualModel)
+QML_DECLARE_TYPE(QQuickVisualItemModel)
+QML_DECLARE_TYPEINFO(QQuickVisualItemModel, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
-#endif // QSGVISUALITEMMODEL_P_H
+#endif // QQUICKVISUALITEMMODEL_P_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the QtDeclarative 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 "qsgitemsmodule_p.h"
-
-#include "qsgitem.h"
-#include "qsgitem_p.h"
-#include "qsgevents_p_p.h"
-#include "qsgrectangle_p.h"
-#include "qsgfocusscope_p.h"
-#include "qsgtext_p.h"
-#include "qsgtextinput_p.h"
-#include "qsgtextedit_p.h"
-#include "qsgimage_p.h"
-#include "qsgborderimage_p.h"
-#include "qsgscalegrid_p_p.h"
-#include "qsgmousearea_p.h"
-#include "qsgpincharea_p.h"
-#include "qsgflickable_p.h"
-#include "qsgflickable_p_p.h"
-#include "qsglistview_p.h"
-#include "qsgvisualitemmodel_p.h"
-#include "qsgvisualdatamodel_p.h"
-#include "qsggridview_p.h"
-#include "qsgpathview_p.h"
-#include <private/qdeclarativepath_p.h>
-#include <private/qdeclarativepathinterpolator_p.h>
-#include "qsgpositioners_p.h"
-#include "qsgrepeater_p.h"
-#include "qsgloader_p.h"
-#include "qsganimatedimage_p.h"
-#include "qsgflipable_p.h"
-#include "qsgtranslate_p.h"
-#include "qsgstateoperations_p.h"
-#include "qsganimation_p.h"
-#include <private/qsgshadereffect_p.h>
-#include <private/qsgshadereffectsource_p.h>
-//#include <private/qsgpincharea_p.h>
-#include <private/qsgcanvasitem_p.h>
-#include <private/qsgcontext2d_p.h>
-#include "qsgsprite_p.h"
-#include "qsgspriteimage_p.h"
-#include "qsgdrag_p.h"
-#include "qsgdroparea_p.h"
-
-static QDeclarativePrivate::AutoParentResult qsgitem_autoParent(QObject *obj, QObject *parent)
-{
- QSGItem *item = qobject_cast<QSGItem *>(obj);
- if (!item)
- return QDeclarativePrivate::IncompatibleObject;
-
- QSGItem *parentItem = qobject_cast<QSGItem *>(parent);
- if (!parentItem)
- return QDeclarativePrivate::IncompatibleParent;
-
- item->setParentItem(parentItem);
- return QDeclarativePrivate::Parented;
-}
-
-static void qt_sgitems_defineModule(const char *uri, int major, int minor)
-{
- QDeclarativePrivate::RegisterAutoParent autoparent = { 0, &qsgitem_autoParent };
- QDeclarativePrivate::qmlregister(QDeclarativePrivate::AutoParentRegistration, &autoparent);
-
-#ifdef QT_NO_MOVIE
- qmlRegisterTypeNotAvailable(uri,major,minor,"AnimatedImage", qApp->translate("QSGAnimatedImage","Qt was built without support for QMovie"));
-#else
- qmlRegisterType<QSGAnimatedImage>(uri,major,minor,"AnimatedImage");
-#endif
- qmlRegisterType<QSGBorderImage>(uri,major,minor,"BorderImage");
- qmlRegisterType<QSGColumn>(uri,major,minor,"Column");
- qmlRegisterType<QSGFlickable>(uri,major,minor,"Flickable");
- qmlRegisterType<QSGFlipable>(uri,major,minor,"Flipable");
- qmlRegisterType<QSGFlow>(uri,major,minor,"Flow");
-// qmlRegisterType<QDeclarativeFocusPanel>(uri,major,minor,"FocusPanel");
- qmlRegisterType<QSGFocusScope>(uri,major,minor,"FocusScope");
- qmlRegisterType<QSGGradient>(uri,major,minor,"Gradient");
- qmlRegisterType<QSGGradientStop>(uri,major,minor,"GradientStop");
- qmlRegisterType<QSGGrid>(uri,major,minor,"Grid");
- qmlRegisterType<QSGGridView>(uri,major,minor,"GridView");
- qmlRegisterType<QSGImage>(uri,major,minor,"Image");
- qmlRegisterType<QSGItem>(uri,major,minor,"Item");
- qmlRegisterType<QSGListView>(uri,major,minor,"ListView");
- qmlRegisterType<QSGLoader>(uri,major,minor,"Loader");
- qmlRegisterType<QSGMouseArea>(uri,major,minor,"MouseArea");
- qmlRegisterType<QDeclarativePath>(uri,major,minor,"Path");
- qmlRegisterType<QDeclarativePathAttribute>(uri,major,minor,"PathAttribute");
- qmlRegisterType<QDeclarativePathCubic>(uri,major,minor,"PathCubic");
- qmlRegisterType<QDeclarativePathLine>(uri,major,minor,"PathLine");
- qmlRegisterType<QDeclarativePathPercent>(uri,major,minor,"PathPercent");
- qmlRegisterType<QDeclarativePathQuad>(uri,major,minor,"PathQuad");
- qmlRegisterType<QDeclarativePathCatmullRomCurve>("QtQuick",2,0,"PathCurve");
- qmlRegisterType<QDeclarativePathArc>("QtQuick",2,0,"PathArc");
- qmlRegisterType<QDeclarativePathSvg>("QtQuick",2,0,"PathSvg");
- qmlRegisterType<QSGPathView>(uri,major,minor,"PathView");
- qmlRegisterUncreatableType<QSGBasePositioner>(uri,major,minor,"Positioner",
- QStringLiteral("Positioner is an abstract type that is only available as an attached property."));
-#ifndef QT_NO_VALIDATOR
- qmlRegisterType<QIntValidator>(uri,major,minor,"IntValidator");
- qmlRegisterType<QDoubleValidator>(uri,major,minor,"DoubleValidator");
- qmlRegisterType<QRegExpValidator>(uri,major,minor,"RegExpValidator");
-#endif
- qmlRegisterType<QSGRectangle>(uri,major,minor,"Rectangle");
- qmlRegisterType<QSGRepeater>(uri,major,minor,"Repeater");
- qmlRegisterType<QSGRow>(uri,major,minor,"Row");
- qmlRegisterType<QSGTranslate>(uri,major,minor,"Translate");
- qmlRegisterType<QSGRotation>(uri,major,minor,"Rotation");
- qmlRegisterType<QSGScale>(uri,major,minor,"Scale");
- qmlRegisterType<QSGText>(uri,major,minor,"Text");
- qmlRegisterType<QSGTextEdit>(uri,major,minor,"TextEdit");
- qmlRegisterType<QSGTextInput>(uri,major,minor,"TextInput");
- qmlRegisterType<QSGViewSection>(uri,major,minor,"ViewSection");
- qmlRegisterType<QSGVisualDataModel>(uri,major,minor,"VisualDataModel");
- qmlRegisterType<QSGVisualDataGroup>(uri,major,minor,"VisualDataGroup");
- qmlRegisterType<QSGVisualItemModel>(uri,major,minor,"VisualItemModel");
-
- qmlRegisterType<QSGAnchors>();
- qmlRegisterType<QSGKeyEvent>();
- qmlRegisterType<QSGMouseEvent>();
- qmlRegisterType<QSGTransform>();
- qmlRegisterType<QDeclarativePathElement>();
- qmlRegisterType<QDeclarativeCurve>();
- qmlRegisterType<QSGScaleGrid>();
- qmlRegisterType<QSGTextLine>();
-#ifndef QT_NO_VALIDATOR
- qmlRegisterType<QValidator>();
-#endif
- qmlRegisterType<QSGVisualModel>();
- qmlRegisterType<QSGPen>();
- qmlRegisterType<QSGFlickableVisibleArea>();
- qRegisterMetaType<QSGAnchorLine>("QSGAnchorLine");
-
- qmlRegisterUncreatableType<QSGKeyNavigationAttached>(uri,major,minor,"KeyNavigation",QSGKeyNavigationAttached::tr("KeyNavigation is only available via attached properties"));
- qmlRegisterUncreatableType<QSGKeysAttached>(uri,major,minor,"Keys",QSGKeysAttached::tr("Keys is only available via attached properties"));
- qmlRegisterUncreatableType<QSGLayoutMirroringAttached>(uri,major,minor,"LayoutMirroring", QSGLayoutMirroringAttached::tr("LayoutMirroring is only available via attached properties"));
-
- qmlRegisterType<QSGPinchArea>(uri,major,minor,"PinchArea");
- qmlRegisterType<QSGPinch>(uri,major,minor,"Pinch");
- qmlRegisterType<QSGPinchEvent>();
-
- qmlRegisterType<QSGShaderEffectItem>("QtQuick", 2, 0, "ShaderEffectItem"); // TODO: Remove after grace period.
- qmlRegisterType<QSGShaderEffect>("QtQuick", 2, 0, "ShaderEffect");
- qmlRegisterType<QSGShaderEffectSource>("QtQuick", 2, 0, "ShaderEffectSource");
- qmlRegisterUncreatableType<QSGShaderEffectMesh>("QtQuick", 2, 0, "ShaderEffectMesh", QSGShaderEffectMesh::tr("Cannot create instance of abstract class ShaderEffectMesh."));
- qmlRegisterType<QSGGridMesh>("QtQuick", 2, 0, "GridMesh");
-
- qmlRegisterUncreatableType<QSGPaintedItem>("QtQuick", 2, 0, "PaintedItem", QSGPaintedItem::tr("Cannot create instance of abstract class PaintedItem"));
-
- qmlRegisterType<QSGCanvasItem>("QtQuick", 2, 0, "Canvas");
-
- qmlRegisterType<QSGSprite>("QtQuick", 2, 0, "Sprite");
- qmlRegisterType<QSGSpriteImage>("QtQuick", 2, 0, "SpriteImage");
-
- qmlRegisterType<QSGParentChange>(uri, major, minor,"ParentChange");
- qmlRegisterType<QSGAnchorChanges>(uri, major, minor,"AnchorChanges");
- qmlRegisterType<QSGAnchorSet>();
- qmlRegisterType<QSGAnchorAnimation>(uri, major, minor,"AnchorAnimation");
- qmlRegisterType<QSGParentAnimation>(uri, major, minor,"ParentAnimation");
- qmlRegisterType<QSGPathAnimation>("QtQuick",2,0,"PathAnimation");
- qmlRegisterType<QDeclarativePathInterpolator>("QtQuick",2,0,"PathInterpolator");
-
- qmlRegisterType<QSGDropArea>("QtQuick", 2, 0, "DropArea");
- qmlRegisterType<QSGDropEvent>();
- qmlRegisterType<QSGDropAreaDrag>();
- qmlRegisterUncreatableType<QSGDrag>("QtQuick", 2, 0, "Drag", QSGDragAttached::tr("Drag is only available via attached properties"));
-}
-
-void QSGItemsModule::defineModule()
-{
- static bool initialized = false;
- if (initialized)
- return;
- initialized = true;
-
- // XXX todo - Remove before final integration...
- QByteArray mode = qgetenv("QMLSCENE_IMPORT_NAME");
- QByteArray name = "QtQuick";
- int majorVersion = 2;
- int minorVersion = 0;
- if (mode == "quick1") {
- majorVersion = 1;
- } else if (mode == "qt") {
- name = "Qt";
- majorVersion = 4;
- minorVersion = 7;
- }
-
- qt_sgitems_defineModule(name, majorVersion, minorVersion);
-}
-
Default value is true.
*/
-QSGAgeAffector::QSGAgeAffector(QSGItem *parent) :
+QSGAgeAffector::QSGAgeAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_lifeLeft(0), m_advancePosition(true)
{
}
Q_PROPERTY(bool advancePosition READ advancePosition WRITE setAdvancePosition NOTIFY advancePositionChanged)
public:
- explicit QSGAgeAffector(QSGItem *parent = 0);
+ explicit QSGAgeAffector(QQuickItem *parent = 0);
int lifeLeft() const
{
Note that JS is slower to execute, so it is not recommended to use this in
high-volume particle systems.
*/
-QSGCustomAffector::QSGCustomAffector(QSGItem *parent) :
+QSGCustomAffector::QSGCustomAffector(QQuickItem *parent) :
QSGParticleAffector(parent)
{
}
Q_OBJECT
public:
- explicit QSGCustomAffector(QSGItem *parent = 0);
+ explicit QSGCustomAffector(QQuickItem *parent = 0);
virtual void affectSystem(qreal dt);
signals:
****************************************************************************/
#include "qsgcustomparticle_p.h"
-#include <private/qsgshadereffectmesh_p.h>
+#include <private/qquickshadereffectmesh_p.h>
#include <cstdlib>
QT_BEGIN_NAMESPACE
*/
-QSGCustomParticle::QSGCustomParticle(QSGItem* parent)
+QSGCustomParticle::QSGCustomParticle(QQuickItem* parent)
: QSGParticlePainter(parent)
, m_dirtyData(true)
, m_material(0)
, m_rootNode(0)
{
- setFlag(QSGItem::ItemHasContents);
+ setFlag(QQuickItem::ItemHasContents);
}
-class QSGShaderEffectMaterialObject : public QObject, public QSGShaderEffectMaterial { };
+class QSGShaderEffectMaterialObject : public QObject, public QQuickShaderEffectMaterial { };
QSGCustomParticle::~QSGCustomParticle()
{
}
QObject *obj = qVariantValue<QObject *>(var);
- source.item = qobject_cast<QSGItem *>(obj);
+ source.item = qobject_cast<QQuickItem *>(obj);
if (!source.item || !source.item->isTextureProvider()) {
qWarning("ShaderEffect: source uniform [%s] is not assigned a valid texture provider: %s [%s]",
source.name.constData(), qPrintable(obj->objectName()), obj->metaObject()->className());
buildData();
}
-QSGShaderEffectNode* QSGCustomParticle::buildCustomNodes()
+QQuickShaderEffectNode* QSGCustomParticle::buildCustomNodes()
{
#ifdef QT_OPENGL_ES_2
if (m_count * 4 > 0xffff) {
updateProperties();
- QSGShaderEffectProgram s = m_source;
+ QQuickShaderEffectProgram s = m_source;
if (s.fragmentCode.isEmpty())
s.fragmentCode = qt_particles_default_fragment_code;
if (s.vertexCode.isEmpty())
int gIdx = m_system->groupIds[str];
int count = m_system->groupData[gIdx]->size();
- QSGShaderEffectNode* node = new QSGShaderEffectNode();
+ QQuickShaderEffectNode* node = new QQuickShaderEffectNode();
m_nodes.insert(gIdx, node);
node->setMaterial(m_material);
indices += 6;
}
}
- foreach (QSGShaderEffectNode* node, m_nodes){
+ foreach (QQuickShaderEffectNode* node, m_nodes){
if (node == *(m_nodes.begin()))
continue;
(*(m_nodes.begin()))->appendChildNode(node);
for (int i = 0; i < oldTextures.size(); ++i) {
QSGTextureProvider *t = oldTextures.at(i).second;
if (t)
- foreach (QSGShaderEffectNode* node, m_nodes)
+ foreach (QQuickShaderEffectNode* node, m_nodes)
disconnect(t, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()));
}
for (int i = 0; i < m_sources.size(); ++i) {
QSGTextureProvider *t = source.item->textureProvider();
textures.append(qMakePair(source.name, t));
if (t)
- foreach (QSGShaderEffectNode* node, m_nodes)
+ foreach (QQuickShaderEffectNode* node, m_nodes)
connect(t, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()), Qt::DirectConnection);
}
for (QSet<QByteArray>::const_iterator it = m_source.uniformNames.begin();
m_material->setUniforms(values);
m_material->setTextureProviders(textures);
m_dirtyData = false;
- foreach (QSGShaderEffectNode* node, m_nodes)
+ foreach (QQuickShaderEffectNode* node, m_nodes)
node->markDirty(QSGNode::DirtyMaterial);
}
#ifndef CUSTOM_PARTICLE_H
#define CUSTOM_PARTICLE_H
#include "qsgparticlepainter_p.h"
-#include <private/qsgshadereffectnode_p.h>
+#include <private/qquickshadereffectnode_p.h>
#include <QSignalMapper>
QT_BEGIN_HEADER
Q_PROPERTY(QByteArray vertexShader READ vertexShader WRITE setVertexShader NOTIFY vertexShaderChanged)
public:
- explicit QSGCustomParticle(QSGItem* parent=0);
+ explicit QSGCustomParticle(QQuickItem* parent=0);
~QSGCustomParticle();
QByteArray fragmentShader() const { return m_source.fragmentCode; }
void updateProperties();
void lookThroughShaderCode(const QByteArray &code);
virtual void componentComplete();
- QSGShaderEffectNode *buildCustomNodes();
+ QQuickShaderEffectNode *buildCustomNodes();
void performPendingResize();
private:
void buildData();
bool m_dirtyData;
- QSGShaderEffectProgram m_source;
+ QQuickShaderEffectProgram m_source;
struct SourceData
{
QSignalMapper *mapper;
- QPointer<QSGItem> item;
+ QPointer<QQuickItem> item;
QByteArray name;
};
QVector<SourceData> m_sources;
QSGShaderEffectMaterialObject *m_material;
- QSGShaderEffectNode* m_rootNode;
- QHash<int, QSGShaderEffectNode*> m_nodes;
+ QQuickShaderEffectNode* m_rootNode;
+ QHash<int, QQuickShaderEffectNode*> m_nodes;
qreal m_lastTime;
};
return a >= 0 ? 1 : -1;
}
-QSGFrictionAffector::QSGFrictionAffector(QSGItem *parent) :
+QSGFrictionAffector::QSGFrictionAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_factor(0.0)
{
}
Q_OBJECT
Q_PROPERTY(qreal factor READ factor WRITE setFactor NOTIFY factorChanged)
public:
- explicit QSGFrictionAffector(QSGItem *parent = 0);
+ explicit QSGFrictionAffector(QQuickItem *parent = 0);
qreal factor() const
{
Angle of acceleration.
*/
-QSGGravityAffector::QSGGravityAffector(QSGItem *parent) :
+QSGGravityAffector::QSGGravityAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_acceleration(-10), m_angle(90), m_xAcc(0), m_yAcc(0)
{
connect(this, SIGNAL(accelerationChanged(qreal)),
Q_PROPERTY(qreal acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
Q_PROPERTY(qreal angle READ angle WRITE setAngle NOTIFY angleChanged)
public:
- explicit QSGGravityAffector(QSGItem *parent = 0);
+ explicit QSGGravityAffector(QQuickItem *parent = 0);
qreal acceleration() const
{
return m_acceleration;
****************************************************************************/
#include "qsggroupgoal_p.h"
-#include <private/qsgspriteengine_p.h>
-#include <private/qsgsprite_p.h>
+#include <private/qquickspriteengine_p.h>
+#include <private/qquicksprite_p.h>
#include "qsgimageparticle_p.h"
#include <QDebug>
Default is false.
*/
-QSGGroupGoalAffector::QSGGroupGoalAffector(QSGItem *parent) :
+QSGGroupGoalAffector::QSGGroupGoalAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_jump(false)
{
}
bool QSGGroupGoalAffector::affectParticle(QSGParticleData *d, qreal dt)
{
Q_UNUSED(dt);
- QSGStochasticEngine *engine = m_system->stateEngine;
+ QQuickStochasticEngine *engine = m_system->stateEngine;
bool notUsingEngine = false;
if (!engine)
notUsingEngine = true;
QT_MODULE(Declarative)
-class QSGStochasticEngine;
+class QQuickStochasticEngine;
class QSGGroupGoalAffector : public QSGParticleAffector
{
Q_PROPERTY(QString goalState READ goalState WRITE setGoalState NOTIFY goalStateChanged)
Q_PROPERTY(bool jump READ jump WRITE setJump NOTIFY jumpChanged)
public:
- explicit QSGGroupGoalAffector(QSGItem *parent = 0);
+ explicit QSGGroupGoalAffector(QQuickItem *parent = 0);
QString goalState() const
{
#include <QFile>
#include "qsgimageparticle_p.h"
#include "qsgparticleemitter_p.h"
-#include <private/qsgsprite_p.h>
-#include <private/qsgspriteengine_p.h>
+#include <private/qquicksprite_p.h>
+#include <private/qquickspriteengine_p.h>
#include <QOpenGLFunctions>
#include <qsgengine.h>
#include <private/qsgtexture_p.h>
*/
-QSGImageParticle::QSGImageParticle(QSGItem* parent)
+QSGImageParticle::QSGImageParticle(QQuickItem* parent)
: QSGParticlePainter(parent)
, m_color_variation(0.0)
, m_rootNode(0)
{
}
-QDeclarativeListProperty<QSGSprite> QSGImageParticle::sprites()
+QDeclarativeListProperty<QQuickSprite> QSGImageParticle::sprites()
{
- return QDeclarativeListProperty<QSGSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
+ return QDeclarativeListProperty<QQuickSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
}
void QSGImageParticle::setImage(const QUrl &image)
if (m_spriteEngine)
delete m_spriteEngine;
if (m_sprites.count())
- m_spriteEngine = new QSGSpriteEngine(m_sprites, this);
+ m_spriteEngine = new QQuickSpriteEngine(m_sprites, this);
else
m_spriteEngine = 0;
m_explicitAnimation = true;
class ImageMaterialData;
class QSGGeometryNode;
-class QSGSprite;
-class QSGStochasticEngine;
+class QQuickSprite;
+class QQuickStochasticEngine;
struct SimpleVertex {
float x;
Q_PROPERTY(QSGDirection* xVector READ xVector WRITE setXVector NOTIFY xVectorChanged RESET resetDeformation)
//yVector is the same, but top-left to bottom-left. The particle is always a parallelogram.
Q_PROPERTY(QSGDirection* yVector READ yVector WRITE setYVector NOTIFY yVectorChanged RESET resetDeformation)
- Q_PROPERTY(QDeclarativeListProperty<QSGSprite> sprites READ sprites)
+ Q_PROPERTY(QDeclarativeListProperty<QQuickSprite> sprites READ sprites)
Q_PROPERTY(bool spritesInterpolate READ spritesInterpolate WRITE setSpritesInterpolate NOTIFY spritesInterpolateChanged)
Q_PROPERTY(EntryEffect entryEffect READ entryEffect WRITE setEntryEffect NOTIFY entryEffectChanged)
Q_PROPERTY(bool bloat READ bloat WRITE setBloat NOTIFY bloatChanged)//Just a debugging property to bypass optimizations
Q_ENUMS(EntryEffect)
public:
- explicit QSGImageParticle(QSGItem *parent = 0);
+ explicit QSGImageParticle(QQuickItem *parent = 0);
virtual ~QSGImageParticle();
- QDeclarativeListProperty<QSGSprite> sprites();
- QSGStochasticEngine* spriteEngine() {return m_spriteEngine;}
+ QDeclarativeListProperty<QQuickSprite> sprites();
+ QQuickStochasticEngine* spriteEngine() {return m_spriteEngine;}
enum EntryEffect {
None = 0,
QSGDirection* m_xVector;
QSGDirection* m_yVector;
- QList<QSGSprite*> m_sprites;
- QSGSpriteEngine* m_spriteEngine;
+ QList<QQuickSprite*> m_sprites;
+ QQuickSpriteEngine* m_spriteEngine;
bool m_spritesInterpolate;
bool m_explicitColor;
****************************************************************************/
#include "qsgitemparticle_p.h"
-#include <private/qsgvisualitemmodel_p.h>
+#include <private/qquickvisualitemmodel_p.h>
#include <qsgnode.h>
#include <QTimer>
#include <QDeclarativeComponent>
QT_BEGIN_NAMESPACE
/*!
- \qmlclass ItemParticle QSGItemParticle
+ \qmlclass ItemParticle QQuickItemParticle
\inqmlmodule QtQuick.Particles 2
\inherits ParticlePainter
\brief The ItemParticle element allows you to specify your own delegate to paint particles.
particle, and moved along with it.
*/
-QSGItemParticle::QSGItemParticle(QSGItem *parent) :
+QQuickItemParticle::QQuickItemParticle(QQuickItem *parent) :
QSGParticlePainter(parent), m_fade(true), m_delegate(0)
{
- setFlag(QSGItem::ItemHasContents);
+ setFlag(QQuickItem::ItemHasContents);
QTimer* manageDelegates = new QTimer(this);//TODO: don't leak
connect(manageDelegates, SIGNAL(timeout()),
this, SLOT(tick()));
}
-void QSGItemParticle::freeze(QSGItem* item)
+void QQuickItemParticle::freeze(QQuickItem* item)
{
m_stasis << item;
}
-void QSGItemParticle::unfreeze(QSGItem* item)
+void QQuickItemParticle::unfreeze(QQuickItem* item)
{
m_stasis.remove(item);
}
-void QSGItemParticle::take(QSGItem *item, bool prioritize)
+void QQuickItemParticle::take(QQuickItem *item, bool prioritize)
{
if (prioritize)
m_pendingItems.push_front(item);
m_pendingItems.push_back(item);
}
-void QSGItemParticle::give(QSGItem *item)
+void QQuickItemParticle::give(QQuickItem *item)
{
//TODO: This
}
-void QSGItemParticle::initialize(int gIdx, int pIdx)
+void QQuickItemParticle::initialize(int gIdx, int pIdx)
{
m_loadables << m_system->groupData[gIdx]->data[pIdx];//defer to other thread
}
-void QSGItemParticle::commit(int, int)
+void QQuickItemParticle::commit(int, int)
{
}
-void QSGItemParticle::tick()
+void QQuickItemParticle::tick()
{
- foreach (QSGItem* item, m_deletables){
+ foreach (QQuickItem* item, m_deletables){
if (m_fade)
item->setOpacity(0.);
item->setVisible(false);
- QSGItemParticleAttached* mpa;
- if ((mpa = qobject_cast<QSGItemParticleAttached*>(qmlAttachedPropertiesObject<QSGItemParticle>(item))))
+ QQuickItemParticleAttached* mpa;
+ if ((mpa = qobject_cast<QQuickItemParticleAttached*>(qmlAttachedPropertiesObject<QQuickItemParticle>(item))))
mpa->detach();//reparent as well?
//TODO: Delete iff we created it
m_activeCount--;
d->delegate = m_pendingItems.front();
m_pendingItems.pop_front();
}else if (m_delegate){
- d->delegate = qobject_cast<QSGItem*>(m_delegate->create(qmlContext(this)));
+ d->delegate = qobject_cast<QQuickItem*>(m_delegate->create(qmlContext(this)));
}
if (d->delegate && d){//###Data can be zero if creating an item leads to a reset - this screws things up.
d->delegate->setX(d->curX() - d->delegate->width()/2);//TODO: adjust for system?
d->delegate->setY(d->curY() - d->delegate->height()/2);
- QSGItemParticleAttached* mpa = qobject_cast<QSGItemParticleAttached*>(qmlAttachedPropertiesObject<QSGItemParticle>(d->delegate));
+ QQuickItemParticleAttached* mpa = qobject_cast<QQuickItemParticleAttached*>(qmlAttachedPropertiesObject<QQuickItemParticle>(d->delegate));
if (mpa){
mpa->m_mp = this;
mpa->attach();
m_loadables.clear();
}
-void QSGItemParticle::reset()
+void QQuickItemParticle::reset()
{
QSGParticlePainter::reset();
//TODO: Cleanup items?
}
-QSGNode* QSGItemParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
+QSGNode* QQuickItemParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
{
//Dummy update just to get painting tick
if (m_pleaseReset){
update();//Get called again
if (n)
n->markDirty(QSGNode::DirtyMaterial);
- return QSGItem::updatePaintNode(n,d);
+ return QQuickItem::updatePaintNode(n,d);
}
-void QSGItemParticle::prepareNextFrame()
+void QQuickItemParticle::prepareNextFrame()
{
if (!m_system)
return;
for (int i=0; i<count; i++){
QSGParticleData* data = m_system->groupData[gIdx]->data[i];
- QSGItem* item = data->delegate;
+ QQuickItem* item = data->delegate;
if (!item)
continue;
qreal t = ((timeStamp/1000.0) - data->t) / data->lifeSpan;
}
}
-QSGItemParticleAttached *QSGItemParticle::qmlAttachedProperties(QObject *object)
+QQuickItemParticleAttached *QQuickItemParticle::qmlAttachedProperties(QObject *object)
{
- return new QSGItemParticleAttached(object);
+ return new QQuickItemParticleAttached(object);
}
QT_END_NAMESPACE
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class QSGVisualDataModel;
-class QSGItemParticleAttached;
+class QQuickVisualDataModel;
+class QQuickItemParticleAttached;
-class QSGItemParticle : public QSGParticlePainter
+class QQuickItemParticle : public QSGParticlePainter
{
Q_OBJECT
Q_PROPERTY(bool fade READ fade WRITE setFade NOTIFY fadeChanged)
Q_PROPERTY(QDeclarativeComponent* delegate READ delegate WRITE setDelegate NOTIFY delegateChanged)
public:
- explicit QSGItemParticle(QSGItem *parent = 0);
+ explicit QQuickItemParticle(QQuickItem *parent = 0);
bool fade() const { return m_fade; }
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- static QSGItemParticleAttached *qmlAttachedProperties(QObject *object);
+ static QQuickItemParticleAttached *qmlAttachedProperties(QObject *object);
QDeclarativeComponent* delegate() const
{
return m_delegate;
public slots:
//TODO: Add a follow mode, where moving the delegate causes the logical particle to go with it?
- void freeze(QSGItem* item);
- void unfreeze(QSGItem* item);
- void take(QSGItem* item,bool prioritize=false);//take by modelparticle
- void give(QSGItem* item);//give from modelparticle
+ void freeze(QQuickItem* item);
+ void unfreeze(QQuickItem* item);
+ void take(QQuickItem* item,bool prioritize=false);//take by modelparticle
+ void give(QQuickItem* item);//give from modelparticle
void setFade(bool arg){if (arg == m_fade) return; m_fade = arg; emit fadeChanged();}
void setDelegate(QDeclarativeComponent* arg)
private slots:
void tick();
private:
- QList<QSGItem* > m_deletables;
+ QList<QQuickItem* > m_deletables;
QList< QSGParticleData* > m_loadables;
bool m_fade;
- QList<QSGItem*> m_pendingItems;
+ QList<QQuickItem*> m_pendingItems;
QList<int> m_available;
- QSet<QSGItem*> m_stasis;
+ QSet<QQuickItem*> m_stasis;
qreal m_lastT;
int m_activeCount;
QDeclarativeComponent* m_delegate;
};
-class QSGItemParticleAttached : public QObject
+class QQuickItemParticleAttached : public QObject
{
Q_OBJECT
- Q_PROPERTY(QSGItemParticle* particle READ particle CONSTANT);
+ Q_PROPERTY(QQuickItemParticle* particle READ particle CONSTANT);
public:
- QSGItemParticleAttached(QObject* parent)
+ QQuickItemParticleAttached(QObject* parent)
: QObject(parent), m_mp(0)
{;}
- QSGItemParticle* particle() {return m_mp;}
+ QQuickItemParticle* particle() {return m_mp;}
void detach(){emit detached();}
void attach(){emit attached();}
private:
- QSGItemParticle* m_mp;
- friend class QSGItemParticle;
+ QQuickItemParticle* m_mp;
+ friend class QQuickItemParticle;
Q_SIGNALS:
void detached();
void attached();
QT_END_NAMESPACE
-QML_DECLARE_TYPEINFO(QSGItemParticle, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPEINFO(QQuickItemParticle, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
#endif // ITEMPARTICLE_H
to the new one.
*/
-QSGMoveAffector::QSGMoveAffector(QSGItem *parent)
+QSGMoveAffector::QSGMoveAffector(QQuickItem *parent)
: QSGParticleAffector(parent)
, m_position(&m_nullVector)
, m_speed(&m_nullVector)
Q_PROPERTY(QSGDirection *acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged RESET accelerationReset)
public:
- explicit QSGMoveAffector(QSGItem *parent = 0);
+ explicit QSGMoveAffector(QQuickItem *parent = 0);
QSGDirection * position() const
{
return m_position;
x,y is the particles current position.
*/
-QSGParticleAffector::QSGParticleAffector(QSGItem *parent) :
- QSGItem(parent), m_needsReset(false), m_system(0), m_enabled(true)
+QSGParticleAffector::QSGParticleAffector(QQuickItem *parent) :
+ QQuickItem(parent), m_needsReset(false), m_system(0), m_enabled(true)
, m_updateIntSet(false), m_shape(new QSGParticleExtruder(this))
{
}
{
if (!m_system && qobject_cast<QSGParticleSystem*>(parentItem()))
setSystem(qobject_cast<QSGParticleSystem*>(parentItem()));
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
}
bool QSGParticleAffector::activeGroup(int g) {
QT_MODULE(Declarative)
-class QSGParticleAffector : public QSGItem
+class QSGParticleAffector : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QSGParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_PROPERTY(QSGParticleExtruder* shape READ shape WRITE setShape NOTIFY shapeChanged)
public:
- explicit QSGParticleAffector(QSGItem *parent = 0);
+ explicit QSGParticleAffector(QQuickItem *parent = 0);
virtual void affectSystem(qreal dt);
virtual void reset(QSGParticleData*);//As some store their own data per particle?
QSGParticleSystem* system() const
it back off.
*/
-QSGParticleEmitter::QSGParticleEmitter(QSGItem *parent) :
- QSGItem(parent)
+QSGParticleEmitter::QSGParticleEmitter(QQuickItem *parent) :
+ QQuickItem(parent)
, m_particlesPerSecond(10)
, m_particleDuration(1000)
, m_particleDurationVariation(0)
{
if (!m_system && qobject_cast<QSGParticleSystem*>(parentItem()))
setSystem(qobject_cast<QSGParticleSystem*>(parentItem()));
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
}
void QSGParticleEmitter::setEnabled(bool arg)
#ifndef PARTICLEEMITTER_H
#define PARTICLEEMITTER_H
-#include <QSGItem>
+#include <QQuickItem>
#include <QDebug>
#include "qsgparticlesystem_p.h"
#include "qsgparticleextruder_p.h"
QT_MODULE(Declarative)
-class QSGParticleEmitter : public QSGItem
+class QSGParticleEmitter : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QSGParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_ENUMS(Lifetime)
public:
- explicit QSGParticleEmitter(QSGItem *parent = 0);
+ explicit QSGParticleEmitter(QQuickItem *parent = 0);
virtual ~QSGParticleEmitter();
virtual void emitWindow(int timeStamp);
*/
QSGParticleGroup::QSGParticleGroup(QObject* parent)
- : QSGStochasticState(parent)
+ : QQuickStochasticState(parent)
, m_system(0)
{
****************************************************************************/
#ifndef QSGPARTICLEGROUP
#define QSGPARTICLEGROUP
-#include <private/qsgspriteengine_p.h>
+#include <private/qquickspriteengine_p.h>
#include "qsgparticlesystem_p.h"
#include "qdeclarativeparserstatus.h"
QT_BEGIN_NAMESPACE
-class QSGParticleGroup : public QSGStochasticState, public QDeclarativeParserStatus
+class QSGParticleGroup : public QQuickStochasticState, public QDeclarativeParserStatus
{
Q_OBJECT
//### Would setting limits per group be useful? Or clutter the API?
If empty, it will paint the default particle group ("").
*/
-QSGParticlePainter::QSGParticlePainter(QSGItem *parent) :
- QSGItem(parent),
+QSGParticlePainter::QSGParticlePainter(QQuickItem *parent) :
+ QQuickItem(parent),
m_system(0), m_count(0), m_pleaseReset(true), m_sentinel(new QSGParticleData(0))
{
}
{
if (!m_system && qobject_cast<QSGParticleSystem*>(parentItem()))
setSystem(qobject_cast<QSGParticleSystem*>(parentItem()));
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
}
QT_MODULE(Declarative)
-class QSGParticlePainter : public QSGItem
+class QSGParticlePainter : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QSGParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_PROPERTY(QStringList groups READ groups WRITE setGroups NOTIFY groupsChanged)
public:
- explicit QSGParticlePainter(QSGItem *parent = 0);
+ explicit QSGParticlePainter(QQuickItem *parent = 0);
//Data Interface to system
void load(QSGParticleData*);
void reload(QSGParticleData*);
qmlRegisterType<QSGImageParticle>(uri, 2, 0, "ImageParticle");
qmlRegisterType<QSGCustomParticle>(uri, 2, 0, "CustomParticle");
- qmlRegisterType<QSGItemParticle>(uri, 2, 0, "ItemParticle");
+ qmlRegisterType<QQuickItemParticle>(uri, 2, 0, "ItemParticle");
qmlRegisterType<QSGParticleEmitter>(uri, 2, 0, "Emitter");
qmlRegisterType<QSGTrailEmitter>(uri, 2, 0, "TrailEmitter");
#include "qsgparticleemitter_p.h"
#include "qsgparticleaffector_p.h"
#include "qsgparticlepainter_p.h"
-#include <private/qsgspriteengine_p.h>
-#include <private/qsgsprite_p.h>
+#include <private/qquickspriteengine_p.h>
+#include <private/qquicksprite_p.h>
#include "qsgv8particledata_p.h"
#include "qsgparticlegroup_p.h"
vy = evy;
}
-QSGParticleSystem::QSGParticleSystem(QSGItem *parent) :
- QSGItem(parent),
+QSGParticleSystem::QSGParticleSystem(QQuickItem *parent) :
+ QQuickItem(parent),
stateEngine(0),
m_running(true),
particleCount(0),
void QSGParticleSystem::componentComplete()
{
- QSGItem::componentComplete();
+ QQuickItem::componentComplete();
m_componentComplete = true;
m_animation = new QSGParticleSystemAnimation(this);
reset();//restarts animation as well
}
}
m_groups = newList;
- QList<QSGStochasticState*> states;
+ QList<QQuickStochasticState*> states;
foreach (QSGParticleGroup* g, m_groups)
- states << (QSGStochasticState*)g;
+ states << (QQuickStochasticState*)g;
if (!stateEngine)
- stateEngine = new QSGStochasticEngine(this);
+ stateEngine = new QQuickStochasticEngine(this);
stateEngine->setCount(particleCount);
stateEngine->m_states = states;
#ifndef PARTICLESYSTEM_H
#define PARTICLESYSTEM_H
-#include <QSGItem>
+#include <QQuickItem>
#include <QElapsedTimer>
#include <QVector>
#include <QHash>
#include <QPointer>
#include <QSignalMapper>
-#include <private/qsgsprite_p.h>
+#include <private/qquicksprite_p.h>
#include <QAbstractAnimation>
#include <QtDeclarative/qdeclarative.h>
#include <private/qv8engine_p.h> //For QDeclarativeV8Handle
class QSGParticlePainter;
class QSGParticleData;
class QSGParticleSystemAnimation;
-class QSGStochasticEngine;
-class QSGSprite;
+class QQuickStochasticEngine;
+class QQuickSprite;
class QSGV8ParticleData;
class QSGParticleGroup;
class QSGImageParticle;
float animWidth;
float animHeight;
float r;
- QSGItem* delegate;
+ QQuickItem* delegate;
int modelIndex;
float update;//Used by custom affectors
QSGV8ParticleData* v8Datum;
};
-class Q_AUTOTEST_EXPORT QSGParticleSystem : public QSGItem
+class Q_AUTOTEST_EXPORT QSGParticleSystem : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(bool running READ isRunning WRITE setRunning NOTIFY runningChanged)
Q_PROPERTY(bool empty READ isEmpty NOTIFY emptyChanged)
public:
- explicit QSGParticleSystem(QSGItem *parent = 0);
+ explicit QSGParticleSystem(QQuickItem *parent = 0);
~QSGParticleSystem();
bool isRunning() const
QVector<QSGParticleData*> bySysIdx; //Another reference to the data (data owned by group), but by sysIdx
QHash<QString, int> groupIds;
QHash<int, QSGParticleGroupData*> groupData;
- QSGStochasticEngine* stateEngine;
+ QQuickStochasticEngine* stateEngine;
//Also only here for auto-test usage
void updateCurrentTime( int currentTime );
*/
-QSGAttractorAffector::QSGAttractorAffector(QSGItem *parent) :
+QSGAttractorAffector::QSGAttractorAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_strength(0.0), m_x(0), m_y(0)
, m_physics(Velocity), m_proportionalToDistance(Linear)
{
Acceleration
};
- explicit QSGAttractorAffector(QSGItem *parent = 0);
+ explicit QSGAttractorAffector(QQuickItem *parent = 0);
qreal strength() const
{
****************************************************************************/
#include "qsgspritegoal_p.h"
-#include <private/qsgspriteengine_p.h>
-#include <private/qsgsprite_p.h>
+#include <private/qquickspriteengine_p.h>
+#include <private/qquicksprite_p.h>
#include "qsgimageparticle_p.h"
#include <QDebug>
deprecated, use GroupGoal instead
*/
-QSGSpriteGoalAffector::QSGSpriteGoalAffector(QSGItem *parent) :
+QSGSpriteGoalAffector::QSGSpriteGoalAffector(QQuickItem *parent) :
QSGParticleAffector(parent),
m_goalIdx(-1),
m_lastEngine(0),
{
}
-void QSGSpriteGoalAffector::updateStateIndex(QSGStochasticEngine* e)
+void QSGSpriteGoalAffector::updateStateIndex(QQuickStochasticEngine* e)
{
if (m_systemStates){
m_goalIdx = m_system->groupIds[m_goalState];
bool QSGSpriteGoalAffector::affectParticle(QSGParticleData *d, qreal dt)
{
Q_UNUSED(dt);
- QSGStochasticEngine *engine = 0;
+ QQuickStochasticEngine *engine = 0;
if (!m_systemStates){
//TODO: Affect all engines
foreach (QSGParticlePainter *p, m_system->groupData[d->group]->painters)
QT_MODULE(Declarative)
-class QSGStochasticEngine;
+class QQuickStochasticEngine;
class QSGSpriteGoalAffector : public QSGParticleAffector
{
Q_PROPERTY(bool jump READ jump WRITE setJump NOTIFY jumpChanged)
Q_PROPERTY(bool systemStates READ systemStates WRITE setSystemStates NOTIFY systemStatesChanged)
public:
- explicit QSGSpriteGoalAffector(QSGItem *parent = 0);
+ explicit QSGSpriteGoalAffector(QQuickItem *parent = 0);
QString goalState() const
{
}
private:
- void updateStateIndex(QSGStochasticEngine* e);
+ void updateStateIndex(QQuickStochasticEngine* e);
QString m_goalState;
int m_goalIdx;
- QSGStochasticEngine* m_lastEngine;
+ QQuickStochasticEngine* m_lastEngine;
bool m_jump;
bool m_systemStates;
#include "qsgtargetaffector_p.h"
#include <QDebug>
-QSGTargetAffector::QSGTargetAffector(QSGItem *parent) :
+QSGTargetAffector::QSGTargetAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_targetX(0), m_targetY(0),
m_targetWidth(0), m_targetHeight(0), m_defaultShape(new QSGParticleExtruder(this)),
m_targetShape(m_defaultShape), m_targetTime(-1)
Q_PROPERTY(int targetTime READ targetTime WRITE setTargetTime NOTIFY targetTimeChanged)
public:
- explicit QSGTargetAffector(QSGItem *parent = 0);
+ explicit QSGTargetAffector(QQuickItem *parent = 0);
int targetX() const
{
QT_MODULE(Declarative)
-class QSGItem;
+class QQuickItem;
class QSGTargetDirection : public QSGDirection
{
Q_OBJECT
Q_PROPERTY(qreal targetX READ targetX WRITE setTargetX NOTIFY targetXChanged)
Q_PROPERTY(qreal targetY READ targetY WRITE setTargetY NOTIFY targetYChanged)
//If targetItem is set, X/Y are ignored. Aims at middle of item, use variation for variation
- Q_PROPERTY(QSGItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
+ Q_PROPERTY(QQuickItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
Q_PROPERTY(qreal targetVariation READ targetVariation WRITE setTargetVariation NOTIFY targetVariationChanged)
return m_magnitudeVariation;
}
- QSGItem* targetItem() const
+ QQuickItem* targetItem() const
{
return m_targetItem;
}
void magnitudeVariationChanged(qreal arg);
- void targetItemChanged(QSGItem* arg);
+ void targetItemChanged(QQuickItem* arg);
public slots:
void setTargetX(qreal arg)
}
}
- void setTargetItem(QSGItem* arg)
+ void setTargetItem(QQuickItem* arg)
{
if (m_targetItem != arg) {
m_targetItem = arg;
bool m_proportionalMagnitude;
qreal m_magnitude;
qreal m_magnitudeVariation;
- QSGItem *m_targetItem;
+ QQuickItem *m_targetItem;
};
QT_END_NAMESPACE
This element emits logical particles into the ParticleSystem, with the
starting positions based on those of other logical particles.
*/
-QSGTrailEmitter::QSGTrailEmitter(QSGItem *parent) :
+QSGTrailEmitter::QSGTrailEmitter(QQuickItem *parent) :
QSGParticleEmitter(parent)
, m_particlesPerParticlePerSecond(0)
, m_lastTimeStamp(0)
enum EmitSize {
ParticleSize = -2//Anything less than 0 will do
};
- explicit QSGTrailEmitter(QSGItem *parent = 0);
+ explicit QSGTrailEmitter(QQuickItem *parent = 0);
virtual void emitWindow(int timeStamp);
virtual void reset();
A default image will be used if none is provided.
*/
-QSGTurbulenceAffector::QSGTurbulenceAffector(QSGItem *parent) :
+QSGTurbulenceAffector::QSGTurbulenceAffector(QQuickItem *parent) :
QSGParticleAffector(parent),
m_strength(10), m_lastT(0), m_gridSize(0), m_field(0), m_vectorField(0), m_inited(false)
{
Q_PROPERTY(qreal strength READ strength WRITE setStrength NOTIFY strengthChanged)
Q_PROPERTY(QUrl noiseSource READ noiseSource WRITE setNoiseSource NOTIFY noiseSourceChanged)
public:
- explicit QSGTurbulenceAffector(QSGItem *parent = 0);
+ explicit QSGTurbulenceAffector(QQuickItem *parent = 0);
~QSGTurbulenceAffector();
virtual void affectSystem(qreal dt);
-//### Particle data handles are not locked to within certain scopes like QSGContext2D, but there's no way to reload either...
+//### Particle data handles are not locked to within certain scopes like QQuickContext2D, but there's no way to reload either...
class QV8ParticleDataResource : public QV8ObjectResource
{
V8_RESOURCE_TYPE(ParticleDataType)
\endlist
*/
-QSGWanderAffector::QSGWanderAffector(QSGItem *parent) :
+QSGWanderAffector::QSGWanderAffector(QQuickItem *parent) :
QSGParticleAffector(parent), m_xVariance(0), m_yVariance(0), m_pace(0)
, m_affectedParameter(Velocity)
{
Acceleration
};
- explicit QSGWanderAffector(QSGItem *parent = 0);
+ explicit QSGWanderAffector(QQuickItem *parent = 0);
~QSGWanderAffector();
virtual void reset(int systemIdx);
#include <private/qobject_p.h>
#include <private/qdeclarativeutilmodule_p.h>
-#include <private/qsgitemsmodule_p.h>
+#include <private/qquickitemsmodule_p.h>
#include <private/qsgparticlesmodule_p.h>
#ifdef Q_OS_WIN // for %APPDATA%
qt_QmlQtModule_registered = true;
QDeclarativeUtilModule::defineModule();
QDeclarativeEnginePrivate::defineModule();
- QSGItemsModule::defineModule();
+ QQuickItemsModule::defineModule();
QSGParticlesModule::defineModule();
QDeclarativeValueTypeFactory::registerValueTypes();
}
#include <private/qdeclarativefastproperties_p.h>
#include <private/qdeclarativedebugtrace_p.h>
-#include <private/qsganchors_p_p.h> // For AnchorLine
+#include <private/qquickanchors_p_p.h> // For AnchorLine
#include <QtDeclarative/qdeclarativeinfo.h>
#include <QtCore/qnumeric.h>
QDeclarative1AnchorLine ra = qvariant_cast<QDeclarative1AnchorLine>(v4);
return la == ra;
- } else if (type == qMetaTypeId<QSGAnchorLine>()) {
- QSGAnchorLine la = qvariant_cast<QSGAnchorLine>(qtscript);
- QSGAnchorLine ra = qvariant_cast<QSGAnchorLine>(v4);
+ } else if (type == qMetaTypeId<QQuickAnchorLine>()) {
+ QQuickAnchorLine la = qvariant_cast<QQuickAnchorLine>(qtscript);
+ QQuickAnchorLine ra = qvariant_cast<QQuickAnchorLine>(v4);
return la == ra;
} else if (type == QMetaType::Double) {
default:
if (resultType == qMetaTypeId<QDeclarative1AnchorLine>()) {
v4value = qVariantFromValue<QDeclarative1AnchorLine>(*(QDeclarative1AnchorLine *)result.typeDataPtr());
- } else if (resultType == qMetaTypeId<QSGAnchorLine>()) {
- v4value = qVariantFromValue<QSGAnchorLine>(*(QSGAnchorLine *)result.typeDataPtr());
+ } else if (resultType == qMetaTypeId<QQuickAnchorLine>()) {
+ v4value = qVariantFromValue<QQuickAnchorLine>(*(QQuickAnchorLine *)result.typeDataPtr());
} else {
iserror = true;
v4Result = "Unknown V4 type";
#include <private/qdeclarativejsast_p.h>
#include <private/qdeclarativefastproperties_p.h>
#include <private/qdeclarativejsengine_p.h>
-#include <private/qsganchors_p_p.h> // For AnchorLine
+#include <private/qquickanchors_p_p.h> // For AnchorLine
QT_BEGIN_NAMESPACE
default:
if (propTy == qMetaTypeId<QDeclarative1AnchorLine>()) {
regType = PODValueType;
- } else if (propTy == qMetaTypeId<QSGAnchorLine>()) {
+ } else if (propTy == qMetaTypeId<QQuickAnchorLine>()) {
regType = PODValueType;
} else if (QDeclarativeMetaType::isQObject(propTy)) {
regType = QObjectStarType;
test.regType = qMetaTypeId<QDeclarative1AnchorLine>();
break;
case IR::SGAnchorLineType:
- test.regType = qMetaTypeId<QSGAnchorLine>();
+ test.regType = qMetaTypeId<QQuickAnchorLine>();
break;
case IR::ObjectType:
test.regType = QMetaType::QObjectStar;
#include "qv4irbuilder_p.h"
#include "qv4compiler_p_p.h"
-#include <private/qsganchors_p_p.h> // For AnchorLine
+#include <private/qquickanchors_p_p.h> // For AnchorLine
#include <private/qdeclarativetypenamecache_p.h>
DEFINE_BOOL_CONFIG_OPTION(qmlVerboseCompiler, QML_VERBOSE_COMPILER)
default:
if (t == qMetaTypeId<QDeclarative1AnchorLine>())
return IR::AnchorLineType;
- else if (t == qMetaTypeId<QSGAnchorLine>())
+ else if (t == qMetaTypeId<QQuickAnchorLine>())
return IR::SGAnchorLineType;
else if (const QMetaObject *m = engine->metaObjectForType(t)) {
meta = m;
#include "qsgnode.h"
#include "qsgtexture.h"
-#include <private/qsgtext_p.h>
#include <QtCore/qobject.h>
#include <QtCore/qrect.h>
#include <QtGui/qbrush.h>
#include <QtGui/qglyphrun.h>
#include <QtCore/qurl.h>
-#include <private/qsgtext_p.h>
+// ### remove
+#include <private/qquicktext_p.h>
QT_BEGIN_HEADER
virtual void setGlyphs(const QPointF &position, const QGlyphRun &glyphs) = 0;
virtual void setColor(const QColor &color) = 0;
- virtual void setStyle(QSGText::TextStyle style) = 0;
+ virtual void setStyle(QQuickText::TextStyle style) = 0;
virtual void setStyleColor(const QColor &color) = 0;
virtual QPointF baseLine() const = 0;
Factory function for the scene graph renderers.
The renderers are used for the toplevel renderer and once for every
- QSGShaderEffectSource used in the QML scene.
+ QQuickShaderEffectSource used in the QML scene.
*/
QSGRenderer *QSGContext::createRenderer()
{
virtual void setColor(const QColor &color);
virtual void setPreferredAntialiasingMode(AntialiasingMode) { }
- virtual void setStyle(QSGText::TextStyle) { }
+ virtual void setStyle(QQuickText::TextStyle) { }
virtual void setStyleColor(const QColor &) { }
virtual void update() { }
, m_glyph_cacheManager(cacheManager)
, m_glyph_cache(0)
, m_geometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 0)
- , m_style(QSGText::Normal)
+ , m_style(QQuickText::Normal)
, m_antialiasingMode(GrayAntialiasing)
, m_dirtyFont(false)
, m_dirtyGeometry(false)
m_dirtyMaterial = true;
}
-void QSGDistanceFieldGlyphNode::setStyle(QSGText::TextStyle style)
+void QSGDistanceFieldGlyphNode::setStyle(QQuickText::TextStyle style)
{
if (m_style == style)
return;
{
delete m_material;
- if (m_style == QSGText::Normal) {
+ if (m_style == QQuickText::Normal) {
switch (m_antialiasingMode) {
case HighQualitySubPixelAntialiasing:
m_material = new QSGHiQSubPixelDistanceFieldTextMaterial;
}
} else {
QSGDistanceFieldStyledTextMaterial *material;
- if (m_style == QSGText::Outline) {
+ if (m_style == QQuickText::Outline) {
material = new QSGDistanceFieldOutlineTextMaterial;
} else {
QSGDistanceFieldShiftedStyleTextMaterial *sMaterial = new QSGDistanceFieldShiftedStyleTextMaterial;
- if (m_style == QSGText::Raised)
+ if (m_style == QQuickText::Raised)
sMaterial->setShift(QPointF(0.0, 1.0));
else
sMaterial->setShift(QPointF(0.0, -1.0));
#include <private/qsgadaptationlayer_p.h>
#include "qsgtexture.h"
-#include <private/qsgtext_p.h>
+
+#include <private/qquicktext_p.h>
QT_BEGIN_HEADER
virtual void setPreferredAntialiasingMode(AntialiasingMode mode);
- virtual void setStyle(QSGText::TextStyle style);
+ virtual void setStyle(QQuickText::TextStyle style);
virtual void setStyleColor(const QColor &color);
virtual void update();
QSGDistanceFieldGlyphCacheManager *m_glyph_cacheManager;
QSGDistanceFieldGlyphCache *m_glyph_cache;
QSGGeometry m_geometry;
- QSGText::TextStyle m_style;
+ QQuickText::TextStyle m_style;
QColor m_styleColor;
AntialiasingMode m_antialiasingMode;
#include "qsgpainternode_p.h"
-#include "qsgpainteditem.h"
-#include <private/qsgpainteditem_p.h>
+#include <private/qquickpainteditem_p.h>
+
#include <private/qsgcontext_p.h>
#include <private/qopenglextensions_p.h>
#include <qopenglframebufferobject.h>
m_dirty_rect = QRect();
}
-QSGPainterNode::QSGPainterNode(QSGPaintedItem *item)
+QSGPainterNode::QSGPainterNode(QQuickPaintedItem *item)
: QSGGeometryNode()
- , m_preferredRenderTarget(QSGPaintedItem::Image)
- , m_actualRenderTarget(QSGPaintedItem::Image)
+ , m_preferredRenderTarget(QQuickPaintedItem::Image)
+ , m_actualRenderTarget(QQuickPaintedItem::Image)
, m_item(item)
, m_fbo(0)
, m_multisampledFbo(0)
, m_dirtyRenderTarget(false)
, m_dirtyTexture(false)
{
- m_context = static_cast<QSGPaintedItemPrivate *>(QObjectPrivate::get(item))->sceneGraphContext();
+ m_context = static_cast<QQuickPaintedItemPrivate *>(QObjectPrivate::get(item))->sceneGraphContext();
setMaterial(&m_materialO);
setOpaqueMaterial(&m_material);
QRect dirtyRect = m_dirtyRect.isNull() ? QRect(0, 0, m_size.width(), m_size.height()) : m_dirtyRect;
QPainter painter;
- if (m_actualRenderTarget == QSGPaintedItem::Image)
+ if (m_actualRenderTarget == QQuickPaintedItem::Image)
painter.begin(&m_image);
else {
if (!m_gl_device) {
m_item->paint(&painter);
painter.end();
- if (m_actualRenderTarget == QSGPaintedItem::Image) {
+ if (m_actualRenderTarget == QQuickPaintedItem::Image) {
m_texture->setImage(m_image);
m_texture->setDirtyRect(dirtyRect);
} else if (m_multisampledFbo) {
void QSGPainterNode::updateGeometry()
{
QRectF source;
- if (m_actualRenderTarget == QSGPaintedItem::Image)
+ if (m_actualRenderTarget == QQuickPaintedItem::Image)
source = QRectF(0, 0, 1, 1);
else
source = QRectF(0, 0, qreal(m_size.width()) / m_fboSize.width(), qreal(m_size.height()) / m_fboSize.height());
m_dirtyContents = true;
- QSGPaintedItem::RenderTarget oldTarget = m_actualRenderTarget;
- if (m_preferredRenderTarget == QSGPaintedItem::Image) {
- m_actualRenderTarget = QSGPaintedItem::Image;
+ QQuickPaintedItem::RenderTarget oldTarget = m_actualRenderTarget;
+ if (m_preferredRenderTarget == QQuickPaintedItem::Image) {
+ m_actualRenderTarget = QQuickPaintedItem::Image;
} else {
if (!m_multisamplingSupported && m_smoothPainting)
- m_actualRenderTarget = QSGPaintedItem::Image;
+ m_actualRenderTarget = QQuickPaintedItem::Image;
else
- m_actualRenderTarget = QSGPaintedItem::FramebufferObject;
+ m_actualRenderTarget = QQuickPaintedItem::FramebufferObject;
}
if (oldTarget != m_actualRenderTarget) {
m_image = QImage();
m_fbo = m_multisampledFbo = 0;
}
- if (m_actualRenderTarget == QSGPaintedItem::FramebufferObject) {
+ if (m_actualRenderTarget == QQuickPaintedItem::FramebufferObject) {
const QOpenGLContext *ctx = m_context->glContext();
if (m_fbo && !m_dirtyGeometry && (!ctx->format().samples() || !m_multisamplingSupported))
return;
}
QSGPainterTexture *texture = new QSGPainterTexture;
- if (m_actualRenderTarget == QSGPaintedItem::Image) {
+ if (m_actualRenderTarget == QQuickPaintedItem::Image) {
texture->setOwnsTexture(true);
texture->setTextureSize(m_size);
} else {
m_fboSize = QSize(fboWidth, fboHeight);
}
-void QSGPainterNode::setPreferredRenderTarget(QSGPaintedItem::RenderTarget target)
+void QSGPainterNode::setPreferredRenderTarget(QQuickPaintedItem::RenderTarget target)
{
if (m_preferredRenderTarget == target)
return;
QImage QSGPainterNode::toImage() const
{
- if (m_actualRenderTarget == QSGPaintedItem::Image)
+ if (m_actualRenderTarget == QQuickPaintedItem::Image)
return m_image;
else
return m_fbo->toImage();
#include "qsgnode.h"
#include "qsgtexturematerial.h"
#include "qsgtexture_p.h"
-#include "qsgpainteditem.h"
+
+#include <qquickpainteditem.h>
#include <QtGui/qcolor.h>
class Q_DECLARATIVE_EXPORT QSGPainterNode : public QSGGeometryNode
{
public:
- QSGPainterNode(QSGPaintedItem *item);
+ QSGPainterNode(QQuickPaintedItem *item);
virtual ~QSGPainterNode();
- void setPreferredRenderTarget(QSGPaintedItem::RenderTarget target);
+ void setPreferredRenderTarget(QQuickPaintedItem::RenderTarget target);
void setSize(const QSize &size);
QSize size() const { return m_size; }
QSGContext *m_context;
- QSGPaintedItem::RenderTarget m_preferredRenderTarget;
- QSGPaintedItem::RenderTarget m_actualRenderTarget;
+ QQuickPaintedItem::RenderTarget m_preferredRenderTarget;
+ QQuickPaintedItem::RenderTarget m_actualRenderTarget;
- QSGPaintedItem *m_item;
+ QQuickPaintedItem *m_item;
QOpenGLFramebufferObject *m_fbo;
QOpenGLFramebufferObject *m_multisampledFbo;
#include "qsgtextureprovider_p.h"
-#include <private/qsgimage_p.h>
-#include <private/qsgshadereffectsource_p.h>
-
#ifndef GL_CLAMP_TO_EDGE
#define GL_CLAMP_TO_EDGE 0x812F
#endif
private:
Q_DISABLE_COPY(QDeclarativePath)
Q_DECLARE_PRIVATE(QDeclarativePath)
- friend class QSGPathAnimationUpdater;
+ friend class QQuickPathAnimationUpdater;
public:
QPainterPath createPath(const QPointF &startPoint, const QPointF &endPoint, const QStringList &attributes, qreal &pathLength, QList<AttributePoint> &attributePoints, bool *closed = 0);
#include "QtQuickTest/private/quicktestresult_p.h"
#include "QtQuickTest/private/quicktestevent_p.h"
#include "private/qtestoptions_p.h"
-#include "QtDeclarative/qsgitem.h"
+#include "QtDeclarative/qquickitem.h"
#include <QtDeclarative/private/qdeclarativeengine_p.h>
QML_DECLARE_TYPE(QuickTestResult)
class ToolBox;
/*
- * The common code between QSGView and QDeclarativeView inspectors lives here,
+ * The common code between QQuickView and QDeclarativeView inspectors lives here,
*/
class AbstractViewInspector : public QObject
{
#include <QtCore/qplugin.h>
#include <QtDeclarative/private/qdeclarativeinspectorservice_p.h>
-#include <QtDeclarative/QSGView>
+#include <QtDeclarative/QQuickView>
namespace QmlJSDebugger {
QObject *firstView = views.first();
if (QDeclarativeView *declarativeView = qobject_cast<QDeclarativeView*>(firstView))
m_inspector = new QDeclarativeViewInspector(declarativeView, declarativeView);
- else if (QSGView *sgView = qobject_cast<QSGView*>(firstView))
+ else if (QQuickView *sgView = qobject_cast<QQuickView*>(firstView))
m_inspector = new SGViewInspector(sgView, sgView);
}
namespace QmlJSDebugger {
-SGHighlight::SGHighlight(QSGItem *item, QSGItem *parent)
- : QSGPaintedItem(parent)
+SGHighlight::SGHighlight(QQuickItem *item, QQuickItem *parent)
+ : QQuickPaintedItem(parent)
{
setItem(item);
}
-void SGHighlight::setItem(QSGItem *item)
+void SGHighlight::setItem(QQuickItem *item)
{
if (m_item)
m_item.data()->disconnect(this);
void SGHighlight::adjust()
{
- const QSGItem *item = m_item.data();
+ const QQuickItem *item = m_item.data();
setSize(QSizeF(item->width(), item->height()));
setPos(parentItem()->mapFromItem(item->parentItem(), item->pos()));
setRotation(item->rotation());
#define SGHIGHLIGHT_H
#include <QtCore/QWeakPointer>
-#include <QtDeclarative/QSGPaintedItem>
+#include <QtDeclarative/QQuickPaintedItem>
namespace QmlJSDebugger {
-class SGHighlight : public QSGPaintedItem
+class SGHighlight : public QQuickPaintedItem
{
Q_OBJECT
public:
- SGHighlight(QSGItem *parent) : QSGPaintedItem(parent) {}
- SGHighlight(QSGItem *item, QSGItem *parent);
+ SGHighlight(QQuickItem *parent) : QQuickPaintedItem(parent) {}
+ SGHighlight(QQuickItem *item, QQuickItem *parent);
- void setItem(QSGItem *item);
+ void setItem(QQuickItem *item);
private slots:
void adjust();
private:
- QWeakPointer<QSGItem> m_item;
+ QWeakPointer<QQuickItem> m_item;
};
/**
class SGSelectionHighlight : public SGHighlight
{
public:
- SGSelectionHighlight(QSGItem *item, QSGItem *parent)
+ SGSelectionHighlight(QQuickItem *item, QQuickItem *parent)
: SGHighlight(item, parent)
{}
class SGHoverHighlight : public SGHighlight
{
public:
- SGHoverHighlight(QSGItem *parent)
+ SGHoverHighlight(QQuickItem *parent)
: SGHighlight(parent)
{
setZ(1); // hover highlight on top of selection highlight
#include <QtWidgets/QMenu>
#include <QtGui/QMouseEvent>
-#include <QtDeclarative/QSGView>
-#include <QtDeclarative/QSGItem>
+#include <QtDeclarative/QQuickView>
+#include <QtDeclarative/QQuickItem>
namespace QmlJSDebugger {
void SGSelectionTool::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton) {
- if (QSGItem *item = inspector()->topVisibleItemAt(event->pos()))
- inspector()->setSelectedItems(QList<QSGItem*>() << item);
+ if (QQuickItem *item = inspector()->topVisibleItemAt(event->pos()))
+ inspector()->setSelectedItems(QList<QQuickItem*>() << item);
} else if (event->button() == Qt::RightButton) {
- QList<QSGItem*> items = inspector()->itemsAt(event->pos());
+ QList<QQuickItem*> items = inspector()->itemsAt(event->pos());
createContextMenu(items, event->globalPos());
}
}
void SGSelectionTool::hoverMoveEvent(QMouseEvent *event)
{
- QSGItem *item = inspector()->topVisibleItemAt(event->pos());
+ QQuickItem *item = inspector()->topVisibleItemAt(event->pos());
if (!item) {
m_hoverHighlight->setVisible(false);
} else {
}
}
-void SGSelectionTool::createContextMenu(const QList<QSGItem *> &items, QPoint pos)
+void SGSelectionTool::createContextMenu(const QList<QQuickItem *> &items, QPoint pos)
{
QMenu contextMenu;
connect(&contextMenu, SIGNAL(hovered(QAction*)),
this, SLOT(contextMenuElementHovered(QAction*)));
- const QList<QSGItem*> selectedItems = inspector()->selectedItems();
+ const QList<QQuickItem*> selectedItems = inspector()->selectedItems();
int shortcutKey = Qt::Key_1;
- foreach (QSGItem *item, items) {
+ foreach (QQuickItem *item, items) {
const QString title = inspector()->titleForItem(item);
QAction *elementAction = contextMenu.addAction(title);
elementAction->setData(QVariant::fromValue(item));
void SGSelectionTool::contextMenuElementHovered(QAction *action)
{
- if (QSGItem *item = action->data().value<QSGItem*>())
+ if (QQuickItem *item = action->data().value<QQuickItem*>())
m_hoverHighlight->setItem(item);
}
void SGSelectionTool::contextMenuElementSelected()
{
- if (QSGItem *item = static_cast<QAction*>(sender())->data().value<QSGItem*>())
- inspector()->setSelectedItems(QList<QSGItem*>() << item);
+ if (QQuickItem *item = static_cast<QAction*>(sender())->data().value<QQuickItem*>())
+ inspector()->setSelectedItems(QList<QQuickItem*>() << item);
}
SGViewInspector *SGSelectionTool::inspector() const
#include <QtCore/QPoint>
QT_FORWARD_DECLARE_CLASS(QAction)
-QT_FORWARD_DECLARE_CLASS(QSGItem)
+QT_FORWARD_DECLARE_CLASS(QQuickItem)
namespace QmlJSDebugger {
void contextMenuElementSelected();
private:
- void createContextMenu(const QList<QSGItem*> &items, QPoint pos);
+ void createContextMenu(const QList<QQuickItem*> &items, QPoint pos);
SGViewInspector *inspector() const;
#include "sghighlight.h"
#include "sgselectiontool.h"
-#include <QtDeclarative/private/qsgitem_p.h>
+#include <QtDeclarative/private/qquickitem_p.h>
-#include <QtDeclarative/QSGView>
-#include <QtDeclarative/QSGItem>
+#include <QtDeclarative/QQuickView>
+#include <QtDeclarative/QQuickItem>
#include <cfloat>
/*
* Collects all the items at the given position, from top to bottom.
*/
-static void collectItemsAt(QSGItem *item, const QPointF &pos, QSGItem *overlay,
- QList<QSGItem *> &resultList)
+static void collectItemsAt(QQuickItem *item, const QPointF &pos, QQuickItem *overlay,
+ QList<QQuickItem *> &resultList)
{
if (item == overlay)
return;
- if (item->flags() & QSGItem::ItemClipsChildrenToShape) {
+ if (item->flags() & QQuickItem::ItemClipsChildrenToShape) {
if (!QRectF(0, 0, item->width(), item->height()).contains(pos))
return;
}
- QList<QSGItem *> children = QSGItemPrivate::get(item)->paintOrderChildItems();
+ QList<QQuickItem *> children = QQuickItemPrivate::get(item)->paintOrderChildItems();
for (int i = children.count() - 1; i >= 0; --i) {
- QSGItem *child = children.at(i);
+ QQuickItem *child = children.at(i);
collectItemsAt(child, item->mapToItem(child, pos), overlay, resultList);
}
* Returns the first visible item at the given position, or 0 when no such
* child exists.
*/
-static QSGItem *itemAt(QSGItem *item, const QPointF &pos, QSGItem *overlay)
+static QQuickItem *itemAt(QQuickItem *item, const QPointF &pos, QQuickItem *overlay)
{
if (item == overlay)
return 0;
if (!item->isVisible() || item->opacity() == 0.0)
return 0;
- if (item->flags() & QSGItem::ItemClipsChildrenToShape) {
+ if (item->flags() & QQuickItem::ItemClipsChildrenToShape) {
if (!QRectF(0, 0, item->width(), item->height()).contains(pos))
return 0;
}
- QList<QSGItem *> children = QSGItemPrivate::get(item)->paintOrderChildItems();
+ QList<QQuickItem *> children = QQuickItemPrivate::get(item)->paintOrderChildItems();
for (int i = children.count() - 1; i >= 0; --i) {
- QSGItem *child = children.at(i);
- if (QSGItem *betterCandidate = itemAt(child, item->mapToItem(child, pos), overlay))
+ QQuickItem *child = children.at(i);
+ if (QQuickItem *betterCandidate = itemAt(child, item->mapToItem(child, pos), overlay))
return betterCandidate;
}
- if (!(item->flags() & QSGItem::ItemHasContents))
+ if (!(item->flags() & QQuickItem::ItemHasContents))
return 0;
if (!QRectF(0, 0, item->width(), item->height()).contains(pos))
}
-SGViewInspector::SGViewInspector(QSGView *view, QObject *parent) :
+SGViewInspector::SGViewInspector(QQuickView *view, QObject *parent) :
AbstractViewInspector(parent),
m_view(view),
- m_overlay(new QSGItem),
+ m_overlay(new QQuickItem),
m_selectionTool(new SGSelectionTool(this)),
m_designMode(true)
{
// Make sure mouse hover events are received
// m_view->setMouseTracking(true);
- if (QSGItem *root = view->rootItem())
+ if (QQuickItem *root = view->rootItem())
m_overlay->setParentItem(root);
view->installEventFilter(this);
void SGViewInspector::changeCurrentObjects(const QList<QObject*> &objects)
{
- QList<QSGItem*> items;
+ QList<QQuickItem*> items;
foreach (QObject *obj, objects)
- if (QSGItem *item = qobject_cast<QSGItem*>(obj))
+ if (QQuickItem *item = qobject_cast<QQuickItem*>(obj))
items << item;
syncSelectedItems(items);
return;
object->setParent(newParent);
- QSGItem *newParentItem = qobject_cast<QSGItem*>(newParent);
- QSGItem *item = qobject_cast<QSGItem*>(object);
+ QQuickItem *newParentItem = qobject_cast<QQuickItem*>(newParent);
+ QQuickItem *item = qobject_cast<QQuickItem*>(object);
if (newParentItem && item)
item->setParentItem(newParentItem);
}
return m_view->engine();
}
-QSGItem *SGViewInspector::topVisibleItemAt(const QPointF &pos) const
+QQuickItem *SGViewInspector::topVisibleItemAt(const QPointF &pos) const
{
- QSGItem *root = m_view->rootItem();
+ QQuickItem *root = m_view->rootItem();
return itemAt(root, root->mapFromScene(pos), m_overlay);
}
-QList<QSGItem *> SGViewInspector::itemsAt(const QPointF &pos) const
+QList<QQuickItem *> SGViewInspector::itemsAt(const QPointF &pos) const
{
- QSGItem *root = m_view->rootItem();
- QList<QSGItem *> resultList;
+ QQuickItem *root = m_view->rootItem();
+ QList<QQuickItem *> resultList;
collectItemsAt(root, root->mapFromScene(pos), m_overlay, resultList);
return resultList;
}
-QList<QSGItem*> SGViewInspector::selectedItems() const
+QList<QQuickItem*> SGViewInspector::selectedItems() const
{
- QList<QSGItem *> selection;
- foreach (const QWeakPointer<QSGItem> &selectedItem, m_selectedItems) {
+ QList<QQuickItem *> selection;
+ foreach (const QWeakPointer<QQuickItem> &selectedItem, m_selectedItems) {
if (selectedItem)
selection << selectedItem.data();
}
return selection;
}
-void SGViewInspector::setSelectedItems(const QList<QSGItem *> &items)
+void SGViewInspector::setSelectedItems(const QList<QQuickItem *> &items)
{
if (!syncSelectedItems(items))
return;
QList<QObject*> objectList;
- foreach (QSGItem *item, items)
+ foreach (QQuickItem *item, items)
objectList << item;
sendCurrentObjects(objectList);
}
-bool SGViewInspector::syncSelectedItems(const QList<QSGItem *> &items)
+bool SGViewInspector::syncSelectedItems(const QList<QQuickItem *> &items)
{
bool selectionChanged = false;
// Disconnect and remove items that are no longer selected
- foreach (const QWeakPointer<QSGItem> &item, m_selectedItems) {
+ foreach (const QWeakPointer<QQuickItem> &item, m_selectedItems) {
if (!item) // Don't see how this can happen due to handling of destroyed()
continue;
if (items.contains(item.data()))
}
// Connect and add newly selected items
- foreach (QSGItem *item, items) {
+ foreach (QQuickItem *item, items) {
if (m_selectedItems.contains(item))
continue;
void SGViewInspector::removeFromSelectedItems(QObject *object)
{
- if (QSGItem *item = qobject_cast<QSGItem*>(object)) {
+ if (QQuickItem *item = qobject_cast<QQuickItem*>(object)) {
if (m_selectedItems.removeOne(item))
delete m_highlightItems.take(item);
}
bool SGViewInspector::mouseMoveEvent(QMouseEvent *event)
{
// TODO
-// if (QSGItem *item = topVisibleItemAt(event->pos()))
+// if (QQuickItem *item = topVisibleItemAt(event->pos()))
// m_view->setToolTip(titleForItem(item));
// else
// m_view->setToolTip(QString());
return AbstractViewInspector::mouseMoveEvent(event);
}
-QString SGViewInspector::titleForItem(QSGItem *item) const
+QString SGViewInspector::titleForItem(QQuickItem *item) const
{
QString className = QLatin1String(item->metaObject()->className());
QString objectStringId = idStringForObject(item);
className.remove(QRegExp(QLatin1String("_QMLTYPE_\\d+")));
className.remove(QRegExp(QLatin1String("_QML_\\d+")));
- if (className.startsWith(QLatin1String("QSG")))
- className = className.mid(3);
+ if (className.startsWith(QLatin1String("QQuick")))
+ className = className.mid(6);
QString constructedName;
#include <QtCore/QHash>
QT_BEGIN_NAMESPACE
-class QSGView;
-class QSGItem;
+class QQuickView;
+class QQuickItem;
QT_END_NAMESPACE
namespace QmlJSDebugger {
{
Q_OBJECT
public:
- explicit SGViewInspector(QSGView *view, QObject *parent = 0);
+ explicit SGViewInspector(QQuickView *view, QObject *parent = 0);
// AbstractViewInspector
void changeCurrentObjects(const QList<QObject*> &objects);
void setWindowFlags(Qt::WindowFlags flags);
QDeclarativeEngine *declarativeEngine() const;
- QSGView *view() const { return m_view; }
- QSGItem *overlay() const { return m_overlay; }
+ QQuickView *view() const { return m_view; }
+ QQuickItem *overlay() const { return m_overlay; }
- QSGItem *topVisibleItemAt(const QPointF &pos) const;
- QList<QSGItem *> itemsAt(const QPointF &pos) const;
+ QQuickItem *topVisibleItemAt(const QPointF &pos) const;
+ QList<QQuickItem *> itemsAt(const QPointF &pos) const;
- QList<QSGItem *> selectedItems() const;
- void setSelectedItems(const QList<QSGItem*> &items);
+ QList<QQuickItem *> selectedItems() const;
+ void setSelectedItems(const QList<QQuickItem*> &items);
- QString titleForItem(QSGItem *item) const;
+ QString titleForItem(QQuickItem *item) const;
protected:
bool eventFilter(QObject *obj, QEvent *event);
void removeFromSelectedItems(QObject *);
private:
- bool syncSelectedItems(const QList<QSGItem*> &items);
+ bool syncSelectedItems(const QList<QQuickItem*> &items);
- QSGView *m_view;
- QSGItem *m_overlay;
+ QQuickView *m_view;
+ QQuickItem *m_overlay;
SGSelectionTool *m_selectionTool;
- QList<QWeakPointer<QSGItem> > m_selectedItems;
- QHash<QSGItem*, SGSelectionHighlight*> m_highlightItems;
+ QList<QWeakPointer<QQuickItem> > m_selectedItems;
+ QHash<QQuickItem*, SGSelectionHighlight*> m_highlightItems;
bool m_designMode;
};
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecontext.h>
#if defined(QML_VERSION) && QML_VERSION >= 0x020000
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickview.h>
#define QUICK_TEST_SCENEGRAPH 1
#endif
#include <QtDeclarative/qjsvalue.h>
// in turn with a QDeclarativeView.
#ifdef QUICK_TEST_SCENEGRAPH
if (qtQuick2) {
- QSGView view;
+ QQuickView view;
QTestRootObject rootobj;
QEventLoop eventLoop;
QObject::connect(view.engine(), SIGNAL(quit()),
view.setSource(QUrl::fromLocalFile(path));
if (QTest::printAvailableFunctions)
continue;
- if (view.status() == QSGView::Error) {
+ if (view.status() == QQuickView::Error) {
// Error compiling the test - flag failure in the log and continue.
QList<QDeclarativeError> errors = view.errors();
QuickTestResult results;
#include <QtQuick1/qdeclarativeitem.h>
#include <QtQuick1/qdeclarativeview.h>
#if defined(QML_VERSION) && QML_VERSION >= 0x020000
-#include <QtDeclarative/qsgitem.h>
-#include <QtDeclarative/qsgcanvas.h>
+#include <QtDeclarative/qquickitem.h>
+#include <QtDeclarative/qquickcanvas.h>
#define QUICK_TEST_SCENEGRAPH 1
#endif
#include <QtWidgets/qgraphicsscene.h>
QDeclarativeView *view = qobject_cast<QDeclarativeView *>(window);
QWindow *eventWindow = window;
#ifdef QUICK_TEST_SCENEGRAPH
- QSGItem *sgitem = qobject_cast<QSGItem *>(item);
+ QQuickItem *sgitem = qobject_cast<QQuickItem *>(item);
if (sgitem) {
pos = sgitem->mapToScene(_pos).toPoint();
} else
QDeclarativeView *view = qobject_cast<QDeclarativeView *>(window);
QWindow *eventWindow = window;
#ifdef QUICK_TEST_SCENEGRAPH
- QSGItem *sgitem = qobject_cast<QSGItem *>(item);
+ QQuickItem *sgitem = qobject_cast<QQuickItem *>(item);
if (sgitem) {
pos = sgitem->mapToScene(_pos).toPoint();
} else
QWindow *QuickTestEvent::eventWindow()
{
#ifdef QUICK_TEST_SCENEGRAPH
- QSGItem *sgitem = qobject_cast<QSGItem *>(parent());
+ QQuickItem *sgitem = qobject_cast<QQuickItem *>(parent());
if (sgitem)
return sgitem->canvas();
#endif
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativeexpression.h>
#include <QtDeclarative/qdeclarativeproperty.h>
-#include <QtDeclarative/qsgitem.h>
+#include <QtDeclarative/qquickitem.h>
#include <private/qdeclarativebinding_p.h>
#include <private/qdeclarativeenginedebug_p.h>
QDeclarativeDebugConnection *m_conn;
QDeclarativeEngineDebug *m_dbg;
QDeclarativeEngine *m_engine;
- QSGItem *m_rootItem;
+ QQuickItem *m_rootItem;
QObjectList m_components;
QCOMPARE(p.value(), pmeta.read(o));
if (p.name() == "parent")
- QVERIFY(p.valueTypeName() == "QGraphicsObject*" || p.valueTypeName() == "QSGItem*");
+ QVERIFY(p.valueTypeName() == "QGraphicsObject*" || p.valueTypeName() == "QQuickItem*");
else
QCOMPARE(p.valueTypeName(), QString::fromUtf8(pmeta.typeName()));
QDeclarativeComponent component(m_engine);
component.setData(qml[i], QUrl::fromLocalFile(""));
QVERIFY(component.isReady()); // fails if bad syntax
- m_components << qobject_cast<QSGItem*>(component.create());
+ m_components << qobject_cast<QQuickItem*>(component.create());
}
- m_rootItem = qobject_cast<QSGItem*>(m_components.first());
+ m_rootItem = qobject_cast<QQuickItem*>(m_components.first());
// add an extra context to test for multiple contexts
QDeclarativeContext *context = new QDeclarativeContext(m_engine->rootContext(), this);
# This test requires the xmlpatterns module
!contains(QT_CONFIG,xmlpatterns):PRIVATETESTS -= qdeclarativexmllistmodel
-SGTESTS = \
- qsganimatedimage \
- qsgborderimage \
- qsgcanvas \
- qsgdrag \
- qsgdroparea \
- qsgflickable \
- qsgflipable \
- qsgfocusscope \
- qsggridview \
- qsgimage \
- qsgitem \
- qsgitem2 \
- qsglistview \
- qsgloader \
- qsgmousearea \
- qsgpathview \
- qsgpincharea \
- qsgpositioners \
- qsgrepeater \
- qsgtext \
- qsgtextedit \
- qsgtextinput \
- qsgvisualdatamodel \
- qsgview \
- qsgcanvasitem \
+QUICKTESTS = \
+ qquickanimatedimage \
+ qquickborderimage \
+ qquickcanvas \
+ qquickdrag \
+ qquickdroparea \
+ qquickflickable \
+ qquickflipable \
+ qquickfocusscope \
+ qquickgridview \
+ qquickimage \
+ qquickitem \
+ qquickitem2 \
+ qquicklistview \
+ qquickloader \
+ qquickmousearea \
+ qquickpathview \
+ qquickpincharea \
+ qquickpositioners \
+ qquickrepeater \
+ qquicktext \
+ qquicktextedit \
+ qquicktextinput \
+ qquickvisualdatamodel \
+ qquickview \
+ qquickcanvasitem \
SUBDIRS += $$PUBLICTESTS
contains(QT_CONFIG, private_tests) {
SUBDIRS += $$PRIVATETESTS
- SUBDIRS += $$SGTESTS
+ SUBDIRS += $$QUICKTESTS
}
#include <QDir>
#include <QProcess>
#include <QDebug>
-#include <QSGView>
+#include <QQuickView>
#include <QDeclarativeError>
class tst_examples : public QObject
excludedDirs << "examples/declarative/text/fonts"; // QTBUG-21415
#endif
- // Not run in QSGView
+ // Not run in QQuickView
excludedDirs << "examples/declarative/qtquick1";
// These snippets are not expected to run on their own.
{
QFETCH(QString, file);
- QSGView view;
+ QQuickView view;
QtMsgHandler old = qInstallMsgHandler(silentErrorsMsgHandler);
view.setSource(file);
qInstallMsgHandler(old);
- if (view.status() == QSGView::Error)
+ if (view.status() == QQuickView::Error)
qWarning() << view.errors();
- QCOMPARE(view.status(), QSGView::Ready);
+ QCOMPARE(view.status(), QQuickView::Ready);
view.show();
QTest::qWait(100);
#include <QtTest/QtTest>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <QtDeclarative/private/qsgrectangle_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <QtDeclarative/private/qquickrectangle_p.h>
#include <QtDeclarative/private/qdeclarativeanimation_p.h>
#include <QtDeclarative/private/qdeclarativetransition_p.h>
-#include <QtDeclarative/private/qsganimation_p.h>
+#include <QtDeclarative/private/qquickanimation_p.h>
#include <QtDeclarative/private/qdeclarativepathinterpolator_p.h>
-#include <QtDeclarative/private/qsgitem_p.h>
+#include <QtDeclarative/private/qquickitem_p.h>
#include <QVariantAnimation>
#include <QEasingCurve>
void tst_qdeclarativeanimations::simpleProperty()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativePropertyAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
void tst_qdeclarativeanimations::simpleNumber()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativeNumberAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
void tst_qdeclarativeanimations::simpleColor()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativeColorAnimation animation;
animation.setTarget(&rect);
animation.setProperty("color");
void tst_qdeclarativeanimations::simpleRotation()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativeRotationAnimation animation;
animation.setTarget(&rect);
animation.setProperty("rotation");
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathAnimation.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
+ QQuickRectangle *redRect = rect->findChild<QQuickRectangle*>();
QVERIFY(redRect);
- QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
+ QQuickPathAnimation *pathAnim = rect->findChild<QQuickPathAnimation*>();
QVERIFY(pathAnim);
pathAnim->start();
QTRY_COMPARE(redRect->x(), qreal(300));
QCOMPARE(redRect->y(), qreal(300));
- pathAnim->setOrientation(QSGPathAnimation::RightFirst);
- QCOMPARE(pathAnim->orientation(), QSGPathAnimation::RightFirst);
+ pathAnim->setOrientation(QQuickPathAnimation::RightFirst);
+ QCOMPARE(pathAnim->orientation(), QQuickPathAnimation::RightFirst);
pathAnim->start();
QTRY_VERIFY(redRect->rotation() != 0);
pathAnim->stop();
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathAnimation2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
+ QQuickRectangle *redRect = rect->findChild<QQuickRectangle*>();
QVERIFY(redRect);
- QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
+ QQuickPathAnimation *pathAnim = rect->findChild<QQuickPathAnimation*>();
QVERIFY(pathAnim);
- QCOMPARE(pathAnim->orientation(), QSGPathAnimation::RightFirst);
+ QCOMPARE(pathAnim->orientation(), QQuickPathAnimation::RightFirst);
pathAnim->start();
pathAnim->pause();
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathAnimationNoStart.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
+ QQuickRectangle *redRect = rect->findChild<QQuickRectangle*>();
QVERIFY(redRect);
- QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
+ QQuickPathAnimation *pathAnim = rect->findChild<QQuickPathAnimation*>();
QVERIFY(pathAnim);
pathAnim->start();
void tst_qdeclarativeanimations::alwaysRunToEnd()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativePropertyAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
void tst_qdeclarativeanimations::complete()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativePropertyAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
void tst_qdeclarativeanimations::resume()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativePropertyAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
void tst_qdeclarativeanimations::dotProperty()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativeNumberAnimation animation;
animation.setTarget(&rect);
animation.setProperty("border.width");
{
//don't crash
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("badtype1.qml")));
qApp->processEvents();
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("badtype4.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state1");
QTest::qWait(1000 + 50);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("MyRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("MyRect");
QVERIFY(myRect);
QCOMPARE(myRect->x(),qreal(200));
}
QDeclarativeComponent c1(&engine, QUrl::fromLocalFile(TESTDATA("badproperty1.qml")));
QByteArray message = QUrl::fromLocalFile(TESTDATA("badproperty1.qml")).toString().toUtf8() + ":18:9: QML ColorAnimation: Cannot animate non-existent property \"border.colr\"";
QTest::ignoreMessage(QtWarningMsg, message);
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c1.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c1.create());
QVERIFY(rect);
QDeclarativeComponent c2(&engine, QUrl::fromLocalFile(TESTDATA("badproperty2.qml")));
message = QUrl::fromLocalFile(TESTDATA("badproperty2.qml")).toString().toUtf8() + ":18:9: QML ColorAnimation: Cannot animate read-only property \"border\"";
QTest::ignoreMessage(QtWarningMsg, message);
- rect = qobject_cast<QSGRectangle*>(c2.create());
+ rect = qobject_cast<QQuickRectangle*>(c2.create());
QVERIFY(rect);
//### should we warn here are well?
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("mixedtype1.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state1");
QTest::qWait(500);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("MyRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("MyRect");
QVERIFY(myRect);
//rather inexact -- is there a better way?
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("mixedtype2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state1");
QTest::qWait(500);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("MyRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("MyRect");
QVERIFY(myRect);
//rather inexact -- is there a better way?
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("properties.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(200));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("properties2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(200));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("properties3.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(300));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("properties4.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->y(),qreal(200));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("properties5.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(100));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickItemPrivate::get(rect)->setState("moved");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(200));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QCOMPARE(myRect->x(),qreal(200));
QCOMPARE(myRect->y(),qreal(100));
QTest::qWait(waitDuration);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition3.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QCOMPARE(myRect->x(),qreal(200));
QCOMPARE(myRect->y(),qreal(100));
}
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition4.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QCOMPARE(myRect->x(),qreal(100));
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(200));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition5.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QCOMPARE(myRect->x(),qreal(100));
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(200));
/*{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition6.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QCOMPARE(myRect->x(),qreal(100));
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(100));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("propertiesTransition7.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickItemPrivate::get(rect)->setState("moved");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QTest::qWait(waitDuration);
QTIMED_COMPARE(myRect->x(),qreal(200));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathTransition.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("redRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("redRect");
QVERIFY(myRect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QTRY_VERIFY(myRect->x() < 500 && myRect->x() > 100 && myRect->y() > 50 && myRect->y() < 700 ); //animation started
QTRY_VERIFY(qFuzzyCompare(myRect->x(), qreal(100)) && qFuzzyCompare(myRect->y(), qreal(700)));
QTest::qWait(100);
- QSGItemPrivate::get(rect)->setState("");
+ QQuickItemPrivate::get(rect)->setState("");
QTRY_VERIFY(myRect->x() < 500 && myRect->x() > 100 && myRect->y() > 50 && myRect->y() < 700 ); //animation started
QTRY_VERIFY(qFuzzyCompare(myRect->x(), qreal(500)) && qFuzzyCompare(myRect->y(), qreal(50)));
}
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("disabledTransition.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *myRect = rect->findChild<QSGRectangle*>("TheRect");
+ QQuickRectangle *myRect = rect->findChild<QQuickRectangle*>("TheRect");
QVERIFY(myRect);
QDeclarativeTransition *trans = rect->findChild<QDeclarativeTransition*>();
QCOMPARE(trans->enabled(), false);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
QCOMPARE(myRect->x(),qreal(200));
trans->setEnabled(true);
- QSGItemPrivate::get(rect)->setState("");
+ QQuickItemPrivate::get(rect)->setState("");
QCOMPARE(myRect->x(),qreal(200));
QTest::qWait(300);
QTIMED_COMPARE(myRect->x(),qreal(100));
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("attached.qml")));
QTest::ignoreMessage(QtDebugMsg, "off");
QTest::ignoreMessage(QtDebugMsg, "on");
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
}
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("valuesource.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *myAnim = rect->findChild<QDeclarativeAbstractAnimation*>("MyAnim");
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("valuesource2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *myAnim = rect->findChild<QDeclarativeAbstractAnimation*>("MyAnim");
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("dontAutoStart.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *myAnim = rect->findChild<QDeclarativeAbstractAnimation*>("MyAnim");
QString warning = c.url().toString() + ":14:13: QML NumberAnimation: setRunning() cannot be used on non-root animation nodes.";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *myAnim = rect->findChild<QDeclarativeAbstractAnimation*>("MyAnim");
QString warning = c.url().toString() + ":15:17: QML NumberAnimation: setRunning() cannot be used on non-root animation nodes.";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *myAnim = rect->findChild<QDeclarativeAbstractAnimation*>("MyAnim");
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("rotation.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *rr = rect->findChild<QSGRectangle*>("rr");
- QSGRectangle *rr2 = rect->findChild<QSGRectangle*>("rr2");
- QSGRectangle *rr3 = rect->findChild<QSGRectangle*>("rr3");
- QSGRectangle *rr4 = rect->findChild<QSGRectangle*>("rr4");
+ QQuickRectangle *rr = rect->findChild<QQuickRectangle*>("rr");
+ QQuickRectangle *rr2 = rect->findChild<QQuickRectangle*>("rr2");
+ QQuickRectangle *rr3 = rect->findChild<QQuickRectangle*>("rr3");
+ QQuickRectangle *rr4 = rect->findChild<QQuickRectangle*>("rr4");
- QSGItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state1");
QTest::qWait(800);
qreal r1 = rr->rotation();
qreal r2 = rr2->rotation();
//ensure we start correctly when "running: true" is explicitly set
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("runningTrueBug.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *cloud = rect->findChild<QSGRectangle*>("cloud");
+ QQuickRectangle *cloud = rect->findChild<QQuickRectangle*>("cloud");
QVERIFY(cloud);
QTest::qWait(1000);
QVERIFY(cloud->x() > qreal(0));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("nonTransitionBug.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
- QSGRectangle *mover = rect->findChild<QSGRectangle*>("mover");
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
+ QQuickRectangle *mover = rect->findChild<QQuickRectangle*>("mover");
mover->setX(100);
QCOMPARE(mover->x(), qreal(100));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("registrationBug.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QTRY_COMPARE(rect->property("value"), QVariant(int(100)));
}
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("doubleRegistrationBug.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QDeclarativeAbstractAnimation *anim = rect->findChild<QDeclarativeAbstractAnimation*>("animation");
//QTBUG-16736
void tst_qdeclarativeanimations::alwaysRunToEndRestartBug()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativePropertyAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("transitionAssignmentBug.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QCOMPARE(rect->property("nullObject").toBool(), false);
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pauseBindingBug.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QDeclarativeAbstractAnimation *anim = rect->findChild<QDeclarativeAbstractAnimation*>("animation");
QVERIFY(anim->qtAnimation()->state() == QAbstractAnimation::Paused);
#include <qtest.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativeengine.h>
-#include <QtDeclarative/qsgitem.h>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickitem.h>
+#include <QtDeclarative/qquickview.h>
#include <QtGui/qinputpanel.h>
class tst_qdeclarativeapplication : public QObject
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Item { property bool active: Qt.application.active }", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem *>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem *>(component.create());
QVERIFY(item);
- QSGView view;
+ QQuickView view;
item->setParentItem(view.rootObject());
// not active
view.show();
view.requestActivateWindow();
QTest::qWait(50);
- QTRY_COMPARE(view.status(), QSGView::Ready);
+ QTRY_COMPARE(view.status(), QQuickView::Ready);
QCOMPARE(item->property("active").toBool(), QGuiApplication::activeWindow() != 0);
// not active again
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Item { property bool layoutDirection: Qt.application.layoutDirection }", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem *>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem *>(component.create());
QVERIFY(item);
- QSGView view;
+ QQuickView view;
item->setParentItem(view.rootObject());
// not mirrored
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Item { property variant inputPanel: Qt.application.inputPanel }", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem *>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem *>(component.create());
QVERIFY(item);
- QSGView view;
+ QQuickView view;
item->setParentItem(view.rootObject());
// check that the inputPanel property maches with application's input panel
#include <qsignalspy.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgtext_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquicktext_p.h>
#include <private/qdeclarativebehavior_p.h>
#include <private/qdeclarativeanimation_p.h>
-#include <private/qsgitem_p.h>
+#include <private/qquickitem_p.h>
#include "../shared/util.h"
class tst_qdeclarativebehaviors : public QObject
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("simple.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
QTRY_VERIFY(qobject_cast<QDeclarativeBehavior*>(rect->findChild<QDeclarativeBehavior*>("MyBehavior"))->animation());
- QSGItemPrivate::get(rect)->setState("moved");
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() > 0);
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() < 200);
+ QQuickItemPrivate::get(rect)->setState("moved");
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() > 0);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() < 200);
//i.e. the behavior has been triggered
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("scripttrigger.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
rect->setColor(QColor("red"));
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() > 0);
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() < 200);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() > 0);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() < 200);
//i.e. the behavior has been triggered
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("cpptrigger.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QTRY_VERIFY(innerRect);
innerRect->setProperty("x", 200);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("loop.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
//don't crash
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
delete rect;
}
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("color.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
- QSGItemPrivate::get(rect)->setState("red");
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->color() != QColor("red"));
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->color() != QColor("green"));
+ QQuickItemPrivate::get(rect)->setState("red");
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->color() != QColor("red"));
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->color() != QColor("green"));
//i.e. the behavior has been triggered
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("parent.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
- QSGItemPrivate::get(rect)->setState("reparented");
- QTRY_VERIFY(rect->findChild<QSGRectangle*>("MyRect")->parentItem() != rect->findChild<QSGItem*>("NewParent"));
- QTRY_VERIFY(rect->findChild<QSGRectangle*>("MyRect")->parentItem() == rect->findChild<QSGItem*>("NewParent"));
+ QQuickItemPrivate::get(rect)->setState("reparented");
+ QTRY_VERIFY(rect->findChild<QQuickRectangle*>("MyRect")->parentItem() != rect->findChild<QQuickItem*>("NewParent"));
+ QTRY_VERIFY(rect->findChild<QQuickRectangle*>("MyRect")->parentItem() == rect->findChild<QQuickItem*>("NewParent"));
delete rect;
}
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("binding.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickItemPrivate::get(rect)->setState("moved");
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QTRY_VERIFY(innerRect);
QTRY_VERIFY(innerRect->x() > 0);
QTRY_VERIFY(innerRect->x() < 200);
rect->setProperty("movedx", 210);
QTRY_COMPARE(innerRect->x(), (qreal)210);
- QSGItemPrivate::get(rect)->setState("");
+ QQuickItemPrivate::get(rect)->setState("");
QTRY_VERIFY(innerRect->x() > 10);
QTRY_VERIFY(innerRect->x() < 210); //i.e. the behavior has been triggered
QTRY_COMPARE(innerRect->x(), (qreal)10);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("groupProperty.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
qDebug() << c.errorString();
QTRY_VERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
+ QQuickItemPrivate::get(rect)->setState("moved");
//QTest::qWait(200);
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() > 0);
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() < 200);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() > 0);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() < 200);
//i.e. the behavior has been triggered
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("groupProperty2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QTRY_VERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->border()->width() > 0);
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->border()->width() < 4);
+ QQuickItemPrivate::get(rect)->setState("moved");
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->border()->width() > 0);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->border()->width() < 4);
//i.e. the behavior has been triggered
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("empty.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- qreal x = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x();
+ QQuickItemPrivate::get(rect)->setState("moved");
+ qreal x = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x();
QCOMPARE(x, qreal(200)); //should change immediately
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("explicit.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() > 0);
- QTRY_VERIFY(qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x() < 200);
+ QQuickItemPrivate::get(rect)->setState("moved");
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() > 0);
+ QTRY_VERIFY(qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x() < 200);
//i.e. the behavior has been triggered
delete rect;
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("nonSelecting2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGItemPrivate::get(rect)->setState("moved");
- qreal x = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x();
+ QQuickItemPrivate::get(rect)->setState("moved");
+ qreal x = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x();
QCOMPARE(x, qreal(200)); //should change immediately
delete rect;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("reassignedAnimation.qml")));
QString warning = QUrl::fromLocalFile(TESTDATA("reassignedAnimation.qml")).toString() + ":9:9: QML Behavior: Cannot change the animation assigned to a Behavior.";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QCOMPARE(qobject_cast<QDeclarativeNumberAnimation*>(
rect->findChild<QDeclarativeBehavior*>("MyBehavior")->animation())->duration(), 200);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("disabled.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QCOMPARE(rect->findChild<QDeclarativeBehavior*>("MyBehavior")->enabled(), false);
- QSGItemPrivate::get(rect)->setState("moved");
- qreal x = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"))->x();
+ QQuickItemPrivate::get(rect)->setState("moved");
+ qreal x = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"))->x();
QCOMPARE(x, qreal(200)); //should change immediately
delete rect;
QString warning = c.url().toString() + ":13:13: QML NumberAnimation: setRunning() cannot be used on non-root animation nodes.";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *myAnim = rect->findChild<QDeclarativeAbstractAnimation*>("MyAnim");
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("startup.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *innerRect = rect->findChild<QSGRectangle*>("innerRect");
+ QQuickRectangle *innerRect = rect->findChild<QQuickRectangle*>("innerRect");
QVERIFY(innerRect);
QCOMPARE(innerRect->x(), qreal(100)); //should be set immediately
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("startup2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *innerRect = rect->findChild<QSGRectangle*>("innerRect");
+ QQuickRectangle *innerRect = rect->findChild<QQuickRectangle*>("innerRect");
QVERIFY(innerRect);
- QSGText *text = rect->findChild<QSGText*>();
+ QQuickText *text = rect->findChild<QQuickText*>();
QVERIFY(text);
QCOMPARE(innerRect->x(), text->width()); //should be set immediately
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("groupedPropertyCrash.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect); //don't crash
}
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("runningTrue.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
QDeclarativeAbstractAnimation *animation = rect->findChild<QDeclarativeAbstractAnimation*>("rotAnim");
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("qtbug12295.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *target = rect->findChild<QSGRectangle*>("myRect");
+ QQuickRectangle *target = rect->findChild<QQuickRectangle*>("myRect");
QVERIFY(target);
target->setX(100);
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("delayedRegistration.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItem *innerRect = rect->property("myItem").value<QSGItem*>();
+ QQuickItem *innerRect = rect->property("myItem").value<QQuickItem*>();
QVERIFY(innerRect != 0);
QCOMPARE(innerRect->property("x").toInt(), int(0));
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <private/qdeclarativebind_p.h>
-#include <private/qsgrectangle_p.h>
+#include <private/qquickrectangle_p.h>
#include "../shared/util.h"
class tst_qdeclarativebinding : public QObject
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("test-binding.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QDeclarativeBind *binding3 = qobject_cast<QDeclarativeBind*>(rect->findChild<QDeclarativeBind*>("binding3"));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("test-binding2.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QCOMPARE(rect->color(), QColor("yellow"));
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("restoreBinding.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGRectangle *myItem = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("myItem"));
+ QQuickRectangle *myItem = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("myItem"));
QVERIFY(myItem != 0);
myItem->setY(25);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("restoreBindingWithLoop.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGRectangle *myItem = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("myItem"));
+ QQuickRectangle *myItem = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("myItem"));
QVERIFY(myItem != 0);
myItem->setY(25);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("deletedObject.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
QGuiApplication::sendPostedEvents(0, QEvent::DeferredDelete);
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgitem.h>
+#include <QtDeclarative/qquickitem.h>
#include <QtDeclarative/qdeclarativeproperty.h>
#include <QtDeclarative/qdeclarativeincubator.h>
#include <qcolor.h>
QObject *testObject2 = object->property("declarativeitem").value<QObject*>();
QVERIFY(testObject2);
QVERIFY(testObject2->parent() == object);
- QCOMPARE(testObject2->metaObject()->className(), "QSGItem");
+ QCOMPARE(testObject2->metaObject()->className(), "QQuickItem");
}
void tst_qdeclarativecomponent::qmlCreateObjectWithProperties()
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <private/qdeclarativeconnections_p.h>
-#include <private/qsgitem_p.h>
+#include <private/qquickitem_p.h>
#include "../shared/util.h"
#include <QtDeclarative/qdeclarativescriptstring.h>
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("test-connection.qml")));
- QSGItem *item = qobject_cast<QSGItem*>(c.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(c.create());
QVERIFY(item != 0);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("trimming.qml")));
- QSGItem *item = qobject_cast<QSGItem*>(c.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(c.create());
QVERIFY(item != 0);
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("connection-targetchange.qml")));
- QSGItem *item = qobject_cast<QSGItem*>(c.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(c.create());
QVERIFY(item != 0);
QDeclarativeConnections *connections = item->findChild<QDeclarativeConnections*>("connections");
QVERIFY(connections);
- QSGItem *item1 = item->findChild<QSGItem*>("item1");
+ QQuickItem *item1 = item->findChild<QQuickItem*>("item1");
QVERIFY(item1);
item1->setWidth(200);
- QSGItem *item2 = item->findChild<QSGItem*>("item2");
+ QQuickItem *item2 = item->findChild<QQuickItem*>("item2");
QVERIFY(item2);
QVERIFY(connections->target() == item2);
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, url);
- QSGItem *item = qobject_cast<QSGItem*>(c.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(c.create());
QVERIFY(item != 0);
// check that connection is created (they are all runtime errors)
#include <QtTest/QtTest>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativeimageprovider.h>
-#include <private/qsgimage_p.h>
+#include <private/qquickimage_p.h>
#include <QImageReader>
#include <QWaitCondition>
+ properties + " }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
if (async)
- QTRY_VERIFY(obj->status() == QSGImage::Loading);
+ QTRY_VERIFY(obj->status() == QQuickImage::Loading);
QCOMPARE(obj->source(), QUrl(source));
if (error.isEmpty()) {
if (async)
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
else
- QVERIFY(obj->status() == QSGImage::Ready);
+ QVERIFY(obj->status() == QQuickImage::Ready);
if (QByteArray(QTest::currentDataTag()).startsWith("qimage"))
QCOMPARE(static_cast<TestQImageProvider*>(provider)->lastImageId, imageId);
else
QCOMPARE(obj->width(), qreal(size.width()));
QCOMPARE(obj->height(), qreal(size.height()));
- QCOMPARE(obj->fillMode(), QSGImage::Stretch);
+ QCOMPARE(obj->fillMode(), QQuickImage::Stretch);
QCOMPARE(obj->progress(), 1.0);
} else {
if (async)
- QTRY_VERIFY(obj->status() == QSGImage::Error);
+ QTRY_VERIFY(obj->status() == QQuickImage::Error);
else
- QVERIFY(obj->status() == QSGImage::Error);
+ QVERIFY(obj->status() == QQuickImage::Error);
}
delete obj;
QString componentStr = "import QtQuick 2.0\nImage { asynchronous: true; source: \"image://test/pixmap-async-test.png\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
delete obj;
QString componentStr = "import QtQuick 2.0\nImage { source: \"" + newImageFileName() + "\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
- QCOMPARE(obj->status(), QSGImage::Ready);
+ QCOMPARE(obj->status(), QQuickImage::Ready);
// remove the provider and confirm
QString fileName = newImageFileName();
engine.removeImageProvider("test");
obj->setSource(QUrl(fileName));
- QCOMPARE(obj->status(), QSGImage::Error);
+ QCOMPARE(obj->status(), QQuickImage::Error);
delete obj;
}
QObject *obj = component.create();
//MUST not deadlock
QVERIFY(obj != 0);
- QList<QSGImage *> images = obj->findChildren<QSGImage *>();
+ QList<QQuickImage *> images = obj->findChildren<QQuickImage *>();
QCOMPARE(images.count(), 4);
QTest::qWait(100);
- foreach (QSGImage *img, images) {
- QCOMPARE(img->status(), QSGImage::Loading);
+ foreach (QQuickImage *img, images) {
+ QCOMPARE(img->status(), QQuickImage::Loading);
}
provider->ok = true;
provider->cond.wakeAll();
QTest::qWait(250);
- foreach (QSGImage *img, images) {
- QTRY_VERIFY(img->status() == QSGImage::Ready);
+ foreach (QQuickImage *img, images) {
+ QTRY_VERIFY(img->status() == QQuickImage::Ready);
}
}
QTest::newRow("local import")
<< "import \"subdir\"\n" // QT-613
"Test {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("local import second")
<< "import QtQuick 2.0\nimport \"subdir\"\n"
"Test {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("local import subsubdir")
<< "import QtQuick 2.0\nimport \"subdir/subsubdir\"\n"
"SubTest {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("local import QTBUG-7721 A")
<< "subdir.Test {}" // no longer allowed (QTBUG-7721)
QTest::newRow("local import as")
<< "import \"subdir\" as T\n"
"T.Test {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("wrong local import as")
<< "import \"subdir\" as T\n"
QString serverdir = "http://127.0.0.1:14447/qtest/declarative/qmllanguage";
- QTest::newRow("remote import") << "import \""+serverdir+"\"\nTest {}" << "QSGRectangle"
+ QTest::newRow("remote import") << "import \""+serverdir+"\"\nTest {}" << "QQuickRectangle"
<< "";
- QTest::newRow("remote import with subdir") << "import \""+serverdir+"\"\nTestSubDir {}" << "QSGText"
+ QTest::newRow("remote import with subdir") << "import \""+serverdir+"\"\nTestSubDir {}" << "QQuickText"
<< "";
- QTest::newRow("remote import with local") << "import \""+serverdir+"\"\nTestLocal {}" << "QSGImage"
+ QTest::newRow("remote import with local") << "import \""+serverdir+"\"\nTestLocal {}" << "QQuickImage"
<< "";
QTest::newRow("wrong remote import with undeclared local") << "import \""+serverdir+"\"\nWrongTestLocal {}" << ""
<< "WrongTestLocal is not a type";
QTest::newRow("installed import 0")
<< "import com.nokia.installedtest0 0.0\n"
"InstalledTestTP {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("installed import 0 as TP")
<< "import com.nokia.installedtest0 0.0 as TP\n"
"TP.InstalledTestTP {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("installed import 1")
<< "import com.nokia.installedtest 1.0\n"
"InstalledTest {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("installed import 2")
<< "import com.nokia.installedtest 1.3\n"
"InstalledTest {}"
- << "QSGRectangle"
+ << "QQuickRectangle"
<< "";
QTest::newRow("installed import 3")
<< "import com.nokia.installedtest 1.4\n"
"InstalledTest {}"
- << "QSGText"
+ << "QQuickText"
<< "";
QTest::newRow("installed import minor version not available") // QTBUG-11936
<< "import com.nokia.installedtest 0.1\n"
"import com.nokia.installedtest 1.4\n"
"import com.nokia.installedtest 1.4\n"
"InstalledTest {}"
- << (!qmlCheckTypes()?"QSGText":"")
+ << (!qmlCheckTypes()?"QQuickText":"")
<< (!qmlCheckTypes()?"":"InstalledTest is ambiguous. Found in lib/com/nokia/installedtest in version 1.4 and 1.4");
QTest::newRow("installed import overrides 1") <<
"import com.nokia.installedtest 1.0\n"
"import com.nokia.installedtest 1.4\n"
"InstalledTest {}"
- << (!qmlCheckTypes()?"QSGText":"")
+ << (!qmlCheckTypes()?"QQuickText":"")
<< (!qmlCheckTypes()?"":"InstalledTest is ambiguous. Found in lib/com/nokia/installedtest in version 1.4 and 1.0");
QTest::newRow("installed import overrides 2") <<
"import com.nokia.installedtest 1.4\n"
"import com.nokia.installedtest 1.0\n"
"InstalledTest {}"
- << (!qmlCheckTypes()?"QSGRectangle":"")
+ << (!qmlCheckTypes()?"QQuickRectangle":"")
<< (!qmlCheckTypes()?"":"InstalledTest is ambiguous. Found in lib/com/nokia/installedtest in version 1.0 and 1.4");
QTest::newRow("installed import re-overrides 1") <<
"import com.nokia.installedtest 1.4\n"
"import com.nokia.installedtest 1.0\n"
"import com.nokia.installedtest 1.4\n"
"InstalledTest {}"
- << (!qmlCheckTypes()?"QSGText":"")
+ << (!qmlCheckTypes()?"QQuickText":"")
<< (!qmlCheckTypes()?"":"InstalledTest is ambiguous. Found in lib/com/nokia/installedtest in version 1.4 and 1.0");
QTest::newRow("installed import re-overrides 2") <<
"import com.nokia.installedtest 1.4\n"
"import com.nokia.installedtest 1.4\n"
"import com.nokia.installedtest 1.0\n"
"InstalledTest {}"
- << (!qmlCheckTypes()?"QSGRectangle":"")
+ << (!qmlCheckTypes()?"QQuickRectangle":"")
<< (!qmlCheckTypes()?"":"InstalledTest is ambiguous. Found in lib/com/nokia/installedtest in version 1.0 and 1.4");
QTest::newRow("installed import versus builtin 1") <<
"import com.nokia.installedtest 1.5\n"
"import QtQuick 2.0\n"
"Rectangle {}"
- << (!qmlCheckTypes()?"QSGRectangle":"")
+ << (!qmlCheckTypes()?"QQuickRectangle":"")
<< (!qmlCheckTypes()?"":"Rectangle is ambiguous. Found in Qt and in lib/com/nokia/installedtest");
QTest::newRow("installed import versus builtin 2") <<
"import QtQuick 2.0\n"
"import com.nokia.installedtest 1.5\n"
"Rectangle {}"
- << (!qmlCheckTypes()?"QSGText":"")
+ << (!qmlCheckTypes()?"QQuickText":"")
<< (!qmlCheckTypes()?"":"Rectangle is ambiguous. Found in lib/com/nokia/installedtest and in Qt");
QTest::newRow("namespaces cannot be overridden by types 1") <<
"import QtQuick 2.0 as Rectangle\n"
"import QtQuick 2.0 as Rectangle\n"
"import com.nokia.installedtest 1.5\n"
"Rectangle.Image {}"
- << "QSGImage"
+ << "QQuickImage"
<< "";
QTest::newRow("local last 1") <<
"LocalLast {}"
- << "QSGText"
+ << "QQuickText"
<< "";
QTest::newRow("local last 2") <<
"import com.nokia.installedtest 1.0\n"
"LocalLast {}"
- << (!qmlCheckTypes()?"QSGRectangle":"")// i.e. from com.nokia.installedtest, not data/LocalLast.qml
+ << (!qmlCheckTypes()?"QQuickRectangle":"")// i.e. from com.nokia.installedtest, not data/LocalLast.qml
<< (!qmlCheckTypes()?"":"LocalLast is ambiguous. Found in lib/com/nokia/installedtest and in local directory");
}
**
****************************************************************************/
#include <qtest.h>
-#include <QtDeclarative/private/qsgitem_p.h>
-#include <QtDeclarative/private/qsgtext_p.h>
+#include <QtDeclarative/private/qquickitem_p.h>
+#include <QtDeclarative/private/qquicktext_p.h>
#include <QtDeclarative/private/qdeclarativeengine_p.h>
#include <QtDeclarative/private/qdeclarativelistmodel_p.h>
#include <QtDeclarative/private/qdeclarativeexpression_p.h>
private:
int roleFromName(const QDeclarativeListModel *model, const QString &roleName);
- QSGItem *createWorkerTest(QDeclarativeEngine *eng, QDeclarativeComponent *component, QDeclarativeListModel *model);
- void waitForWorker(QSGItem *item);
+ QQuickItem *createWorkerTest(QDeclarativeEngine *eng, QDeclarativeComponent *component, QDeclarativeListModel *model);
+ void waitForWorker(QQuickItem *item);
private slots:
void static_types();
return -1;
}
-QSGItem *tst_qdeclarativelistmodel::createWorkerTest(QDeclarativeEngine *eng, QDeclarativeComponent *component, QDeclarativeListModel *model)
+QQuickItem *tst_qdeclarativelistmodel::createWorkerTest(QDeclarativeEngine *eng, QDeclarativeComponent *component, QDeclarativeListModel *model)
{
- QSGItem *item = qobject_cast<QSGItem*>(component->create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component->create());
QDeclarativeEngine::setContextForObject(model, eng->rootContext());
if (item)
item->setProperty("model", qVariantFromValue(model));
return item;
}
-void tst_qdeclarativelistmodel::waitForWorker(QSGItem *item)
+void tst_qdeclarativelistmodel::waitForWorker(QQuickItem *item)
{
QEventLoop loop;
QTimer timer;
QTest::newRow("enum")
<< "ListElement { foo: Text.AlignHCenter }"
- << QVariant(double(QSGText::AlignHCenter));
+ << QVariant(double(QQuickText::AlignHCenter));
QTest::newRow("Qt enum")
<< "ListElement { foo: Qt.AlignBottom }"
QDeclarativeListModel model;
QDeclarativeEngine eng;
QDeclarativeComponent component(&eng, QUrl::fromLocalFile(SRCDIR "/data/model.qml"));
- QSGItem *item = createWorkerTest(&eng, &component, &model);
+ QQuickItem *item = createWorkerTest(&eng, &component, &model);
QVERIFY(item != 0);
QSignalSpy spyCount(&model, SIGNAL(countChanged()));
QDeclarativeListModel model;
QDeclarativeEngine eng;
QDeclarativeComponent component(&eng, QUrl::fromLocalFile(SRCDIR "/data/model.qml"));
- QSGItem *item = createWorkerTest(&eng, &component, &model);
+ QQuickItem *item = createWorkerTest(&eng, &component, &model);
QVERIFY(item != 0);
if (script[0] == QLatin1Char('{') && script[script.length()-1] == QLatin1Char('}'))
QDeclarativeListModel model;
QDeclarativeEngine eng;
QDeclarativeComponent component(&eng, QUrl::fromLocalFile(SRCDIR "/data/model.qml"));
- QSGItem *item = createWorkerTest(&eng, &component, &model);
+ QQuickItem *item = createWorkerTest(&eng, &component, &model);
QVERIFY(item != 0);
RUNEVAL(item, "model.append({foo: 123})");
QDeclarativeListModel model;
QDeclarativeEngine eng;
QDeclarativeComponent component(&eng, QUrl::fromLocalFile(SRCDIR "/data/model.qml"));
- QSGItem *item = createWorkerTest(&eng, &component, &model);
+ QQuickItem *item = createWorkerTest(&eng, &component, &model);
QVERIFY(item != 0);
RUNEVAL(item, "model.append({foo: 123})");
QDeclarativeEngine eng;
QDeclarativeComponent component(&eng, QUrl::fromLocalFile(SRCDIR "/data/enumerate.qml"));
QVERIFY(!component.isError());
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item != 0);
QStringList r = item->property("result").toString().split(":");
QCOMPARE(r[0],QLatin1String("val1=1Y"));
QDeclarativeListModel model;
QDeclarativeEngine eng;
QDeclarativeComponent component(&eng, QUrl::fromLocalFile(SRCDIR "/data/model.qml"));
- QSGItem *item = createWorkerTest(&eng, &component, &model);
+ QQuickItem *item = createWorkerTest(&eng, &component, &model);
QVERIFY(item != 0);
// Add some values like get() test
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(SRCDIR "/data/model.qml"));
QVERIFY2(component.errorString().isEmpty(), component.errorString().toUtf8());
- QSGItem *item = createWorkerTest(&engine, &component, &model);
+ QQuickItem *item = createWorkerTest(&engine, &component, &model);
QVERIFY(item != 0);
QDeclarativeExpression expr(engine.rootContext(), &model, script_setup);
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativepropertymap.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <private/qsgtext_p.h>
+#include <private/qquicktext_p.h>
#include <QSignalSpy>
class tst_QDeclarativePropertyMap : public QObject
component.setData("import QtQuick 2.0\nText { text: { testdata.key1 = 'Hello World'; 'X' } }",
QUrl::fromLocalFile(""));
QVERIFY(component.isReady());
- QSGText *txt = qobject_cast<QSGText*>(component.create());
+ QQuickText *txt = qobject_cast<QQuickText*>(component.create());
QVERIFY(txt);
QCOMPARE(txt->text(), QString('X'));
QCOMPARE(spy.count(), 1);
#include <QDir>
#include <QVector3D>
#include <QCryptographicHash>
-#include <QSGItem>
+#include <QQuickItem>
#include <QSignalSpy>
#include "../shared/util.h"
QCOMPARE(object->property("emptyArg").toBool(), true);
QCOMPARE(object->property("success").toBool(), true);
- QSGItem *item = qobject_cast<QSGItem *>(object);
+ QQuickItem *item = qobject_cast<QQuickItem *>(object);
QVERIFY(item != 0);
QVERIFY(item->childItems().count() == 1);
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <private/qdeclarativesmoothedanimation_p.h>
-#include <private/qsgrectangle_p.h>
+#include <private/qquickrectangle_p.h>
#include <private/qdeclarativevaluetype_p.h>
#include "../shared/util.h"
void tst_qdeclarativesmoothedanimation::simpleAnimation()
{
- QSGRectangle rect;
+ QQuickRectangle rect;
QDeclarativeSmoothedAnimation animation;
animation.setTarget(&rect);
animation.setProperty("x");
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("smoothedanimationValueSource.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *theRect = rect->findChild<QSGRectangle*>("theRect");
+ QQuickRectangle *theRect = rect->findChild<QQuickRectangle*>("theRect");
QVERIFY(theRect);
QDeclarativeSmoothedAnimation *easeX = rect->findChild<QDeclarativeSmoothedAnimation*>("easeX");
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("smoothedanimationBehavior.qml")));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect);
- QSGRectangle *theRect = rect->findChild<QSGRectangle*>("theRect");
+ QQuickRectangle *theRect = rect->findChild<QQuickRectangle*>("theRect");
QVERIFY(theRect);
QDeclarativeSmoothedAnimation *easeX = rect->findChild<QDeclarativeSmoothedAnimation*>("easeX");
#include <qtest.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <private/qsgtext_p.h>
+#include <private/qquicktext_p.h>
#include <private/qdeclarativeengine_p.h>
#include <QtCore/qcryptographichash.h>
/*
QDeclarativeComponent component(engine);
component.setData(qml.toUtf8(), QUrl::fromLocalFile(TESTDATA("empty.qml"))); // just a file for relative local imports
QVERIFY(!component.isError());
- QSGText *text = qobject_cast<QSGText*>(component.create());
+ QQuickText *text = qobject_cast<QQuickText*>(component.create());
QVERIFY(text != 0);
QCOMPARE(text->text(),QString("passed"));
}
#include <qtest.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgstateoperations_p.h>
-#include <private/qsganchors_p_p.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgimage_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickstateoperations_p.h>
+#include <private/qquickanchors_p_p.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquickimage_p.h>
#include <private/qdeclarativepropertychanges_p.h>
#include <private/qdeclarativestategroup_p.h>
-#include <private/qsgitem_p.h>
+#include <private/qquickitem_p.h>
#include <private/qdeclarativeproperty_p.h>
#include "../shared/util.h"
int m_foo;
};
-class MyRect : public QSGRectangle
+class MyRect : public QQuickRectangle
{
Q_OBJECT
Q_PROPERTY(int propertyWithNotify READ propertyWithNotify WRITE setPropertyWithNotify NOTIFY oddlyNamedNotifySignal)
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicChanges.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicChanges2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicChanges3.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
QDeclarativeComponent component(&engine, TESTDATA("attachedPropertyChanges.qml"));
QVERIFY(component.isReady());
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item != 0);
QCOMPARE(item->width(), 50.0);
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicExtension.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("fakeExtension.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicBinding.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicBinding2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicBinding3.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicBinding4.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
rect->doSomething();
QCOMPARE(rect->color(),QColor("blue"));
- QSGItemPrivate::get(rect)->setState("green");
+ QQuickItemPrivate::get(rect)->setState("green");
rect->doSomething();
QCOMPARE(rect->color(),QColor("green"));
}
rect->doSomething();
QCOMPARE(rect->color(),QColor("blue"));
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("extendedRect"));
- QSGItemPrivate::get(innerRect)->setState("green");
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("extendedRect"));
+ QQuickItemPrivate::get(innerRect)->setState("green");
rect->doSomething();
QCOMPARE(rect->color(),QColor("blue"));
QCOMPARE(innerRect->color(),QColor("green"));
MyRect *rect = qobject_cast<MyRect*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate::get(rect)->setState("overridden");
+ QQuickItemPrivate::get(rect)->setState("overridden");
rect->doSomething();
}
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("signalOverrideCrash2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate::get(rect)->setState("state1");
- QSGItemPrivate::get(rect)->setState("state2");
- QSGItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state2");
+ QQuickItemPrivate::get(rect)->setState("state1");
delete rect;
}
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("parentChange1.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
QDeclarativeListReference list(rect, "states");
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGParentChange *pChange = qobject_cast<QSGParentChange*>(state->operationAt(0));
+ QQuickParentChange *pChange = qobject_cast<QQuickParentChange*>(state->operationAt(0));
QVERIFY(pChange != 0);
- QSGItem *nParent = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("NewParent"));
+ QQuickItem *nParent = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("NewParent"));
QVERIFY(nParent != 0);
QCOMPARE(pChange->parent(), nParent);
- QSGItemPrivate::get(rect)->setState("reparented");
+ QQuickItemPrivate::get(rect)->setState("reparented");
QCOMPARE(innerRect->rotation(), qreal(0));
QCOMPARE(innerRect->scale(), qreal(1));
QCOMPARE(innerRect->x(), qreal(-133));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("parentChange2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
rectPrivate->setState("reparented");
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("parentChange3.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
rectPrivate->setState("reparented");
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("parentChange6.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
- QSGItemPrivate::get(rect)->setState("reparented");
+ QQuickItemPrivate::get(rect)->setState("reparented");
QCOMPARE(innerRect->rotation(), qreal(180));
QCOMPARE(innerRect->scale(), qreal(1));
QCOMPARE(innerRect->x(), qreal(-105));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("parentChange4.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
QTest::ignoreMessage(QtWarningMsg, fullDataPath("parentChange4.qml") + ":25:9: QML ParentChange: Unable to preserve appearance under non-uniform scale");
- QSGItemPrivate::get(rect)->setState("reparented");
+ QQuickItemPrivate::get(rect)->setState("reparented");
QCOMPARE(innerRect->rotation(), qreal(0));
QCOMPARE(innerRect->scale(), qreal(1));
QCOMPARE(innerRect->x(), qreal(5));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("parentChange5.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
QTest::ignoreMessage(QtWarningMsg, fullDataPath("parentChange5.qml") + ":25:9: QML ParentChange: Unable to preserve appearance under complex transform");
- QSGItemPrivate::get(rect)->setState("reparented");
+ QQuickItemPrivate::get(rect)->setState("reparented");
QCOMPARE(innerRect->rotation(), qreal(0));
QCOMPARE(innerRect->scale(), qreal(1));
QCOMPARE(innerRect->x(), qreal(5));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges1.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
QDeclarativeListReference list(rect, "states");
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGAnchorChanges *aChanges = qobject_cast<QSGAnchorChanges*>(state->operationAt(0));
+ QQuickAnchorChanges *aChanges = qobject_cast<QQuickAnchorChanges*>(state->operationAt(0));
QVERIFY(aChanges != 0);
rectPrivate->setState("right");
QCOMPARE(innerRect->x(), qreal(150));
- QCOMPARE(aChanges->object(), qobject_cast<QSGItem*>(innerRect));
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QSGAnchorLine::Invalid); //### was reset (how do we distinguish from not set at all)
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
+ QCOMPARE(aChanges->object(), qobject_cast<QQuickItem*>(innerRect));
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QQuickAnchorLine::Invalid); //### was reset (how do we distinguish from not set at all)
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
rectPrivate->setState("");
QCOMPARE(innerRect->x(), qreal(5));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
rectPrivate->setState("right");
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges3.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
- QSGItem *leftGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("LeftGuideline"));
+ QQuickItem *leftGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("LeftGuideline"));
QVERIFY(leftGuideline != 0);
- QSGItem *bottomGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("BottomGuideline"));
+ QQuickItem *bottomGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("BottomGuideline"));
QVERIFY(bottomGuideline != 0);
QDeclarativeListReference list(rect, "states");
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGAnchorChanges *aChanges = qobject_cast<QSGAnchorChanges*>(state->operationAt(0));
+ QQuickAnchorChanges *aChanges = qobject_cast<QQuickAnchorChanges*>(state->operationAt(0));
QVERIFY(aChanges != 0);
rectPrivate->setState("reanchored");
- QCOMPARE(aChanges->object(), qobject_cast<QSGItem*>(innerRect));
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->left().item, QSGItemPrivate::get(leftGuideline)->left().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QSGItemPrivate::get(leftGuideline)->left().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->top().item, rectPrivate->top().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->top().anchorLine, rectPrivate->top().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->bottom().item, QSGItemPrivate::get(bottomGuideline)->bottom().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->bottom().anchorLine, QSGItemPrivate::get(bottomGuideline)->bottom().anchorLine);
+ QCOMPARE(aChanges->object(), qobject_cast<QQuickItem*>(innerRect));
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->left().item, QQuickItemPrivate::get(leftGuideline)->left().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QQuickItemPrivate::get(leftGuideline)->left().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->top().item, rectPrivate->top().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->top().anchorLine, rectPrivate->top().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->bottom().item, QQuickItemPrivate::get(bottomGuideline)->bottom().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->bottom().anchorLine, QQuickItemPrivate::get(bottomGuideline)->bottom().anchorLine);
QCOMPARE(innerRect->x(), qreal(10));
QCOMPARE(innerRect->y(), qreal(0));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges4.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
- QSGItem *leftGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("LeftGuideline"));
+ QQuickItem *leftGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("LeftGuideline"));
QVERIFY(leftGuideline != 0);
- QSGItem *bottomGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("BottomGuideline"));
+ QQuickItem *bottomGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("BottomGuideline"));
QVERIFY(bottomGuideline != 0);
QDeclarativeListReference list(rect, "states");
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGAnchorChanges *aChanges = qobject_cast<QSGAnchorChanges*>(state->operationAt(0));
+ QQuickAnchorChanges *aChanges = qobject_cast<QQuickAnchorChanges*>(state->operationAt(0));
QVERIFY(aChanges != 0);
- QSGItemPrivate::get(rect)->setState("reanchored");
- QCOMPARE(aChanges->object(), qobject_cast<QSGItem*>(innerRect));
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->horizontalCenter().item, QSGItemPrivate::get(bottomGuideline)->horizontalCenter().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->horizontalCenter().anchorLine, QSGItemPrivate::get(bottomGuideline)->horizontalCenter().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->verticalCenter().item, QSGItemPrivate::get(leftGuideline)->verticalCenter().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->verticalCenter().anchorLine, QSGItemPrivate::get(leftGuideline)->verticalCenter().anchorLine);
+ QQuickItemPrivate::get(rect)->setState("reanchored");
+ QCOMPARE(aChanges->object(), qobject_cast<QQuickItem*>(innerRect));
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->horizontalCenter().item, QQuickItemPrivate::get(bottomGuideline)->horizontalCenter().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->horizontalCenter().anchorLine, QQuickItemPrivate::get(bottomGuideline)->horizontalCenter().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->verticalCenter().item, QQuickItemPrivate::get(leftGuideline)->verticalCenter().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->verticalCenter().anchorLine, QQuickItemPrivate::get(leftGuideline)->verticalCenter().anchorLine);
delete rect;
}
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges5.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
- QSGItem *leftGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("LeftGuideline"));
+ QQuickItem *leftGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("LeftGuideline"));
QVERIFY(leftGuideline != 0);
- QSGItem *bottomGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("BottomGuideline"));
+ QQuickItem *bottomGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("BottomGuideline"));
QVERIFY(bottomGuideline != 0);
QDeclarativeListReference list(rect, "states");
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGAnchorChanges *aChanges = qobject_cast<QSGAnchorChanges*>(state->operationAt(0));
+ QQuickAnchorChanges *aChanges = qobject_cast<QQuickAnchorChanges*>(state->operationAt(0));
QVERIFY(aChanges != 0);
- QSGItemPrivate::get(rect)->setState("reanchored");
- QCOMPARE(aChanges->object(), qobject_cast<QSGItem*>(innerRect));
+ QQuickItemPrivate::get(rect)->setState("reanchored");
+ QCOMPARE(aChanges->object(), qobject_cast<QQuickItem*>(innerRect));
//QCOMPARE(aChanges->anchors()->horizontalCenter().item, bottomGuideline->horizontalCenter().item);
//QCOMPARE(aChanges->anchors()->horizontalCenter().anchorLine, bottomGuideline->horizontalCenter().anchorLine);
//QCOMPARE(aChanges->anchors()->baseline().item, leftGuideline->baseline().item);
delete rect;
}
-void mirrorAnchors(QSGItem *item) {
- QSGItemPrivate *itemPrivate = QSGItemPrivate::get(item);
+void mirrorAnchors(QQuickItem *item) {
+ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
itemPrivate->setLayoutMirror(true);
}
-qreal offsetRTL(QSGItem *anchorItem, QSGItem *item) {
+qreal offsetRTL(QQuickItem *anchorItem, QQuickItem *item) {
return anchorItem->width()+2*anchorItem->x()-item->width();
}
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges1.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
mirrorAnchors(innerRect);
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGAnchorChanges *aChanges = qobject_cast<QSGAnchorChanges*>(state->operationAt(0));
+ QQuickAnchorChanges *aChanges = qobject_cast<QQuickAnchorChanges*>(state->operationAt(0));
QVERIFY(aChanges != 0);
rectPrivate->setState("right");
QCOMPARE(innerRect->x(), offsetRTL(rect, innerRect) - qreal(150));
- QCOMPARE(aChanges->object(), qobject_cast<QSGItem*>(innerRect));
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QSGAnchorLine::Invalid); //### was reset (how do we distinguish from not set at all)
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
+ QCOMPARE(aChanges->object(), qobject_cast<QQuickItem*>(innerRect));
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QQuickAnchorLine::Invalid); //### was reset (how do we distinguish from not set at all)
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
rectPrivate->setState("");
QCOMPARE(innerRect->x(), offsetRTL(rect, innerRect) -qreal(5));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
mirrorAnchors(innerRect);
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChanges3.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
- QSGRectangle *innerRect = qobject_cast<QSGRectangle*>(rect->findChild<QSGRectangle*>("MyRect"));
+ QQuickRectangle *innerRect = qobject_cast<QQuickRectangle*>(rect->findChild<QQuickRectangle*>("MyRect"));
QVERIFY(innerRect != 0);
mirrorAnchors(innerRect);
- QSGItem *leftGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("LeftGuideline"));
+ QQuickItem *leftGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("LeftGuideline"));
QVERIFY(leftGuideline != 0);
- QSGItem *bottomGuideline = qobject_cast<QSGItem*>(rect->findChild<QSGItem*>("BottomGuideline"));
+ QQuickItem *bottomGuideline = qobject_cast<QQuickItem*>(rect->findChild<QQuickItem*>("BottomGuideline"));
QVERIFY(bottomGuideline != 0);
QDeclarativeListReference list(rect, "states");
QVERIFY(state != 0);
qmlExecuteDeferred(state);
- QSGAnchorChanges *aChanges = qobject_cast<QSGAnchorChanges*>(state->operationAt(0));
+ QQuickAnchorChanges *aChanges = qobject_cast<QQuickAnchorChanges*>(state->operationAt(0));
QVERIFY(aChanges != 0);
rectPrivate->setState("reanchored");
- QCOMPARE(aChanges->object(), qobject_cast<QSGItem*>(innerRect));
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->left().item, QSGItemPrivate::get(leftGuideline)->left().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QSGItemPrivate::get(leftGuideline)->left().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->top().item, rectPrivate->top().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->top().anchorLine, rectPrivate->top().anchorLine);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->bottom().item, QSGItemPrivate::get(bottomGuideline)->bottom().item);
- QCOMPARE(QSGItemPrivate::get(aChanges->object())->anchors()->bottom().anchorLine, QSGItemPrivate::get(bottomGuideline)->bottom().anchorLine);
+ QCOMPARE(aChanges->object(), qobject_cast<QQuickItem*>(innerRect));
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->left().item, QQuickItemPrivate::get(leftGuideline)->left().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->left().anchorLine, QQuickItemPrivate::get(leftGuideline)->left().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().item, rectPrivate->right().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->right().anchorLine, rectPrivate->right().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->top().item, rectPrivate->top().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->top().anchorLine, rectPrivate->top().anchorLine);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->bottom().item, QQuickItemPrivate::get(bottomGuideline)->bottom().item);
+ QCOMPARE(QQuickItemPrivate::get(aChanges->object())->anchors()->bottom().anchorLine, QQuickItemPrivate::get(bottomGuideline)->bottom().anchorLine);
QCOMPARE(innerRect->x(), offsetRTL(leftGuideline, innerRect) - qreal(10));
QCOMPARE(innerRect->y(), qreal(0));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorChangesCrash.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate::get(rect)->setState("reanchored");
+ QQuickItemPrivate::get(rect)->setState("reanchored");
delete rect;
}
// QTBUG-12273
void tst_qdeclarativestates::anchorRewindBug()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("anchorRewindBug.qml")));
view->show();
QTest::qWaitForWindowShown(view);
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(view->rootObject());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(view->rootObject());
QVERIFY(rect != 0);
- QSGItem * column = rect->findChild<QSGItem*>("column");
+ QQuickItem * column = rect->findChild<QQuickItem*>("column");
QVERIFY(column != 0);
- QVERIFY(!QSGItemPrivate::get(column)->heightValid);
- QVERIFY(!QSGItemPrivate::get(column)->widthValid);
+ QVERIFY(!QQuickItemPrivate::get(column)->heightValid);
+ QVERIFY(!QQuickItemPrivate::get(column)->widthValid);
QCOMPARE(column->height(), 200.0);
- QSGItemPrivate::get(rect)->setState("reanchored");
+ QQuickItemPrivate::get(rect)->setState("reanchored");
// column height and width should stay implicit
// and column's implicit resizing should still work
- QVERIFY(!QSGItemPrivate::get(column)->heightValid);
- QVERIFY(!QSGItemPrivate::get(column)->widthValid);
+ QVERIFY(!QQuickItemPrivate::get(column)->heightValid);
+ QVERIFY(!QQuickItemPrivate::get(column)->widthValid);
QTRY_COMPARE(column->height(), 100.0);
- QSGItemPrivate::get(rect)->setState("");
+ QQuickItemPrivate::get(rect)->setState("");
// column height and width should stay implicit
// and column's implicit resizing should still work
- QVERIFY(!QSGItemPrivate::get(column)->heightValid);
- QVERIFY(!QSGItemPrivate::get(column)->widthValid);
+ QVERIFY(!QQuickItemPrivate::get(column)->heightValid);
+ QVERIFY(!QQuickItemPrivate::get(column)->widthValid);
QTRY_COMPARE(column->height(), 200.0);
delete view;
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("anchorRewindBug2.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGRectangle *mover = rect->findChild<QSGRectangle*>("mover");
+ QQuickRectangle *mover = rect->findChild<QQuickRectangle*>("mover");
QVERIFY(mover != 0);
QCOMPARE(mover->y(), qreal(0.0));
QCOMPARE(mover->width(), qreal(50.0));
- QSGItemPrivate::get(rect)->setState("anchored");
+ QQuickItemPrivate::get(rect)->setState("anchored");
QCOMPARE(mover->y(), qreal(250.0));
QCOMPARE(mover->width(), qreal(200.0));
- QSGItemPrivate::get(rect)->setState("");
+ QQuickItemPrivate::get(rect)->setState("");
QCOMPARE(mover->y(), qreal(0.0));
QCOMPARE(mover->width(), qreal(50.0));
{
QDeclarativeComponent rectComponent(&engine, TESTDATA("script.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QCOMPARE(rect->color(),QColor("red"));
rectPrivate->setState("blue");
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("restoreEntryValues.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QCOMPARE(rect->color(),QColor("red"));
rectPrivate->setState("blue");
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("explicit.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QDeclarativeListReference list(rect, "states");
QDeclarativeState *state = qobject_cast<QDeclarativeState*>(list.at(0));
QVERIFY(state != 0);
{
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("propertyErrors.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
QCOMPARE(rect->color(),QColor("red"));
QTest::ignoreMessage(QtWarningMsg, fullDataPath("propertyErrors.qml") + ":8:9: QML PropertyChanges: Cannot assign to non-existent property \"colr\"");
QTest::ignoreMessage(QtWarningMsg, fullDataPath("propertyErrors.qml") + ":8:9: QML PropertyChanges: Cannot assign to read-only property \"activeFocus\"");
- QSGItemPrivate::get(rect)->setState("blue");
+ QQuickItemPrivate::get(rect)->setState("blue");
}
void tst_qdeclarativestates::incorrectRestoreBug()
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("basicChanges.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QCOMPARE(rect->color(),QColor("red"));
rectPrivate->setState("blue");
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("deleting.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
rectPrivate->setState("blue");
QCOMPARE(rect->color(),QColor("blue"));
QCOMPARE(rect->radius(),qreal(5));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("deletingState.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
QDeclarativeStateGroup *sg = rect->findChild<QDeclarativeStateGroup*>();
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("legalTempState.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QTest::ignoreMessage(QtDebugMsg, "entering placed");
QTest::ignoreMessage(QtDebugMsg, "entering idle");
rectPrivate->setState("placed");
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("illegalTempState.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QTest::ignoreMessage(QtWarningMsg, "<Unknown File>: QML StateGroup: Can't apply a state change as part of a state definition.");
rectPrivate->setState("placed");
QCOMPARE(rectPrivate->state(), QLatin1String("placed"));
QDeclarativeEngine engine;
QDeclarativeComponent rectComponent(&engine, TESTDATA("nonExistantProp.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(rectComponent.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(rectComponent.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QTest::ignoreMessage(QtWarningMsg, fullDataPath("nonExistantProp.qml") + ":9:9: QML PropertyChanges: Cannot assign to non-existent property \"colr\"");
rectPrivate->setState("blue");
QCOMPARE(rectPrivate->state(), QLatin1String("blue"));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("reset.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGImage *image = rect->findChild<QSGImage*>();
+ QQuickImage *image = rect->findChild<QQuickImage*>();
QVERIFY(image != 0);
QCOMPARE(image->width(), qreal(40.));
QCOMPARE(image->height(), qreal(20.));
- QSGItemPrivate::get(rect)->setState("state1");
+ QQuickItemPrivate::get(rect)->setState("state1");
QCOMPARE(image->width(), 20.0);
QCOMPARE(image->height(), qreal(20.));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("whenOrdering.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QCOMPARE(rectPrivate->state(), QLatin1String(""));
rect->setProperty("condition2", true);
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("urlResolution.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItem *myType = rect->findChild<QSGItem*>("MyType");
- QSGImage *image1 = rect->findChild<QSGImage*>("image1");
- QSGImage *image2 = rect->findChild<QSGImage*>("image2");
- QSGImage *image3 = rect->findChild<QSGImage*>("image3");
+ QQuickItem *myType = rect->findChild<QQuickItem*>("MyType");
+ QQuickImage *image1 = rect->findChild<QQuickImage*>("image1");
+ QQuickImage *image2 = rect->findChild<QQuickImage*>("image2");
+ QQuickImage *image3 = rect->findChild<QQuickImage*>("image3");
QVERIFY(myType != 0 && image1 != 0 && image2 != 0 && image3 != 0);
- QSGItemPrivate::get(myType)->setState("SetImageState");
+ QQuickItemPrivate::get(myType)->setState("SetImageState");
QUrl resolved = QUrl::fromLocalFile(TESTDATA("Implementation/images/qt-logo.png"));
QCOMPARE(image1->source(), resolved);
QCOMPARE(image2->source(), resolved);
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("unnamedWhen.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QCOMPARE(rectPrivate->state(), QLatin1String(""));
QCOMPARE(rect->property("stateString").toString(), QLatin1String(""));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("returnToBase.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QCOMPARE(rectPrivate->state(), QLatin1String(""));
QCOMPARE(rect->property("stateString").toString(), QLatin1String(""));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("extendsBug.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
- QSGRectangle *greenRect = rect->findChild<QSGRectangle*>("greenRect");
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
+ QQuickRectangle *greenRect = rect->findChild<QQuickRectangle*>("greenRect");
rectPrivate->setState("b");
QCOMPARE(greenRect->x(), qreal(100));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("editProperties.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
QDeclarativeStateGroup *stateGroup = rectPrivate->_states();
QVERIFY(stateGroup != 0);
QDeclarativePropertyChanges *propertyChangesGreen = qobject_cast<QDeclarativePropertyChanges*>(greenState->operationAt(0));
QVERIFY(propertyChangesGreen != 0);
- QSGRectangle *childRect = rect->findChild<QSGRectangle*>("rect2");
+ QQuickRectangle *childRect = rect->findChild<QQuickRectangle*>("rect2");
QVERIFY(childRect != 0);
QCOMPARE(childRect->width(), qreal(402));
QVERIFY(QDeclarativePropertyPrivate::binding(QDeclarativeProperty(childRect, "width")));
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, TESTDATA("QTBUG-14830.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItem *item = rect->findChild<QSGItem*>("area");
+ QQuickItem *item = rect->findChild<QQuickItem*>("area");
QCOMPARE(item->width(), qreal(171));
}
//shouldn't fast forward if there isn't a transition
QDeclarativeComponent c(&engine, TESTDATA("avoidFastForward.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(c.create());
QVERIFY(rect != 0);
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
rectPrivate->setState("a");
QCOMPARE(rect->property("updateCount").toInt(), 1);
}
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <private/qdeclarativetimer_p.h>
-#include <QtDeclarative/qsgitem.h>
+#include <QtDeclarative/qquickitem.h>
#include <QDebug>
class tst_qdeclarativetimer : public QObject
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine);
component.setData(QByteArray("import QtQuick 2.0\nItem { Timer { objectName: \"timer\"; running: parent.visible } }"), QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item != 0);
QDeclarativeTimer *timer = item->findChild<QDeclarativeTimer*>("timer");
QVERIFY(timer != 0);
#include <QDir>
#include <QProcess>
#include <QDebug>
-#include <QSGView>
#include <QDeclarativeError>
#include <cstdlib>
excludedDirs << "doc/src/snippets/qtquick1/imports";
// Add invalid files (i.e. files with syntax errors)
- invalidFiles << "tests/auto/declarative/qsgloader/data/InvalidSourceComponent.qml";
+ invalidFiles << "tests/auto/declarative/qquickloader/data/InvalidSourceComponent.qml";
invalidFiles << "tests/auto/declarative/qdeclarativelanguage/data/dynamicObjectProperties.2.qml";
invalidFiles << "tests/auto/declarative/qdeclarativelanguage/data/signal.3.qml";
invalidFiles << "tests/auto/declarative/qdeclarativelanguage/data/property.4.qml";
CONFIG += testcase
-TARGET = tst_qsganimatedimage
+TARGET = tst_qquickanimatedimage
HEADERS += ../shared/testhttpserver.h
-SOURCES += tst_qsganimatedimage.cpp ../shared/testhttpserver.cpp
+SOURCES += tst_qquickanimatedimage.cpp ../shared/testhttpserver.cpp
macx:CONFIG -= app_bundle
testDataFiles.files = data
#include <qtest.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgimage_p.h>
-#include <private/qsganimatedimage_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquickimage_p.h>
+#include <private/qquickanimatedimage_p.h>
#include <QSignalSpy>
#include <QtDeclarative/qdeclarativecontext.h>
#include "../shared/testhttpserver.h"
#include "../shared/util.h"
-class tst_qsganimatedimage : public QObject
+class tst_qquickanimatedimage : public QObject
{
Q_OBJECT
public:
- tst_qsganimatedimage() {}
+ tst_qquickanimatedimage() {}
private slots:
void play();
};
-void tst_qsganimatedimage::play()
+void tst_qquickanimatedimage::play()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("stickman.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QVERIFY(anim->isPlaying());
delete anim;
}
-void tst_qsganimatedimage::pause()
+void tst_qquickanimatedimage::pause()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("stickmanpause.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QVERIFY(anim->isPlaying());
QVERIFY(anim->isPaused());
delete anim;
}
-void tst_qsganimatedimage::stopped()
+void tst_qquickanimatedimage::stopped()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("stickmanstopped.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QVERIFY(!anim->isPlaying());
QCOMPARE(anim->currentFrame(), 0);
delete anim;
}
-void tst_qsganimatedimage::setFrame()
+void tst_qquickanimatedimage::setFrame()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("stickmanpause.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QVERIFY(anim->isPlaying());
QCOMPARE(anim->currentFrame(), 2);
delete anim;
}
-void tst_qsganimatedimage::frameCount()
+void tst_qquickanimatedimage::frameCount()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("colors.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QVERIFY(anim->isPlaying());
QCOMPARE(anim->frameCount(), 3);
delete anim;
}
-void tst_qsganimatedimage::mirror_running()
+void tst_qquickanimatedimage::mirror_running()
{
// test where mirror is set to true after animation has started
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->show();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("hearts.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(canvas->rootObject());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(canvas->rootObject());
QVERIFY(anim);
int width = anim->property("width").toInt();
delete canvas;
}
-void tst_qsganimatedimage::mirror_notRunning()
+void tst_qquickanimatedimage::mirror_notRunning()
{
QFETCH(QUrl, fileUrl);
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->show();
canvas->setSource(fileUrl);
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(canvas->rootObject());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(canvas->rootObject());
QVERIFY(anim);
int width = anim->property("width").toInt();
delete canvas;
}
-void tst_qsganimatedimage::mirror_notRunning_data()
+void tst_qquickanimatedimage::mirror_notRunning_data()
{
QTest::addColumn<QUrl>("fileUrl");
QTest::newRow("stopped") << QUrl::fromLocalFile(TESTDATA("stickmanstopped.qml"));
}
-void tst_qsganimatedimage::remote()
+void tst_qquickanimatedimage::remote()
{
QFETCH(QString, fileName);
QFETCH(bool, paused);
QDeclarativeComponent component(&engine, QUrl("http://127.0.0.1:14449/" + fileName));
QTRY_VERIFY(component.isReady());
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QTRY_VERIFY(anim->isPlaying());
QTRY_VERIFY(anim->isPaused());
QCOMPARE(anim->currentFrame(), 2);
}
- QVERIFY(anim->status() != QSGAnimatedImage::Error);
+ QVERIFY(anim->status() != QQuickAnimatedImage::Error);
delete anim;
}
-void tst_qsganimatedimage::sourceSize()
+void tst_qquickanimatedimage::sourceSize()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("stickmanscaled.qml")));
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QCOMPARE(anim->width(),240.0);
QCOMPARE(anim->height(),180.0);
delete anim;
}
-void tst_qsganimatedimage::sourceSizeReadOnly()
+void tst_qquickanimatedimage::sourceSizeReadOnly()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("stickmanerror1.qml")));
QCOMPARE(component.errors().at(0).description(), QString("Invalid property assignment: \"sourceSize\" is a read-only property"));
}
-void tst_qsganimatedimage::remote_data()
+void tst_qquickanimatedimage::remote_data()
{
QTest::addColumn<QString>("fileName");
QTest::addColumn<bool>("paused");
QTest::newRow("paused") << "stickmanpause.qml" << true;
}
-void tst_qsganimatedimage::invalidSource()
+void tst_qquickanimatedimage::invalidSource()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine);
QTest::ignoreMessage(QtWarningMsg, "file::2:2: QML AnimatedImage: Error Reading Animated Image File file:no-such-file.gif");
- QSGAnimatedImage *anim = qobject_cast<QSGAnimatedImage *>(component.create());
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(component.create());
QVERIFY(anim);
QVERIFY(!anim->isPlaying());
QTRY_VERIFY(anim->status() == 3);
}
-void tst_qsganimatedimage::qtbug_16520()
+void tst_qquickanimatedimage::qtbug_16520()
{
TestHTTPServer server(14449);
QVERIFY(server.isValid());
QDeclarativeComponent component(&engine, QUrl::fromLocalFile(TESTDATA("qtbug-16520.qml")));
QTRY_VERIFY(component.isReady());
- QSGRectangle *root = qobject_cast<QSGRectangle *>(component.create());
+ QQuickRectangle *root = qobject_cast<QQuickRectangle *>(component.create());
QVERIFY(root);
- QSGAnimatedImage *anim = root->findChild<QSGAnimatedImage*>("anim");
+ QQuickAnimatedImage *anim = root->findChild<QQuickAnimatedImage*>("anim");
anim->setProperty("source", "http://127.0.0.1:14449/stickman.gif");
delete anim;
}
-void tst_qsganimatedimage::progressAndStatusChanges()
+void tst_qquickanimatedimage::progressAndStatusChanges()
{
TestHTTPServer server(14449);
QVERIFY(server.isValid());
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("stickman.gif")));
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
- QVERIFY(obj->status() == QSGImage::Ready);
+ QVERIFY(obj->status() == QQuickImage::Ready);
QTRY_VERIFY(obj->progress() == 1.0);
QSignalSpy sourceSpy(obj, SIGNAL(sourceChanged(const QUrl &)));
QSignalSpy progressSpy(obj, SIGNAL(progressChanged(qreal)));
- QSignalSpy statusSpy(obj, SIGNAL(statusChanged(QSGImageBase::Status)));
+ QSignalSpy statusSpy(obj, SIGNAL(statusChanged(QQuickImageBase::Status)));
// Loading local file
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("colors.gif")));
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QTRY_VERIFY(obj->progress() == 1.0);
QTRY_COMPARE(sourceSpy.count(), 1);
QTRY_COMPARE(progressSpy.count(), 0);
// Loading remote file
ctxt->setContextProperty("srcImage", "http://127.0.0.1:14449/stickman.gif");
- QTRY_VERIFY(obj->status() == QSGImage::Loading);
+ QTRY_VERIFY(obj->status() == QQuickImage::Loading);
QTRY_VERIFY(obj->progress() == 0.0);
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QTRY_VERIFY(obj->progress() == 1.0);
QTRY_COMPARE(sourceSpy.count(), 2);
QTRY_VERIFY(progressSpy.count() > 1);
QTRY_COMPARE(statusSpy.count(), 2);
ctxt->setContextProperty("srcImage", "");
- QTRY_VERIFY(obj->status() == QSGImage::Null);
+ QTRY_VERIFY(obj->status() == QQuickImage::Null);
QTRY_VERIFY(obj->progress() == 0.0);
QTRY_COMPARE(sourceSpy.count(), 3);
QTRY_VERIFY(progressSpy.count() > 2);
QTRY_COMPARE(statusSpy.count(), 3);
}
-QTEST_MAIN(tst_qsganimatedimage)
+QTEST_MAIN(tst_qquickanimatedimage)
-#include "tst_qsganimatedimage.moc"
+#include "tst_qquickanimatedimage.moc"
CONFIG += testcase
-TARGET = tst_qsgborderimage
+TARGET = tst_qquickborderimage
macx:CONFIG -= app_bundle
HEADERS += ../shared/testhttpserver.h
-SOURCES += tst_qsgborderimage.cpp ../shared/testhttpserver.cpp
+SOURCES += tst_qquickborderimage.cpp ../shared/testhttpserver.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <private/qsgborderimage_p.h>
-#include <private/qsgimagebase_p.h>
-#include <private/qsgscalegrid_p_p.h>
-#include <private/qsgloader_p.h>
-#include <QtDeclarative/qsgview.h>
+#include <private/qquickborderimage_p.h>
+#include <private/qquickimagebase_p.h>
+#include <private/qquickscalegrid_p_p.h>
+#include <private/qquickloader_p.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include "../shared/testhttpserver.h"
#define SERVER_PORT 14446
#define SERVER_ADDR "http://127.0.0.1:14446"
-class tst_qsgborderimage : public QObject
+class tst_qquickborderimage : public QObject
{
Q_OBJECT
public:
- tst_qsgborderimage();
+ tst_qquickborderimage();
private slots:
void noSource();
QDeclarativeEngine engine;
};
-tst_qsgborderimage::tst_qsgborderimage()
+tst_qquickborderimage::tst_qquickborderimage()
{
}
-void tst_qsgborderimage::noSource()
+void tst_qquickborderimage::noSource()
{
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->source(), QUrl());
QCOMPARE(obj->width(), 0.);
QCOMPARE(obj->height(), 0.);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Stretch);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Stretch);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Stretch);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Stretch);
delete obj;
}
-void tst_qsgborderimage::imageSource_data()
+void tst_qquickborderimage::imageSource_data()
{
QTest::addColumn<QString>("source");
QTest::addColumn<bool>("remote");
<< "file::2:1: QML BorderImage: Error downloading " SERVER_ADDR "/no-such-file.png - server replied: Not found";
}
-void tst_qsgborderimage::imageSource()
+void tst_qquickborderimage::imageSource()
{
QFETCH(QString, source);
QFETCH(bool, remote);
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + source + "\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
if (remote)
- QTRY_VERIFY(obj->status() == QSGBorderImage::Loading);
+ QTRY_VERIFY(obj->status() == QQuickBorderImage::Loading);
QCOMPARE(obj->source(), remote ? source : QUrl(source));
if (error.isEmpty()) {
- QTRY_VERIFY(obj->status() == QSGBorderImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickBorderImage::Ready);
QCOMPARE(obj->width(), 120.);
QCOMPARE(obj->height(), 120.);
QCOMPARE(obj->sourceSize().width(), 120);
QCOMPARE(obj->sourceSize().height(), 120);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Stretch);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Stretch);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Stretch);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Stretch);
} else {
- QTRY_VERIFY(obj->status() == QSGBorderImage::Error);
+ QTRY_VERIFY(obj->status() == QQuickBorderImage::Error);
}
delete obj;
delete server;
}
-void tst_qsgborderimage::clearSource()
+void tst_qquickborderimage::clearSource()
{
QString componentStr = "import QtQuick 2.0\nBorderImage { source: srcImage }";
QDeclarativeContext *ctxt = engine.rootContext();
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("colors.png")));
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
- QVERIFY(obj->status() == QSGBorderImage::Ready);
+ QVERIFY(obj->status() == QQuickBorderImage::Ready);
QCOMPARE(obj->width(), 120.);
QCOMPARE(obj->height(), 120.);
ctxt->setContextProperty("srcImage", "");
QVERIFY(obj->source().isEmpty());
- QVERIFY(obj->status() == QSGBorderImage::Null);
+ QVERIFY(obj->status() == QQuickBorderImage::Null);
QCOMPARE(obj->width(), 0.);
QCOMPARE(obj->height(), 0.);
}
-void tst_qsgborderimage::resized()
+void tst_qquickborderimage::resized()
{
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + QUrl::fromLocalFile(TESTDATA("colors.png")).toString() + "\"; width: 300; height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 300.);
QCOMPARE(obj->sourceSize().width(), 120);
QCOMPARE(obj->sourceSize().height(), 120);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Stretch);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Stretch);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Stretch);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Stretch);
delete obj;
}
-void tst_qsgborderimage::smooth()
+void tst_qquickborderimage::smooth()
{
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + TESTDATA("colors.png") + "\"; smooth: true; width: 300; height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 300.);
QCOMPARE(obj->smooth(), true);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Stretch);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Stretch);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Stretch);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Stretch);
delete obj;
}
-void tst_qsgborderimage::mirror()
+void tst_qquickborderimage::mirror()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->show();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("mirror.qml")));
- QSGBorderImage *image = qobject_cast<QSGBorderImage*>(canvas->rootObject());
+ QQuickBorderImage *image = qobject_cast<QQuickBorderImage*>(canvas->rootObject());
QVERIFY(image != 0);
canvas->show();
delete canvas;
}
-void tst_qsgborderimage::tileModes()
+void tst_qquickborderimage::tileModes()
{
{
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + TESTDATA("colors.png") + "\"; width: 100; height: 300; horizontalTileMode: BorderImage.Repeat; verticalTileMode: BorderImage.Repeat }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 100.);
QCOMPARE(obj->height(), 300.);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Repeat);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Repeat);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Repeat);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Repeat);
delete obj;
}
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + TESTDATA("colors.png") + "\"; width: 300; height: 150; horizontalTileMode: BorderImage.Round; verticalTileMode: BorderImage.Round }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 150.);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Round);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Round);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Round);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Round);
delete obj;
}
}
-void tst_qsgborderimage::sciSource()
+void tst_qquickborderimage::sciSource()
{
QFETCH(QString, source);
QFETCH(bool, valid);
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + source + "\"; width: 300; height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
if (remote)
- QTRY_VERIFY(obj->status() == QSGBorderImage::Loading);
+ QTRY_VERIFY(obj->status() == QQuickBorderImage::Loading);
QCOMPARE(obj->source(), remote ? source : QUrl(source));
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 300.);
if (valid) {
- QTRY_VERIFY(obj->status() == QSGBorderImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickBorderImage::Ready);
QCOMPARE(obj->border()->left(), 10);
QCOMPARE(obj->border()->top(), 20);
QCOMPARE(obj->border()->right(), 30);
QCOMPARE(obj->border()->bottom(), 40);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Round);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Repeat);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Round);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Repeat);
} else {
- QTRY_VERIFY(obj->status() == QSGBorderImage::Error);
+ QTRY_VERIFY(obj->status() == QQuickBorderImage::Error);
}
delete obj;
delete server;
}
-void tst_qsgborderimage::sciSource_data()
+void tst_qquickborderimage::sciSource_data()
{
QTest::addColumn<QString>("source");
QTest::addColumn<bool>("valid");
QTest::newRow("remote not found") << SERVER_ADDR "/no-such-file.sci" << false;
}
-void tst_qsgborderimage::invalidSciFile()
+void tst_qquickborderimage::invalidSciFile()
{
- QTest::ignoreMessage(QtWarningMsg, "QSGGridScaledImage: Invalid tile rule specified. Using Stretch."); // for "Roun"
- QTest::ignoreMessage(QtWarningMsg, "QSGGridScaledImage: Invalid tile rule specified. Using Stretch."); // for "Repea"
+ QTest::ignoreMessage(QtWarningMsg, "QQuickGridScaledImage: Invalid tile rule specified. Using Stretch."); // for "Roun"
+ QTest::ignoreMessage(QtWarningMsg, "QQuickGridScaledImage: Invalid tile rule specified. Using Stretch."); // for "Repea"
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + QUrl::fromLocalFile(TESTDATA("invalid.sci")).toString() +"\"; width: 300; height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 300.);
- QCOMPARE(obj->status(), QSGImageBase::Error);
- QCOMPARE(obj->horizontalTileMode(), QSGBorderImage::Stretch);
- QCOMPARE(obj->verticalTileMode(), QSGBorderImage::Stretch);
+ QCOMPARE(obj->status(), QQuickImageBase::Error);
+ QCOMPARE(obj->horizontalTileMode(), QQuickBorderImage::Stretch);
+ QCOMPARE(obj->verticalTileMode(), QQuickBorderImage::Stretch);
delete obj;
}
-void tst_qsgborderimage::pendingRemoteRequest()
+void tst_qquickborderimage::pendingRemoteRequest()
{
QFETCH(QString, source);
QString componentStr = "import QtQuick 2.0\nBorderImage { source: \"" + source + "\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGBorderImage *obj = qobject_cast<QSGBorderImage*>(component.create());
+ QQuickBorderImage *obj = qobject_cast<QQuickBorderImage*>(component.create());
QVERIFY(obj != 0);
- QCOMPARE(obj->status(), QSGBorderImage::Loading);
+ QCOMPARE(obj->status(), QQuickBorderImage::Loading);
// verify no crash
// This will cause a delayed "QThread: Destroyed while thread is still running" warning
QTest::qWait(50);
}
-void tst_qsgborderimage::pendingRemoteRequest_data()
+void tst_qquickborderimage::pendingRemoteRequest_data()
{
QTest::addColumn<QString>("source");
QTest::newRow("sci file") << "http://localhost/none.sci";
}
-QTEST_MAIN(tst_qsgborderimage)
+QTEST_MAIN(tst_qquickborderimage)
-#include "tst_qsgborderimage.moc"
+#include "tst_qquickborderimage.moc"
CONFIG += testcase
-TARGET = tst_qsgcanvas
-SOURCES += tst_qsgcanvas.cpp
+TARGET = tst_qquickcanvas
+SOURCES += tst_qquickcanvas.cpp
macx:CONFIG -= app_bundle
#include <qtest.h>
#include <QDebug>
#include <QTouchEvent>
-#include <QtDeclarative/QSGItem>
-#include <QtDeclarative/QSGCanvas>
-#include <QtDeclarative/private/qsgrectangle_p.h>
+#include <QtDeclarative/QQuickItem>
+#include <QtDeclarative/QQuickCanvas>
+#include <QtDeclarative/private/qquickrectangle_p.h>
#include <QtGui/QWindowSystemInterface>
struct TouchEventData {
QList<QTouchEvent::TouchPoint> touchPoints;
};
-static QTouchEvent::TouchPoint makeTouchPoint(QSGItem *item, const QPointF &p, const QPointF &lastPoint = QPointF())
+static QTouchEvent::TouchPoint makeTouchPoint(QQuickItem *item, const QPointF &p, const QPointF &lastPoint = QPointF())
{
QPointF last = lastPoint.isNull() ? p : lastPoint;
} \
}
-class TestTouchItem : public QSGRectangle
+class TestTouchItem : public QQuickRectangle
{
Q_OBJECT
public:
- TestTouchItem(QSGItem *parent = 0)
- : QSGRectangle(parent), acceptEvents(true), mousePressId(0)
+ TestTouchItem(QQuickItem *parent = 0)
+ : QQuickRectangle(parent), acceptEvents(true), mousePressId(0)
{
border()->setWidth(1);
setAcceptedMouseButtons(Qt::LeftButton);
mousePressId = ++mousePressNum;
}
- bool childMouseEventFilter(QSGItem *, QEvent *) {
+ bool childMouseEventFilter(QQuickItem *, QEvent *) {
mousePressId = ++mousePressNum;
return false;
}
int TestTouchItem::mousePressNum = 0;
-class ConstantUpdateItem : public QSGItem
+class ConstantUpdateItem : public QQuickItem
{
Q_OBJECT
public:
- ConstantUpdateItem(QSGItem *parent = 0) : QSGItem(parent), iterations(0) {setFlag(ItemHasContents);}
+ ConstantUpdateItem(QQuickItem *parent = 0) : QQuickItem(parent), iterations(0) {setFlag(ItemHasContents);}
int iterations;
protected:
}
};
-class tst_qsgcanvas : public QObject
+class tst_qquickcanvas : public QObject
{
Q_OBJECT
public:
- tst_qsgcanvas();
+ tst_qquickcanvas();
private slots:
void initTestCase();
void mouseFiltering();
};
-tst_qsgcanvas::tst_qsgcanvas()
+tst_qquickcanvas::tst_qquickcanvas()
{
}
-void tst_qsgcanvas::initTestCase()
+void tst_qquickcanvas::initTestCase()
{
}
-void tst_qsgcanvas::cleanupTestCase()
+void tst_qquickcanvas::cleanupTestCase()
{
}
//If the item calls update inside updatePaintNode, it should schedule another update
-void tst_qsgcanvas::constantUpdates()
+void tst_qquickcanvas::constantUpdates()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ConstantUpdateItem item(canvas.rootItem());
canvas.show();
QTRY_VERIFY(item.iterations > 60);
}
-void tst_qsgcanvas::touchEvent_basic()
+void tst_qquickcanvas::touchEvent_basic()
{
- QSGCanvas *canvas = new QSGCanvas;
+ QQuickCanvas *canvas = new QQuickCanvas;
canvas->resize(250, 250);
canvas->move(100, 100);
canvas->show();
delete canvas;
}
-void tst_qsgcanvas::touchEvent_propagation()
+void tst_qquickcanvas::touchEvent_propagation()
{
QFETCH(bool, acceptEvents);
QFETCH(bool, enableItem);
QFETCH(qreal, itemOpacity);
- QSGCanvas *canvas = new QSGCanvas;
+ QQuickCanvas *canvas = new QQuickCanvas;
canvas->resize(250, 250);
canvas->move(100, 100);
canvas->show();
delete canvas;
}
-void tst_qsgcanvas::touchEvent_propagation_data()
+void tst_qquickcanvas::touchEvent_propagation_data()
{
QTest::addColumn<bool>("acceptEvents");
QTest::addColumn<bool>("enableItem");
QTest::newRow("opacity of 0") << true << true << 0.0;
}
-void tst_qsgcanvas::clearCanvas()
+void tst_qquickcanvas::clearCanvas()
{
- QSGCanvas *canvas = new QSGCanvas;
- QSGItem *item = new QSGItem;
+ QQuickCanvas *canvas = new QQuickCanvas;
+ QQuickItem *item = new QQuickItem;
item->setParentItem(canvas->rootItem());
QVERIFY(item->canvas() == canvas);
delete item;
}
-void tst_qsgcanvas::mouseFiltering()
+void tst_qquickcanvas::mouseFiltering()
{
- QSGCanvas *canvas = new QSGCanvas;
+ QQuickCanvas *canvas = new QQuickCanvas;
canvas->resize(250, 250);
canvas->move(100, 100);
canvas->show();
}
-QTEST_MAIN(tst_qsgcanvas)
+QTEST_MAIN(tst_qquickcanvas)
-#include "tst_qsgcanvas.moc"
+#include "tst_qquickcanvas.moc"
QT += core-private gui-private declarative-private widgets
TEMPLATE=app
-TARGET=tst_qsgcanvasitem
+TARGET=tst_qquickcanvasitem
CONFIG+=insignificant_test
CONFIG += warn_on qmltestcase
-SOURCES += tst_qsgcanvasitem.cpp
+SOURCES += tst_qquickcanvasitem.cpp
importFiles.files = data
importFiles.path = .
**
****************************************************************************/
#include <QtQuickTest/quicktest.h>
-QUICK_TEST_MAIN(qsgcanvasitem)
+QUICK_TEST_MAIN(qquickcanvasitem)
-TARGET = tst_qsgdrag
+TARGET = tst_qquickdrag
CONFIG += testcase
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgdrag.cpp
+SOURCES += tst_qquickdrag.cpp
CONFIG += parallel_test
#include <QtTest/QtTest>
#include <QtTest/QSignalSpy>
-#include <QtDeclarative/qsgitem.h>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickitem.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativeexpression.h>
Q_DECLARE_METATYPE(Qt::DropActions)
-class TestDropTarget : public QSGItem
+class TestDropTarget : public QQuickItem
{
Q_OBJECT
public:
- TestDropTarget(QSGItem *parent = 0)
- : QSGItem(parent)
+ TestDropTarget(QQuickItem *parent = 0)
+ : QQuickItem(parent)
, enterEvents(0)
, moveEvents(0)
, leaveEvents(0)
bool accept;
};
-class tst_QSGDrag: public QObject
+class tst_QQuickDrag: public QObject
{
Q_OBJECT
private slots:
QDeclarativeEngine engine;
};
-void tst_QSGDrag::initTestCase()
+void tst_QQuickDrag::initTestCase()
{
}
-void tst_QSGDrag::cleanupTestCase()
+void tst_QQuickDrag::cleanupTestCase()
{
}
-void tst_QSGDrag::active()
+void tst_QQuickDrag::active()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
TestDropTarget dropTarget(canvas.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QDeclarativeComponent component(&engine);
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
item->setParentItem(&dropTarget);
QCOMPARE(evaluate<QObject *>(item, "dragTarget"), static_cast<QObject *>(0));
QCOMPARE(dropTarget.enterEvents, 0); QCOMPARE(dropTarget.leaveEvents, 1);
- // Enter events aren't sent to items without the QSGItem::ItemAcceptsDrops flag.
- dropTarget.setFlags(QSGItem::Flags());
+ // Enter events aren't sent to items without the QQuickItem::ItemAcceptsDrops flag.
+ dropTarget.setFlags(QQuickItem::Flags());
dropTarget.reset();
evaluate<void>(item, "Drag.active = true");
QCOMPARE(evaluate<QObject *>(item, "dragTarget"), static_cast<QObject *>(0));
QCOMPARE(dropTarget.enterEvents, 0); QCOMPARE(dropTarget.leaveEvents, 0);
- dropTarget.setFlags(QSGItem::ItemAcceptsDrops);
+ dropTarget.setFlags(QQuickItem::ItemAcceptsDrops);
dropTarget.reset();
evaluate<void>(item, "Drag.active = true");
QCOMPARE(evaluate<QObject *>(item, "dragTarget"), static_cast<QObject *>(&dropTarget));
QCOMPARE(dropTarget.enterEvents, 1); QCOMPARE(dropTarget.leaveEvents, 0);
- dropTarget.setFlags(QSGItem::Flags());
+ dropTarget.setFlags(QQuickItem::Flags());
dropTarget.reset();
evaluate<void>(item, "Drag.active = false");
QCOMPARE(dropTarget.enterEvents, 0); QCOMPARE(dropTarget.leaveEvents, 1);
// Follow up events aren't sent to items if the enter event isn't accepted.
- dropTarget.setFlags(QSGItem::ItemAcceptsDrops);
+ dropTarget.setFlags(QQuickItem::ItemAcceptsDrops);
dropTarget.accept = false;
dropTarget.reset();
QCOMPARE(dropTarget.enterEvents, 0); QCOMPARE(dropTarget.leaveEvents, 0);
}
-void tst_QSGDrag::drop()
+void tst_QQuickDrag::drop()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
TestDropTarget outerTarget(canvas.rootItem());
outerTarget.setSize(QSizeF(100, 100));
outerTarget.acceptAction = Qt::CopyAction;
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
item->setParentItem(&outerTarget);
// Inner target doesn't accept enter so drop goes directly to outer.
innerTarget.accept = true;
- innerTarget.setFlags(QSGItem::Flags());
+ innerTarget.setFlags(QQuickItem::Flags());
innerTarget.reset(); outerTarget.reset();
evaluate<void>(item, "Drag.active = true");
QCOMPARE(innerTarget.enterEvents, 0); QCOMPARE(innerTarget.leaveEvents, 0); QCOMPARE(innerTarget.dropEvents, 0);
}
-void tst_QSGDrag::move()
+void tst_QQuickDrag::move()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
TestDropTarget outerTarget(canvas.rootItem());
outerTarget.setSize(QSizeF(100, 100));
TestDropTarget leftTarget(&outerTarget);
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
item->setParentItem(&outerTarget);
QCOMPARE(rightTarget.enterEvents, 0); QCOMPARE(rightTarget.leaveEvents, 0); QCOMPARE(rightTarget.moveEvents, 0);
QCOMPARE(outerTarget.position.x(), qreal(60)); QCOMPARE(outerTarget.position.y(), qreal(50));
- // Clear the QSGItem::ItemAcceptsDrops flag from the outer target after it accepted an enter event.
- outerTarget.setFlags(QSGItem::Flags());
+ // Clear the QQuickItem::ItemAcceptsDrops flag from the outer target after it accepted an enter event.
+ outerTarget.setFlags(QQuickItem::Flags());
outerTarget.reset(); leftTarget.reset(); rightTarget.reset();
item->setPos(QPointF(40, 50));
QCOMPARE(rightTarget.enterEvents, 0); QCOMPARE(rightTarget.leaveEvents, 0); QCOMPARE(rightTarget.moveEvents, 0);
QCOMPARE(outerTarget.position.x(), qreal(40)); QCOMPARE(outerTarget.position.y(), qreal(50));
- // Clear the QSGItem::ItemAcceptsDrops flag from the left target before it accepts an enter event.
- leftTarget.setFlags(QSGItem::Flags());
+ // Clear the QQuickItem::ItemAcceptsDrops flag from the left target before it accepts an enter event.
+ leftTarget.setFlags(QQuickItem::Flags());
outerTarget.reset(); leftTarget.reset(); rightTarget.reset();
item->setPos(QPointF(25, 50));
}
-void tst_QSGDrag::hotSpot()
+void tst_QQuickDrag::hotSpot()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
TestDropTarget dropTarget(canvas.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QDeclarativeComponent component(&engine);
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
item->setParentItem(&dropTarget);
QCOMPARE(dropTarget.position.y(), qreal(30));
}
-void tst_QSGDrag::supportedActions()
+void tst_QQuickDrag::supportedActions()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
TestDropTarget dropTarget(canvas.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QDeclarativeComponent component(&engine);
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
item->setParentItem(&dropTarget);
QCOMPARE(dropTarget.supportedActions, Qt::MoveAction);
}
-void tst_QSGDrag::proposedAction()
+void tst_QQuickDrag::proposedAction()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
TestDropTarget dropTarget(canvas.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QDeclarativeComponent component(&engine);
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
item->setParentItem(&dropTarget);
QCOMPARE(dropTarget.proposedAction, Qt::LinkAction);
}
-void tst_QSGDrag::keys()
+void tst_QQuickDrag::keys()
{
QDeclarativeComponent component(&engine);
component.setData(
"width: 10; height: 10\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
// QCOMPARE(evaluate<QStringList>(item, "Drag.keys"), QStringList());
QCOMPARE(item->property("keys").toStringList(), QStringList() << "red" << "blue");
}
-void tst_QSGDrag::source()
+void tst_QQuickDrag::source()
{
QDeclarativeComponent component(&engine);
"Item { id: proxySource; objectName: \"proxySource\" }\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *item = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
QCOMPARE(evaluate<QObject *>(item, "Drag.source"), static_cast<QObject *>(item));
QCOMPARE(evaluate<QObject *>(item, "source"), static_cast<QObject *>(item));
- QSGItem *proxySource = item->findChild<QSGItem *>("proxySource");
+ QQuickItem *proxySource = item->findChild<QQuickItem *>("proxySource");
QVERIFY(proxySource);
evaluate<void>(item, "Drag.source = proxySource");
QCOMPARE(evaluate<QObject *>(item, "source"), static_cast<QObject *>(item));
}
-QTEST_MAIN(tst_QSGDrag)
+QTEST_MAIN(tst_QQuickDrag)
-#include "tst_qsgdrag.moc"
+#include "tst_qquickdrag.moc"
-TARGET = tst_qsgdroparea
+TARGET = tst_qquickdroparea
CONFIG += testcase
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgdroparea.cpp
+SOURCES += tst_qquickdroparea.cpp
CONFIG += parallel_test
#include <QtTest/QtTest>
#include <QtTest/QSignalSpy>
-#include <QtDeclarative/qsgitem.h>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickitem.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativeexpression.h>
qWarning() << expr.error().toString();
}
-class tst_QSGDropArea: public QObject
+class tst_QQuickDropArea: public QObject
{
Q_OBJECT
private slots:
QDeclarativeEngine engine;
};
-void tst_QSGDropArea::initTestCase()
+void tst_QQuickDropArea::initTestCase()
{
}
-void tst_QSGDropArea::cleanupTestCase()
+void tst_QQuickDropArea::cleanupTestCase()
{
}
-void tst_QSGDropArea::containsDrag_internal()
+void tst_QQuickDropArea::containsDrag_internal()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"}\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
- QSGItem *dragItem = dropArea->findChild<QSGItem *>("dragItem");
+ QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
evaluate<void>(dragItem, "Drag.active = false");
}
-void tst_QSGDropArea::containsDrag_external()
+void tst_QQuickDropArea::containsDrag_external()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"onExited: {++exitEvents}\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
QMimeData data;
- QSGCanvas alternateCanvas;
+ QQuickCanvas alternateCanvas;
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(150, 50));
}
-void tst_QSGDropArea::keys_internal()
+void tst_QQuickDropArea::keys_internal()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"}\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
- QSGItem *dragItem = dropArea->findChild<QSGItem *>("dragItem");
+ QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "red" << "blue");
}
-void tst_QSGDropArea::keys_external()
+void tst_QQuickDropArea::keys_external()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"onEntered: {++enterEvents; dragKeys = drag.keys }\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
dropArea->setParentItem(canvas.rootItem());
QMimeData data;
- QSGCanvas alternateCanvas;
+ QQuickCanvas alternateCanvas;
data.setData("text/x-red", "red");
data.setData("text/x-blue", "blue");
QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(50, 50));
}
-void tst_QSGDropArea::source_internal()
+void tst_QQuickDropArea::source_internal()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"Item { id: dragSource; objectName: \"dragSource\" }\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
- QSGItem *dragItem = dropArea->findChild<QSGItem *>("dragItem");
+ QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
- QSGItem *dragSource = dropArea->findChild<QSGItem *>("dragSource");
+ QQuickItem *dragSource = dropArea->findChild<QQuickItem *>("dragSource");
QVERIFY(dragSource);
QCOMPARE(evaluate<QObject *>(dropArea, "source"), static_cast<QObject *>(0));
// Setting a source can't be emulated using the QWindowSystemInterface API.
-//void tst_QSGDropArea::source_external()
+//void tst_QQuickDropArea::source_external()
//{
//}
-void tst_QSGDropArea::position_internal()
+void tst_QQuickDropArea::position_internal()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"}\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
- QSGItem *dragItem = dropArea->findChild<QSGItem *>("dragItem");
+ QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
evaluate<void>(dragItem, "Drag.active = true");
evaluate<void>(dragItem, "Drag.active = false");
}
-void tst_QSGDropArea::position_external()
+void tst_QQuickDropArea::position_external()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"onPositionChanged: {++moveEvents; eventX = drag.x; eventY = drag.y}\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
QMimeData data;
QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(75, 25));
}
-void tst_QSGDropArea::drop_internal()
+void tst_QQuickDropArea::drop_internal()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"}\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea);
dropArea->setParentItem(canvas.rootItem());
- QSGItem *dragItem = dropArea->findChild<QSGItem *>("dragItem");
+ QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
evaluate<void>(dragItem, "Drag.active = true");
// Setting the supportedActions can't be emulated using the QWindowSystemInterface API.
-//void tst_QSGDropArea::drop_external()
+//void tst_QQuickDropArea::drop_external()
//{
//}
-void tst_QSGDropArea::simultaneousDrags()
+void tst_QQuickDropArea::simultaneousDrags()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
QDeclarativeComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
- QSGItem *dropArea1 = qobject_cast<QSGItem *>(object.data());
+ QQuickItem *dropArea1 = qobject_cast<QQuickItem *>(object.data());
+ QVERIFY(dropArea1);
dropArea1->setParentItem(canvas.rootItem());
- QSGItem *dropArea2 = dropArea1->findChild<QSGItem *>("dropArea2");
+ QQuickItem *dropArea2 = dropArea1->findChild<QQuickItem *>("dropArea2");
QVERIFY(dropArea2);
- QSGItem *dragItem1 = dropArea1->findChild<QSGItem *>("dragItem1");
+ QQuickItem *dragItem1 = dropArea1->findChild<QQuickItem *>("dragItem1");
QVERIFY(dragItem1);
- QSGItem *dragItem2 = dropArea1->findChild<QSGItem *>("dragItem2");
+ QQuickItem *dragItem2 = dropArea1->findChild<QQuickItem *>("dragItem2");
QVERIFY(dragItem2);
QMimeData data;
data.setData("text/x-red", "red");
data.setData("text/x-blue", "blue");
- QSGCanvas alternateCanvas;
+ QQuickCanvas alternateCanvas;
// Mixed internal drags.
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
QWindowSystemInterface::handleDrop(&alternateCanvas, &data, QPoint(50, 50));
}
-QTEST_MAIN(tst_QSGDropArea)
+QTEST_MAIN(tst_QQuickDropArea)
-#include "tst_qsgdroparea.moc"
+#include "tst_qquickdroparea.moc"
CONFIG += testcase
-TARGET = tst_qsgflickable
+TARGET = tst_qquickflickable
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgflickable.cpp
+SOURCES += tst_qquickflickable.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtTest/QSignalSpy>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgflickable_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickflickable_p.h>
#include <private/qdeclarativevaluetype_p.h>
#include <math.h>
#include "../shared/util.h"
#include <QtOpenGL/QGLShaderProgram>
-class tst_qsgflickable : public QObject
+class tst_qquickflickable : public QObject
{
Q_OBJECT
public:
- tst_qsgflickable();
+ tst_qquickflickable();
private slots:
void initTestCase();
private:
QDeclarativeEngine engine;
- void flick(QSGView *canvas, const QPoint &from, const QPoint &to, int duration);
+ void flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration);
template<typename T>
- T *findItem(QSGItem *parent, const QString &objectName);
+ T *findItem(QQuickItem *parent, const QString &objectName);
};
-tst_qsgflickable::tst_qsgflickable()
+tst_qquickflickable::tst_qquickflickable()
{
}
-void tst_qsgflickable::initTestCase()
+void tst_qquickflickable::initTestCase()
{
}
-void tst_qsgflickable::cleanupTestCase()
+void tst_qquickflickable::cleanupTestCase()
{
}
-void tst_qsgflickable::create()
+void tst_qquickflickable::create()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("flickable01.qml")));
- QSGFlickable *obj = qobject_cast<QSGFlickable*>(c.create());
+ QQuickFlickable *obj = qobject_cast<QQuickFlickable*>(c.create());
QVERIFY(obj != 0);
QCOMPARE(obj->isAtXBeginning(), true);
QCOMPARE(obj->verticalVelocity(), 0.);
QCOMPARE(obj->isInteractive(), true);
- QCOMPARE(obj->boundsBehavior(), QSGFlickable::DragAndOvershootBounds);
+ QCOMPARE(obj->boundsBehavior(), QQuickFlickable::DragAndOvershootBounds);
QCOMPARE(obj->pressDelay(), 0);
QCOMPARE(obj->maximumFlickVelocity(), 2500.);
delete obj;
}
-void tst_qsgflickable::horizontalViewportSize()
+void tst_qquickflickable::horizontalViewportSize()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("flickable02.qml")));
- QSGFlickable *obj = qobject_cast<QSGFlickable*>(c.create());
+ QQuickFlickable *obj = qobject_cast<QQuickFlickable*>(c.create());
QVERIFY(obj != 0);
QCOMPARE(obj->contentWidth(), 800.);
delete obj;
}
-void tst_qsgflickable::verticalViewportSize()
+void tst_qquickflickable::verticalViewportSize()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("flickable03.qml")));
- QSGFlickable *obj = qobject_cast<QSGFlickable*>(c.create());
+ QQuickFlickable *obj = qobject_cast<QQuickFlickable*>(c.create());
QVERIFY(obj != 0);
QCOMPARE(obj->contentWidth(), 200.);
delete obj;
}
-void tst_qsgflickable::properties()
+void tst_qquickflickable::properties()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("flickable04.qml")));
- QSGFlickable *obj = qobject_cast<QSGFlickable*>(c.create());
+ QQuickFlickable *obj = qobject_cast<QQuickFlickable*>(c.create());
QVERIFY(obj != 0);
QCOMPARE(obj->isInteractive(), false);
- QCOMPARE(obj->boundsBehavior(), QSGFlickable::StopAtBounds);
+ QCOMPARE(obj->boundsBehavior(), QQuickFlickable::StopAtBounds);
QCOMPARE(obj->pressDelay(), 200);
QCOMPARE(obj->maximumFlickVelocity(), 2000.);
delete obj;
}
-void tst_qsgflickable::boundsBehavior()
+void tst_qquickflickable::boundsBehavior()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Flickable { boundsBehavior: Flickable.StopAtBounds }", QUrl::fromLocalFile(""));
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(component.create());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(component.create());
QSignalSpy spy(flickable, SIGNAL(boundsBehaviorChanged()));
QVERIFY(flickable);
- QVERIFY(flickable->boundsBehavior() == QSGFlickable::StopAtBounds);
+ QVERIFY(flickable->boundsBehavior() == QQuickFlickable::StopAtBounds);
- flickable->setBoundsBehavior(QSGFlickable::DragAndOvershootBounds);
- QVERIFY(flickable->boundsBehavior() == QSGFlickable::DragAndOvershootBounds);
+ flickable->setBoundsBehavior(QQuickFlickable::DragAndOvershootBounds);
+ QVERIFY(flickable->boundsBehavior() == QQuickFlickable::DragAndOvershootBounds);
QCOMPARE(spy.count(),1);
- flickable->setBoundsBehavior(QSGFlickable::DragAndOvershootBounds);
+ flickable->setBoundsBehavior(QQuickFlickable::DragAndOvershootBounds);
QCOMPARE(spy.count(),1);
- flickable->setBoundsBehavior(QSGFlickable::DragOverBounds);
- QVERIFY(flickable->boundsBehavior() == QSGFlickable::DragOverBounds);
+ flickable->setBoundsBehavior(QQuickFlickable::DragOverBounds);
+ QVERIFY(flickable->boundsBehavior() == QQuickFlickable::DragOverBounds);
QCOMPARE(spy.count(),2);
- flickable->setBoundsBehavior(QSGFlickable::DragOverBounds);
+ flickable->setBoundsBehavior(QQuickFlickable::DragOverBounds);
QCOMPARE(spy.count(),2);
- flickable->setBoundsBehavior(QSGFlickable::StopAtBounds);
- QVERIFY(flickable->boundsBehavior() == QSGFlickable::StopAtBounds);
+ flickable->setBoundsBehavior(QQuickFlickable::StopAtBounds);
+ QVERIFY(flickable->boundsBehavior() == QQuickFlickable::StopAtBounds);
QCOMPARE(spy.count(),3);
- flickable->setBoundsBehavior(QSGFlickable::StopAtBounds);
+ flickable->setBoundsBehavior(QQuickFlickable::StopAtBounds);
QCOMPARE(spy.count(),3);
}
-void tst_qsgflickable::maximumFlickVelocity()
+void tst_qquickflickable::maximumFlickVelocity()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Flickable { maximumFlickVelocity: 1.0; }", QUrl::fromLocalFile(""));
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(component.create());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(component.create());
QSignalSpy spy(flickable, SIGNAL(maximumFlickVelocityChanged()));
QVERIFY(flickable);
QCOMPARE(spy.count(),1);
}
-void tst_qsgflickable::flickDeceleration()
+void tst_qquickflickable::flickDeceleration()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Flickable { flickDeceleration: 1.0; }", QUrl::fromLocalFile(""));
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(component.create());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(component.create());
QSignalSpy spy(flickable, SIGNAL(flickDecelerationChanged()));
QVERIFY(flickable);
QCOMPARE(spy.count(),1);
}
-void tst_qsgflickable::pressDelay()
+void tst_qquickflickable::pressDelay()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Flickable { pressDelay: 100; }", QUrl::fromLocalFile(""));
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(component.create());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(component.create());
QSignalSpy spy(flickable, SIGNAL(pressDelayChanged()));
QVERIFY(flickable);
}
// QTBUG-17361
-void tst_qsgflickable::nestedPressDelay()
+void tst_qquickflickable::nestedPressDelay()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("nestedPressDelay.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGFlickable *outer = qobject_cast<QSGFlickable*>(canvas->rootObject());
+ QQuickFlickable *outer = qobject_cast<QQuickFlickable*>(canvas->rootObject());
QVERIFY(outer != 0);
- QSGFlickable *inner = canvas->rootObject()->findChild<QSGFlickable*>("innerFlickable");
+ QQuickFlickable *inner = canvas->rootObject()->findChild<QQuickFlickable*>("innerFlickable");
QVERIFY(inner != 0);
QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(150, 150));
delete canvas;
}
-void tst_qsgflickable::flickableDirection()
+void tst_qquickflickable::flickableDirection()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Flickable { flickableDirection: Flickable.VerticalFlick; }", QUrl::fromLocalFile(""));
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(component.create());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(component.create());
QSignalSpy spy(flickable, SIGNAL(flickableDirectionChanged()));
QVERIFY(flickable);
- QCOMPARE(flickable->flickableDirection(), QSGFlickable::VerticalFlick);
+ QCOMPARE(flickable->flickableDirection(), QQuickFlickable::VerticalFlick);
- flickable->setFlickableDirection(QSGFlickable::HorizontalAndVerticalFlick);
- QCOMPARE(flickable->flickableDirection(), QSGFlickable::HorizontalAndVerticalFlick);
+ flickable->setFlickableDirection(QQuickFlickable::HorizontalAndVerticalFlick);
+ QCOMPARE(flickable->flickableDirection(), QQuickFlickable::HorizontalAndVerticalFlick);
QCOMPARE(spy.count(),1);
- flickable->setFlickableDirection(QSGFlickable::AutoFlickDirection);
- QCOMPARE(flickable->flickableDirection(), QSGFlickable::AutoFlickDirection);
+ flickable->setFlickableDirection(QQuickFlickable::AutoFlickDirection);
+ QCOMPARE(flickable->flickableDirection(), QQuickFlickable::AutoFlickDirection);
QCOMPARE(spy.count(),2);
- flickable->setFlickableDirection(QSGFlickable::HorizontalFlick);
- QCOMPARE(flickable->flickableDirection(), QSGFlickable::HorizontalFlick);
+ flickable->setFlickableDirection(QQuickFlickable::HorizontalFlick);
+ QCOMPARE(flickable->flickableDirection(), QQuickFlickable::HorizontalFlick);
QCOMPARE(spy.count(),3);
- flickable->setFlickableDirection(QSGFlickable::HorizontalFlick);
- QCOMPARE(flickable->flickableDirection(), QSGFlickable::HorizontalFlick);
+ flickable->setFlickableDirection(QQuickFlickable::HorizontalFlick);
+ QCOMPARE(flickable->flickableDirection(), QQuickFlickable::HorizontalFlick);
QCOMPARE(spy.count(),3);
}
// QtQuick 1.1
-void tst_qsgflickable::resizeContent()
+void tst_qquickflickable::resizeContent()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("resize.qml")));
- QSGItem *root = qobject_cast<QSGItem*>(c.create());
- QSGFlickable *obj = findItem<QSGFlickable>(root, "flick");
+ QQuickItem *root = qobject_cast<QQuickItem*>(c.create());
+ QQuickFlickable *obj = findItem<QQuickFlickable>(root, "flick");
QVERIFY(obj != 0);
QCOMPARE(obj->contentX(), 0.);
}
// QtQuick 1.1
-void tst_qsgflickable::returnToBounds()
+void tst_qquickflickable::returnToBounds()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("resize.qml")));
- QSGItem *root = qobject_cast<QSGItem*>(c.create());
- QSGFlickable *obj = findItem<QSGFlickable>(root, "flick");
+ QQuickItem *root = qobject_cast<QQuickItem*>(c.create());
+ QQuickFlickable *obj = findItem<QQuickFlickable>(root, "flick");
QVERIFY(obj != 0);
QCOMPARE(obj->contentX(), 0.);
delete root;
}
-void tst_qsgflickable::wheel()
+void tst_qquickflickable::wheel()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("wheel.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGFlickable *flick = canvas->rootObject()->findChild<QSGFlickable*>("flick");
+ QQuickFlickable *flick = canvas->rootObject()->findChild<QQuickFlickable*>("flick");
QVERIFY(flick != 0);
{
delete canvas;
}
-void tst_qsgflickable::movingAndDragging()
+void tst_qquickflickable::movingAndDragging()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("flickable03.qml")));
canvas->show();
canvas->requestActivateWindow();
QTest::qWaitForWindowShown(canvas);
QVERIFY(canvas->rootObject() != 0);
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
QVERIFY(flickable != 0);
QSignalSpy vDragSpy(flickable, SIGNAL(draggingVerticallyChanged()));
delete canvas;
}
-void tst_qsgflickable::disabled()
+void tst_qquickflickable::disabled()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("disabled.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGFlickable *flick = canvas->rootObject()->findChild<QSGFlickable*>("flickable");
+ QQuickFlickable *flick = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flick != 0);
QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50, 90));
QTRY_VERIFY(canvas->rootObject()->property("clicked").toBool() == true);
}
-void tst_qsgflickable::flickVelocity()
+void tst_qquickflickable::flickVelocity()
{
#ifdef Q_WS_MAC
QSKIP("Producing flicks on Mac CI impossible due to timing problems");
#endif
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("flickable03.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
QVERIFY(flickable != 0);
// flick up
delete canvas;
}
-void tst_qsgflickable::margins()
+void tst_qquickflickable::margins()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("margins.qml")));
- QSGItem *root = qobject_cast<QSGItem*>(c.create());
- QSGFlickable *obj = qobject_cast<QSGFlickable*>(root);
+ QQuickItem *root = qobject_cast<QQuickItem*>(c.create());
+ QQuickFlickable *obj = qobject_cast<QQuickFlickable*>(root);
QVERIFY(obj != 0);
// starting state
delete root;
}
-void tst_qsgflickable::flick(QSGView *canvas, const QPoint &from, const QPoint &to, int duration)
+void tst_qquickflickable::flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration)
{
const int pointCount = 5;
QPoint diff = to - from;
}
template<typename T>
-T *tst_qsgflickable::findItem(QSGItem *parent, const QString &objectName)
+T *tst_qquickflickable::findItem(QQuickItem *parent, const QString &objectName)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
return 0;
}
-QTEST_MAIN(tst_qsgflickable)
+QTEST_MAIN(tst_qquickflickable)
-#include "tst_qsgflickable.moc"
+#include "tst_qquickflickable.moc"
CONFIG += testcase
-TARGET = tst_qsgflipable
+TARGET = tst_qquickflipable
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgflipable.cpp
+SOURCES += tst_qquickflipable.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <qtest.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgflipable_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickflipable_p.h>
#include <private/qdeclarativevaluetype_p.h>
#include <QFontMetrics>
-#include <private/qsgrectangle_p.h>
+#include <private/qquickrectangle_p.h>
#include <math.h>
#include <QtOpenGL/QGLShaderProgram>
#include "../shared/util.h"
-class tst_qsgflipable : public QObject
+class tst_qquickflipable : public QObject
{
Q_OBJECT
public:
- tst_qsgflipable();
+ tst_qquickflipable();
private slots:
void initTestCase();
QDeclarativeEngine engine;
};
-tst_qsgflipable::tst_qsgflipable()
+tst_qquickflipable::tst_qquickflipable()
{
}
-void tst_qsgflipable::initTestCase()
+void tst_qquickflipable::initTestCase()
{
}
-void tst_qsgflipable::cleanupTestCase()
+void tst_qquickflipable::cleanupTestCase()
{
}
-void tst_qsgflipable::create()
+void tst_qquickflipable::create()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("test-flipable.qml")));
- QSGFlipable *obj = qobject_cast<QSGFlipable*>(c.create());
+ QQuickFlipable *obj = qobject_cast<QQuickFlipable*>(c.create());
QVERIFY(obj != 0);
delete obj;
}
-void tst_qsgflipable::checkFrontAndBack()
+void tst_qquickflipable::checkFrontAndBack()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("test-flipable.qml")));
- QSGFlipable *obj = qobject_cast<QSGFlipable*>(c.create());
+ QQuickFlipable *obj = qobject_cast<QQuickFlipable*>(c.create());
QVERIFY(obj != 0);
QVERIFY(obj->front() != 0);
delete obj;
}
-void tst_qsgflipable::setFrontAndBack()
+void tst_qquickflipable::setFrontAndBack()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("test-flipable.qml")));
- QSGFlipable *obj = qobject_cast<QSGFlipable*>(c.create());
+ QQuickFlipable *obj = qobject_cast<QQuickFlipable*>(c.create());
QVERIFY(obj != 0);
QVERIFY(obj->front() != 0);
QString message = c.url().toString() + ":3:1: QML Flipable: front is a write-once property";
QTest::ignoreMessage(QtWarningMsg, qPrintable(message));
- obj->setFront(new QSGRectangle());
+ obj->setFront(new QQuickRectangle());
message = c.url().toString() + ":3:1: QML Flipable: back is a write-once property";
QTest::ignoreMessage(QtWarningMsg, qPrintable(message));
- obj->setBack(new QSGRectangle());
+ obj->setBack(new QQuickRectangle());
delete obj;
}
-void tst_qsgflipable::QTBUG_9161_crash()
+void tst_qquickflipable::QTBUG_9161_crash()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("crash.qml")));
- QSGItem *root = canvas->rootObject();
+ QQuickItem *root = canvas->rootObject();
QVERIFY(root != 0);
canvas->show();
delete canvas;
}
-void tst_qsgflipable::QTBUG_8474_qgv_abort()
+void tst_qquickflipable::QTBUG_8474_qgv_abort()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("flipable-abort.qml")));
- QSGItem *root = canvas->rootObject();
+ QQuickItem *root = canvas->rootObject();
QVERIFY(root != 0);
canvas->show();
delete canvas;
}
-QTEST_MAIN(tst_qsgflipable)
+QTEST_MAIN(tst_qquickflipable)
-#include "tst_qsgflipable.moc"
+#include "tst_qquickflipable.moc"
CONFIG += testcase
-TARGET = tst_qsgfocusscope
-SOURCES += tst_qsgfocusscope.cpp
+TARGET = tst_qquickfocusscope
+SOURCES += tst_qquickfocusscope.cpp
macx:CONFIG -= app_bundle
testDataFiles.files = data
#include <QSignalSpy>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgtextedit_p.h>
-#include <private/qsgtext_p.h>
-#include <QtDeclarative/private/qsgfocusscope_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquicktextedit_p.h>
+#include <private/qquicktext_p.h>
+#include <QtDeclarative/private/qquickfocusscope_p.h>
#include "../shared/util.h"
-class tst_qsgfocusscope : public QObject
+class tst_qquickfocusscope : public QObject
{
Q_OBJECT
public:
- tst_qsgfocusscope() {}
+ tst_qquickfocusscope() {}
template<typename T>
- T *findItem(QSGItem *parent, const QString &id);
+ T *findItem(QQuickItem *parent, const QString &id);
private slots:
void initTestCase();
void forceActiveFocus();
void canvasFocus();
};
-void tst_qsgfocusscope::initTestCase()
+void tst_qquickfocusscope::initTestCase()
{
}
-void tst_qsgfocusscope::cleanupTestCase()
+void tst_qquickfocusscope::cleanupTestCase()
{
}
Find an item with the specified id.
*/
template<typename T>
-T *tst_qsgfocusscope::findItem(QSGItem *parent, const QString &objectName)
+T *tst_qquickfocusscope::findItem(QQuickItem *parent, const QString &objectName)
{
const QMetaObject &mo = T::staticMetaObject;
- QList<QSGItem *> children = parent->childItems();
+ QList<QQuickItem *> children = parent->childItems();
for (int i = 0; i < children.count(); ++i) {
- QSGItem *item = children.at(i);
+ QQuickItem *item = children.at(i);
if (item) {
if (mo.cast(item) && (objectName.isEmpty() || item->objectName() == objectName)) {
return static_cast<T*>(item);
return 0;
}
-void tst_qsgfocusscope::basic()
+void tst_qquickfocusscope::basic()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("test.qml")));
- QSGFocusScope *item0 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item0"));
- QSGRectangle *item1 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item1"));
- QSGRectangle *item2 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item2"));
- QSGRectangle *item3 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item3"));
+ QQuickFocusScope *item0 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item0"));
+ QQuickRectangle *item1 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item1"));
+ QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
+ QQuickRectangle *item3 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item3"));
QVERIFY(item0 != 0);
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
delete view;
}
-void tst_qsgfocusscope::nested()
+void tst_qquickfocusscope::nested()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("test2.qml")));
- QSGFocusScope *item1 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item1"));
- QSGFocusScope *item2 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item2"));
- QSGFocusScope *item3 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item3"));
- QSGFocusScope *item4 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item4"));
- QSGFocusScope *item5 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item5"));
+ QQuickFocusScope *item1 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item1"));
+ QQuickFocusScope *item2 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item2"));
+ QQuickFocusScope *item3 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item3"));
+ QQuickFocusScope *item4 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item4"));
+ QQuickFocusScope *item5 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item5"));
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
QVERIFY(item3 != 0);
delete view;
}
-void tst_qsgfocusscope::noFocus()
+void tst_qquickfocusscope::noFocus()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("test4.qml")));
- QSGRectangle *item0 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item0"));
- QSGRectangle *item1 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item1"));
- QSGRectangle *item2 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item2"));
- QSGRectangle *item3 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item3"));
+ QQuickRectangle *item0 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item0"));
+ QQuickRectangle *item1 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item1"));
+ QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
+ QQuickRectangle *item3 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item3"));
QVERIFY(item0 != 0);
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
delete view;
}
-void tst_qsgfocusscope::textEdit()
+void tst_qquickfocusscope::textEdit()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("test5.qml")));
- QSGFocusScope *item0 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item0"));
- QSGTextEdit *item1 = findItem<QSGTextEdit>(view->rootObject(), QLatin1String("item1"));
- QSGRectangle *item2 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item2"));
- QSGTextEdit *item3 = findItem<QSGTextEdit>(view->rootObject(), QLatin1String("item3"));
+ QQuickFocusScope *item0 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item0"));
+ QQuickTextEdit *item1 = findItem<QQuickTextEdit>(view->rootObject(), QLatin1String("item1"));
+ QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
+ QQuickTextEdit *item3 = findItem<QQuickTextEdit>(view->rootObject(), QLatin1String("item3"));
QVERIFY(item0 != 0);
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
delete view;
}
-void tst_qsgfocusscope::forceFocus()
+void tst_qquickfocusscope::forceFocus()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("forcefocus.qml")));
- QSGFocusScope *item0 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item0"));
- QSGRectangle *item1 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item1"));
- QSGRectangle *item2 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item2"));
- QSGFocusScope *item3 = findItem<QSGFocusScope>(view->rootObject(), QLatin1String("item3"));
- QSGRectangle *item4 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item4"));
- QSGRectangle *item5 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item5"));
+ QQuickFocusScope *item0 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item0"));
+ QQuickRectangle *item1 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item1"));
+ QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
+ QQuickFocusScope *item3 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item3"));
+ QQuickRectangle *item4 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item4"));
+ QQuickRectangle *item5 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item5"));
QVERIFY(item0 != 0);
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
delete view;
}
-void tst_qsgfocusscope::noParentFocus()
+void tst_qquickfocusscope::noParentFocus()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("chain.qml")));
QVERIFY(view->rootObject());
delete view;
}
-void tst_qsgfocusscope::signalEmission()
+void tst_qquickfocusscope::signalEmission()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("signalEmission.qml")));
- QSGRectangle *item1 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item1"));
- QSGRectangle *item2 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item2"));
- QSGRectangle *item3 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item3"));
- QSGRectangle *item4 = findItem<QSGRectangle>(view->rootObject(), QLatin1String("item4"));
+ QQuickRectangle *item1 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item1"));
+ QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
+ QQuickRectangle *item3 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item3"));
+ QQuickRectangle *item4 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item4"));
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
QVERIFY(item3 != 0);
delete view;
}
-void tst_qsgfocusscope::qtBug13380()
+void tst_qquickfocusscope::qtBug13380()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("qtBug13380.qml")));
view->show();
delete view;
}
-void tst_qsgfocusscope::forceActiveFocus()
+void tst_qquickfocusscope::forceActiveFocus()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("forceActiveFocus.qml")));
view->show();
qt_x11_wait_for_window_manager(view);
#endif
- QSGItem *rootObject = view->rootObject();
+ QQuickItem *rootObject = view->rootObject();
QVERIFY(rootObject);
- QSGItem *scope = findItem<QSGItem>(rootObject, QLatin1String("scope"));
- QSGItem *itemA1 = findItem<QSGItem>(rootObject, QLatin1String("item-a1"));
- QSGItem *scopeA = findItem<QSGItem>(rootObject, QLatin1String("scope-a"));
- QSGItem *itemA2 = findItem<QSGItem>(rootObject, QLatin1String("item-a2"));
- QSGItem *itemB1 = findItem<QSGItem>(rootObject, QLatin1String("item-b1"));
- QSGItem *scopeB = findItem<QSGItem>(rootObject, QLatin1String("scope-b"));
- QSGItem *itemB2 = findItem<QSGItem>(rootObject, QLatin1String("item-b2"));
+ QQuickItem *scope = findItem<QQuickItem>(rootObject, QLatin1String("scope"));
+ QQuickItem *itemA1 = findItem<QQuickItem>(rootObject, QLatin1String("item-a1"));
+ QQuickItem *scopeA = findItem<QQuickItem>(rootObject, QLatin1String("scope-a"));
+ QQuickItem *itemA2 = findItem<QQuickItem>(rootObject, QLatin1String("item-a2"));
+ QQuickItem *itemB1 = findItem<QQuickItem>(rootObject, QLatin1String("item-b1"));
+ QQuickItem *scopeB = findItem<QQuickItem>(rootObject, QLatin1String("scope-b"));
+ QQuickItem *itemB2 = findItem<QQuickItem>(rootObject, QLatin1String("item-b2"));
QVERIFY(scope);
QVERIFY(itemA1);
delete view;
}
-void tst_qsgfocusscope::canvasFocus()
+void tst_qquickfocusscope::canvasFocus()
{
- QSGView *view = new QSGView;
+ QQuickView *view = new QQuickView;
view->setSource(QUrl::fromLocalFile(TESTDATA("canvasFocus.qml")));
- QSGItem *rootObject = view->rootObject();
+ QQuickItem *rootObject = view->rootObject();
QVERIFY(rootObject);
- QSGItem *rootItem = view->rootItem();
- QSGItem *scope1 = findItem<QSGItem>(rootObject, QLatin1String("scope1"));
- QSGItem *item1 = findItem<QSGItem>(rootObject, QLatin1String("item1"));
- QSGItem *scope2 = findItem<QSGItem>(rootObject, QLatin1String("scope2"));
- QSGItem *item2 = findItem<QSGItem>(rootObject, QLatin1String("item2"));
+ QQuickItem *rootItem = view->rootItem();
+ QQuickItem *scope1 = findItem<QQuickItem>(rootObject, QLatin1String("scope1"));
+ QQuickItem *item1 = findItem<QQuickItem>(rootObject, QLatin1String("item1"));
+ QQuickItem *scope2 = findItem<QQuickItem>(rootObject, QLatin1String("scope2"));
+ QQuickItem *item2 = findItem<QQuickItem>(rootObject, QLatin1String("item2"));
QVERIFY(scope1);
QVERIFY(item1);
delete view;
}
-QTEST_MAIN(tst_qsgfocusscope)
+QTEST_MAIN(tst_qquickfocusscope)
-#include "tst_qsgfocusscope.moc"
+#include "tst_qquickfocusscope.moc"
CONFIG += testcase
-TARGET = tst_qsggridview
+TARGET = tst_qquickgridview
macx:CONFIG -= app_bundle
-SOURCES += tst_qsggridview.cpp
+SOURCES += tst_qquickgridview.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtTest/QtTest>
#include <QtWidgets/qstringlistmodel.h>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeexpression.h>
-#include <QtDeclarative/private/qsgitem_p.h>
+#include <QtDeclarative/private/qquickitem_p.h>
#include <QtDeclarative/private/qlistmodelinterface_p.h>
-#include <QtDeclarative/private/qsggridview_p.h>
-#include <QtDeclarative/private/qsgtext_p.h>
+#include <QtDeclarative/private/qquickgridview_p.h>
+#include <QtDeclarative/private/qquicktext_p.h>
#include <QtDeclarative/private/qdeclarativelistmodel_p.h>
#include "../shared/util.h"
#include <QtGui/qguiapplication.h>
Q_DECLARE_METATYPE(Qt::LayoutDirection)
-Q_DECLARE_METATYPE(QSGGridView::Flow)
+Q_DECLARE_METATYPE(QQuickGridView::Flow)
-class tst_QSGGridView : public QObject
+class tst_QQuickGridView : public QObject
{
Q_OBJECT
public:
- tst_QSGGridView();
+ tst_QQuickGridView();
private slots:
void initTestCase();
void snapToRow();
private:
- QSGView *createView();
- void flick(QSGView *canvas, const QPoint &from, const QPoint &to, int duration);
+ QQuickView *createView();
+ void flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration);
template<typename T>
- T *findItem(QSGItem *parent, const QString &id, int index=-1);
+ T *findItem(QQuickItem *parent, const QString &id, int index=-1);
template<typename T>
- QList<T*> findItems(QSGItem *parent, const QString &objectName);
- void dumpTree(QSGItem *parent, int depth = 0);
+ QList<T*> findItems(QQuickItem *parent, const QString &objectName);
+ void dumpTree(QQuickItem *parent, int depth = 0);
};
template<typename T>
-void tst_qsggridview_move(int from, int to, int n, T *items)
+void tst_qquickgridview_move(int from, int to, int n, T *items)
{
if (n == 1) {
items->move(from, to);
}
}
-void tst_QSGGridView::initTestCase()
+void tst_QQuickGridView::initTestCase()
{
}
-void tst_QSGGridView::cleanupTestCase()
+void tst_QQuickGridView::cleanupTestCase()
{
}
void moveItems(int from, int to, int count) {
emit beginMoveRows(QModelIndex(), from, from+count-1, QModelIndex(), to > from ? to+count : to);
- tst_qsggridview_move(from, to, count, &list);
+ tst_qquickgridview_move(from, to, count, &list);
emit endMoveRows();
}
QList<QPair<QString,QString> > list;
};
-tst_QSGGridView::tst_QSGGridView()
+tst_QQuickGridView::tst_QQuickGridView()
{
}
-void tst_QSGGridView::items()
+void tst_QQuickGridView::items()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
model.addItem("Fred", "12345");
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->count(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
for (int i = 0; i < model.count(); ++i) {
- QSGText *name = findItem<QSGText>(contentItem, "textName", i);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", i);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", i);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
TestModel model2;
ctxt->setContextProperty("testModel", &model2);
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QTRY_VERIFY(itemCount == 0);
delete canvas;
}
-void tst_QSGGridView::changed()
+void tst_QQuickGridView::changed()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
model.addItem("Fred", "12345");
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGFlickable *gridview = findItem<QSGFlickable>(canvas->rootObject(), "grid");
+ QQuickFlickable *gridview = findItem<QQuickFlickable>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.modifyItem(1, "Will", "9876");
- QSGText *name = findItem<QSGText>(contentItem, "textName", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(1));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 1);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 1);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
delete canvas;
}
-void tst_QSGGridView::inserted()
+void tst_QQuickGridView::inserted()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.insertItem(1, "Will", "9876");
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
- QSGText *name = findItem<QSGText>(contentItem, "textName", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(1));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 1);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 1);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
// Confirm items positioned correctly
for (int i = 0; i < model.count(); ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_COMPARE(item->x(), (i%3)*80.0);
QTRY_COMPARE(item->y(), (i/3)*60.0);
}
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
- name = findItem<QSGText>(contentItem, "textName", 0);
+ name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- number = findItem<QSGText>(contentItem, "textNumber", 0);
+ number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
// Confirm items positioned correctly
for (int i = 0; i < model.count(); ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_VERIFY(item->x() == (i%3)*80);
QTRY_VERIFY(item->y() == (i/3)*60);
}
delete canvas;
}
-void tst_QSGGridView::inserted_more()
+void tst_QQuickGridView::inserted_more()
{
QFETCH(qreal, contentY);
QFETCH(int, insertIndex);
QFETCH(int, insertCount);
QFETCH(qreal, itemsOffsetAfterMove);
- QSGText *name;
- QSGText *number;
- QSGView *canvas = createView();
+ QQuickText *name;
+ QQuickText *number;
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
gridview->setContentY(contentY);
QTRY_COMPARE(gridview->property("count").toInt(), model.count());
// check visibleItems.first() is in correct position
- QSGItem *item0 = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item0 = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item0);
QCOMPARE(item0->y(), itemsOffsetAfterMove);
- QList<QSGItem*> items = findItems<QSGItem>(contentItem, "wrapper");
+ QList<QQuickItem*> items = findItems<QQuickItem>(contentItem, "wrapper");
int firstVisibleIndex = -1;
for (int i=0; i<items.count(); i++) {
if (items[i]->y() >= contentY) {
QVERIFY2(firstVisibleIndex >= 0, QTest::toString(firstVisibleIndex));
// Confirm items positioned correctly and indexes correct
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = firstVisibleIndex; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY2(item, QTest::toString(QString("Item %1 not found").arg(i)));
QCOMPARE(item->x(), (i%3)*80.0);
QCOMPARE(item->y(), (i/3)*60.0 + itemsOffsetAfterMove);
- name = findItem<QSGText>(contentItem, "textName", i);
+ name = findItem<QQuickText>(contentItem, "textName", i);
QVERIFY(name != 0);
QCOMPARE(name->text(), model.name(i));
- number = findItem<QSGText>(contentItem, "textNumber", i);
+ number = findItem<QQuickText>(contentItem, "textNumber", i);
QVERIFY(number != 0);
QCOMPARE(number->text(), model.number(i));
}
delete canvas;
}
-void tst_QSGGridView::inserted_more_data()
+void tst_QQuickGridView::inserted_more_data()
{
QTest::addColumn<qreal>("contentY");
QTest::addColumn<int>("insertIndex");
<< 0.0;
}
-void tst_QSGGridView::removed()
+void tst_QQuickGridView::removed()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.removeItem(1);
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
- QSGText *name = findItem<QSGText>(contentItem, "textName", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(1));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 1);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 1);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
QTRY_COMPARE(removed, QString("Item1"));
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item->x() == (i%3)*80);
QTRY_VERIFY(item->y() == (i/3)*60);
model.removeItem(0);
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
- name = findItem<QSGText>(contentItem, "textName", 0);
+ name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- number = findItem<QSGText>(contentItem, "textNumber", 0);
+ number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item->x() == (i%3)*80);
QTRY_VERIFY(item->y() == (i/3)*60);
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item->x() == (i%3)*80);
QTRY_VERIFY(item->y() == (i/3)*60);
// Confirm items positioned correctly
for (int i = 6; i < 18; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item->x() == (i%3)*80);
QTRY_VERIFY(item->y() == (i/3)*60);
}
// Remove currentIndex
- QSGItem *oldCurrent = gridview->currentItem();
+ QQuickItem *oldCurrent = gridview->currentItem();
model.removeItem(9);
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
QTest::qWait(300);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_VERIFY(item->x() == (i%3)*80);
QTRY_VERIFY(item->y() == (i/3)*60);
}
delete canvas;
}
-void tst_QSGGridView::clear()
+void tst_QQuickGridView::clear()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QVERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
model.clear();
delete canvas;
}
-void tst_QSGGridView::moved()
+void tst_QQuickGridView::moved()
{
QFETCH(qreal, contentY);
QFETCH(int, from);
QFETCH(int, count);
QFETCH(qreal, itemsOffsetAfterMove);
- QSGText *name;
- QSGText *number;
- QSGView *canvas = createView();
+ QQuickText *name;
+ QQuickText *number;
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGItem *currentItem = gridview->currentItem();
+ QQuickItem *currentItem = gridview->currentItem();
QTRY_VERIFY(currentItem != 0);
gridview->setContentY(contentY);
// Confirm items positioned correctly and indexes correct
int firstVisibleIndex = qCeil(contentY / 60.0) * 3;
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = firstVisibleIndex; i < model.count() && i < itemCount; ++i) {
if (i >= firstVisibleIndex + 18) // index has moved out of view
continue;
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY2(item, QTest::toString(QString("Item %1 not found").arg(i)));
QTRY_COMPARE(item->x(), (i%3)*80.0);
QTRY_COMPARE(item->y(), (i/3)*60.0 + itemsOffsetAfterMove);
- name = findItem<QSGText>(contentItem, "textName", i);
+ name = findItem<QQuickText>(contentItem, "textName", i);
QVERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- number = findItem<QSGText>(contentItem, "textNumber", i);
+ number = findItem<QQuickText>(contentItem, "textNumber", i);
QVERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
delete canvas;
}
-void tst_QSGGridView::moved_data()
+void tst_QQuickGridView::moved_data()
{
QTest::addColumn<qreal>("contentY");
QTest::addColumn<int>("from");
};
Q_DECLARE_METATYPE(QList<ListChange>)
-void tst_QSGGridView::multipleChanges()
+void tst_QQuickGridView::multipleChanges()
{
QFETCH(int, startCount);
QFETCH(QList<ListChange>, changes);
QFETCH(int, newCount);
QFETCH(int, newCurrentIndex);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
for (int i=0; i<changes.count(); i++) {
QCOMPARE(gridview->count(), model.count());
QTRY_COMPARE(gridview->currentIndex(), newCurrentIndex);
- QSGText *name;
- QSGText *number;
- QSGItem *contentItem = gridview->contentItem();
+ QQuickText *name;
+ QQuickText *number;
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i=0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY2(item, QTest::toString(QString("Item %1 not found").arg(i)));
- name = findItem<QSGText>(contentItem, "textName", i);
+ name = findItem<QQuickText>(contentItem, "textName", i);
QVERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- number = findItem<QSGText>(contentItem, "textNumber", i);
+ number = findItem<QQuickText>(contentItem, "textNumber", i);
QVERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
delete canvas;
}
-void tst_QSGGridView::multipleChanges_data()
+void tst_QQuickGridView::multipleChanges_data()
{
QTest::addColumn<int>("startCount");
QTest::addColumn<QList<ListChange> >("changes");
}
-void tst_QSGGridView::swapWithFirstItem()
+void tst_QQuickGridView::swapWithFirstItem()
{
// QTBUG_9697
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
// ensure content position is stable
delete canvas;
}
-void tst_QSGGridView::currentIndex()
+void tst_QQuickGridView::currentIndex()
{
TestModel model;
for (int i = 0; i < 60; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
canvas->show();
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QVERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
// current item should be third item
QCOMPARE(gridview->currentIndex(), 35);
- QCOMPARE(gridview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 35));
+ QCOMPARE(gridview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 35));
QCOMPARE(gridview->currentItem()->y(), gridview->highlightItem()->y());
QCOMPARE(gridview->contentY(), 400.0);
QTRY_COMPARE(gridview->contentY(), 0.0);
- gridview->setFlow(QSGGridView::TopToBottom);
+ gridview->setFlow(QQuickGridView::TopToBottom);
canvas->requestActivateWindow();
QTest::qWaitForWindowShown(canvas);
gridview->setHighlightFollowsCurrentItem(true);
- gridview->setFlow(QSGGridView::LeftToRight);
+ gridview->setFlow(QQuickGridView::LeftToRight);
gridview->setLayoutDirection(Qt::RightToLeft);
canvas->requestActivateWindow();
delete canvas;
}
-void tst_QSGGridView::noCurrentIndex()
+void tst_QQuickGridView::noCurrentIndex()
{
TestModel model;
for (int i = 0; i < 60; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
QDeclarativeContext *ctxt = canvas->rootContext();
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QVERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
// current index should be -1
delete canvas;
}
-void tst_QSGGridView::changeFlow()
+void tst_QQuickGridView::changeFlow()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly and indexes correct
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal((i%3)*80));
QTRY_COMPARE(item->y(), qreal((i/3)*60));
- QSGText *name = findItem<QSGText>(contentItem, "textName", i);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", i);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", i);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
ctxt->setContextProperty("testTopToBottom", QVariant(true));
// Confirm items positioned correctly and indexes correct
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal((i/5)*80));
QTRY_COMPARE(item->y(), qreal((i%5)*60));
- QSGText *name = findItem<QSGText>(contentItem, "textName", i);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", i);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", i);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
ctxt->setContextProperty("testRightToLeft", QVariant(true));
// Confirm items positioned correctly and indexes correct
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(-(i/5)*80 - item->width()));
QTRY_COMPARE(item->y(), qreal((i%5)*60));
- QSGText *name = findItem<QSGText>(contentItem, "textName", i);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", i);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", i);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
QTRY_COMPARE(gridview->contentX(), 0.);
// Confirm items positioned correctly and indexes correct
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(240 - (i%3+1)*80));
QTRY_COMPARE(item->y(), qreal((i/3)*60));
- QSGText *name = findItem<QSGText>(contentItem, "textName", i);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", i);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", i);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
delete canvas;
}
-void tst_QSGGridView::defaultValues()
+void tst_QQuickGridView::defaultValues()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("gridview3.qml")));
- QSGGridView *obj = qobject_cast<QSGGridView*>(c.create());
+ QQuickGridView *obj = qobject_cast<QQuickGridView*>(c.create());
QTRY_VERIFY(obj != 0);
QTRY_VERIFY(obj->model() == QVariant());
delete obj;
}
-void tst_QSGGridView::properties()
+void tst_QQuickGridView::properties()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("gridview2.qml")));
- QSGGridView *obj = qobject_cast<QSGGridView*>(c.create());
+ QQuickGridView *obj = qobject_cast<QQuickGridView*>(c.create());
QTRY_VERIFY(obj != 0);
QTRY_VERIFY(obj->model() != QVariant());
delete obj;
}
-void tst_QSGGridView::propertyChanges()
+void tst_QQuickGridView::propertyChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QTRY_VERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychangestest.qml")));
- QSGGridView *gridView = canvas->rootObject()->findChild<QSGGridView*>("gridView");
+ QQuickGridView *gridView = canvas->rootObject()->findChild<QQuickGridView*>("gridView");
QTRY_VERIFY(gridView);
QSignalSpy keyNavigationWrapsSpy(gridView, SIGNAL(keyNavigationWrapsChanged()));
QTRY_COMPARE(gridView->isWrapEnabled(), true);
QTRY_COMPARE(gridView->cacheBuffer(), 10);
- QTRY_COMPARE(gridView->flow(), QSGGridView::LeftToRight);
+ QTRY_COMPARE(gridView->flow(), QQuickGridView::LeftToRight);
gridView->setWrapEnabled(false);
gridView->setCacheBuffer(3);
- gridView->setFlow(QSGGridView::TopToBottom);
+ gridView->setFlow(QQuickGridView::TopToBottom);
QTRY_COMPARE(gridView->isWrapEnabled(), false);
QTRY_COMPARE(gridView->cacheBuffer(), 3);
- QTRY_COMPARE(gridView->flow(), QSGGridView::TopToBottom);
+ QTRY_COMPARE(gridView->flow(), QQuickGridView::TopToBottom);
QTRY_COMPARE(keyNavigationWrapsSpy.count(),1);
QTRY_COMPARE(cacheBufferSpy.count(),1);
gridView->setWrapEnabled(false);
gridView->setCacheBuffer(3);
- gridView->setFlow(QSGGridView::TopToBottom);
+ gridView->setFlow(QQuickGridView::TopToBottom);
QTRY_COMPARE(keyNavigationWrapsSpy.count(),1);
QTRY_COMPARE(cacheBufferSpy.count(),1);
QTRY_COMPARE(flowSpy.count(),1);
- gridView->setFlow(QSGGridView::LeftToRight);
- QTRY_COMPARE(gridView->flow(), QSGGridView::LeftToRight);
+ gridView->setFlow(QQuickGridView::LeftToRight);
+ QTRY_COMPARE(gridView->flow(), QQuickGridView::LeftToRight);
gridView->setWrapEnabled(true);
gridView->setCacheBuffer(5);
QTRY_COMPARE(layoutSpy.count(),1);
QTRY_COMPARE(flowSpy.count(),2);
- gridView->setFlow(QSGGridView::TopToBottom);
- QTRY_COMPARE(gridView->flow(), QSGGridView::TopToBottom);
+ gridView->setFlow(QQuickGridView::TopToBottom);
+ QTRY_COMPARE(gridView->flow(), QQuickGridView::TopToBottom);
QTRY_COMPARE(flowSpy.count(),3);
- gridView->setFlow(QSGGridView::TopToBottom);
+ gridView->setFlow(QQuickGridView::TopToBottom);
QTRY_COMPARE(flowSpy.count(),3);
delete canvas;
}
-void tst_QSGGridView::componentChanges()
+void tst_QQuickGridView::componentChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QTRY_VERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychangestest.qml")));
- QSGGridView *gridView = canvas->rootObject()->findChild<QSGGridView*>("gridView");
+ QQuickGridView *gridView = canvas->rootObject()->findChild<QQuickGridView*>("gridView");
QTRY_VERIFY(gridView);
QDeclarativeComponent component(canvas->engine());
delete canvas;
}
-void tst_QSGGridView::modelChanges()
+void tst_QQuickGridView::modelChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QTRY_VERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychangestest.qml")));
- QSGGridView *gridView = canvas->rootObject()->findChild<QSGGridView*>("gridView");
+ QQuickGridView *gridView = canvas->rootObject()->findChild<QQuickGridView*>("gridView");
QTRY_VERIFY(gridView);
QDeclarativeListModel *alternateModel = canvas->rootObject()->findChild<QDeclarativeListModel*>("alternateModel");
delete canvas;
}
-void tst_QSGGridView::positionViewAtIndex()
+void tst_QQuickGridView::positionViewAtIndex()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 40; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), (i%3)*80.);
}
// Position on a currently visible item
- gridview->positionViewAtIndex(4, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(4, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->indexAt(120, 90), 4);
QTRY_COMPARE(gridview->contentY(), 60.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 3; i < model.count() && i < itemCount-3-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), (i%3)*80.);
}
// Position on an item beyond the visible items
- gridview->positionViewAtIndex(21, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(21, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->indexAt(40, 450), 21);
QTRY_COMPARE(gridview->contentY(), 420.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 22; i < model.count() && i < itemCount-22-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), (i%3)*80.);
}
// Position on an item that would leave empty space if positioned at the top
- gridview->positionViewAtIndex(31, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(31, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->indexAt(120, 630), 31);
QTRY_COMPARE(gridview->contentY(), 520.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 24; i < model.count() && i < itemCount-24-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), (i%3)*80.);
}
// Position at the beginning again
- gridview->positionViewAtIndex(0, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(0, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->indexAt(0, 0), 0);
QTRY_COMPARE(gridview->indexAt(40, 30), 0);
QTRY_COMPARE(gridview->indexAt(80, 60), 4);
QTRY_COMPARE(gridview->contentY(), 0.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), (i%3)*80.);
}
// Position at End
- gridview->positionViewAtIndex(30, QSGGridView::End);
+ gridview->positionViewAtIndex(30, QQuickGridView::End);
QTRY_COMPARE(gridview->contentY(), 340.);
// Position in Center
- gridview->positionViewAtIndex(15, QSGGridView::Center);
+ gridview->positionViewAtIndex(15, QQuickGridView::Center);
QTRY_COMPARE(gridview->contentY(), 170.);
// Ensure at least partially visible
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentY(), 170.);
gridview->setContentY(302);
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentY(), 302.);
gridview->setContentY(360);
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentY(), 300.);
gridview->setContentY(60);
- gridview->positionViewAtIndex(20, QSGGridView::Visible);
+ gridview->positionViewAtIndex(20, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentY(), 60.);
gridview->setContentY(20);
- gridview->positionViewAtIndex(20, QSGGridView::Visible);
+ gridview->positionViewAtIndex(20, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentY(), 100.);
// Ensure completely visible
gridview->setContentY(120);
- gridview->positionViewAtIndex(20, QSGGridView::Contain);
+ gridview->positionViewAtIndex(20, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentY(), 120.);
gridview->setContentY(302);
- gridview->positionViewAtIndex(15, QSGGridView::Contain);
+ gridview->positionViewAtIndex(15, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentY(), 300.);
gridview->setContentY(60);
- gridview->positionViewAtIndex(20, QSGGridView::Contain);
+ gridview->positionViewAtIndex(20, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentY(), 100.);
// Test for Top To Bottom layout
ctxt->setContextProperty("testTopToBottom", QVariant(true));
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), (i/5)*80.);
}
// Position at End
- gridview->positionViewAtIndex(30, QSGGridView::End);
+ gridview->positionViewAtIndex(30, QQuickGridView::End);
QTRY_COMPARE(gridview->contentX(), 320.);
QTRY_COMPARE(gridview->contentY(), 0.);
// Position in Center
- gridview->positionViewAtIndex(15, QSGGridView::Center);
+ gridview->positionViewAtIndex(15, QQuickGridView::Center);
QTRY_COMPARE(gridview->contentX(), 160.);
// Ensure at least partially visible
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), 160.);
gridview->setContentX(170);
- gridview->positionViewAtIndex(25, QSGGridView::Visible);
+ gridview->positionViewAtIndex(25, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), 170.);
- gridview->positionViewAtIndex(30, QSGGridView::Visible);
+ gridview->positionViewAtIndex(30, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), 320.);
gridview->setContentX(170);
- gridview->positionViewAtIndex(25, QSGGridView::Contain);
+ gridview->positionViewAtIndex(25, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentX(), 240.);
// positionViewAtBeginning
delete canvas;
}
-void tst_QSGGridView::snapping()
+void tst_QQuickGridView::snapping()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 40; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setHeight(220);
QCOMPARE(gridview->height(), 220.);
- gridview->positionViewAtIndex(12, QSGGridView::Visible);
+ gridview->positionViewAtIndex(12, QQuickGridView::Visible);
QCOMPARE(gridview->contentY(), 80.);
gridview->setContentY(0);
QCOMPARE(gridview->contentY(), 0.);
- gridview->setSnapMode(QSGGridView::SnapToRow);
- QCOMPARE(gridview->snapMode(), QSGGridView::SnapToRow);
+ gridview->setSnapMode(QQuickGridView::SnapToRow);
+ QCOMPARE(gridview->snapMode(), QQuickGridView::SnapToRow);
- gridview->positionViewAtIndex(12, QSGGridView::Visible);
+ gridview->positionViewAtIndex(12, QQuickGridView::Visible);
QCOMPARE(gridview->contentY(), 60.);
- gridview->positionViewAtIndex(15, QSGGridView::End);
+ gridview->positionViewAtIndex(15, QQuickGridView::End);
QCOMPARE(gridview->contentY(), 120.);
delete canvas;
}
-void tst_QSGGridView::mirroring()
+void tst_QQuickGridView::mirroring()
{
- QSGView *canvasA = createView();
+ QQuickView *canvasA = createView();
canvasA->setSource(QUrl::fromLocalFile(TESTDATA("mirroring.qml")));
- QSGGridView *gridviewA = findItem<QSGGridView>(canvasA->rootObject(), "view");
+ QQuickGridView *gridviewA = findItem<QQuickGridView>(canvasA->rootObject(), "view");
QTRY_VERIFY(gridviewA != 0);
- QSGView *canvasB = createView();
+ QQuickView *canvasB = createView();
canvasB->setSource(QUrl::fromLocalFile(TESTDATA("mirroring.qml")));
- QSGGridView *gridviewB = findItem<QSGGridView>(canvasB->rootObject(), "view");
+ QQuickGridView *gridviewB = findItem<QQuickGridView>(canvasB->rootObject(), "view");
QTRY_VERIFY(gridviewA != 0);
qApp->processEvents();
// LTR != RTL
foreach (const QString objectName, objectNames)
- QVERIFY(findItem<QSGItem>(gridviewA, objectName)->x() != findItem<QSGItem>(gridviewB, objectName)->x());
+ QVERIFY(findItem<QQuickItem>(gridviewA, objectName)->x() != findItem<QQuickItem>(gridviewB, objectName)->x());
gridviewA->setProperty("layoutDirection", Qt::LeftToRight);
gridviewB->setProperty("layoutDirection", Qt::LeftToRight);
// LTR == LTR
foreach (const QString objectName, objectNames)
- QCOMPARE(findItem<QSGItem>(gridviewA, objectName)->x(), findItem<QSGItem>(gridviewB, objectName)->x());
+ QCOMPARE(findItem<QQuickItem>(gridviewA, objectName)->x(), findItem<QQuickItem>(gridviewB, objectName)->x());
QVERIFY(gridviewB->layoutDirection() == gridviewB->effectiveLayoutDirection());
- QSGItemPrivate::get(gridviewB)->setLayoutMirror(true);
+ QQuickItemPrivate::get(gridviewB)->setLayoutMirror(true);
QVERIFY(gridviewB->layoutDirection() != gridviewB->effectiveLayoutDirection());
// LTR != LTR+mirror
foreach (const QString objectName, objectNames)
- QVERIFY(findItem<QSGItem>(gridviewA, objectName)->x() != findItem<QSGItem>(gridviewB, objectName)->x());
+ QVERIFY(findItem<QQuickItem>(gridviewA, objectName)->x() != findItem<QQuickItem>(gridviewB, objectName)->x());
gridviewA->setProperty("layoutDirection", Qt::RightToLeft);
// RTL == LTR+mirror
foreach (const QString objectName, objectNames)
- QCOMPARE(findItem<QSGItem>(gridviewA, objectName)->x(), findItem<QSGItem>(gridviewB, objectName)->x());
+ QCOMPARE(findItem<QQuickItem>(gridviewA, objectName)->x(), findItem<QQuickItem>(gridviewB, objectName)->x());
gridviewB->setProperty("layoutDirection", Qt::RightToLeft);
// RTL != RTL+mirror
foreach (const QString objectName, objectNames)
- QVERIFY(findItem<QSGItem>(gridviewA, objectName)->x() != findItem<QSGItem>(gridviewB, objectName)->x());
+ QVERIFY(findItem<QQuickItem>(gridviewA, objectName)->x() != findItem<QQuickItem>(gridviewB, objectName)->x());
gridviewA->setProperty("layoutDirection", Qt::LeftToRight);
// LTR == RTL+mirror
foreach (const QString objectName, objectNames)
- QCOMPARE(findItem<QSGItem>(gridviewA, objectName)->x(), findItem<QSGItem>(gridviewB, objectName)->x());
+ QCOMPARE(findItem<QQuickItem>(gridviewA, objectName)->x(), findItem<QQuickItem>(gridviewB, objectName)->x());
delete canvasA;
delete canvasB;
}
-void tst_QSGGridView::positionViewAtIndex_rightToLeft()
+void tst_QQuickGridView::positionViewAtIndex_rightToLeft()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 40; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(-(i/5)*80-item->width()));
}
// Position on a currently visible item
- gridview->positionViewAtIndex(6, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(6, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->contentX(), -320.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 3; i < model.count() && i < itemCount-3-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(-(i/5)*80-item->width()));
}
// Position on an item beyond the visible items
- gridview->positionViewAtIndex(21, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(21, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->contentX(), -560.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 22; i < model.count() && i < itemCount-22-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(-(i/5)*80-item->width()));
}
// Position on an item that would leave empty space if positioned at the top
- gridview->positionViewAtIndex(31, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(31, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->contentX(), -640.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 24; i < model.count() && i < itemCount-24-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(-(i/5)*80-item->width()));
}
// Position at the beginning again
- gridview->positionViewAtIndex(0, QSGGridView::Beginning);
+ gridview->positionViewAtIndex(0, QQuickGridView::Beginning);
QTRY_COMPARE(gridview->contentX(), -240.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), qreal(-(i/5)*80-item->width()));
}
// Position at End
- gridview->positionViewAtIndex(30, QSGGridView::End);
+ gridview->positionViewAtIndex(30, QQuickGridView::End);
QTRY_COMPARE(gridview->contentX(), -560.);
// Position in Center
- gridview->positionViewAtIndex(15, QSGGridView::Center);
+ gridview->positionViewAtIndex(15, QQuickGridView::Center);
QTRY_COMPARE(gridview->contentX(), -400.);
// Ensure at least partially visible
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), -400.);
gridview->setContentX(-555.);
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), -555.);
gridview->setContentX(-239);
- gridview->positionViewAtIndex(15, QSGGridView::Visible);
+ gridview->positionViewAtIndex(15, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), -320.);
gridview->setContentX(-239);
- gridview->positionViewAtIndex(20, QSGGridView::Visible);
+ gridview->positionViewAtIndex(20, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), -400.);
gridview->setContentX(-640);
- gridview->positionViewAtIndex(20, QSGGridView::Visible);
+ gridview->positionViewAtIndex(20, QQuickGridView::Visible);
QTRY_COMPARE(gridview->contentX(), -560.);
// Ensure completely visible
gridview->setContentX(-400);
- gridview->positionViewAtIndex(20, QSGGridView::Contain);
+ gridview->positionViewAtIndex(20, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentX(), -400.);
gridview->setContentX(-315);
- gridview->positionViewAtIndex(15, QSGGridView::Contain);
+ gridview->positionViewAtIndex(15, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentX(), -320.);
gridview->setContentX(-640);
- gridview->positionViewAtIndex(20, QSGGridView::Contain);
+ gridview->positionViewAtIndex(20, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentX(), -560.);
delete canvas;
}
-void tst_QSGGridView::resetModel()
+void tst_QQuickGridView::resetModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QStringList strings;
strings << "one" << "two" << "three";
canvas->setSource(QUrl::fromLocalFile(TESTDATA("displaygrid.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->count(), model.rowCount());
for (int i = 0; i < model.rowCount(); ++i) {
- QSGText *display = findItem<QSGText>(contentItem, "displayText", i);
+ QQuickText *display = findItem<QQuickText>(contentItem, "displayText", i);
QTRY_VERIFY(display != 0);
QTRY_COMPARE(display->text(), strings.at(i));
}
QTRY_COMPARE(gridview->count(), model.rowCount());
for (int i = 0; i < model.rowCount(); ++i) {
- QSGText *display = findItem<QSGText>(contentItem, "displayText", i);
+ QQuickText *display = findItem<QQuickText>(contentItem, "displayText", i);
QTRY_VERIFY(display != 0);
QTRY_COMPARE(display->text(), strings.at(i));
}
delete canvas;
}
-void tst_QSGGridView::enforceRange()
+void tst_QQuickGridView::enforceRange()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
qApp->processEvents();
QVERIFY(canvas->rootObject() != 0);
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QTRY_COMPARE(gridview->preferredHighlightBegin(), 100.0);
QTRY_COMPARE(gridview->preferredHighlightEnd(), 100.0);
- QTRY_COMPARE(gridview->highlightRangeMode(), QSGGridView::StrictlyEnforceRange);
+ QTRY_COMPARE(gridview->highlightRangeMode(), QQuickGridView::StrictlyEnforceRange);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// view should be positioned at the top of the range.
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QTRY_VERIFY(item);
QTRY_COMPARE(gridview->contentY(), -100.0);
- QSGText *name = findItem<QSGText>(contentItem, "textName", 0);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 0);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
delete canvas;
}
-void tst_QSGGridView::enforceRange_rightToLeft()
+void tst_QQuickGridView::enforceRange_rightToLeft()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
qApp->processEvents();
QVERIFY(canvas->rootObject() != 0);
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QTRY_COMPARE(gridview->preferredHighlightBegin(), 100.0);
QTRY_COMPARE(gridview->preferredHighlightEnd(), 100.0);
- QTRY_COMPARE(gridview->highlightRangeMode(), QSGGridView::StrictlyEnforceRange);
+ QTRY_COMPARE(gridview->highlightRangeMode(), QQuickGridView::StrictlyEnforceRange);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// view should be positioned at the top of the range.
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QTRY_VERIFY(item);
QTRY_COMPARE(gridview->contentX(), -100.);
QTRY_COMPARE(gridview->contentY(), 0.0);
- QSGText *name = findItem<QSGText>(contentItem, "textName", 0);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 0);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
delete canvas;
}
-void tst_QSGGridView::QTBUG_8456()
+void tst_QQuickGridView::QTBUG_8456()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("setindex.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QTRY_COMPARE(gridview->currentIndex(), 0);
delete canvas;
}
-void tst_QSGGridView::manualHighlight()
+void tst_QQuickGridView::manualHighlight()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QString filename(TESTDATA("manual-highlight.qml"));
canvas->setSource(QUrl::fromLocalFile(filename));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->currentIndex(), 0);
- QTRY_COMPARE(gridview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 0));
+ QTRY_COMPARE(gridview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 0));
QTRY_COMPARE(gridview->highlightItem()->y() - 5, gridview->currentItem()->y());
QTRY_COMPARE(gridview->highlightItem()->x() - 5, gridview->currentItem()->x());
gridview->setCurrentIndex(2);
QTRY_COMPARE(gridview->currentIndex(), 2);
- QTRY_COMPARE(gridview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 2));
+ QTRY_COMPARE(gridview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 2));
QTRY_COMPARE(gridview->highlightItem()->y() - 5, gridview->currentItem()->y());
QTRY_COMPARE(gridview->highlightItem()->x() - 5, gridview->currentItem()->x());
- gridview->positionViewAtIndex(8, QSGGridView::Contain);
+ gridview->positionViewAtIndex(8, QQuickGridView::Contain);
QTRY_COMPARE(gridview->currentIndex(), 2);
- QTRY_COMPARE(gridview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 2));
+ QTRY_COMPARE(gridview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 2));
QTRY_COMPARE(gridview->highlightItem()->y() - 5, gridview->currentItem()->y());
QTRY_COMPARE(gridview->highlightItem()->x() - 5, gridview->currentItem()->x());
- gridview->setFlow(QSGGridView::TopToBottom);
- QTRY_COMPARE(gridview->flow(), QSGGridView::TopToBottom);
+ gridview->setFlow(QQuickGridView::TopToBottom);
+ QTRY_COMPARE(gridview->flow(), QQuickGridView::TopToBottom);
gridview->setCurrentIndex(0);
QTRY_COMPARE(gridview->currentIndex(), 0);
- QTRY_COMPARE(gridview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 0));
+ QTRY_COMPARE(gridview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 0));
QTRY_COMPARE(gridview->highlightItem()->y() - 5, gridview->currentItem()->y());
QTRY_COMPARE(gridview->highlightItem()->x() - 5, gridview->currentItem()->x());
}
-void tst_QSGGridView::footer()
+void tst_QQuickGridView::footer()
{
- QFETCH(QSGGridView::Flow, flow);
+ QFETCH(QQuickGridView::Flow, flow);
QFETCH(Qt::LayoutDirection, layoutDirection);
QFETCH(QPointF, initialFooterPos);
QFETCH(QPointF, changedFooterPos);
QFETCH(QPointF, firstDelegatePos);
QFETCH(QPointF, resizeContentPos);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("footer.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGText *footer = findItem<QSGText>(contentItem, "footer");
+ QQuickText *footer = findItem<QQuickText>(contentItem, "footer");
QVERIFY(footer);
QVERIFY(footer == gridview->footerItem());
QCOMPARE(footer->height(), 30.);
QCOMPARE(QPointF(gridview->contentX(), gridview->contentY()), initialContentPos);
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
- if (flow == QSGGridView::LeftToRight) {
+ if (flow == QQuickGridView::LeftToRight) {
// shrink by one row
model.removeItem(2);
QTRY_COMPARE(footer->y(), initialFooterPos.y() - gridview->cellHeight());
QPointF posWhenNoItems(0, 0);
if (layoutDirection == Qt::RightToLeft)
- posWhenNoItems.setX(flow == QSGGridView::LeftToRight ? gridview->width() - footer->width() : -footer->width());
+ posWhenNoItems.setX(flow == QQuickGridView::LeftToRight ? gridview->width() - footer->width() : -footer->width());
QTRY_COMPARE(footer->pos(), posWhenNoItems);
// if header is present, it's at a negative pos, so the footer should not move
canvas->rootObject()->setProperty("showHeader", true);
- QVERIFY(findItem<QSGItem>(contentItem, "header") != 0);
+ QVERIFY(findItem<QQuickItem>(contentItem, "header") != 0);
QTRY_COMPARE(footer->pos(), posWhenNoItems);
canvas->rootObject()->setProperty("showHeader", false);
QCOMPARE(footerItemSpy.count(), 1);
- footer = findItem<QSGText>(contentItem, "footer");
+ footer = findItem<QQuickText>(contentItem, "footer");
QVERIFY(!footer);
- footer = findItem<QSGText>(contentItem, "footer2");
+ footer = findItem<QQuickText>(contentItem, "footer2");
QVERIFY(footer);
QVERIFY(footer == gridview->footerItem());
QCOMPARE(footer->height(), 20.);
QTRY_COMPARE(QPointF(gridview->contentX(), gridview->contentY()), changedContentPos);
- item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
delete canvas;
}
-void tst_QSGGridView::footer_data()
+void tst_QQuickGridView::footer_data()
{
- QTest::addColumn<QSGGridView::Flow>("flow");
+ QTest::addColumn<QQuickGridView::Flow>("flow");
QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
QTest::addColumn<QPointF>("initialFooterPos");
QTest::addColumn<QPointF>("changedFooterPos");
// view height = 320
// footer below items, bottom left
- QTest::newRow("flow left to right") << QSGGridView::LeftToRight << Qt::LeftToRight
+ QTest::newRow("flow left to right") << QQuickGridView::LeftToRight << Qt::LeftToRight
<< QPointF(0, 3 * 60) // 180 = height of 3 rows (cell height is 60)
<< QPointF(0, 10 * 60) // 30 items = 10 rows
<< QPointF(0, 0)
<< QPointF(0, 10 * 60 - 320 + 10);
// footer below items, bottom right
- QTest::newRow("flow left to right, layout right to left") << QSGGridView::LeftToRight << Qt::RightToLeft
+ QTest::newRow("flow left to right, layout right to left") << QQuickGridView::LeftToRight << Qt::RightToLeft
<< QPointF(240 - 100, 3 * 60)
<< QPointF((240 - 100) + 50, 10 * 60) // 50 = width diff between old and new footers
<< QPointF(0, 0)
<< QPointF(0, 10 * 60 - 320 + 10);
// footer to right of items
- QTest::newRow("flow top to bottom, layout left to right") << QSGGridView::TopToBottom << Qt::LeftToRight
+ QTest::newRow("flow top to bottom, layout left to right") << QQuickGridView::TopToBottom << Qt::LeftToRight
<< QPointF(2 * 80, 0) // 2 columns, cell width 80
<< QPointF(6 * 80, 0) // 30 items = 6 columns
<< QPointF(0, 0)
<< QPointF(6 * 80 - 240 + 40, 0);
// footer to left of items
- QTest::newRow("flow top to bottom, layout right to left") << QSGGridView::TopToBottom << Qt::RightToLeft
+ QTest::newRow("flow top to bottom, layout right to left") << QQuickGridView::TopToBottom << Qt::RightToLeft
<< QPointF(-(2 * 80) - 100, 0)
<< QPointF(-(6 * 80) - 50, 0) // 50 = new footer width
<< QPointF(-240, 0)
<< QPointF(-(6 * 80) - 40, 0);
}
-void tst_QSGGridView::header()
+void tst_QQuickGridView::header()
{
- QFETCH(QSGGridView::Flow, flow);
+ QFETCH(QQuickGridView::Flow, flow);
QFETCH(Qt::LayoutDirection, layoutDirection);
QFETCH(QPointF, initialHeaderPos);
QFETCH(QPointF, changedHeaderPos);
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->rootContext()->setContextProperty("testModel", &model);
canvas->rootContext()->setContextProperty("initialViewWidth", 240);
canvas->rootContext()->setContextProperty("initialViewHeight", 320);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("header.qml")));
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGText *header = findItem<QSGText>(contentItem, "header");
+ QQuickText *header = findItem<QQuickText>(contentItem, "header");
QVERIFY(header);
QVERIFY(header == gridview->headerItem());
QCOMPARE(header->height(), 30.);
QCOMPARE(QPointF(gridview->contentX(), gridview->contentY()), initialContentPos);
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
QCOMPARE(headerItemSpy.count(), 1);
- header = findItem<QSGText>(contentItem, "header");
+ header = findItem<QQuickText>(contentItem, "header");
QVERIFY(!header);
- header = findItem<QSGText>(contentItem, "header2");
+ header = findItem<QQuickText>(contentItem, "header2");
QVERIFY(header);
QVERIFY(header == gridview->headerItem());
QCOMPARE(header->height(), 20.);
QTRY_COMPARE(QPointF(gridview->contentX(), gridview->contentY()), changedContentPos);
- item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
canvas->rootContext()->setContextProperty("initialViewHeight", 320);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("header.qml")));
- gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
delete canvas;
}
-void tst_QSGGridView::header_data()
+void tst_QQuickGridView::header_data()
{
- QTest::addColumn<QSGGridView::Flow>("flow");
+ QTest::addColumn<QQuickGridView::Flow>("flow");
QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
QTest::addColumn<QPointF>("initialHeaderPos");
QTest::addColumn<QPointF>("changedHeaderPos");
// view width = 240
// header above items, top left
- QTest::newRow("flow left to right") << QSGGridView::LeftToRight << Qt::LeftToRight
+ QTest::newRow("flow left to right") << QQuickGridView::LeftToRight << Qt::LeftToRight
<< QPointF(0, -30)
<< QPointF(0, -20)
<< QPointF(0, -30)
<< QPointF(0, -10);
// header above items, top right
- QTest::newRow("flow left to right, layout right to left") << QSGGridView::LeftToRight << Qt::RightToLeft
+ QTest::newRow("flow left to right, layout right to left") << QQuickGridView::LeftToRight << Qt::RightToLeft
<< QPointF(240 - 100, -30)
<< QPointF((240 - 100) + 50, -20) // 50 = width diff between old and new headers
<< QPointF(0, -30)
<< QPointF(0, -10);
// header to left of items
- QTest::newRow("flow top to bottom, layout left to right") << QSGGridView::TopToBottom << Qt::LeftToRight
+ QTest::newRow("flow top to bottom, layout left to right") << QQuickGridView::TopToBottom << Qt::LeftToRight
<< QPointF(-100, 0)
<< QPointF(-50, 0)
<< QPointF(-100, 0)
<< QPointF(-40, 0);
// header to right of items
- QTest::newRow("flow top to bottom, layout right to left") << QSGGridView::TopToBottom << Qt::RightToLeft
+ QTest::newRow("flow top to bottom, layout right to left") << QQuickGridView::TopToBottom << Qt::RightToLeft
<< QPointF(0, 0)
<< QPointF(0, 0)
<< QPointF(-(240 - 100), 0)
<< QPointF(-(240 - 40), 0);
}
-void tst_QSGGridView::resizeViewAndRepaint()
+void tst_QQuickGridView::resizeViewAndRepaint()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("resizeview.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// item at index 10 should not be currently visible
- QVERIFY(!findItem<QSGItem>(contentItem, "wrapper", 10));
+ QVERIFY(!findItem<QQuickItem>(contentItem, "wrapper", 10));
gridview->setHeight(320);
- QTRY_VERIFY(findItem<QSGItem>(contentItem, "wrapper", 10));
+ QTRY_VERIFY(findItem<QQuickItem>(contentItem, "wrapper", 10));
gridview->setHeight(100);
- QTRY_VERIFY(!findItem<QSGItem>(contentItem, "wrapper", 10));
+ QTRY_VERIFY(!findItem<QQuickItem>(contentItem, "wrapper", 10));
delete canvas;
}
-void tst_QSGGridView::indexAt()
+void tst_QQuickGridView::indexAt()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
model.addItem("Fred", "12345");
canvas->setSource(QUrl::fromLocalFile(TESTDATA("gridview1.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->count(), model.count());
delete canvas;
}
-void tst_QSGGridView::onAdd()
+void tst_QQuickGridView::onAdd()
{
QFETCH(int, initialItemCount);
QFETCH(int, itemsToAdd);
const int delegateWidth = 50;
const int delegateHeight = 100;
TestModel model;
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setGeometry(0,0,5 * delegateWidth, 5 * delegateHeight); // just ensure all items fit
// these initial items should not trigger GridView.onAdd
items << qMakePair(QString("value %1").arg(i), QString::number(i));
model.addItems(items);
- QTRY_COMPARE(model.count(), qobject_cast<QSGGridView*>(canvas->rootObject())->count());
+ QTRY_COMPARE(model.count(), qobject_cast<QQuickGridView*>(canvas->rootObject())->count());
qApp->processEvents();
QVariantList result = object->property("addedDelegates").toList();
delete canvas;
}
-void tst_QSGGridView::onAdd_data()
+void tst_QQuickGridView::onAdd_data()
{
QTest::addColumn<int>("initialItemCount");
QTest::addColumn<int>("itemsToAdd");
QTest::newRow("5, add 10") << 5 << 10;
}
-void tst_QSGGridView::onRemove()
+void tst_QQuickGridView::onRemove()
{
QFETCH(int, initialItemCount);
QFETCH(int, indexToRemove);
for (int i=0; i<initialItemCount; i++)
model.addItem(QString("value %1").arg(i), "dummy value");
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("delegateWidth", delegateWidth);
QObject *object = canvas->rootObject();
model.removeItems(indexToRemove, removeCount);
- QTRY_COMPARE(model.count(), qobject_cast<QSGGridView*>(canvas->rootObject())->count());
+ QTRY_COMPARE(model.count(), qobject_cast<QQuickGridView*>(canvas->rootObject())->count());
QCOMPARE(object->property("removedDelegateCount"), QVariant(removeCount));
delete canvas;
}
-void tst_QSGGridView::onRemove_data()
+void tst_QQuickGridView::onRemove_data()
{
QTest::addColumn<int>("initialItemCount");
QTest::addColumn<int>("indexToRemove");
QTest::newRow("ten items, remove 4-10") << 10 << 4 << 6;
}
-void tst_QSGGridView::testQtQuick11Attributes()
+void tst_QQuickGridView::testQtQuick11Attributes()
{
QFETCH(QString, code);
QFETCH(QString, warning);
delete obj;
}
-void tst_QSGGridView::testQtQuick11Attributes_data()
+void tst_QQuickGridView::testQtQuick11Attributes_data()
{
QTest::addColumn<QString>("code");
QTest::addColumn<QString>("warning");
<< "";
}
-void tst_QSGGridView::columnCount()
+void tst_QQuickGridView::columnCount()
{
- QSGView canvas;
+ QQuickView canvas;
canvas.setSource(QUrl::fromLocalFile(TESTDATA("gridview4.qml")));
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
- QSGGridView *view = qobject_cast<QSGGridView*>(canvas.rootObject());
+ QQuickGridView *view = qobject_cast<QQuickGridView*>(canvas.rootObject());
QCOMPARE(view->cellWidth(), qreal(405)/qreal(9));
QCOMPARE(view->cellHeight(), qreal(100));
- QList<QSGItem*> items = findItems<QSGItem>(view, "delegate");
+ QList<QQuickItem*> items = findItems<QQuickItem>(view, "delegate");
QCOMPARE(items.size(), 18);
QCOMPARE(items.at(8)->y(), qreal(0));
QCOMPARE(items.at(9)->y(), qreal(100));
}
-void tst_QSGGridView::margins()
+void tst_QQuickGridView::margins()
{
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("margins.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(gridview->contentX(), -30.);
}
{
//RTL
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("margins.qml")));
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(gridview->contentX(), -240+30.);
}
}
-void tst_QSGGridView::creationContext()
+void tst_QQuickGridView::creationContext()
{
- QSGView canvas;
+ QQuickView canvas;
canvas.setGeometry(0,0,240,320);
canvas.setSource(QUrl::fromLocalFile(TESTDATA("creationContext.qml")));
qApp->processEvents();
- QSGItem *rootItem = qobject_cast<QSGItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
QVERIFY(rootItem);
QVERIFY(rootItem->property("count").toInt() > 0);
- QSGItem *item;
- QVERIFY(item = rootItem->findChild<QSGItem *>("listItem"));
+ QQuickItem *item;
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("listItem"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
- QVERIFY(item = rootItem->findChild<QSGItem *>("header"));
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("header"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
- QVERIFY(item = rootItem->findChild<QSGItem *>("footer"));
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("footer"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
}
-void tst_QSGGridView::snapToRow_data()
+void tst_QQuickGridView::snapToRow_data()
{
- QTest::addColumn<QSGGridView::Flow>("flow");
+ QTest::addColumn<QQuickGridView::Flow>("flow");
QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
QTest::addColumn<int>("highlightRangeMode");
QTest::addColumn<QPoint>("flickStart");
QTest::addColumn<qreal>("endExtent");
QTest::addColumn<qreal>("startExtent");
- QTest::newRow("vertical, left to right") << QSGGridView::LeftToRight << Qt::LeftToRight << int(QSGItemView::NoHighlightRange)
+ QTest::newRow("vertical, left to right") << QQuickGridView::LeftToRight << Qt::LeftToRight << int(QQuickItemView::NoHighlightRange)
<< QPoint(20, 200) << QPoint(20, 20) << 60.0 << 1200.0 << 0.0;
- QTest::newRow("horizontal, left to right") << QSGGridView::TopToBottom << Qt::LeftToRight << int(QSGItemView::NoHighlightRange)
+ QTest::newRow("horizontal, left to right") << QQuickGridView::TopToBottom << Qt::LeftToRight << int(QQuickItemView::NoHighlightRange)
<< QPoint(200, 20) << QPoint(20, 20) << 60.0 << 1200.0 << 0.0;
- QTest::newRow("horizontal, right to left") << QSGGridView::TopToBottom << Qt::RightToLeft << int(QSGItemView::NoHighlightRange)
+ QTest::newRow("horizontal, right to left") << QQuickGridView::TopToBottom << Qt::RightToLeft << int(QQuickItemView::NoHighlightRange)
<< QPoint(20, 20) << QPoint(200, 20) << -60.0 << -1200.0 - 240.0 << -240.0;
- QTest::newRow("vertical, left to right, enforce range") << QSGGridView::LeftToRight << Qt::LeftToRight << int(QSGItemView::StrictlyEnforceRange)
+ QTest::newRow("vertical, left to right, enforce range") << QQuickGridView::LeftToRight << Qt::LeftToRight << int(QQuickItemView::StrictlyEnforceRange)
<< QPoint(20, 200) << QPoint(20, 20) << 60.0 << 1340.0 << -20.0;
- QTest::newRow("horizontal, left to right, enforce range") << QSGGridView::TopToBottom << Qt::LeftToRight << int(QSGItemView::StrictlyEnforceRange)
+ QTest::newRow("horizontal, left to right, enforce range") << QQuickGridView::TopToBottom << Qt::LeftToRight << int(QQuickItemView::StrictlyEnforceRange)
<< QPoint(200, 20) << QPoint(20, 20) << 60.0 << 1340.0 << -20.0;
- QTest::newRow("horizontal, right to left, enforce range") << QSGGridView::TopToBottom << Qt::RightToLeft << int(QSGItemView::StrictlyEnforceRange)
+ QTest::newRow("horizontal, right to left, enforce range") << QQuickGridView::TopToBottom << Qt::RightToLeft << int(QQuickItemView::StrictlyEnforceRange)
<< QPoint(20, 20) << QPoint(200, 20) << -60.0 << -1200.0 - 240.0 - 140.0 << -220.0;
}
-void tst_QSGGridView::snapToRow()
+void tst_QQuickGridView::snapToRow()
{
- QFETCH(QSGGridView::Flow, flow);
+ QFETCH(QQuickGridView::Flow, flow);
QFETCH(Qt::LayoutDirection, layoutDirection);
QFETCH(int, highlightRangeMode);
QFETCH(QPoint, flickStart);
QFETCH(qreal, endExtent);
QFETCH(qreal, startExtent);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("snapToRow.qml")));
canvas->show();
qApp->processEvents();
- QSGGridView *gridview = findItem<QSGGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
- gridview->setHighlightRangeMode(QSGItemView::HighlightRangeMode(highlightRangeMode));
+ gridview->setHighlightRangeMode(QQuickItemView::HighlightRangeMode(highlightRangeMode));
- QSGItem *contentItem = gridview->contentItem();
+ QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// confirm that a flick hits an item boundary
flick(canvas, flickStart, flickEnd, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
- if (flow == QSGGridView::LeftToRight)
+ if (flow == QQuickGridView::LeftToRight)
QCOMPARE(qreal(fmod(gridview->contentY(),80.0)), snapAlignment);
else
QCOMPARE(qreal(fmod(gridview->contentX(),80.0)), snapAlignment);
do {
flick(canvas, flickStart, flickEnd, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
- } while (flow == QSGGridView::LeftToRight
+ } while (flow == QQuickGridView::LeftToRight
? !gridview->isAtYEnd()
: layoutDirection == Qt::LeftToRight ? !gridview->isAtXEnd() : !gridview->isAtXBeginning());
- if (flow == QSGGridView::LeftToRight)
+ if (flow == QQuickGridView::LeftToRight)
QCOMPARE(gridview->contentY(), endExtent);
else
QCOMPARE(gridview->contentX(), endExtent);
do {
flick(canvas, flickEnd, flickStart, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
- } while (flow == QSGGridView::LeftToRight
+ } while (flow == QQuickGridView::LeftToRight
? !gridview->isAtYBeginning()
: layoutDirection == Qt::LeftToRight ? !gridview->isAtXBeginning() : !gridview->isAtXEnd());
- if (flow == QSGGridView::LeftToRight)
+ if (flow == QQuickGridView::LeftToRight)
QCOMPARE(gridview->contentY(), startExtent);
else
QCOMPARE(gridview->contentX(), startExtent);
}
-QSGView *tst_QSGGridView::createView()
+QQuickView *tst_QQuickGridView::createView()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
return canvas;
}
-void tst_QSGGridView::flick(QSGView *canvas, const QPoint &from, const QPoint &to, int duration)
+void tst_QQuickGridView::flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration)
{
const int pointCount = 5;
QPoint diff = to - from;
item must also evaluate the {index} expression equal to index
*/
template<typename T>
-T *tst_QSGGridView::findItem(QSGItem *parent, const QString &objectName, int index)
+T *tst_QQuickGridView::findItem(QQuickItem *parent, const QString &objectName, int index)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
}
template<typename T>
-QList<T*> tst_QSGGridView::findItems(QSGItem *parent, const QString &objectName)
+QList<T*> tst_QQuickGridView::findItems(QQuickItem *parent, const QString &objectName)
{
QList<T*> items;
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
return items;
}
-void tst_QSGGridView::dumpTree(QSGItem *parent, int depth)
+void tst_QQuickGridView::dumpTree(QQuickItem *parent, int depth)
{
static QString padding(" ");
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
QDeclarativeContext *context = QDeclarativeEngine::contextForObject(item);
}
-QTEST_MAIN(tst_QSGGridView)
+QTEST_MAIN(tst_QQuickGridView)
-#include "tst_qsggridview.moc"
+#include "tst_qquickgridview.moc"
CONFIG += testcase
-TARGET = tst_qsgimage
+TARGET = tst_qquickimage
macx:CONFIG -= app_bundle
HEADERS += ../shared/testhttpserver.h
-SOURCES += tst_qsgimage.cpp ../shared/testhttpserver.cpp
+SOURCES += tst_qquickimage.cpp ../shared/testhttpserver.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgimage_p.h>
-#include <private/qsgimagebase_p.h>
-#include <private/qsgloader_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickimage_p.h>
+#include <private/qquickimagebase_p.h>
+#include <private/qquickloader_p.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeexpression.h>
#include <QtTest/QSignalSpy>
#define SERVER_PORT 14451
#define SERVER_ADDR "http://127.0.0.1:14451"
-class tst_qsgimage : public QObject
+class tst_qquickimage : public QObject
{
Q_OBJECT
public:
- tst_qsgimage();
+ tst_qquickimage();
private slots:
void noSource();
private:
template<typename T>
- T *findItem(QSGItem *parent, const QString &id, int index=-1);
+ T *findItem(QQuickItem *parent, const QString &id, int index=-1);
QDeclarativeEngine engine;
};
-tst_qsgimage::tst_qsgimage()
+tst_qquickimage::tst_qquickimage()
{
}
-void tst_qsgimage::noSource()
+void tst_qquickimage::noSource()
{
QString componentStr = "import QtQuick 2.0\nImage { source: \"\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->source(), QUrl());
- QVERIFY(obj->status() == QSGImage::Null);
+ QVERIFY(obj->status() == QQuickImage::Null);
QCOMPARE(obj->width(), 0.);
QCOMPARE(obj->height(), 0.);
- QCOMPARE(obj->fillMode(), QSGImage::Stretch);
+ QCOMPARE(obj->fillMode(), QQuickImage::Stretch);
QCOMPARE(obj->progress(), 0.0);
delete obj;
}
-void tst_qsgimage::imageSource_data()
+void tst_qquickimage::imageSource_data()
{
QTest::addColumn<QString>("source");
QTest::addColumn<double>("width");
}
-void tst_qsgimage::imageSource()
+void tst_qquickimage::imageSource()
{
QFETCH(QString, source);
QFETCH(double, width);
+ (cache ? QLatin1String("true") : QLatin1String("false")) + " }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
if (async)
QVERIFY(obj->cache() == false);
if (remote || async)
- QTRY_VERIFY(obj->status() == QSGImage::Loading);
+ QTRY_VERIFY(obj->status() == QQuickImage::Loading);
QCOMPARE(obj->source(), remote ? source : QUrl(source));
if (error.isEmpty()) {
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QCOMPARE(obj->width(), qreal(width));
QCOMPARE(obj->height(), qreal(height));
- QCOMPARE(obj->fillMode(), QSGImage::Stretch);
+ QCOMPARE(obj->fillMode(), QQuickImage::Stretch);
QCOMPARE(obj->progress(), 1.0);
} else {
- QTRY_VERIFY(obj->status() == QSGImage::Error);
+ QTRY_VERIFY(obj->status() == QQuickImage::Error);
}
delete obj;
}
-void tst_qsgimage::clearSource()
+void tst_qquickimage::clearSource()
{
QString componentStr = "import QtQuick 2.0\nImage { source: srcImage }";
QDeclarativeContext *ctxt = engine.rootContext();
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("colors.png")));
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
- QVERIFY(obj->status() == QSGImage::Ready);
+ QVERIFY(obj->status() == QQuickImage::Ready);
QCOMPARE(obj->width(), 120.);
QCOMPARE(obj->height(), 120.);
QCOMPARE(obj->progress(), 1.0);
ctxt->setContextProperty("srcImage", "");
QVERIFY(obj->source().isEmpty());
- QVERIFY(obj->status() == QSGImage::Null);
+ QVERIFY(obj->status() == QQuickImage::Null);
QCOMPARE(obj->width(), 0.);
QCOMPARE(obj->height(), 0.);
QCOMPARE(obj->progress(), 0.0);
delete obj;
}
-void tst_qsgimage::resized()
+void tst_qquickimage::resized()
{
QString componentStr = "import QtQuick 2.0\nImage { source: \"" + TESTDATA("colors.png") + "\"; width: 300; height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 300.);
- QCOMPARE(obj->fillMode(), QSGImage::Stretch);
+ QCOMPARE(obj->fillMode(), QQuickImage::Stretch);
delete obj;
}
-void tst_qsgimage::preserveAspectRatio()
+void tst_qquickimage::preserveAspectRatio()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->show();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("aspectratio.qml")));
- QSGImage *image = qobject_cast<QSGImage*>(canvas->rootObject());
+ QQuickImage *image = qobject_cast<QQuickImage*>(canvas->rootObject());
QVERIFY(image != 0);
image->setWidth(80.0);
QCOMPARE(image->width(), 80.);
QCOMPARE(image->height(), 80.);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("aspectratio.qml")));
- image = qobject_cast<QSGImage*>(canvas->rootObject());
+ image = qobject_cast<QQuickImage*>(canvas->rootObject());
image->setHeight(60.0);
QVERIFY(image != 0);
QCOMPARE(image->height(), 60.);
delete canvas;
}
-void tst_qsgimage::smooth()
+void tst_qquickimage::smooth()
{
QString componentStr = "import QtQuick 2.0\nImage { source: \"" + TESTDATA("colors.png") + "\"; smooth: true; width: 300; height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.);
QCOMPARE(obj->height(), 300.);
QCOMPARE(obj->smooth(), true);
- QCOMPARE(obj->fillMode(), QSGImage::Stretch);
+ QCOMPARE(obj->fillMode(), QQuickImage::Stretch);
delete obj;
}
-void tst_qsgimage::mirror()
+void tst_qquickimage::mirror()
{
- QMap<QSGImage::FillMode, QImage> screenshots;
- QList<QSGImage::FillMode> fillModes;
- fillModes << QSGImage::Stretch << QSGImage::PreserveAspectFit << QSGImage::PreserveAspectCrop
- << QSGImage::Tile << QSGImage::TileVertically << QSGImage::TileHorizontally;
+ QMap<QQuickImage::FillMode, QImage> screenshots;
+ QList<QQuickImage::FillMode> fillModes;
+ fillModes << QQuickImage::Stretch << QQuickImage::PreserveAspectFit << QQuickImage::PreserveAspectCrop
+ << QQuickImage::Tile << QQuickImage::TileVertically << QQuickImage::TileHorizontally;
qreal width = 300;
qreal height = 250;
- foreach (QSGImage::FillMode fillMode, fillModes) {
- QSGView *canvas = new QSGView;
+ foreach (QQuickImage::FillMode fillMode, fillModes) {
+ QQuickView *canvas = new QQuickView;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("mirror.qml")));
- QSGImage *obj = canvas->rootObject()->findChild<QSGImage*>("image");
+ QQuickImage *obj = canvas->rootObject()->findChild<QQuickImage*>("image");
QVERIFY(obj != 0);
obj->setFillMode(fillMode);
delete canvas;
}
- foreach (QSGImage::FillMode fillMode, fillModes) {
+ foreach (QQuickImage::FillMode fillMode, fillModes) {
QPixmap srcPixmap;
QVERIFY(srcPixmap.load(TESTDATA("pattern.png")));
p_e.setTransform(transform);
switch (fillMode) {
- case QSGImage::Stretch:
+ case QQuickImage::Stretch:
p_e.drawPixmap(QRect(0, 0, width, height), srcPixmap, QRect(0, 0, srcPixmap.width(), srcPixmap.height()));
break;
- case QSGImage::PreserveAspectFit:
+ case QQuickImage::PreserveAspectFit:
p_e.drawPixmap(QRect(25, 0, height, height), srcPixmap, QRect(0, 0, srcPixmap.width(), srcPixmap.height()));
break;
- case QSGImage::PreserveAspectCrop:
+ case QQuickImage::PreserveAspectCrop:
{
qreal ratio = width/srcPixmap.width(); // width is the longer side
QRect rect(0, 0, srcPixmap.width()*ratio, srcPixmap.height()*ratio);
p_e.drawPixmap(rect, srcPixmap, QRect(0, 0, srcPixmap.width(), srcPixmap.height()));
break;
}
- case QSGImage::Tile:
+ case QQuickImage::Tile:
p_e.drawTiledPixmap(QRect(0, 0, width, height), srcPixmap);
break;
- case QSGImage::TileVertically:
+ case QQuickImage::TileVertically:
transform.scale(width / srcPixmap.width(), 1.0);
p_e.setTransform(transform);
p_e.drawTiledPixmap(QRect(0, 0, width, height), srcPixmap);
break;
- case QSGImage::TileHorizontally:
+ case QQuickImage::TileHorizontally:
transform.scale(1.0, height / srcPixmap.height());
p_e.setTransform(transform);
p_e.drawTiledPixmap(QRect(0, 0, width, height), srcPixmap);
}
}
-void tst_qsgimage::svg()
+void tst_qquickimage::svg()
{
if (!QImageReader::supportedImageFormats().contains("svg"))
QSKIP("svg support not available");
QString componentStr = "import QtQuick 2.0\nImage { source: \"" + src + "\"; sourceSize.width: 300; sourceSize.height: 300 }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 300.0);
QCOMPARE(obj->height(), 300.0);
delete obj;
}
-void tst_qsgimage::geometry_data()
+void tst_qquickimage::geometry_data()
{
QTest::addColumn<QString>("fillMode");
QTest::addColumn<bool>("explicitWidth");
}
}
-void tst_qsgimage::geometry()
+void tst_qquickimage::geometry()
{
QFETCH(QString, fillMode);
QFETCH(bool, explicitWidth);
componentStr.append("}");
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), itemWidth);
delete obj;
}
-void tst_qsgimage::big()
+void tst_qquickimage::big()
{
// If the JPEG loader does not implement scaling efficiently, it would
// have to build a 400 MB image. That would be a bug in the JPEG loader.
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 100.0);
QCOMPARE(obj->height(), 256.0);
delete obj;
}
-void tst_qsgimage::tiling_QTBUG_6716()
+void tst_qquickimage::tiling_QTBUG_6716()
{
QFETCH(QString, source);
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA(source)));
canvas->show();
qApp->processEvents();
- QSGImage *tiling = findItem<QSGImage>(canvas->rootObject(), "tiling");
+ QQuickImage *tiling = findItem<QQuickImage>(canvas->rootObject(), "tiling");
QVERIFY(tiling != 0);
QImage img = canvas->grabFrameBuffer();
delete canvas;
}
-void tst_qsgimage::tiling_QTBUG_6716_data()
+void tst_qquickimage::tiling_QTBUG_6716_data()
{
QTest::addColumn<QString>("source");
QTest::newRow("vertical_tiling") << "vtiling.qml";
QTest::newRow("horizontal_tiling") << "htiling.qml";
}
-void tst_qsgimage::noLoading()
+void tst_qquickimage::noLoading()
{
TestHTTPServer server(SERVER_PORT);
QVERIFY(server.isValid());
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("heart.png")));
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
- QVERIFY(obj->status() == QSGImage::Ready);
+ QVERIFY(obj->status() == QQuickImage::Ready);
QSignalSpy sourceSpy(obj, SIGNAL(sourceChanged(const QUrl &)));
QSignalSpy progressSpy(obj, SIGNAL(progressChanged(qreal)));
- QSignalSpy statusSpy(obj, SIGNAL(statusChanged(QSGImageBase::Status)));
+ QSignalSpy statusSpy(obj, SIGNAL(statusChanged(QQuickImageBase::Status)));
// Loading local file
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("green.png")));
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QTRY_VERIFY(obj->progress() == 1.0);
QTRY_COMPARE(sourceSpy.count(), 1);
QTRY_COMPARE(progressSpy.count(), 0);
// Loading remote file
ctxt->setContextProperty("srcImage", QString(SERVER_ADDR) + "/rect.png");
- QTRY_VERIFY(obj->status() == QSGImage::Loading);
+ QTRY_VERIFY(obj->status() == QQuickImage::Loading);
QTRY_VERIFY(obj->progress() == 0.0);
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QTRY_VERIFY(obj->progress() == 1.0);
QTRY_COMPARE(sourceSpy.count(), 2);
QTRY_COMPARE(progressSpy.count(), 2);
// Loading remote file again - should not go through 'Loading' state.
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("green.png")));
ctxt->setContextProperty("srcImage", QString(SERVER_ADDR) + "/rect.png");
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QTRY_VERIFY(obj->progress() == 1.0);
QTRY_COMPARE(sourceSpy.count(), 4);
QTRY_COMPARE(progressSpy.count(), 2);
delete obj;
}
-void tst_qsgimage::paintedWidthHeight()
+void tst_qquickimage::paintedWidthHeight()
{
{
QString src = QUrl::fromLocalFile(TESTDATA("heart.png")).toString();
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 200.0);
QCOMPARE(obj->height(), 25.0);
QString componentStr = "import QtQuick 2.0\nImage { source: \"" + src + "\"; width: 26; height: 175; fillMode: Image.PreserveAspectFit }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QVERIFY(obj != 0);
QCOMPARE(obj->width(), 26.0);
QCOMPARE(obj->height(), 175.0);
}
}
-void tst_qsgimage::sourceSize_QTBUG_14303()
+void tst_qquickimage::sourceSize_QTBUG_14303()
{
QString componentStr = "import QtQuick 2.0\nImage { source: srcImage }";
QDeclarativeContext *ctxt = engine.rootContext();
ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(TESTDATA("heart200.png")));
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGImage *obj = qobject_cast<QSGImage*>(component.create());
+ QQuickImage *obj = qobject_cast<QQuickImage*>(component.create());
QSignalSpy sourceSizeSpy(obj, SIGNAL(sourceSizeChanged()));
QTRY_VERIFY(obj != 0);
- QTRY_VERIFY(obj->status() == QSGImage::Ready);
+ QTRY_VERIFY(obj->status() == QQuickImage::Ready);
QTRY_COMPARE(obj->sourceSize().width(), 200);
QTRY_COMPARE(obj->sourceSize().height(), 200);
delete obj;
}
-void tst_qsgimage::sourceSize_QTBUG_16389()
+void tst_qquickimage::sourceSize_QTBUG_16389()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("qtbug_16389.qml")));
canvas->show();
qApp->processEvents();
- QSGImage *image = findItem<QSGImage>(canvas->rootObject(), "iconImage");
- QSGItem *handle = findItem<QSGItem>(canvas->rootObject(), "blueHandle");
+ QQuickImage *image = findItem<QQuickImage>(canvas->rootObject(), "iconImage");
+ QQuickItem *handle = findItem<QQuickItem>(canvas->rootObject(), "blueHandle");
QCOMPARE(image->sourceSize().width(), 200);
QCOMPARE(image->sourceSize().height(), 200);
}
// QTBUG-15690
-void tst_qsgimage::nullPixmapPaint()
+void tst_qquickimage::nullPixmapPaint()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("nullpixmap.qml")));
canvas->show();
- QSGImage *image = qobject_cast<QSGImage*>(canvas->rootObject());
+ QQuickImage *image = qobject_cast<QQuickImage*>(canvas->rootObject());
QTRY_VERIFY(image != 0);
image->setSource(SERVER_ADDR + QString("/no-such-file.png"));
item must also evaluate the {index} expression equal to index
*/
template<typename T>
-T *tst_qsgimage::findItem(QSGItem *parent, const QString &objectName, int index)
+T *tst_qquickimage::findItem(QQuickItem *parent, const QString &objectName, int index)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
return 0;
}
-QTEST_MAIN(tst_qsgimage)
+QTEST_MAIN(tst_qquickimage)
-#include "tst_qsgimage.moc"
+#include "tst_qquickimage.moc"
CONFIG += testcase
-TARGET = tst_qsgitem
-SOURCES += tst_qsgitem.cpp
+TARGET = tst_qquickitem
+SOURCES += tst_qquickitem.cpp
macx:CONFIG -= app_bundle
#include <qtest.h>
-#include "qsgitem.h"
-#include "qsgcanvas.h"
+#include "qquickitem.h"
+#include "qquickcanvas.h"
#include <QtWidgets/QGraphicsSceneMouseEvent>
-#include "private/qsgfocusscope_p.h"
+#include "private/qquickfocusscope_p.h"
#include <QDebug>
#include <QTimer>
-class TestItem : public QSGItem
+class TestItem : public QQuickItem
{
Q_OBJECT
public:
- TestItem(QSGItem *parent = 0) : QSGItem(parent), focused(false), pressCount(0), releaseCount(0), wheelCount(0) {}
+ TestItem(QQuickItem *parent = 0) : QQuickItem(parent), focused(false), pressCount(0), releaseCount(0), wheelCount(0) {}
bool focused;
int pressCount;
virtual void wheelEvent(QWheelEvent *event) { event->accept(); ++wheelCount; }
};
-class TestPolishItem : public QSGItem
+class TestPolishItem : public QQuickItem
{
Q_OBJECT
public:
- TestPolishItem(QSGItem *parent)
- : QSGItem(parent), wasPolished(false) {
+ TestPolishItem(QQuickItem *parent)
+ : QQuickItem(parent), wasPolished(false) {
QTimer::singleShot(10, this, SLOT(doPolish()));
}
}
};
-class TestFocusScope : public QSGFocusScope
+class TestFocusScope : public QQuickFocusScope
{
Q_OBJECT
public:
- TestFocusScope(QSGItem *parent = 0) : QSGFocusScope(parent), focused(false) {}
+ TestFocusScope(QQuickItem *parent = 0) : QQuickFocusScope(parent), focused(false) {}
bool focused;
protected:
virtual void focusOutEvent(QFocusEvent *) { Q_ASSERT(focused); focused = false; }
};
-class tst_qsgitem : public QObject
+class tst_qquickitem : public QObject
{
Q_OBJECT
public:
- tst_qsgitem();
+ tst_qquickitem();
private slots:
void initTestCase();
}
};
-tst_qsgitem::tst_qsgitem()
+tst_qquickitem::tst_qquickitem()
{
}
-void tst_qsgitem::initTestCase()
+void tst_qquickitem::initTestCase()
{
}
-void tst_qsgitem::cleanupTestCase()
+void tst_qquickitem::cleanupTestCase()
{
}
// Focus has no effect when outside a canvas
-void tst_qsgitem::noCanvas()
+void tst_qquickitem::noCanvas()
{
- QSGItem *root = new TestItem;
- QSGItem *child = new TestItem(root);
- QSGItem *scope = new TestItem(root);
- QSGFocusScope *scopedChild = new TestFocusScope(scope);
- QSGFocusScope *scopedChild2 = new TestFocusScope(scope);
+ QQuickItem *root = new TestItem;
+ QQuickItem *child = new TestItem(root);
+ QQuickItem *scope = new TestItem(root);
+ QQuickFocusScope *scopedChild = new TestFocusScope(scope);
+ QQuickFocusScope *scopedChild2 = new TestFocusScope(scope);
QCOMPARE(root->hasFocus(), false);
QCOMPARE(child->hasFocus(), false);
bool focus;
bool activeFocus;
};
-struct FocusState : public QHash<QSGItem *, FocusData>
+struct FocusState : public QHash<QQuickItem *, FocusData>
{
FocusState() : activeFocusItem(0) {}
- FocusState &operator<<(QSGItem *item) {
+ FocusState &operator<<(QQuickItem *item) {
insert(item, FocusData());
return *this;
}
- void active(QSGItem *i) {
+ void active(QQuickItem *i) {
activeFocusItem = i;
}
- QSGItem *activeFocusItem;
+ QQuickItem *activeFocusItem;
};
#define FVERIFY() \
} else { \
QCOMPARE(canvas.activeFocusItem(), canvas.rootItem()); \
} \
- for (QHash<QSGItem *, FocusData>::Iterator iter = focusState.begin(); \
+ for (QHash<QQuickItem *, FocusData>::Iterator iter = focusState.begin(); \
iter != focusState.end(); \
iter++) { \
QCOMPARE(iter.key()->hasFocus(), iter.value().focus); \
} while (false)
// Tests a simple set of top-level scoped items
-void tst_qsgitem::simpleFocus()
+void tst_qquickitem::simpleFocus()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *l1c1 = new TestItem(canvas.rootItem());
- QSGItem *l1c2 = new TestItem(canvas.rootItem());
- QSGItem *l1c3 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c1 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c2 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c3 = new TestItem(canvas.rootItem());
- QSGItem *l2c1 = new TestItem(l1c1);
- QSGItem *l2c2 = new TestItem(l1c1);
- QSGItem *l2c3 = new TestItem(l1c3);
+ QQuickItem *l2c1 = new TestItem(l1c1);
+ QQuickItem *l2c2 = new TestItem(l1c1);
+ QQuickItem *l2c3 = new TestItem(l1c3);
FocusState focusState;
focusState << l1c1 << l1c2 << l1c3
}
// Items with a focus scope
-void tst_qsgitem::scopedFocus()
+void tst_qquickitem::scopedFocus()
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *l1c1 = new TestItem(canvas.rootItem());
- QSGItem *l1c2 = new TestItem(canvas.rootItem());
- QSGItem *l1c3 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c1 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c2 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c3 = new TestItem(canvas.rootItem());
- QSGItem *l2c1 = new TestItem(l1c1);
- QSGItem *l2c2 = new TestItem(l1c1);
- QSGItem *l2c3 = new TestFocusScope(l1c3);
+ QQuickItem *l2c1 = new TestItem(l1c1);
+ QQuickItem *l2c2 = new TestItem(l1c1);
+ QQuickItem *l2c3 = new TestFocusScope(l1c3);
- QSGItem *l3c1 = new TestItem(l2c3);
- QSGItem *l3c2 = new TestFocusScope(l2c3);
+ QQuickItem *l3c1 = new TestItem(l2c3);
+ QQuickItem *l3c2 = new TestFocusScope(l2c3);
- QSGItem *l4c1 = new TestItem(l3c2);
- QSGItem *l4c2 = new TestItem(l3c2);
+ QQuickItem *l4c1 = new TestItem(l3c2);
+ QQuickItem *l4c2 = new TestItem(l3c2);
FocusState focusState;
focusState << l1c1 << l1c2 << l1c3
}
// Tests focus corrects itself when a tree is added to a canvas for the first time
-void tst_qsgitem::addedToCanvas()
+void tst_qquickitem::addedToCanvas()
{
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *item = new TestItem;
+ QQuickItem *item = new TestItem;
FocusState focusState;
focusState << item;
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *item = new TestItem(canvas.rootItem());
+ QQuickItem *item = new TestItem(canvas.rootItem());
- QSGItem *tree = new TestItem;
- QSGItem *c1 = new TestItem(tree);
- QSGItem *c2 = new TestItem(tree);
+ QQuickItem *tree = new TestItem;
+ QQuickItem *c1 = new TestItem(tree);
+ QQuickItem *c2 = new TestItem(tree);
FocusState focusState;
focusState << item << tree << c1 << c2;
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *tree = new TestItem;
- QSGItem *c1 = new TestItem(tree);
- QSGItem *c2 = new TestItem(tree);
+ QQuickItem *tree = new TestItem;
+ QQuickItem *c1 = new TestItem(tree);
+ QQuickItem *c2 = new TestItem(tree);
FocusState focusState;
focusState << tree << c1 << c2;
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *tree = new TestFocusScope;
- QSGItem *c1 = new TestItem(tree);
- QSGItem *c2 = new TestItem(tree);
+ QQuickItem *tree = new TestFocusScope;
+ QQuickItem *c1 = new TestItem(tree);
+ QQuickItem *c2 = new TestItem(tree);
FocusState focusState;
focusState << tree << c1 << c2;
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *tree = new TestFocusScope;
- QSGItem *c1 = new TestItem(tree);
- QSGItem *c2 = new TestItem(tree);
+ QQuickItem *tree = new TestFocusScope;
+ QQuickItem *c1 = new TestItem(tree);
+ QQuickItem *c2 = new TestItem(tree);
FocusState focusState;
focusState << tree << c1 << c2;
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *child = new TestItem(canvas.rootItem());
- QSGItem *tree = new TestFocusScope;
- QSGItem *c1 = new TestItem(tree);
- QSGItem *c2 = new TestItem(tree);
+ QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickItem *tree = new TestFocusScope;
+ QQuickItem *c1 = new TestItem(tree);
+ QQuickItem *c2 = new TestItem(tree);
FocusState focusState;
focusState << child << tree << c1 << c2;
}
}
-void tst_qsgitem::changeParent()
+void tst_qquickitem::changeParent()
{
// Parent to no parent
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *child = new TestItem(canvas.rootItem());
+ QQuickItem *child = new TestItem(canvas.rootItem());
FocusState focusState;
focusState << child;
// Different parent, same focus scope
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *child = new TestItem(canvas.rootItem());
- QSGItem *child2 = new TestItem(canvas.rootItem());
+ QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickItem *child2 = new TestItem(canvas.rootItem());
FocusState focusState;
focusState << child << child2;
// Different parent, different focus scope
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *child = new TestItem(canvas.rootItem());
- QSGItem *child2 = new TestFocusScope(canvas.rootItem());
- QSGItem *item = new TestItem(child);
+ QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+ QQuickItem *item = new TestItem(child);
FocusState focusState;
focusState << child << child2 << item;
FVERIFY();
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *child = new TestItem(canvas.rootItem());
- QSGItem *child2 = new TestFocusScope(canvas.rootItem());
- QSGItem *item = new TestItem(child2);
+ QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+ QQuickItem *item = new TestItem(child2);
FocusState focusState;
focusState << child << child2 << item;
FVERIFY();
}
{
- QSGCanvas canvas;
+ QQuickCanvas canvas;
ensureFocus(&canvas);
- QSGItem *child = new TestItem(canvas.rootItem());
- QSGItem *child2 = new TestFocusScope(canvas.rootItem());
- QSGItem *item = new TestItem(child2);
+ QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+ QQuickItem *item = new TestItem(child2);
FocusState focusState;
focusState << child << child2 << item;
}
-void tst_qsgitem::constructor()
+void tst_qquickitem::constructor()
{
- QSGItem *root = new QSGItem;
+ QQuickItem *root = new QQuickItem;
QVERIFY(root->parent() == 0);
QVERIFY(root->parentItem() == 0);
- QSGItem *child1 = new QSGItem(root);
+ QQuickItem *child1 = new QQuickItem(root);
QVERIFY(child1->parent() == root);
QVERIFY(child1->parentItem() == root);
QCOMPARE(root->childItems().count(), 1);
QCOMPARE(root->childItems().at(0), child1);
- QSGItem *child2 = new QSGItem(root);
+ QQuickItem *child2 = new QQuickItem(root);
QVERIFY(child2->parent() == root);
QVERIFY(child2->parentItem() == root);
QCOMPARE(root->childItems().count(), 2);
delete root;
}
-void tst_qsgitem::setParentItem()
+void tst_qquickitem::setParentItem()
{
- QSGItem *root = new QSGItem;
+ QQuickItem *root = new QQuickItem;
QVERIFY(root->parent() == 0);
QVERIFY(root->parentItem() == 0);
- QSGItem *child1 = new QSGItem;
+ QQuickItem *child1 = new QQuickItem;
QVERIFY(child1->parent() == 0);
QVERIFY(child1->parentItem() == 0);
QCOMPARE(root->childItems().count(), 1);
QCOMPARE(root->childItems().at(0), child1);
- QSGItem *child2 = new QSGItem;
+ QQuickItem *child2 = new QQuickItem;
QVERIFY(child2->parent() == 0);
QVERIFY(child2->parentItem() == 0);
child2->setParentItem(root);
delete child2;
}
-void tst_qsgitem::visible()
+void tst_qquickitem::visible()
{
- QSGItem *root = new QSGItem;
+ QQuickItem *root = new QQuickItem;
- QSGItem *child1 = new QSGItem;
+ QQuickItem *child1 = new QQuickItem;
child1->setParentItem(root);
- QSGItem *child2 = new QSGItem;
+ QQuickItem *child2 = new QQuickItem;
child2->setParentItem(root);
QVERIFY(child1->isVisible());
delete child2;
}
-void tst_qsgitem::enabled()
+void tst_qquickitem::enabled()
{
- QSGItem *root = new QSGItem;
+ QQuickItem *root = new QQuickItem;
- QSGItem *child1 = new QSGItem;
+ QQuickItem *child1 = new QQuickItem;
child1->setParentItem(root);
- QSGItem *child2 = new QSGItem;
+ QQuickItem *child2 = new QQuickItem;
child2->setParentItem(root);
QVERIFY(child1->isEnabled());
delete child2;
}
-void tst_qsgitem::mouseGrab()
+void tst_qquickitem::mouseGrab()
{
- QSGCanvas *canvas = new QSGCanvas;
+ QQuickCanvas *canvas = new QQuickCanvas;
canvas->resize(200, 200);
canvas->show();
delete canvas;
}
-void tst_qsgitem::polishOutsideAnimation()
+void tst_qquickitem::polishOutsideAnimation()
{
- QSGCanvas *canvas = new QSGCanvas;
+ QQuickCanvas *canvas = new QQuickCanvas;
canvas->resize(200, 200);
canvas->show();
delete canvas;
}
-void tst_qsgitem::wheelEvent_data()
+void tst_qquickitem::wheelEvent_data()
{
QTest::addColumn<bool>("visible");
QTest::addColumn<bool>("enabled");
QTest::newRow("invisible and disabled") << false << false;
}
-void tst_qsgitem::wheelEvent()
+void tst_qquickitem::wheelEvent()
{
QFETCH(bool, visible);
QFETCH(bool, enabled);
const bool shouldReceiveWheelEvents = visible && enabled;
- QSGCanvas *canvas = new QSGCanvas;
+ QQuickCanvas *canvas = new QQuickCanvas;
canvas->resize(200, 200);
canvas->show();
delete canvas;
}
-class HoverItem : public QSGItem
+class HoverItem : public QQuickItem
{
Q_OBJECT
public:
- HoverItem(QSGItem *parent = 0)
- : QSGItem(parent), hoverEnterCount(0), hoverMoveCount(0), hoverLeaveCount(0)
+ HoverItem(QQuickItem *parent = 0)
+ : QQuickItem(parent), hoverEnterCount(0), hoverMoveCount(0), hoverLeaveCount(0)
{ }
void resetCounters() {
hoverEnterCount = 0;
}
};
-void tst_qsgitem::hoverEvent_data()
+void tst_qquickitem::hoverEvent_data()
{
QTest::addColumn<bool>("visible");
QTest::addColumn<bool>("enabled");
QApplication::sendEvent(object, &moveEvent);
}
-void tst_qsgitem::hoverEvent()
+void tst_qquickitem::hoverEvent()
{
QFETCH(bool, visible);
QFETCH(bool, enabled);
QFETCH(bool, acceptHoverEvents);
- QSGCanvas *canvas = new QSGCanvas();
+ QQuickCanvas *canvas = new QQuickCanvas();
canvas->resize(200, 200);
canvas->show();
delete canvas;
}
-void tst_qsgitem::hoverEventInParent()
+void tst_qquickitem::hoverEventInParent()
{
- QSGCanvas *canvas = new QSGCanvas();
+ QQuickCanvas *canvas = new QQuickCanvas();
canvas->resize(200, 200);
canvas->show();
delete canvas;
}
-QTEST_MAIN(tst_qsgitem)
+QTEST_MAIN(tst_qquickitem)
-#include "tst_qsgitem.moc"
+#include "tst_qquickitem.moc"
CONFIG += testcase
-TARGET = tst_qsgitem
+TARGET = tst_qquickitem
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgitem.cpp
+SOURCES += tst_qquickitem.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativecontext.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgitem_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquickitem_p.h>
#include "../shared/util.h"
-class tst_QSGItem : public QObject
+class tst_QQuickItem : public QObject
{
Q_OBJECT
public:
- tst_QSGItem();
+ tst_QQuickItem();
private slots:
void initTestCase();
};
template<typename T>
-T *findItem(QSGItem *parent, const QString &objectName)
+T *findItem(QQuickItem *parent, const QString &objectName)
{
if (!parent)
return 0;
const QMetaObject &mo = T::staticMetaObject;
- //qDebug() << parent->QSGItem::children().count() << "children";
+ //qDebug() << parent->QQuickItem::children().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
private:
};
-class KeyTestItem : public QSGItem
+class KeyTestItem : public QQuickItem
{
Q_OBJECT
public:
- KeyTestItem(QSGItem *parent=0) : QSGItem(parent), mKey(0) {}
+ KeyTestItem(QQuickItem *parent=0) : QQuickItem(parent), mKey(0) {}
protected:
void keyPressEvent(QKeyEvent *e) {
QML_DECLARE_TYPE(KeyTestItem);
-tst_QSGItem::tst_QSGItem()
+tst_QQuickItem::tst_QQuickItem()
{
}
-void tst_QSGItem::initTestCase()
+void tst_QQuickItem::initTestCase()
{
qmlRegisterType<KeyTestItem>("Test",1,0,"KeyTestItem");
}
-void tst_QSGItem::keys()
+void tst_QQuickItem::keys()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
KeysTestObject *testObject = new KeysTestObject;
delete testObject;
}
-void tst_QSGItem::keysProcessingOrder()
+void tst_QQuickItem::keysProcessingOrder()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
KeysTestObject *testObject = new KeysTestObject;
delete testObject;
}
-QSGItemPrivate *childPrivate(QSGItem *rootItem, const char * itemString)
+QQuickItemPrivate *childPrivate(QQuickItem *rootItem, const char * itemString)
{
- QSGItem *item = findItem<QSGItem>(rootItem, QString(QLatin1String(itemString)));
- QSGItemPrivate* itemPrivate = QSGItemPrivate::get(item);
+ QQuickItem *item = findItem<QQuickItem>(rootItem, QString(QLatin1String(itemString)));
+ QQuickItemPrivate* itemPrivate = QQuickItemPrivate::get(item);
return itemPrivate;
}
-QVariant childProperty(QSGItem *rootItem, const char * itemString, const char * property)
+QVariant childProperty(QQuickItem *rootItem, const char * itemString, const char * property)
{
- QSGItem *item = findItem<QSGItem>(rootItem, QString(QLatin1String(itemString)));
+ QQuickItem *item = findItem<QQuickItem>(rootItem, QString(QLatin1String(itemString)));
return item->property(property);
}
-bool anchorsMirrored(QSGItem *rootItem, const char * itemString)
+bool anchorsMirrored(QQuickItem *rootItem, const char * itemString)
{
- QSGItem *item = findItem<QSGItem>(rootItem, QString(QLatin1String(itemString)));
- QSGItemPrivate* itemPrivate = QSGItemPrivate::get(item);
+ QQuickItem *item = findItem<QQuickItem>(rootItem, QString(QLatin1String(itemString)));
+ QQuickItemPrivate* itemPrivate = QQuickItemPrivate::get(item);
return itemPrivate->anchors()->mirrored();
}
-void tst_QSGItem::layoutMirroring()
+void tst_QQuickItem::layoutMirroring()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("layoutmirroring.qml")));
canvas->show();
- QSGItem *rootItem = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(rootItem);
- QSGItemPrivate *rootPrivate = QSGItemPrivate::get(rootItem);
+ QQuickItemPrivate *rootPrivate = QQuickItemPrivate::get(rootItem);
QVERIFY(rootPrivate);
QCOMPARE(childPrivate(rootItem, "mirrored1")->effectiveLayoutMirror, true);
//
// dynamic parenting
//
- QSGItem *parentItem1 = new QSGItem();
- QSGItemPrivate::get(parentItem1)->effectiveLayoutMirror = true; // LayoutMirroring.enabled: true
- QSGItemPrivate::get(parentItem1)->isMirrorImplicit = false;
- QSGItemPrivate::get(parentItem1)->inheritMirrorFromItem = true; // LayoutMirroring.childrenInherit: true
- QSGItemPrivate::get(parentItem1)->resolveLayoutMirror();
+ QQuickItem *parentItem1 = new QQuickItem();
+ QQuickItemPrivate::get(parentItem1)->effectiveLayoutMirror = true; // LayoutMirroring.enabled: true
+ QQuickItemPrivate::get(parentItem1)->isMirrorImplicit = false;
+ QQuickItemPrivate::get(parentItem1)->inheritMirrorFromItem = true; // LayoutMirroring.childrenInherit: true
+ QQuickItemPrivate::get(parentItem1)->resolveLayoutMirror();
// inherit in constructor
- QSGItem *childItem1 = new QSGItem(parentItem1);
- QCOMPARE(QSGItemPrivate::get(childItem1)->effectiveLayoutMirror, true);
- QCOMPARE(QSGItemPrivate::get(childItem1)->inheritMirrorFromParent, true);
+ QQuickItem *childItem1 = new QQuickItem(parentItem1);
+ QCOMPARE(QQuickItemPrivate::get(childItem1)->effectiveLayoutMirror, true);
+ QCOMPARE(QQuickItemPrivate::get(childItem1)->inheritMirrorFromParent, true);
// inherit through a parent change
- QSGItem *childItem2 = new QSGItem();
- QCOMPARE(QSGItemPrivate::get(childItem2)->effectiveLayoutMirror, false);
- QCOMPARE(QSGItemPrivate::get(childItem2)->inheritMirrorFromParent, false);
+ QQuickItem *childItem2 = new QQuickItem();
+ QCOMPARE(QQuickItemPrivate::get(childItem2)->effectiveLayoutMirror, false);
+ QCOMPARE(QQuickItemPrivate::get(childItem2)->inheritMirrorFromParent, false);
childItem2->setParentItem(parentItem1);
- QCOMPARE(QSGItemPrivate::get(childItem2)->effectiveLayoutMirror, true);
- QCOMPARE(QSGItemPrivate::get(childItem2)->inheritMirrorFromParent, true);
+ QCOMPARE(QQuickItemPrivate::get(childItem2)->effectiveLayoutMirror, true);
+ QCOMPARE(QQuickItemPrivate::get(childItem2)->inheritMirrorFromParent, true);
// stop inherting through a parent change
- QSGItem *parentItem2 = new QSGItem();
- QSGItemPrivate::get(parentItem2)->effectiveLayoutMirror = true; // LayoutMirroring.enabled: true
- QSGItemPrivate::get(parentItem2)->resolveLayoutMirror();
+ QQuickItem *parentItem2 = new QQuickItem();
+ QQuickItemPrivate::get(parentItem2)->effectiveLayoutMirror = true; // LayoutMirroring.enabled: true
+ QQuickItemPrivate::get(parentItem2)->resolveLayoutMirror();
childItem2->setParentItem(parentItem2);
- QCOMPARE(QSGItemPrivate::get(childItem2)->effectiveLayoutMirror, false);
- QCOMPARE(QSGItemPrivate::get(childItem2)->inheritMirrorFromParent, false);
+ QCOMPARE(QQuickItemPrivate::get(childItem2)->effectiveLayoutMirror, false);
+ QCOMPARE(QQuickItemPrivate::get(childItem2)->inheritMirrorFromParent, false);
delete parentItem1;
delete parentItem2;
}
-void tst_QSGItem::layoutMirroringIllegalParent()
+void tst_QQuickItem::layoutMirroringIllegalParent()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; QtObject { LayoutMirroring.enabled: true; LayoutMirroring.childrenInherit: true }", QUrl::fromLocalFile(""));
QVERIFY(object != 0);
}
-void tst_QSGItem::keyNavigation()
+void tst_QQuickItem::keyNavigation()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("keynavigationtest.qml")));
QFocusEvent fe(QEvent::FocusIn);
QApplication::sendEvent(canvas, &fe);
- QSGItem *item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
delete canvas;
}
-void tst_QSGItem::keyNavigation_RightToLeft()
+void tst_QQuickItem::keyNavigation_RightToLeft()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("keynavigationtest.qml")));
canvas->show();
qApp->processEvents();
- QSGItem *rootItem = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(rootItem);
- QSGItemPrivate* rootItemPrivate = QSGItemPrivate::get(rootItem);
+ QQuickItemPrivate* rootItemPrivate = QQuickItemPrivate::get(rootItem);
rootItemPrivate->effectiveLayoutMirror = true; // LayoutMirroring.mirror: true
rootItemPrivate->isMirrorImplicit = false;
QFocusEvent fe(QEvent::FocusIn);
QApplication::sendEvent(canvas, &fe);
- QSGItem *item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
delete canvas;
}
-void tst_QSGItem::keyNavigation_skipNotVisible()
+void tst_QQuickItem::keyNavigation_skipNotVisible()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("keynavigationtest.qml")));
QFocusEvent fe(QEvent::FocusIn);
QApplication::sendEvent(canvas, &fe);
- QSGItem *item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// Set item 2 to not visible
- item = findItem<QSGItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item2");
QVERIFY(item);
item->setVisible(false);
QVERIFY(!item->isVisible());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
//Set item 3 to not visible
- item = findItem<QSGItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item3");
QVERIFY(item);
item->setVisible(false);
QVERIFY(!item->isVisible());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
delete canvas;
}
-void tst_QSGItem::keyNavigation_implicitSetting()
+void tst_QQuickItem::keyNavigation_implicitSetting()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("keynavigationtest_implicit.qml")));
QFocusEvent fe(QEvent::FocusIn);
QApplication::sendEvent(canvas, &fe);
- QSGItem *item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QApplication::sendEvent(canvas, &key);
QVERIFY(key.isAccepted());
- item = findItem<QSGItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(canvas->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
delete canvas;
}
-void tst_QSGItem::smooth()
+void tst_QQuickItem::smooth()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0; Item { smooth: false; }", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QSignalSpy spy(item, SIGNAL(smoothChanged(bool)));
QVERIFY(item);
delete item;
}
-void tst_QSGItem::clip()
+void tst_QQuickItem::clip()
{
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0\nItem { clip: false\n }", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QSignalSpy spy(item, SIGNAL(clipChanged(bool)));
QVERIFY(item);
delete item;
}
-void tst_QSGItem::mapCoordinates()
+void tst_QQuickItem::mapCoordinates()
{
QFETCH(int, x);
QFETCH(int, y);
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(300, 300));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("mapCoordinates.qml")));
canvas->show();
qApp->processEvents();
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root != 0);
- QSGItem *a = findItem<QSGItem>(canvas->rootObject(), "itemA");
+ QQuickItem *a = findItem<QQuickItem>(canvas->rootObject(), "itemA");
QVERIFY(a != 0);
- QSGItem *b = findItem<QSGItem>(canvas->rootObject(), "itemB");
+ QQuickItem *b = findItem<QQuickItem>(canvas->rootObject(), "itemB");
QVERIFY(b != 0);
QVariant result;
QVERIFY(QMetaObject::invokeMethod(root, "mapAToB",
Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));
- QCOMPARE(result.value<QPointF>(), qobject_cast<QSGItem*>(a)->mapToItem(b, QPointF(x, y)));
+ QCOMPARE(result.value<QPointF>(), qobject_cast<QQuickItem*>(a)->mapToItem(b, QPointF(x, y)));
QVERIFY(QMetaObject::invokeMethod(root, "mapAFromB",
Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));
- QCOMPARE(result.value<QPointF>(), qobject_cast<QSGItem*>(a)->mapFromItem(b, QPointF(x, y)));
+ QCOMPARE(result.value<QPointF>(), qobject_cast<QQuickItem*>(a)->mapFromItem(b, QPointF(x, y)));
QVERIFY(QMetaObject::invokeMethod(root, "mapAToNull",
Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));
- QCOMPARE(result.value<QPointF>(), qobject_cast<QSGItem*>(a)->mapToScene(QPointF(x, y)));
+ QCOMPARE(result.value<QPointF>(), qobject_cast<QQuickItem*>(a)->mapToScene(QPointF(x, y)));
QVERIFY(QMetaObject::invokeMethod(root, "mapAFromNull",
Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));
- QCOMPARE(result.value<QPointF>(), qobject_cast<QSGItem*>(a)->mapFromScene(QPointF(x, y)));
+ QCOMPARE(result.value<QPointF>(), qobject_cast<QQuickItem*>(a)->mapFromScene(QPointF(x, y)));
QString warning1 = QUrl::fromLocalFile(TESTDATA("mapCoordinates.qml")).toString() + ":48:5: QML Item: mapToItem() given argument \"1122\" which is neither null nor an Item";
QString warning2 = QUrl::fromLocalFile(TESTDATA("mapCoordinates.qml")).toString() + ":48:5: QML Item: mapFromItem() given argument \"1122\" which is neither null nor an Item";
delete canvas;
}
-void tst_QSGItem::mapCoordinates_data()
+void tst_QQuickItem::mapCoordinates_data()
{
QTest::addColumn<int>("x");
QTest::addColumn<int>("y");
QTest::newRow(QTest::toString(i)) << i << i;
}
-void tst_QSGItem::transforms_data()
+void tst_QQuickItem::transforms_data()
{
QTest::addColumn<QByteArray>("qml");
QTest::addColumn<QTransform>("transform");
<< QTransform(1,0,0,0,1,0,10,20,1) * QTransform(1.5,0,0,0,-2,0,0,0,1);
}
-void tst_QSGItem::transforms()
+void tst_QQuickItem::transforms()
{
QFETCH(QByteArray, qml);
QFETCH(QTransform, transform);
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0\nItem { transform: "+qml+"}", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(item->itemTransform(0,0), transform);
}
-void tst_QSGItem::childrenProperty()
+void tst_QQuickItem::childrenProperty()
{
QDeclarativeComponent component(&engine, TESTDATA("childrenProperty.qml"));
delete o;
}
-void tst_QSGItem::resourcesProperty()
+void tst_QQuickItem::resourcesProperty()
{
QDeclarativeComponent component(&engine, TESTDATA("resourcesProperty.qml"));
delete o;
}
-void tst_QSGItem::propertyChanges()
+void tst_QQuickItem::propertyChanges()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(300, 300));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychanges.qml")));
canvas->show();
QTest::qWaitForWindowShown(canvas);
- QSGItem *item = findItem<QSGItem>(canvas->rootObject(), "item");
- QSGItem *parentItem = findItem<QSGItem>(canvas->rootObject(), "parentItem");
+ QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item");
+ QQuickItem *parentItem = findItem<QQuickItem>(canvas->rootObject(), "parentItem");
QVERIFY(item);
QVERIFY(parentItem);
- QSignalSpy parentSpy(item, SIGNAL(parentChanged(QSGItem *)));
+ QSignalSpy parentSpy(item, SIGNAL(parentChanged(QQuickItem *)));
QSignalSpy widthSpy(item, SIGNAL(widthChanged()));
QSignalSpy heightSpy(item, SIGNAL(heightChanged()));
QSignalSpy baselineOffsetSpy(item, SIGNAL(baselineOffsetChanged(qreal)));
QCOMPARE(parentSpy.count(),1);
QList<QVariant> parentArguments = parentSpy.first();
QVERIFY(parentArguments.count() == 1);
- QCOMPARE(item->parentItem(), qvariant_cast<QSGItem *>(parentArguments.at(0)));
+ QCOMPARE(item->parentItem(), qvariant_cast<QQuickItem *>(parentArguments.at(0)));
QCOMPARE(childrenChangedSpy.count(),1);
item->setParentItem(parentItem);
delete canvas;
}
-void tst_QSGItem::childrenRect()
+void tst_QQuickItem::childrenRect()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("childrenRect.qml")));
canvas->setBaseSize(QSize(240,320));
canvas->show();
- QSGItem *o = canvas->rootObject();
- QSGItem *item = o->findChild<QSGItem*>("testItem");
+ QQuickItem *o = canvas->rootObject();
+ QQuickItem *item = o->findChild<QQuickItem*>("testItem");
QCOMPARE(item->width(), qreal(0));
QCOMPARE(item->height(), qreal(0));
}
// QTBUG-11383
-void tst_QSGItem::childrenRectBug()
+void tst_QQuickItem::childrenRectBug()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("childrenRectBug.qml")));
canvas->show();
- QSGItem *o = canvas->rootObject();
- QSGItem *item = o->findChild<QSGItem*>("theItem");
+ QQuickItem *o = canvas->rootObject();
+ QQuickItem *item = o->findChild<QQuickItem*>("theItem");
QCOMPARE(item->width(), qreal(200));
QCOMPARE(item->height(), qreal(100));
QCOMPARE(item->x(), qreal(100));
}
// QTBUG-11465
-void tst_QSGItem::childrenRectBug2()
+void tst_QQuickItem::childrenRectBug2()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("childrenRectBug2.qml")));
canvas->show();
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(canvas->rootObject());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(canvas->rootObject());
QVERIFY(rect);
- QSGItem *item = rect->findChild<QSGItem*>("theItem");
+ QQuickItem *item = rect->findChild<QQuickItem*>("theItem");
QCOMPARE(item->width(), qreal(100));
QCOMPARE(item->height(), qreal(110));
QCOMPARE(item->x(), qreal(130));
- QSGItemPrivate *rectPrivate = QSGItemPrivate::get(rect);
+ QQuickItemPrivate *rectPrivate = QQuickItemPrivate::get(rect);
rectPrivate->setState("row");
QCOMPARE(item->width(), qreal(210));
QCOMPARE(item->height(), qreal(50));
}
// QTBUG-12722
-void tst_QSGItem::childrenRectBug3()
+void tst_QQuickItem::childrenRectBug3()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("childrenRectBug3.qml")));
canvas->show();
}
// QTBUG-13893
-void tst_QSGItem::transformCrash()
+void tst_QQuickItem::transformCrash()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("transformCrash.qml")));
canvas->show();
delete canvas;
}
-void tst_QSGItem::implicitSize()
+void tst_QQuickItem::implicitSize()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("implicitsize.qml")));
canvas->show();
- QSGItem *item = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *item = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(item);
QCOMPARE(item->width(), qreal(80));
QCOMPARE(item->height(), qreal(60));
delete canvas;
}
-void tst_QSGItem::qtbug_16871()
+void tst_QQuickItem::qtbug_16871()
{
QDeclarativeComponent component(&engine, TESTDATA("qtbug_16871.qml"));
QObject *o = component.create();
delete o;
}
-QTEST_MAIN(tst_QSGItem)
+QTEST_MAIN(tst_QQuickItem)
-#include "tst_qsgitem.moc"
+#include "tst_qquickitem.moc"
CONFIG += testcase
-TARGET = tst_qsglistview
+TARGET = tst_qquicklistview
macx:CONFIG -= app_bundle
HEADERS += incrementalmodel.h
-SOURCES += tst_qsglistview.cpp incrementalmodel.cpp
+SOURCES += tst_qquicklistview.cpp incrementalmodel.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtTest/QtTest>
#include <QtWidgets/QStringListModel>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeexpression.h>
-#include <QtDeclarative/private/qsgitem_p.h>
-#include <QtDeclarative/private/qsglistview_p.h>
-#include <QtDeclarative/private/qsgtext_p.h>
-#include <QtDeclarative/private/qsgvisualitemmodel_p.h>
+#include <QtDeclarative/private/qquickitem_p.h>
+#include <QtDeclarative/private/qquicklistview_p.h>
+#include <QtDeclarative/private/qquicktext_p.h>
+#include <QtDeclarative/private/qquickvisualitemmodel_p.h>
#include <QtDeclarative/private/qdeclarativelistmodel_p.h>
#include <QtDeclarative/private/qlistmodelinterface_p.h>
#include <QtDeclarative/private/qdeclarativechangeset_p.h>
#include <math.h>
Q_DECLARE_METATYPE(Qt::LayoutDirection)
-Q_DECLARE_METATYPE(QSGListView::Orientation)
+Q_DECLARE_METATYPE(QQuickListView::Orientation)
-class tst_QSGListView : public QObject
+class tst_QQuickListView : public QObject
{
Q_OBJECT
public:
- tst_QSGListView();
+ tst_QQuickListView();
private slots:
void initTestCase();
template <class T> void removed(bool animated);
template <class T> void moved();
template <class T> void clear();
- QSGView *createView();
- void flick(QSGView *canvas, const QPoint &from, const QPoint &to, int duration);
- QSGItem *findVisibleChild(QSGItem *parent, const QString &objectName);
+ QQuickView *createView();
+ void flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration);
+ QQuickItem *findVisibleChild(QQuickItem *parent, const QString &objectName);
template<typename T>
- T *findItem(QSGItem *parent, const QString &id, int index=-1);
+ T *findItem(QQuickItem *parent, const QString &id, int index=-1);
template<typename T>
- QList<T*> findItems(QSGItem *parent, const QString &objectName);
- void dumpTree(QSGItem *parent, int depth = 0);
+ QList<T*> findItems(QQuickItem *parent, const QString &objectName);
+ void dumpTree(QQuickItem *parent, int depth = 0);
void inserted_more_data();
void moved_data();
};
-void tst_QSGListView::initTestCase()
+void tst_QQuickListView::initTestCase()
{
}
-void tst_QSGListView::cleanupTestCase()
+void tst_QQuickListView::cleanupTestCase()
{
}
};
template<typename T>
-void tst_qsglistview_move(int from, int to, int n, T *items)
+void tst_qquicklistview_move(int from, int to, int n, T *items)
{
if (from > to) {
// Only move forwards - flip if backwards moving
}
void moveItems(int from, int to, int count) {
- tst_qsglistview_move(from, to, count, &list);
+ tst_qquicklistview_move(from, to, count, &list);
emit itemsMoved(from, to, count);
}
void moveItems(int from, int to, int count) {
emit beginMoveRows(QModelIndex(), from, from+count-1, QModelIndex(), to > from ? to+count : to);
- tst_qsglistview_move(from, to, count, &list);
+ tst_qquicklistview_move(from, to, count, &list);
emit endMoveRows();
}
QList<QPair<QString,QString> > list;
};
-tst_QSGListView::tst_QSGListView()
+tst_QQuickListView::tst_QQuickListView()
{
}
template <class T>
-void tst_QSGListView::items()
+void tst_QQuickListView::items()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
T model;
model.addItem("Fred", "12345");
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
// current item should be first item
- QTRY_COMPARE(listview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 0));
+ QTRY_COMPARE(listview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 0));
for (int i = 0; i < model.count(); ++i) {
- QSGText *name = findItem<QSGText>(contentItem, "textName", i);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", i);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", i);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
T model2;
ctxt->setContextProperty("testModel", &model2);
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QTRY_VERIFY(itemCount == 0);
QTRY_COMPARE(listview->highlightResizeSpeed(), 1000.0);
template <class T>
-void tst_QSGListView::changed()
+void tst_QQuickListView::changed()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
T model;
model.addItem("Fred", "12345");
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGFlickable *listview = findItem<QSGFlickable>(canvas->rootObject(), "list");
+ QQuickFlickable *listview = findItem<QQuickFlickable>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.modifyItem(1, "Will", "9876");
- QSGText *name = findItem<QSGText>(contentItem, "textName", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(1));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 1);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 1);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
}
template <class T>
-void tst_QSGListView::inserted()
+void tst_QQuickListView::inserted()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
T model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.insertItem(1, "Will", "9876");
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
- QSGText *name = findItem<QSGText>(contentItem, "textName", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(1));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 1);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 1);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
// Confirm items positioned correctly
for (int i = 0; i < model.count(); ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_COMPARE(item->y(), i*20.0);
}
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
- name = findItem<QSGText>(contentItem, "textName", 0);
+ name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- number = findItem<QSGText>(contentItem, "textNumber", 0);
+ number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
// Confirm items positioned correctly
for (int i = 0; i < model.count(); ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_COMPARE(item->y(), i*20.0);
}
// Confirm items positioned correctly
for (int i = 5; i < 5+15; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.0 - 20.0);
model.insertItem(0, "Hello", "1234");
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->y(), 0.);
QVERIFY(listview->contentY() == 0);
}
template <class T>
-void tst_QSGListView::inserted_more()
+void tst_QQuickListView::inserted_more()
{
QFETCH(qreal, contentY);
QFETCH(int, insertIndex);
QFETCH(int, insertCount);
QFETCH(qreal, itemsOffsetAfterMove);
- QSGText *name;
- QSGText *number;
- QSGView *canvas = createView();
+ QQuickText *name;
+ QQuickText *number;
+ QQuickView *canvas = createView();
canvas->show();
T model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
listview->setContentY(contentY);
QTRY_COMPARE(listview->property("count").toInt(), model.count());
// check visibleItems.first() is in correct position
- QSGItem *item0 = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item0 = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item0);
QCOMPARE(item0->y(), itemsOffsetAfterMove);
- QList<QSGItem*> items = findItems<QSGItem>(contentItem, "wrapper");
+ QList<QQuickItem*> items = findItems<QQuickItem>(contentItem, "wrapper");
int firstVisibleIndex = -1;
for (int i=0; i<items.count(); i++) {
if (items[i]->y() >= contentY) {
QVERIFY2(firstVisibleIndex >= 0, QTest::toString(firstVisibleIndex));
// Confirm items positioned correctly and indexes correct
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = firstVisibleIndex; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY2(item, QTest::toString(QString("Item %1 not found").arg(i)));
QTRY_COMPARE(item->y(), i*20.0 + itemsOffsetAfterMove);
- name = findItem<QSGText>(contentItem, "textName", i);
+ name = findItem<QQuickText>(contentItem, "textName", i);
QVERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- number = findItem<QSGText>(contentItem, "textNumber", i);
+ number = findItem<QQuickText>(contentItem, "textNumber", i);
QVERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
delete testObject;
}
-void tst_QSGListView::inserted_more_data()
+void tst_QQuickListView::inserted_more_data()
{
QTest::addColumn<qreal>("contentY");
QTest::addColumn<int>("insertIndex");
}
template <class T>
-void tst_QSGListView::removed(bool animated)
+void tst_QQuickListView::removed(bool animated)
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
T model;
for (int i = 0; i < 50; i++)
canvas->show();
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.removeItem(1);
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
- QSGText *name = findItem<QSGText>(contentItem, "textName", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(1));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 1);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 1);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_VERIFY(item->y() == i*20);
model.removeItem(0); // post: top item starts at 20
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
- name = findItem<QSGText>(contentItem, "textName", 0);
+ name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- number = findItem<QSGText>(contentItem, "textNumber", 0);
+ number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(),i*20.0 + 20.0);
QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(),i*20.0+20.0);
// Confirm items positioned correctly
for (int i = 2; i < 18; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(),40+i*20.0);
// Remove current index
QTRY_VERIFY(listview->currentIndex() == 9);
- QSGItem *oldCurrent = listview->currentItem();
+ QQuickItem *oldCurrent = listview->currentItem();
model.removeItem(9);
QTRY_COMPARE(listview->currentIndex(), 9);
QTest::qWait(300);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(),40+i*20.0);
QTRY_COMPARE(listview->count() , model.count());
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i+2);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i+2);
if (!item) qWarning() << "Item" << i+2 << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(),80+i*20.0);
model.addItem("New", "1");
QTRY_COMPARE(listview->count() , model.count());
- QTRY_VERIFY(name = findItem<QSGText>(contentItem, "textName", model.count()-1));
+ QTRY_VERIFY(name = findItem<QQuickText>(contentItem, "textName", model.count()-1));
QCOMPARE(name->text(), QString("New"));
// Add some more items so that we don't run out
listview->setCurrentIndex(0);
listview->setContentY(30);
model.removeItem(0);
- QTRY_VERIFY(name = findItem<QSGText>(contentItem, "textName", 0));
+ QTRY_VERIFY(name = findItem<QQuickText>(contentItem, "textName", 0));
// QTBUG-19198 move to end and remove all visible items one at a time.
listview->positionViewAtEnd();
for (int i = 0; i < 18; ++i)
model.removeItems(model.count() - 1, 1);
- QTRY_VERIFY(findItems<QSGItem>(contentItem, "wrapper").count() > 16);
+ QTRY_VERIFY(findItems<QQuickItem>(contentItem, "wrapper").count() > 16);
delete canvas;
delete testObject;
}
template <class T>
-void tst_QSGListView::clear()
+void tst_QQuickListView::clear()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
T model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
model.clear();
}
template <class T>
-void tst_QSGListView::moved()
+void tst_QQuickListView::moved()
{
QFETCH(qreal, contentY);
QFETCH(int, from);
QFETCH(int, count);
QFETCH(qreal, itemsOffsetAfterMove);
- QSGText *name;
- QSGText *number;
- QSGView *canvas = createView();
+ QQuickText *name;
+ QQuickText *number;
+ QQuickView *canvas = createView();
canvas->show();
T model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGItem *currentItem = listview->currentItem();
+ QQuickItem *currentItem = listview->currentItem();
QTRY_VERIFY(currentItem != 0);
listview->setContentY(contentY);
// wait for items to move
QTest::qWait(100);
- QList<QSGItem*> items = findItems<QSGItem>(contentItem, "wrapper");
+ QList<QQuickItem*> items = findItems<QQuickItem>(contentItem, "wrapper");
int firstVisibleIndex = -1;
for (int i=0; i<items.count(); i++) {
if (items[i]->y() >= contentY) {
QVERIFY2(firstVisibleIndex >= 0, QTest::toString(firstVisibleIndex));
// Confirm items positioned correctly and indexes correct
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = firstVisibleIndex; i < model.count() && i < itemCount; ++i) {
if (i >= firstVisibleIndex + 16) // index has moved out of view
continue;
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY2(item, QTest::toString(QString("Item %1 not found").arg(i)));
QTRY_COMPARE(item->y(), i*20.0 + itemsOffsetAfterMove);
- name = findItem<QSGText>(contentItem, "textName", i);
+ name = findItem<QQuickText>(contentItem, "textName", i);
QVERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- number = findItem<QSGText>(contentItem, "textNumber", i);
+ number = findItem<QQuickText>(contentItem, "textNumber", i);
QVERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
delete testObject;
}
-void tst_QSGListView::moved_data()
+void tst_QQuickListView::moved_data()
{
QTest::addColumn<qreal>("contentY");
QTest::addColumn<int>("from");
};
Q_DECLARE_METATYPE(QList<ListChange>)
-void tst_QSGListView::multipleChanges()
+void tst_QQuickListView::multipleChanges()
{
QFETCH(int, startCount);
QFETCH(QList<ListChange>, changes);
QFETCH(int, newCount);
QFETCH(int, newCurrentIndex);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
for (int i=0; i<changes.count(); i++) {
QCOMPARE(listview->count(), model.count());
QTRY_COMPARE(listview->currentIndex(), newCurrentIndex);
- QSGText *name;
- QSGText *number;
- QSGItem *contentItem = listview->contentItem();
+ QQuickText *name;
+ QQuickText *number;
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i=0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY2(item, QTest::toString(QString("Item %1 not found").arg(i)));
- name = findItem<QSGText>(contentItem, "textName", i);
+ name = findItem<QQuickText>(contentItem, "textName", i);
QVERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(i));
- number = findItem<QSGText>(contentItem, "textNumber", i);
+ number = findItem<QQuickText>(contentItem, "textNumber", i);
QVERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
delete canvas;
}
-void tst_QSGListView::multipleChanges_data()
+void tst_QQuickListView::multipleChanges_data()
{
QTest::addColumn<int>("startCount");
QTest::addColumn<QList<ListChange> >("changes");
) << 5 << -1;
}
-void tst_QSGListView::swapWithFirstItem()
+void tst_QQuickListView::swapWithFirstItem()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
// ensure content position is stable
delete canvas;
}
-void tst_QSGListView::enforceRange()
+void tst_QQuickListView::enforceRange()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listview-enforcerange.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QTRY_COMPARE(listview->preferredHighlightBegin(), 100.0);
QTRY_COMPARE(listview->preferredHighlightEnd(), 100.0);
- QTRY_COMPARE(listview->highlightRangeMode(), QSGListView::StrictlyEnforceRange);
+ QTRY_COMPARE(listview->highlightRangeMode(), QQuickListView::StrictlyEnforceRange);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// view should be positioned at the top of the range.
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QTRY_VERIFY(item);
QTRY_COMPARE(listview->contentY(), -100.0);
- QSGText *name = findItem<QSGText>(contentItem, "textName", 0);
+ QQuickText *name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
QTRY_COMPARE(name->text(), model.name(0));
- QSGText *number = findItem<QSGText>(contentItem, "textNumber", 0);
+ QQuickText *number = findItem<QQuickText>(contentItem, "textNumber", 0);
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(0));
delete canvas;
}
-void tst_QSGListView::enforceRange_withoutHighlight()
+void tst_QQuickListView::enforceRange_withoutHighlight()
{
// QTBUG-20287
// If no highlight is set but StrictlyEnforceRange is used, the content should still move
// to the correct position (i.e. to the next/previous item, not next/previous section)
// when moving up/down via incrementCurrentIndex() and decrementCurrentIndex()
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
QTest::qWait(200);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listview-enforcerange-nohighlight.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
qreal expectedPos = -100.0;
delete canvas;
}
-void tst_QSGListView::spacing()
+void tst_QQuickListView::spacing()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_VERIFY(item->y() == i*20);
QTRY_VERIFY(listview->spacing() == 10);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_VERIFY(item->y() == i*30);
listview->setSpacing(0);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.0);
delete testObject;
}
-void tst_QSGListView::sections()
+void tst_QQuickListView::sections()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listview-sections.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20 + ((i+4)/5) * 20));
- QSGText *next = findItem<QSGText>(item, "nextSection");
+ QQuickText *next = findItem<QQuickText>(item, "nextSection");
QCOMPARE(next->text().toInt(), (i+1)/5);
}
QTRY_COMPARE(listview->count(), model.count());
// New section header created
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 5);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 5);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 40.0);
QTRY_COMPARE(listview->count(), model.count());
// Section header moved
- item = findItem<QSGItem>(contentItem, "wrapper", 5);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 5);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 20.0);
- item = findItem<QSGItem>(contentItem, "wrapper", 6);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 6);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 40.0);
model.insertItem(6, "Replace header", "1");
QTRY_COMPARE(listview->count(), model.count());
- item = findItem<QSGItem>(contentItem, "wrapper", 6);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 6);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 40.0);
- item = findItem<QSGItem>(contentItem, "wrapper", 7);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 7);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 20.0);
QTRY_COMPARE(currentSectionChangedSpy.count(), 2);
- item = findItem<QSGItem>(contentItem, "wrapper", 1);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 1);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 20.0);
model.modifyItem(0, "changed", "2");
QTest::qWait(300);
- item = findItem<QSGItem>(contentItem, "wrapper", 1);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 1);
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 40.0);
delete canvas;
}
-void tst_QSGListView::sectionsDelegate()
+void tst_QQuickListView::sectionsDelegate()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listview-sections_delegate.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20 + ((i+5)/5) * 20));
- QSGText *next = findItem<QSGText>(item, "nextSection");
+ QQuickText *next = findItem<QQuickText>(item, "nextSection");
QCOMPARE(next->text().toInt(), (i+1)/5);
}
for (int i = 0; i < 3; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "sect_" + QString::number(i));
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "sect_" + QString::number(i));
QVERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20*6));
}
QTest::qWait(300);
for (int i = 0; i < 3; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem,
+ QQuickItem *item = findItem<QQuickItem>(contentItem,
"sect_" + (i == 0 ? QString("aaa") : QString::number(i)));
QVERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20*6));
model.removeItem(5);
QTRY_COMPARE(listview->count(), model.count());
for (int i = 0; i < 3; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem,
+ QQuickItem *item = findItem<QQuickItem>(contentItem,
"sect_" + (i == 0 ? QString("aaa") : QString::number(i)));
QVERIFY(item);
}
// QTBUG-17606
- QList<QSGItem*> items = findItems<QSGItem>(contentItem, "sect_1");
+ QList<QQuickItem*> items = findItems<QQuickItem>(contentItem, "sect_1");
QCOMPARE(items.count(), 1);
// QTBUG-17759
model.modifyItem(9, "Two", "aaa");
model.modifyItem(10, "Two", "aaa");
model.modifyItem(11, "Two", "aaa");
- QTRY_COMPARE(findItems<QSGItem>(contentItem, "sect_aaa").count(), 1);
+ QTRY_COMPARE(findItems<QQuickItem>(contentItem, "sect_aaa").count(), 1);
canvas->rootObject()->setProperty("sectionProperty", "name");
// ensure view has settled.
- QTRY_COMPARE(findItems<QSGItem>(contentItem, "sect_Four").count(), 1);
+ QTRY_COMPARE(findItems<QQuickItem>(contentItem, "sect_Four").count(), 1);
for (int i = 0; i < 4; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem,
+ QQuickItem *item = findItem<QQuickItem>(contentItem,
"sect_" + model.name(i*3));
QVERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20*4));
// QTBUG-17769
model.removeItems(10, 20);
// ensure view has settled.
- QTRY_COMPARE(findItems<QSGItem>(contentItem, "wrapper").count(), 10);
+ QTRY_COMPARE(findItems<QQuickItem>(contentItem, "wrapper").count(), 10);
// Drag view up beyond bounds
QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(20,20));
{
delete canvas;
}
-void tst_QSGListView::sectionsPositioning()
+void tst_QQuickListView::sectionsPositioning()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listview-sections_delegate.qml")));
qApp->processEvents();
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QSGViewSection::InlineLabels | QSGViewSection::CurrentLabelAtStart | QSGViewSection::NextLabelAtEnd)));
+ canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart | QQuickViewSection::NextLabelAtEnd)));
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
for (int i = 0; i < 3; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "sect_" + QString::number(i));
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "sect_" + QString::number(i));
QVERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20*6));
}
- QSGItem *topItem = findVisibleChild(contentItem, "sect_0"); // section header
+ QQuickItem *topItem = findVisibleChild(contentItem, "sect_0"); // section header
QVERIFY(topItem);
QCOMPARE(topItem->y(), 0.);
- QSGItem *bottomItem = findVisibleChild(contentItem, "sect_3"); // section footer
+ QQuickItem *bottomItem = findVisibleChild(contentItem, "sect_3"); // section footer
QVERIFY(bottomItem);
QCOMPARE(bottomItem->y(), 300.);
QVERIFY(topItem);
QCOMPARE(topItem->y(), 100.);
- QSGItem *item = findVisibleChild(contentItem, "sect_1");
+ QQuickItem *item = findVisibleChild(contentItem, "sect_1");
QVERIFY(item);
QCOMPARE(item->y(), 120.);
QTRY_COMPARE(listview->currentSection(), QString("aaa"));
for (int i = 0; i < 3; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem,
+ QQuickItem *item = findItem<QQuickItem>(contentItem,
"sect_" + (i == 0 ? QString("aaa") : QString::number(i)));
QVERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20*6));
model.removeItem(5);
QTRY_COMPARE(listview->count(), model.count());
for (int i = 0; i < 3; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem,
+ QQuickItem *item = findItem<QQuickItem>(contentItem,
"sect_" + (i == 0 ? QString("aaa") : QString::number(i)));
QVERIFY(item);
QTRY_COMPARE(item->y(), qreal(i*20*6));
// Turn sticky footer off
listview->setContentY(50);
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QSGViewSection::InlineLabels | QSGViewSection::CurrentLabelAtStart)));
+ canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart)));
item = findVisibleChild(contentItem, "sect_new"); // inline label restored
QCOMPARE(item->y(), 360.);
// Turn sticky header off
listview->setContentY(50);
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QSGViewSection::InlineLabels)));
+ canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels)));
item = findVisibleChild(contentItem, "sect_aaa"); // inline label restored
QCOMPARE(item->y(), 20.);
delete canvas;
}
-void tst_QSGListView::currentIndex_delayedItemCreation()
+void tst_QQuickListView::currentIndex_delayedItemCreation()
{
QFETCH(bool, setCurrentToZero);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("fillModelOnComponentCompleted.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QSignalSpy spy(listview, SIGNAL(currentIndexChanged()));
delete canvas;
}
-void tst_QSGListView::currentIndex_delayedItemCreation_data()
+void tst_QQuickListView::currentIndex_delayedItemCreation_data()
{
QTest::addColumn<bool>("setCurrentToZero");
QTest::newRow("don't set to 0") << false;
}
-void tst_QSGListView::currentIndex()
+void tst_QQuickListView::currentIndex()
{
TestModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
QDeclarativeContext *ctxt = canvas->rootContext();
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// current item should be 20th item at startup
// and current item should be in view
QCOMPARE(listview->currentIndex(), 20);
QCOMPARE(listview->contentY(), 100.0);
- QCOMPARE(listview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 20));
+ QCOMPARE(listview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 20));
QCOMPARE(listview->highlightItem()->y(), listview->currentItem()->y());
// no wrap
delete canvas;
}
-void tst_QSGListView::noCurrentIndex()
+void tst_QQuickListView::noCurrentIndex()
{
TestModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
QDeclarativeContext *ctxt = canvas->rootContext();
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// current index should be -1 at startup
delete canvas;
}
-void tst_QSGListView::itemList()
+void tst_QQuickListView::itemList()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("itemlist.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "view");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "view");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGVisualItemModel *model = canvas->rootObject()->findChild<QSGVisualItemModel*>("itemModel");
+ QQuickVisualItemModel *model = canvas->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
QTRY_COMPARE(listview->currentIndex(), 0);
- QSGItem *item = findItem<QSGItem>(contentItem, "item1");
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "item1");
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), 0.0);
QCOMPARE(item->height(), listview->height());
- QSGText *text = findItem<QSGText>(contentItem, "text1");
+ QQuickText *text = findItem<QQuickText>(contentItem, "text1");
QTRY_VERIFY(text);
QTRY_COMPARE(text->text(), QLatin1String("index: 0"));
listview->setCurrentIndex(2);
- item = findItem<QSGItem>(contentItem, "item3");
+ item = findItem<QQuickItem>(contentItem, "item3");
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), 480.0);
- text = findItem<QSGText>(contentItem, "text3");
+ text = findItem<QQuickText>(contentItem, "text3");
QTRY_VERIFY(text);
QTRY_COMPARE(text->text(), QLatin1String("index: 2"));
delete canvas;
}
-void tst_QSGListView::cacheBuffer()
+void tst_QQuickListView::cacheBuffer()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_VERIFY(listview->delegate() != 0);
QTRY_VERIFY(listview->model() != 0);
QTRY_VERIFY(listview->highlight() != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_VERIFY(item->y() == i*20);
testObject->setCacheBuffer(400);
QTRY_VERIFY(listview->cacheBuffer() == 400);
- int newItemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int newItemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QTRY_VERIFY(newItemCount > itemCount);
// Confirm items positioned correctly
for (int i = 0; i < model.count() && i < newItemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_VERIFY(item->y() == i*20);
delete testObject;
}
-void tst_QSGListView::positionViewAtIndex()
+void tst_QQuickListView::positionViewAtIndex()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 40; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
}
// Position on a currently visible item
- listview->positionViewAtIndex(3, QSGListView::Beginning);
+ listview->positionViewAtIndex(3, QQuickListView::Beginning);
QTRY_COMPARE(listview->contentY(), 60.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 3; i < model.count() && i < itemCount-3-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
}
// Position on an item beyond the visible items
- listview->positionViewAtIndex(22, QSGListView::Beginning);
+ listview->positionViewAtIndex(22, QQuickListView::Beginning);
QTRY_COMPARE(listview->contentY(), 440.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 22; i < model.count() && i < itemCount-22-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
}
// Position on an item that would leave empty space if positioned at the top
- listview->positionViewAtIndex(28, QSGListView::Beginning);
+ listview->positionViewAtIndex(28, QQuickListView::Beginning);
QTRY_COMPARE(listview->contentY(), 480.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 24; i < model.count() && i < itemCount-24-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
}
// Position at the beginning again
- listview->positionViewAtIndex(0, QSGListView::Beginning);
+ listview->positionViewAtIndex(0, QQuickListView::Beginning);
QTRY_COMPARE(listview->contentY(), 0.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount-1; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
}
// Position at End using last index
- listview->positionViewAtIndex(model.count()-1, QSGListView::End);
+ listview->positionViewAtIndex(model.count()-1, QQuickListView::End);
QTRY_COMPARE(listview->contentY(), 480.);
// Confirm items positioned correctly
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 24; i < model.count(); ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
}
// Position at End
- listview->positionViewAtIndex(20, QSGListView::End);
+ listview->positionViewAtIndex(20, QQuickListView::End);
QTRY_COMPARE(listview->contentY(), 100.);
// Position in Center
- listview->positionViewAtIndex(15, QSGListView::Center);
+ listview->positionViewAtIndex(15, QQuickListView::Center);
QTRY_COMPARE(listview->contentY(), 150.);
// Ensure at least partially visible
- listview->positionViewAtIndex(15, QSGListView::Visible);
+ listview->positionViewAtIndex(15, QQuickListView::Visible);
QTRY_COMPARE(listview->contentY(), 150.);
listview->setContentY(302);
- listview->positionViewAtIndex(15, QSGListView::Visible);
+ listview->positionViewAtIndex(15, QQuickListView::Visible);
QTRY_COMPARE(listview->contentY(), 302.);
listview->setContentY(320);
- listview->positionViewAtIndex(15, QSGListView::Visible);
+ listview->positionViewAtIndex(15, QQuickListView::Visible);
QTRY_COMPARE(listview->contentY(), 300.);
listview->setContentY(85);
- listview->positionViewAtIndex(20, QSGListView::Visible);
+ listview->positionViewAtIndex(20, QQuickListView::Visible);
QTRY_COMPARE(listview->contentY(), 85.);
listview->setContentY(75);
- listview->positionViewAtIndex(20, QSGListView::Visible);
+ listview->positionViewAtIndex(20, QQuickListView::Visible);
QTRY_COMPARE(listview->contentY(), 100.);
// Ensure completely visible
listview->setContentY(120);
- listview->positionViewAtIndex(20, QSGListView::Contain);
+ listview->positionViewAtIndex(20, QQuickListView::Contain);
QTRY_COMPARE(listview->contentY(), 120.);
listview->setContentY(302);
- listview->positionViewAtIndex(15, QSGListView::Contain);
+ listview->positionViewAtIndex(15, QQuickListView::Contain);
QTRY_COMPARE(listview->contentY(), 300.);
listview->setContentY(85);
- listview->positionViewAtIndex(20, QSGListView::Contain);
+ listview->positionViewAtIndex(20, QQuickListView::Contain);
QTRY_COMPARE(listview->contentY(), 100.);
// positionAtBeginnging
delete testObject;
}
-void tst_QSGListView::resetModel()
+void tst_QQuickListView::resetModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QStringList strings;
strings << "one" << "two" << "three";
canvas->setSource(QUrl::fromLocalFile(TESTDATA("displaylist.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(listview->count(), model.rowCount());
for (int i = 0; i < model.rowCount(); ++i) {
- QSGText *display = findItem<QSGText>(contentItem, "displayText", i);
+ QQuickText *display = findItem<QQuickText>(contentItem, "displayText", i);
QTRY_VERIFY(display != 0);
QTRY_COMPARE(display->text(), strings.at(i));
}
QTRY_COMPARE(listview->count(), model.rowCount());
for (int i = 0; i < model.rowCount(); ++i) {
- QSGText *display = findItem<QSGText>(contentItem, "displayText", i);
+ QQuickText *display = findItem<QQuickText>(contentItem, "displayText", i);
QTRY_VERIFY(display != 0);
QTRY_COMPARE(display->text(), strings.at(i));
}
delete canvas;
}
-void tst_QSGListView::propertyChanges()
+void tst_QQuickListView::propertyChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QTRY_VERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychangestest.qml")));
- QSGListView *listView = canvas->rootObject()->findChild<QSGListView*>("listView");
+ QQuickListView *listView = canvas->rootObject()->findChild<QQuickListView*>("listView");
QTRY_VERIFY(listView);
QSignalSpy highlightFollowsCurrentItemSpy(listView, SIGNAL(highlightFollowsCurrentItemChanged()));
QTRY_COMPARE(listView->highlightFollowsCurrentItem(), true);
QTRY_COMPARE(listView->preferredHighlightBegin(), 0.0);
QTRY_COMPARE(listView->preferredHighlightEnd(), 0.0);
- QTRY_COMPARE(listView->highlightRangeMode(), QSGListView::ApplyRange);
+ QTRY_COMPARE(listView->highlightRangeMode(), QQuickListView::ApplyRange);
QTRY_COMPARE(listView->isWrapEnabled(), true);
QTRY_COMPARE(listView->cacheBuffer(), 10);
- QTRY_COMPARE(listView->snapMode(), QSGListView::SnapToItem);
+ QTRY_COMPARE(listView->snapMode(), QQuickListView::SnapToItem);
listView->setHighlightFollowsCurrentItem(false);
listView->setPreferredHighlightBegin(1.0);
listView->setPreferredHighlightEnd(1.0);
- listView->setHighlightRangeMode(QSGListView::StrictlyEnforceRange);
+ listView->setHighlightRangeMode(QQuickListView::StrictlyEnforceRange);
listView->setWrapEnabled(false);
listView->setCacheBuffer(3);
- listView->setSnapMode(QSGListView::SnapOneItem);
+ listView->setSnapMode(QQuickListView::SnapOneItem);
QTRY_COMPARE(listView->highlightFollowsCurrentItem(), false);
QTRY_COMPARE(listView->preferredHighlightBegin(), 1.0);
QTRY_COMPARE(listView->preferredHighlightEnd(), 1.0);
- QTRY_COMPARE(listView->highlightRangeMode(), QSGListView::StrictlyEnforceRange);
+ QTRY_COMPARE(listView->highlightRangeMode(), QQuickListView::StrictlyEnforceRange);
QTRY_COMPARE(listView->isWrapEnabled(), false);
QTRY_COMPARE(listView->cacheBuffer(), 3);
- QTRY_COMPARE(listView->snapMode(), QSGListView::SnapOneItem);
+ QTRY_COMPARE(listView->snapMode(), QQuickListView::SnapOneItem);
QTRY_COMPARE(highlightFollowsCurrentItemSpy.count(),1);
QTRY_COMPARE(preferredHighlightBeginSpy.count(),1);
listView->setHighlightFollowsCurrentItem(false);
listView->setPreferredHighlightBegin(1.0);
listView->setPreferredHighlightEnd(1.0);
- listView->setHighlightRangeMode(QSGListView::StrictlyEnforceRange);
+ listView->setHighlightRangeMode(QQuickListView::StrictlyEnforceRange);
listView->setWrapEnabled(false);
listView->setCacheBuffer(3);
- listView->setSnapMode(QSGListView::SnapOneItem);
+ listView->setSnapMode(QQuickListView::SnapOneItem);
QTRY_COMPARE(highlightFollowsCurrentItemSpy.count(),1);
QTRY_COMPARE(preferredHighlightBeginSpy.count(),1);
delete canvas;
}
-void tst_QSGListView::componentChanges()
+void tst_QQuickListView::componentChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QTRY_VERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychangestest.qml")));
- QSGListView *listView = canvas->rootObject()->findChild<QSGListView*>("listView");
+ QQuickListView *listView = canvas->rootObject()->findChild<QQuickListView*>("listView");
QTRY_VERIFY(listView);
QDeclarativeComponent component(canvas->engine());
delete canvas;
}
-void tst_QSGListView::modelChanges()
+void tst_QQuickListView::modelChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QTRY_VERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychangestest.qml")));
- QSGListView *listView = canvas->rootObject()->findChild<QSGListView*>("listView");
+ QQuickListView *listView = canvas->rootObject()->findChild<QQuickListView*>("listView");
QTRY_VERIFY(listView);
QDeclarativeListModel *alternateModel = canvas->rootObject()->findChild<QDeclarativeListModel*>("alternateModel");
delete canvas;
}
-void tst_QSGListView::QTBUG_9791()
+void tst_QQuickListView::QTBUG_9791()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("strictlyenforcerange.qml")));
qApp->processEvents();
- QSGListView *listview = qobject_cast<QSGListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_VERIFY(listview->delegate() != 0);
QTRY_VERIFY(listview->model() != 0);
qApp->processEvents();
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QCOMPARE(itemCount, 3);
for (int i = 0; i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), i*300.0);
delete canvas;
}
-void tst_QSGListView::manualHighlight()
+void tst_QQuickListView::manualHighlight()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
QString filename(TESTDATA("manual-highlight.qml"));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(listview->currentIndex(), 0);
- QTRY_COMPARE(listview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 0));
+ QTRY_COMPARE(listview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 0));
QTRY_COMPARE(listview->highlightItem()->y() - 5, listview->currentItem()->y());
listview->setCurrentIndex(2);
QTRY_COMPARE(listview->currentIndex(), 2);
- QTRY_COMPARE(listview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 2));
+ QTRY_COMPARE(listview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 2));
QTRY_COMPARE(listview->highlightItem()->y() - 5, listview->currentItem()->y());
// QTBUG-15972
- listview->positionViewAtIndex(3, QSGListView::Contain);
+ listview->positionViewAtIndex(3, QQuickListView::Contain);
QTRY_COMPARE(listview->currentIndex(), 2);
- QTRY_COMPARE(listview->currentItem(), findItem<QSGItem>(contentItem, "wrapper", 2));
+ QTRY_COMPARE(listview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 2));
QTRY_COMPARE(listview->highlightItem()->y() - 5, listview->currentItem()->y());
delete canvas;
}
-void tst_QSGListView::QTBUG_11105()
+void tst_QQuickListView::QTBUG_11105()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_VERIFY(item->y() == i*20);
}
- listview->positionViewAtIndex(20, QSGListView::Beginning);
+ listview->positionViewAtIndex(20, QQuickListView::Beginning);
QCOMPARE(listview->contentY(), 280.);
TestModel model2;
ctxt->setContextProperty("testModel", &model2);
- itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QCOMPARE(itemCount, 5);
delete canvas;
delete testObject;
}
-void tst_QSGListView::header()
+void tst_QQuickListView::header()
{
- QFETCH(QSGListView::Orientation, orientation);
+ QFETCH(QQuickListView::Orientation, orientation);
QFETCH(Qt::LayoutDirection, layoutDirection);
QFETCH(QPointF, initialHeaderPos);
QFETCH(QPointF, firstDelegatePos);
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->rootContext()->setContextProperty("testModel", &model);
canvas->rootContext()->setContextProperty("initialViewWidth", 240);
canvas->rootContext()->setContextProperty("initialViewHeight", 320);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("header.qml")));
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGText *header = findItem<QSGText>(contentItem, "header");
+ QQuickText *header = findItem<QQuickText>(contentItem, "header");
QVERIFY(header);
QVERIFY(header == listview->headerItem());
QCOMPARE(header->pos(), initialHeaderPos);
QCOMPARE(QPointF(listview->contentX(), listview->contentY()), initialContentPos);
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
QCOMPARE(headerItemSpy.count(), 1);
- header = findItem<QSGText>(contentItem, "header");
+ header = findItem<QQuickText>(contentItem, "header");
QVERIFY(!header);
- header = findItem<QSGText>(contentItem, "header2");
+ header = findItem<QQuickText>(contentItem, "header2");
QVERIFY(header);
QVERIFY(header == listview->headerItem());
canvas->rootContext()->setContextProperty("initialViewHeight", 0.0);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("header.qml")));
- listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
delete canvas;
}
-void tst_QSGListView::header_data()
+void tst_QQuickListView::header_data()
{
- QTest::addColumn<QSGListView::Orientation>("orientation");
+ QTest::addColumn<QQuickListView::Orientation>("orientation");
QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
QTest::addColumn<QPointF>("initialHeaderPos");
QTest::addColumn<QPointF>("changedHeaderPos");
// view width = 240
// header above items, top left
- QTest::newRow("vertical, left to right") << QSGListView::Vertical << Qt::LeftToRight
+ QTest::newRow("vertical, left to right") << QQuickListView::Vertical << Qt::LeftToRight
<< QPointF(0, -30)
<< QPointF(0, -20)
<< QPointF(0, -30)
<< QPointF(0, -10);
// header above items, top right
- QTest::newRow("vertical, layout right to left") << QSGListView::Vertical << Qt::RightToLeft
+ QTest::newRow("vertical, layout right to left") << QQuickListView::Vertical << Qt::RightToLeft
<< QPointF(0, -30)
<< QPointF(0, -20)
<< QPointF(0, -30)
<< QPointF(0, -10);
// header to left of items
- QTest::newRow("horizontal, layout left to right") << QSGListView::Horizontal << Qt::LeftToRight
+ QTest::newRow("horizontal, layout left to right") << QQuickListView::Horizontal << Qt::LeftToRight
<< QPointF(-100, 0)
<< QPointF(-50, 0)
<< QPointF(-100, 0)
<< QPointF(-40, 0);
// header to right of items
- QTest::newRow("horizontal, layout right to left") << QSGListView::Horizontal << Qt::RightToLeft
+ QTest::newRow("horizontal, layout right to left") << QQuickListView::Horizontal << Qt::RightToLeft
<< QPointF(0, 0)
<< QPointF(0, 0)
<< QPointF(-240 + 100, 0)
<< QPointF(-240 + 40, 0);
}
-void tst_QSGListView::header_delayItemCreation()
+void tst_QQuickListView::header_delayItemCreation()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("fillModelOnComponentCompleted.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGText *header = findItem<QSGText>(contentItem, "header");
+ QQuickText *header = findItem<QQuickText>(contentItem, "header");
QVERIFY(header);
QCOMPARE(header->y(), -header->height());
delete canvas;
}
-void tst_QSGListView::footer()
+void tst_QQuickListView::footer()
{
- QFETCH(QSGListView::Orientation, orientation);
+ QFETCH(QQuickListView::Orientation, orientation);
QFETCH(Qt::LayoutDirection, layoutDirection);
QFETCH(QPointF, initialFooterPos);
QFETCH(QPointF, firstDelegatePos);
QFETCH(QPointF, changedContentPos);
QFETCH(QPointF, resizeContentPos);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 3; i++)
canvas->show();
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGText *footer = findItem<QSGText>(contentItem, "footer");
+ QQuickText *footer = findItem<QQuickText>(contentItem, "footer");
QVERIFY(footer);
QVERIFY(footer == listview->footerItem());
QCOMPARE(footer->height(), 30.);
QCOMPARE(QPointF(listview->contentX(), listview->contentY()), initialContentPos);
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
// remove one item
model.removeItem(1);
- if (orientation == QSGListView::Vertical) {
+ if (orientation == QQuickListView::Vertical) {
QTRY_COMPARE(footer->y(), initialFooterPos.y() - 20); // delegate height = 20
} else {
QTRY_COMPARE(footer->x(), layoutDirection == Qt::LeftToRight ?
model.clear();
QPointF posWhenNoItems(0, 0);
- if (orientation == QSGListView::Horizontal && layoutDirection == Qt::RightToLeft)
+ if (orientation == QQuickListView::Horizontal && layoutDirection == Qt::RightToLeft)
posWhenNoItems.setX(-100);
QTRY_COMPARE(footer->pos(), posWhenNoItems);
QCOMPARE(footerItemSpy.count(), 1);
- footer = findItem<QSGText>(contentItem, "footer");
+ footer = findItem<QQuickText>(contentItem, "footer");
QVERIFY(!footer);
- footer = findItem<QSGText>(contentItem, "footer2");
+ footer = findItem<QQuickText>(contentItem, "footer2");
QVERIFY(footer);
QVERIFY(footer == listview->footerItem());
QCOMPARE(footer->height(), 20.);
QTRY_COMPARE(QPointF(listview->contentX(), listview->contentY()), changedContentPos);
- item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->pos(), firstDelegatePos);
delete canvas;
}
-void tst_QSGListView::footer_data()
+void tst_QQuickListView::footer_data()
{
- QTest::addColumn<QSGListView::Orientation>("orientation");
+ QTest::addColumn<QQuickListView::Orientation>("orientation");
QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
QTest::addColumn<QPointF>("initialFooterPos");
QTest::addColumn<QPointF>("changedFooterPos");
// view height = 320
// footer below items, bottom left
- QTest::newRow("vertical, layout left to right") << QSGListView::Vertical << Qt::LeftToRight
+ QTest::newRow("vertical, layout left to right") << QQuickListView::Vertical << Qt::LeftToRight
<< QPointF(0, 3 * 20)
<< QPointF(0, 30 * 20) // added 30 items
<< QPointF(0, 0)
<< QPointF(0, 30 * 20 - 320 + 10);
// footer below items, bottom right
- QTest::newRow("vertical, layout right to left") << QSGListView::Vertical << Qt::RightToLeft
+ QTest::newRow("vertical, layout right to left") << QQuickListView::Vertical << Qt::RightToLeft
<< QPointF(0, 3 * 20)
<< QPointF(0, 30 * 20)
<< QPointF(0, 0)
<< QPointF(0, 30 * 20 - 320 + 10);
// footer to right of items
- QTest::newRow("horizontal, layout left to right") << QSGListView::Horizontal << Qt::LeftToRight
+ QTest::newRow("horizontal, layout left to right") << QQuickListView::Horizontal << Qt::LeftToRight
<< QPointF(40 * 3, 0)
<< QPointF(40 * 30, 0)
<< QPointF(0, 0)
<< QPointF(40 * 30 - 240 + 40, 0);
// footer to left of items
- QTest::newRow("horizontal, layout right to left") << QSGListView::Horizontal << Qt::RightToLeft
+ QTest::newRow("horizontal, layout right to left") << QQuickListView::Horizontal << Qt::RightToLeft
<< QPointF(-(40 * 3) - 100, 0)
<< QPointF(-(40 * 30) - 50, 0) // 50 = new footer width
<< QPointF(-240, 0)
<< QPointF(-(40 * 30) - 40, 0);
}
-class LVAccessor : public QSGListView
+class LVAccessor : public QQuickListView
{
public:
qreal minY() const { return minYExtent(); }
qreal maxX() const { return maxXExtent(); }
};
-void tst_QSGListView::headerFooter()
+void tst_QQuickListView::headerFooter()
{
{
// Vertical
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
QDeclarativeContext *ctxt = canvas->rootContext();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("headerfooter.qml")));
qApp->processEvents();
- QSGListView *listview = qobject_cast<QSGListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGItem *header = findItem<QSGItem>(contentItem, "header");
+ QQuickItem *header = findItem<QQuickItem>(contentItem, "header");
QVERIFY(header);
QCOMPARE(header->y(), -header->height());
- QSGItem *footer = findItem<QSGItem>(contentItem, "footer");
+ QQuickItem *footer = findItem<QQuickItem>(contentItem, "footer");
QVERIFY(footer);
QCOMPARE(footer->y(), 0.);
}
{
// Horizontal
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
QDeclarativeContext *ctxt = canvas->rootContext();
canvas->rootObject()->setProperty("horizontal", true);
qApp->processEvents();
- QSGListView *listview = qobject_cast<QSGListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGItem *header = findItem<QSGItem>(contentItem, "header");
+ QQuickItem *header = findItem<QQuickItem>(contentItem, "header");
QVERIFY(header);
QCOMPARE(header->x(), -header->width());
- QSGItem *footer = findItem<QSGItem>(contentItem, "footer");
+ QQuickItem *footer = findItem<QQuickItem>(contentItem, "footer");
QVERIFY(footer);
QCOMPARE(footer->x(), 0.);
}
{
// Horizontal RTL
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
QDeclarativeContext *ctxt = canvas->rootContext();
canvas->rootObject()->setProperty("rtl", true);
qApp->processEvents();
- QSGListView *listview = qobject_cast<QSGListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGItem *header = findItem<QSGItem>(contentItem, "header");
+ QQuickItem *header = findItem<QQuickItem>(contentItem, "header");
QVERIFY(header);
QCOMPARE(header->x(), 0.);
- QSGItem *footer = findItem<QSGItem>(contentItem, "footer");
+ QQuickItem *footer = findItem<QQuickItem>(contentItem, "footer");
QVERIFY(footer);
QCOMPARE(footer->x(), -footer->width());
}
}
-void tst_QSGListView::resizeView()
+void tst_QQuickListView::resizeView()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 40; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*20.);
delete testObject;
}
-void tst_QSGListView::resizeViewAndRepaint()
+void tst_QQuickListView::resizeViewAndRepaint()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("resizeview.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// item at index 10 should not be currently visible
- QVERIFY(!findItem<QSGItem>(contentItem, "wrapper", 10));
+ QVERIFY(!findItem<QQuickItem>(contentItem, "wrapper", 10));
listview->setHeight(320);
- QTRY_VERIFY(findItem<QSGItem>(contentItem, "wrapper", 10));
+ QTRY_VERIFY(findItem<QQuickItem>(contentItem, "wrapper", 10));
listview->setHeight(100);
- QTRY_VERIFY(!findItem<QSGItem>(contentItem, "wrapper", 10));
+ QTRY_VERIFY(!findItem<QQuickItem>(contentItem, "wrapper", 10));
delete canvas;
}
-void tst_QSGListView::sizeLessThan1()
+void tst_QQuickListView::sizeLessThan1()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("sizelessthan1.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Confirm items positioned correctly
- int itemCount = findItems<QSGItem>(contentItem, "wrapper").count();
+ int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
for (int i = 0; i < model.count() && i < itemCount; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
if (!item) qWarning() << "Item" << i << "not found";
QTRY_VERIFY(item);
QTRY_COMPARE(item->y(), i*0.5);
delete testObject;
}
-void tst_QSGListView::QTBUG_14821()
+void tst_QQuickListView::QTBUG_14821()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("qtbug14821.qml")));
qApp->processEvents();
- QSGListView *listview = qobject_cast<QSGListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
listview->decrementCurrentIndex();
delete canvas;
}
-void tst_QSGListView::resizeDelegate()
+void tst_QQuickListView::resizeDelegate()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
QStringList strings;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("displaylist.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QCOMPARE(listview->count(), model.rowCount());
QTest::qWait(300);
for (int i = 0; i < 16; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY(item != 0);
QCOMPARE(item->y(), i*20.0);
}
QTest::qWait(300);
for (int i = 0; i < 11; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY(item != 0);
QTRY_COMPARE(item->y(), i*30.0);
}
QTRY_COMPARE(listview->highlightItem()->y(), 750.0);
listview->setCurrentIndex(1);
- listview->positionViewAtIndex(25, QSGListView::Beginning);
- listview->positionViewAtIndex(5, QSGListView::Beginning);
+ listview->positionViewAtIndex(25, QQuickListView::Beginning);
+ listview->positionViewAtIndex(5, QQuickListView::Beginning);
for (int i = 5; i < 16; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY(item != 0);
QCOMPARE(item->y(), i*30.0);
}
QTest::qWait(300);
for (int i = 5; i < 11; ++i) {
- QSGItem *item = findItem<QSGItem>(contentItem, "wrapper", i);
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY(item != 0);
QTRY_COMPARE(item->y(), 150 + (i-5)*20.0);
}
delete canvas;
}
-void tst_QSGListView::resizeFirstDelegate()
+void tst_QQuickListView::resizeFirstDelegate()
{
// QTBUG-20712: Content Y jumps constantly if first delegate height == 0
// and other delegates have height > 0
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
// bug only occurs when all items in the model are visible
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGItem *item = 0;
+ QQuickItem *item = 0;
for (int i = 0; i < model.count(); ++i) {
- item = findItem<QSGItem>(contentItem, "wrapper", i);
+ item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY(item != 0);
QCOMPARE(item->y(), i*20.0);
}
- item = findItem<QSGItem>(contentItem, "wrapper", 0);
+ item = findItem<QQuickItem>(contentItem, "wrapper", 0);
item->setHeight(0);
// check the content y has not jumped up and down
QCOMPARE(spy.count(), 0);
for (int i = 1; i < model.count(); ++i) {
- item = findItem<QSGItem>(contentItem, "wrapper", i);
+ item = findItem<QQuickItem>(contentItem, "wrapper", i);
QVERIFY(item != 0);
QTRY_COMPARE(item->y(), (i-1)*20.0);
}
delete canvas;
}
-void tst_QSGListView::QTBUG_16037()
+void tst_QQuickListView::QTBUG_16037()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("qtbug16037.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "listview");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "listview");
QTRY_VERIFY(listview != 0);
QVERIFY(listview->contentHeight() <= 0.0);
delete canvas;
}
-void tst_QSGListView::indexAt()
+void tst_QQuickListView::indexAt()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
for (int i = 0; i < 30; i++)
canvas->setSource(QUrl::fromLocalFile(TESTDATA("listviewtest.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(listview->indexAt(0,0), 0);
delete testObject;
}
-void tst_QSGListView::incrementalModel()
+void tst_QQuickListView::incrementalModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
IncrementalModel model;
QDeclarativeContext *ctxt = canvas->rootContext();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("displaylist.qml")));
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(listview->count(), 20);
- listview->positionViewAtIndex(10, QSGListView::Beginning);
+ listview->positionViewAtIndex(10, QQuickListView::Beginning);
QTRY_COMPARE(listview->count(), 25);
delete canvas;
}
-void tst_QSGListView::onAdd()
+void tst_QQuickListView::onAdd()
{
QFETCH(int, initialItemCount);
QFETCH(int, itemsToAdd);
for (int i=0; i<initialItemCount; i++)
model.addItem("dummy value", "dummy value");
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setGeometry(0,0,200, delegateHeight * (initialItemCount + itemsToAdd));
QDeclarativeContext *ctxt = canvas->rootContext();
ctxt->setContextProperty("testModel", &model);
delete canvas;
}
-void tst_QSGListView::onAdd_data()
+void tst_QQuickListView::onAdd_data()
{
QTest::addColumn<int>("initialItemCount");
QTest::addColumn<int>("itemsToAdd");
QTest::newRow("5, add 10") << 5 << 10;
}
-void tst_QSGListView::onRemove()
+void tst_QQuickListView::onRemove()
{
QFETCH(int, initialItemCount);
QFETCH(int, indexToRemove);
for (int i=0; i<initialItemCount; i++)
model.addItem(QString("value %1").arg(i), "dummy value");
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("delegateHeight", delegateHeight);
delete canvas;
}
-void tst_QSGListView::onRemove_data()
+void tst_QQuickListView::onRemove_data()
{
QTest::addColumn<int>("initialItemCount");
QTest::addColumn<int>("indexToRemove");
QTest::newRow("ten items, remove 4-10") << 10 << 4 << 6;
}
-void tst_QSGListView::rightToLeft()
+void tst_QQuickListView::rightToLeft()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setGeometry(0,0,640,320);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("rightToLeft.qml")));
qApp->processEvents();
QVERIFY(canvas->rootObject() != 0);
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "view");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "view");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QSGVisualItemModel *model = canvas->rootObject()->findChild<QSGVisualItemModel*>("itemModel");
+ QQuickVisualItemModel *model = canvas->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
// initial position at first item, right edge aligned
QCOMPARE(listview->contentX(), -640.);
- QSGItem *item = findItem<QSGItem>(contentItem, "item1");
+ QQuickItem *item = findItem<QQuickItem>(contentItem, "item1");
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), -100.0);
QCOMPARE(item->height(), listview->height());
- QSGText *text = findItem<QSGText>(contentItem, "text1");
+ QQuickText *text = findItem<QQuickText>(contentItem, "text1");
QTRY_VERIFY(text);
QTRY_COMPARE(text->text(), QLatin1String("index: 0"));
listview->setCurrentIndex(2);
- item = findItem<QSGItem>(contentItem, "item3");
+ item = findItem<QQuickItem>(contentItem, "item3");
QTRY_VERIFY(item);
QTRY_COMPARE(item->x(), -540.0);
- text = findItem<QSGText>(contentItem, "text3");
+ text = findItem<QQuickText>(contentItem, "text3");
QTRY_VERIFY(text);
QTRY_COMPARE(text->text(), QLatin1String("index: 2"));
QCOMPARE(listview->contentX(), -640.);
// Ensure resizing maintains position relative to right edge
- qobject_cast<QSGItem*>(canvas->rootObject())->setWidth(600);
+ qobject_cast<QQuickItem*>(canvas->rootObject())->setWidth(600);
QTRY_COMPARE(listview->contentX(), -600.);
delete canvas;
}
-void tst_QSGListView::test_mirroring()
+void tst_QQuickListView::test_mirroring()
{
- QSGView *canvasA = createView();
+ QQuickView *canvasA = createView();
canvasA->setSource(QUrl::fromLocalFile(TESTDATA("rightToLeft.qml")));
- QSGListView *listviewA = findItem<QSGListView>(canvasA->rootObject(), "view");
+ QQuickListView *listviewA = findItem<QQuickListView>(canvasA->rootObject(), "view");
QTRY_VERIFY(listviewA != 0);
- QSGView *canvasB = createView();
+ QQuickView *canvasB = createView();
canvasB->setSource(QUrl::fromLocalFile(TESTDATA("rightToLeft.qml")));
- QSGListView *listviewB = findItem<QSGListView>(canvasB->rootObject(), "view");
+ QQuickListView *listviewB = findItem<QQuickListView>(canvasB->rootObject(), "view");
QTRY_VERIFY(listviewA != 0);
qApp->processEvents();
// LTR != RTL
foreach (const QString objectName, objectNames)
- QVERIFY(findItem<QSGItem>(listviewA, objectName)->x() != findItem<QSGItem>(listviewB, objectName)->x());
+ QVERIFY(findItem<QQuickItem>(listviewA, objectName)->x() != findItem<QQuickItem>(listviewB, objectName)->x());
listviewA->setProperty("layoutDirection", Qt::LeftToRight);
listviewB->setProperty("layoutDirection", Qt::LeftToRight);
// LTR == LTR
foreach (const QString objectName, objectNames)
- QCOMPARE(findItem<QSGItem>(listviewA, objectName)->x(), findItem<QSGItem>(listviewB, objectName)->x());
+ QCOMPARE(findItem<QQuickItem>(listviewA, objectName)->x(), findItem<QQuickItem>(listviewB, objectName)->x());
QVERIFY(listviewB->layoutDirection() == listviewB->effectiveLayoutDirection());
- QSGItemPrivate::get(listviewB)->setLayoutMirror(true);
+ QQuickItemPrivate::get(listviewB)->setLayoutMirror(true);
QVERIFY(listviewB->layoutDirection() != listviewB->effectiveLayoutDirection());
// LTR != LTR+mirror
foreach (const QString objectName, objectNames)
- QVERIFY(findItem<QSGItem>(listviewA, objectName)->x() != findItem<QSGItem>(listviewB, objectName)->x());
+ QVERIFY(findItem<QQuickItem>(listviewA, objectName)->x() != findItem<QQuickItem>(listviewB, objectName)->x());
listviewA->setProperty("layoutDirection", Qt::RightToLeft);
// RTL == LTR+mirror
foreach (const QString objectName, objectNames)
- QCOMPARE(findItem<QSGItem>(listviewA, objectName)->x(), findItem<QSGItem>(listviewB, objectName)->x());
+ QCOMPARE(findItem<QQuickItem>(listviewA, objectName)->x(), findItem<QQuickItem>(listviewB, objectName)->x());
listviewB->setProperty("layoutDirection", Qt::RightToLeft);
// RTL != RTL+mirror
foreach (const QString objectName, objectNames)
- QVERIFY(findItem<QSGItem>(listviewA, objectName)->x() != findItem<QSGItem>(listviewB, objectName)->x());
+ QVERIFY(findItem<QQuickItem>(listviewA, objectName)->x() != findItem<QQuickItem>(listviewB, objectName)->x());
listviewA->setProperty("layoutDirection", Qt::LeftToRight);
// LTR == RTL+mirror
foreach (const QString objectName, objectNames)
- QCOMPARE(findItem<QSGItem>(listviewA, objectName)->x(), findItem<QSGItem>(listviewB, objectName)->x());
+ QCOMPARE(findItem<QQuickItem>(listviewA, objectName)->x(), findItem<QQuickItem>(listviewB, objectName)->x());
delete canvasA;
delete canvasB;
}
-void tst_QSGListView::margins()
+void tst_QQuickListView::margins()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel2 model;
for (int i = 0; i < 50; i++)
canvas->show();
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(listview->contentY(), -30.);
delete canvas;
}
-void tst_QSGListView::snapToItem_data()
+void tst_QQuickListView::snapToItem_data()
{
- QTest::addColumn<QSGListView::Orientation>("orientation");
+ QTest::addColumn<QQuickListView::Orientation>("orientation");
QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
QTest::addColumn<int>("highlightRangeMode");
QTest::addColumn<QPoint>("flickStart");
QTest::addColumn<qreal>("endExtent");
QTest::addColumn<qreal>("startExtent");
- QTest::newRow("vertical, left to right") << QSGListView::Vertical << Qt::LeftToRight << int(QSGItemView::NoHighlightRange)
+ QTest::newRow("vertical, left to right") << QQuickListView::Vertical << Qt::LeftToRight << int(QQuickItemView::NoHighlightRange)
<< QPoint(20, 200) << QPoint(20, 20) << 60.0 << 1200.0 << 0.0;
- QTest::newRow("horizontal, left to right") << QSGListView::Horizontal << Qt::LeftToRight << int(QSGItemView::NoHighlightRange)
+ QTest::newRow("horizontal, left to right") << QQuickListView::Horizontal << Qt::LeftToRight << int(QQuickItemView::NoHighlightRange)
<< QPoint(200, 20) << QPoint(20, 20) << 60.0 << 1200.0 << 0.0;
- QTest::newRow("horizontal, right to left") << QSGListView::Horizontal << Qt::RightToLeft << int(QSGItemView::NoHighlightRange)
+ QTest::newRow("horizontal, right to left") << QQuickListView::Horizontal << Qt::RightToLeft << int(QQuickItemView::NoHighlightRange)
<< QPoint(20, 20) << QPoint(200, 20) << -60.0 << -1200.0 - 240.0 << -240.0;
- QTest::newRow("vertical, left to right, enforce range") << QSGListView::Vertical << Qt::LeftToRight << int(QSGItemView::StrictlyEnforceRange)
+ QTest::newRow("vertical, left to right, enforce range") << QQuickListView::Vertical << Qt::LeftToRight << int(QQuickItemView::StrictlyEnforceRange)
<< QPoint(20, 200) << QPoint(20, 20) << 60.0 << 1340.0 << -20.0;
- QTest::newRow("horizontal, left to right, enforce range") << QSGListView::Horizontal << Qt::LeftToRight << int(QSGItemView::StrictlyEnforceRange)
+ QTest::newRow("horizontal, left to right, enforce range") << QQuickListView::Horizontal << Qt::LeftToRight << int(QQuickItemView::StrictlyEnforceRange)
<< QPoint(200, 20) << QPoint(20, 20) << 60.0 << 1340.0 << -20.0;
- QTest::newRow("horizontal, right to left, enforce range") << QSGListView::Horizontal << Qt::RightToLeft << int(QSGItemView::StrictlyEnforceRange)
+ QTest::newRow("horizontal, right to left, enforce range") << QQuickListView::Horizontal << Qt::RightToLeft << int(QQuickItemView::StrictlyEnforceRange)
<< QPoint(20, 20) << QPoint(200, 20) << -60.0 << -1200.0 - 240.0 - 140.0 << -220.0;
}
-void tst_QSGListView::snapToItem()
+void tst_QQuickListView::snapToItem()
{
- QFETCH(QSGListView::Orientation, orientation);
+ QFETCH(QQuickListView::Orientation, orientation);
QFETCH(Qt::LayoutDirection, layoutDirection);
QFETCH(int, highlightRangeMode);
QFETCH(QPoint, flickStart);
QFETCH(qreal, endExtent);
QFETCH(qreal, startExtent);
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("snapToItem.qml")));
canvas->show();
qApp->processEvents();
- QSGListView *listview = findItem<QSGListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
- listview->setHighlightRangeMode(QSGItemView::HighlightRangeMode(highlightRangeMode));
+ listview->setHighlightRangeMode(QQuickItemView::HighlightRangeMode(highlightRangeMode));
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// confirm that a flick hits an item boundary
flick(canvas, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
- if (orientation == QSGListView::Vertical)
+ if (orientation == QQuickListView::Vertical)
QCOMPARE(qreal(fmod(listview->contentY(),80.0)), snapAlignment);
else
QCOMPARE(qreal(fmod(listview->contentX(),80.0)), snapAlignment);
do {
flick(canvas, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
- } while (orientation == QSGListView::Vertical
+ } while (orientation == QQuickListView::Vertical
? !listview->isAtYEnd()
: layoutDirection == Qt::LeftToRight ? !listview->isAtXEnd() : !listview->isAtXBeginning());
- if (orientation == QSGListView::Vertical)
+ if (orientation == QQuickListView::Vertical)
QCOMPARE(listview->contentY(), endExtent);
else
QCOMPARE(listview->contentX(), endExtent);
do {
flick(canvas, flickEnd, flickStart, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
- } while (orientation == QSGListView::Vertical
+ } while (orientation == QQuickListView::Vertical
? !listview->isAtYBeginning()
: layoutDirection == Qt::LeftToRight ? !listview->isAtXBeginning() : !listview->isAtXEnd());
- if (orientation == QSGListView::Vertical)
+ if (orientation == QQuickListView::Vertical)
QCOMPARE(listview->contentY(), startExtent);
else
QCOMPARE(listview->contentX(), startExtent);
delete canvas;
}
-void tst_QSGListView::qListModelInterface_items()
+void tst_QQuickListView::qListModelInterface_items()
{
items<TestModel>();
}
-void tst_QSGListView::qAbstractItemModel_items()
+void tst_QQuickListView::qAbstractItemModel_items()
{
items<TestModel2>();
}
-void tst_QSGListView::qListModelInterface_changed()
+void tst_QQuickListView::qListModelInterface_changed()
{
changed<TestModel>();
}
-void tst_QSGListView::qAbstractItemModel_changed()
+void tst_QQuickListView::qAbstractItemModel_changed()
{
changed<TestModel2>();
}
-void tst_QSGListView::qListModelInterface_inserted()
+void tst_QQuickListView::qListModelInterface_inserted()
{
inserted<TestModel>();
}
-void tst_QSGListView::qListModelInterface_inserted_more()
+void tst_QQuickListView::qListModelInterface_inserted_more()
{
inserted_more<TestModel>();
}
-void tst_QSGListView::qListModelInterface_inserted_more_data()
+void tst_QQuickListView::qListModelInterface_inserted_more_data()
{
inserted_more_data();
}
-void tst_QSGListView::qAbstractItemModel_inserted()
+void tst_QQuickListView::qAbstractItemModel_inserted()
{
inserted<TestModel2>();
}
-void tst_QSGListView::qAbstractItemModel_inserted_more()
+void tst_QQuickListView::qAbstractItemModel_inserted_more()
{
inserted_more<TestModel2>();
}
-void tst_QSGListView::qAbstractItemModel_inserted_more_data()
+void tst_QQuickListView::qAbstractItemModel_inserted_more_data()
{
inserted_more_data();
}
-void tst_QSGListView::qListModelInterface_removed()
+void tst_QQuickListView::qListModelInterface_removed()
{
removed<TestModel>(false);
removed<TestModel>(true);
}
-void tst_QSGListView::qAbstractItemModel_removed()
+void tst_QQuickListView::qAbstractItemModel_removed()
{
removed<TestModel2>(false);
removed<TestModel2>(true);
}
-void tst_QSGListView::qListModelInterface_moved()
+void tst_QQuickListView::qListModelInterface_moved()
{
moved<TestModel>();
}
-void tst_QSGListView::qListModelInterface_moved_data()
+void tst_QQuickListView::qListModelInterface_moved_data()
{
moved_data();
}
-void tst_QSGListView::qAbstractItemModel_moved()
+void tst_QQuickListView::qAbstractItemModel_moved()
{
moved<TestModel2>();
}
-void tst_QSGListView::qAbstractItemModel_moved_data()
+void tst_QQuickListView::qAbstractItemModel_moved_data()
{
moved_data();
}
-void tst_QSGListView::qListModelInterface_clear()
+void tst_QQuickListView::qListModelInterface_clear()
{
clear<TestModel>();
}
-void tst_QSGListView::qAbstractItemModel_clear()
+void tst_QQuickListView::qAbstractItemModel_clear()
{
clear<TestModel2>();
}
-void tst_QSGListView::creationContext()
+void tst_QQuickListView::creationContext()
{
- QSGView canvas;
+ QQuickView canvas;
canvas.setGeometry(0,0,240,320);
canvas.setSource(QUrl::fromLocalFile(TESTDATA("creationContext.qml")));
qApp->processEvents();
- QSGItem *rootItem = qobject_cast<QSGItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
QVERIFY(rootItem);
QVERIFY(rootItem->property("count").toInt() > 0);
- QSGItem *item;
- QVERIFY(item = rootItem->findChild<QSGItem *>("listItem"));
+ QQuickItem *item;
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("listItem"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
- QVERIFY(item = rootItem->findChild<QSGItem *>("header"));
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("header"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
- QVERIFY(item = rootItem->findChild<QSGItem *>("footer"));
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("footer"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
- QVERIFY(item = rootItem->findChild<QSGItem *>("section"));
+ QVERIFY(item = rootItem->findChild<QQuickItem *>("section"));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
}
-void tst_QSGListView::QTBUG_21742()
+void tst_QQuickListView::QTBUG_21742()
{
- QSGView canvas;
+ QQuickView canvas;
canvas.setGeometry(0,0,200,200);
canvas.setSource(QUrl::fromLocalFile(TESTDATA("qtbug-21742.qml")));
qApp->processEvents();
- QSGItem *rootItem = qobject_cast<QSGItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
QVERIFY(rootItem);
QCOMPARE(rootItem->property("count").toInt(), 1);
}
-QSGView *tst_QSGListView::createView()
+QQuickView *tst_QQuickListView::createView()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
return canvas;
}
-void tst_QSGListView::flick(QSGView *canvas, const QPoint &from, const QPoint &to, int duration)
+void tst_QQuickListView::flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration)
{
const int pointCount = 5;
QPoint diff = to - from;
}
-QSGItem *tst_QSGListView::findVisibleChild(QSGItem *parent, const QString &objectName)
+QQuickItem *tst_QQuickListView::findVisibleChild(QQuickItem *parent, const QString &objectName)
{
- QSGItem *item = 0;
- QList<QSGItem*> items = parent->findChildren<QSGItem*>(objectName);
+ QQuickItem *item = 0;
+ QList<QQuickItem*> items = parent->findChildren<QQuickItem*>(objectName);
for (int i = 0; i < items.count(); ++i) {
if (items.at(i)->isVisible()) {
item = items.at(i);
item must also evaluate the {index} expression equal to index
*/
template<typename T>
-T *tst_QSGListView::findItem(QSGItem *parent, const QString &objectName, int index)
+T *tst_QQuickListView::findItem(QQuickItem *parent, const QString &objectName, int index)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
}
template<typename T>
-QList<T*> tst_QSGListView::findItems(QSGItem *parent, const QString &objectName)
+QList<T*> tst_QQuickListView::findItems(QQuickItem *parent, const QString &objectName)
{
QList<T*> items;
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item || !item->isVisible())
continue;
//qDebug() << "try" << item;
return items;
}
-void tst_QSGListView::dumpTree(QSGItem *parent, int depth)
+void tst_QQuickListView::dumpTree(QQuickItem *parent, int depth)
{
static QString padding(" ");
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
qDebug() << padding.left(depth*2) << item;
}
}
-QTEST_MAIN(tst_QSGListView)
+QTEST_MAIN(tst_QQuickListView)
-#include "tst_qsglistview.moc"
+#include "tst_qquicklistview.moc"
CONFIG += testcase
-TARGET = tst_qsgloader
+TARGET = tst_qquickloader
macx:CONFIG -= app_bundle
INCLUDEPATH += ../shared/
HEADERS += ../shared/testhttpserver.h
-SOURCES += tst_qsgloader.cpp \
+SOURCES += tst_qquickloader.cpp \
../shared/testhttpserver.cpp
testDataFiles.files = data
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativeincubator.h>
-#include <private/qsgloader_p.h>
+#include <private/qquickloader_p.h>
#include "testhttpserver.h"
#include "../shared/util.h"
}
};
-class tst_QSGLoader : public QObject
+class tst_QQuickLoader : public QObject
{
Q_OBJECT
public:
- tst_QSGLoader();
+ tst_QQuickLoader();
private slots:
void sourceOrComponent();
};
-tst_QSGLoader::tst_QSGLoader()
+tst_QQuickLoader::tst_QQuickLoader()
{
}
-void tst_QSGLoader::sourceOrComponent()
+void tst_QQuickLoader::sourceOrComponent()
{
QFETCH(QString, sourceOrComponent);
QFETCH(QString, sourceDefinition);
"}")
, TEST_FILE(""));
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader != 0);
QCOMPARE(loader->item() == 0, error);
QCOMPARE(loader->source(), sourceUrl);
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(loader->status(), error ? QSGLoader::Error : QSGLoader::Ready);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), error ? 0: 1);
+ QCOMPARE(loader->status(), error ? QQuickLoader::Error : QQuickLoader::Ready);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), error ? 0: 1);
if (!error) {
bool sourceComponentIsChildOfLoader = false;
delete loader;
}
-void tst_QSGLoader::sourceOrComponent_data()
+void tst_QQuickLoader::sourceOrComponent_data()
{
QTest::addColumn<QString>("sourceOrComponent");
QTest::addColumn<QString>("sourceDefinition");
<< QString(QUrl::fromLocalFile(TESTDATA("IDontExist.qml")).toString() + ": File not found");
}
-void tst_QSGLoader::clear()
+void tst_QQuickLoader::clear()
{
{
QDeclarativeComponent component(&engine);
" Timer { interval: 200; running: true; onTriggered: loader.source = '' }\n"
" }")
, TEST_FILE(""));
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader != 0);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
QTRY_VERIFY(loader->item() == 0);
QCOMPARE(loader->progress(), 0.0);
- QCOMPARE(loader->status(), QSGLoader::Null);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 0);
+ QCOMPARE(loader->status(), QQuickLoader::Null);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 0);
delete loader;
}
{
QDeclarativeComponent component(&engine, TEST_FILE("/SetSourceComponent.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
- QSGLoader *loader = qobject_cast<QSGLoader*>(item->QSGItem::childItems().at(0));
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(item->QQuickItem::childItems().at(0));
QVERIFY(loader);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
loader->setSourceComponent(0);
QVERIFY(loader->item() == 0);
QCOMPARE(loader->progress(), 0.0);
- QCOMPARE(loader->status(), QSGLoader::Null);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 0);
+ QCOMPARE(loader->status(), QQuickLoader::Null);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 0);
delete item;
}
{
QDeclarativeComponent component(&engine, TEST_FILE("/SetSourceComponent.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
- QSGLoader *loader = qobject_cast<QSGLoader*>(item->QSGItem::childItems().at(0));
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(item->QQuickItem::childItems().at(0));
QVERIFY(loader);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
QMetaObject::invokeMethod(item, "clear");
QVERIFY(loader->item() == 0);
QCOMPARE(loader->progress(), 0.0);
- QCOMPARE(loader->status(), QSGLoader::Null);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 0);
+ QCOMPARE(loader->status(), QQuickLoader::Null);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 0);
delete item;
}
}
-void tst_QSGLoader::urlToComponent()
+void tst_QQuickLoader::urlToComponent()
{
QDeclarativeComponent component(&engine);
component.setData(QByteArray("import QtQuick 2.0\n"
" Timer { interval: 100; running: true; onTriggered: loader.sourceComponent = myComp }\n"
"}" )
, TEST_FILE(""));
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QTest::qWait(200);
QTRY_VERIFY(loader != 0);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
QCOMPARE(loader->width(), 10.0);
QCOMPARE(loader->height(), 10.0);
delete loader;
}
-void tst_QSGLoader::componentToUrl()
+void tst_QQuickLoader::componentToUrl()
{
QDeclarativeComponent component(&engine, TEST_FILE("/SetSourceComponent.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
- QSGLoader *loader = qobject_cast<QSGLoader*>(item->QSGItem::childItems().at(0));
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(item->QQuickItem::childItems().at(0));
QVERIFY(loader);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
loader->setSource(TEST_FILE("/Rect120x60.qml"));
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
QCOMPARE(loader->width(), 120.0);
QCOMPARE(loader->height(), 60.0);
delete item;
}
-void tst_QSGLoader::anchoredLoader()
+void tst_QQuickLoader::anchoredLoader()
{
QDeclarativeComponent component(&engine, TEST_FILE("/AnchoredLoader.qml"));
- QSGItem *rootItem = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(component.create());
QVERIFY(rootItem != 0);
- QSGItem *loader = rootItem->findChild<QSGItem*>("loader");
- QSGItem *sourceElement = rootItem->findChild<QSGItem*>("sourceElement");
+ QQuickItem *loader = rootItem->findChild<QQuickItem*>("loader");
+ QQuickItem *sourceElement = rootItem->findChild<QQuickItem*>("sourceElement");
QVERIFY(loader != 0);
QVERIFY(sourceElement != 0);
QCOMPARE(sourceElement->height(), 200.0);
}
-void tst_QSGLoader::sizeLoaderToItem()
+void tst_QQuickLoader::sizeLoaderToItem()
{
QDeclarativeComponent component(&engine, TEST_FILE("/SizeToItem.qml"));
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader != 0);
QCOMPARE(loader->width(), 120.0);
QCOMPARE(loader->height(), 60.0);
// Check resize
- QSGItem *rect = qobject_cast<QSGItem*>(loader->item());
+ QQuickItem *rect = qobject_cast<QQuickItem*>(loader->item());
QVERIFY(rect);
rect->setWidth(150);
rect->setHeight(45);
delete loader;
}
-void tst_QSGLoader::sizeItemToLoader()
+void tst_QQuickLoader::sizeItemToLoader()
{
QDeclarativeComponent component(&engine, TEST_FILE("/SizeToLoader.qml"));
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader != 0);
QCOMPARE(loader->width(), 200.0);
QCOMPARE(loader->height(), 80.0);
- QSGItem *rect = qobject_cast<QSGItem*>(loader->item());
+ QQuickItem *rect = qobject_cast<QQuickItem*>(loader->item());
QVERIFY(rect);
QCOMPARE(rect->width(), 200.0);
QCOMPARE(rect->height(), 80.0);
delete loader;
}
-void tst_QSGLoader::noResize()
+void tst_QQuickLoader::noResize()
{
QDeclarativeComponent component(&engine, TEST_FILE("/NoResize.qml"));
- QSGItem* item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem* item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item != 0);
QCOMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 80.0);
delete item;
}
-void tst_QSGLoader::networkRequestUrl()
+void tst_QQuickLoader::networkRequestUrl()
{
TestHTTPServer server(SERVER_PORT);
QVERIFY(server.isValid());
component.setData(QByteArray("import QtQuick 2.0\nLoader { property int signalCount : 0; source: \"http://127.0.0.1:14450/Rect120x60.qml\"; onLoaded: signalCount += 1 }"), QUrl::fromLocalFile(TESTDATA("../dummy.qml")));
if (component.isError())
qDebug() << component.errors();
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader != 0);
- QTRY_VERIFY(loader->status() == QSGLoader::Ready);
+ QTRY_VERIFY(loader->status() == QQuickLoader::Ready);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
QCOMPARE(loader->property("signalCount").toInt(), 1);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
delete loader;
}
/* XXX Component waits until all dependencies are loaded. Is this actually possible?
-void tst_QSGLoader::networkComponent()
+void tst_QQuickLoader::networkComponent()
{
TestHTTPServer server(SERVER_PORT);
QVERIFY(server.isValid());
" Loader { sourceComponent: comp } }")
, TEST_FILE(""));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
- QSGLoader *loader = qobject_cast<QSGLoader*>(item->QSGItem::children().at(1));
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(item->QQuickItem::children().at(1));
QVERIFY(loader);
- QTRY_VERIFY(loader->status() == QSGLoader::Ready);
+ QTRY_VERIFY(loader->status() == QQuickLoader::Ready);
QVERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(loader->status(), QSGLoader::Ready);
- QCOMPARE(static_cast<QSGItem*>(loader)->children().count(), 1);
+ QCOMPARE(loader->status(), QQuickLoader::Ready);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->children().count(), 1);
delete loader;
}
*/
-void tst_QSGLoader::failNetworkRequest()
+void tst_QQuickLoader::failNetworkRequest()
{
TestHTTPServer server(SERVER_PORT);
QVERIFY(server.isValid());
QDeclarativeComponent component(&engine);
component.setData(QByteArray("import QtQuick 2.0\nLoader { property int did_load: 123; source: \"http://127.0.0.1:14450/IDontExist.qml\"; onLoaded: did_load=456 }"), QUrl::fromLocalFile("http://127.0.0.1:14450/dummy.qml"));
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader != 0);
- QTRY_VERIFY(loader->status() == QSGLoader::Error);
+ QTRY_VERIFY(loader->status() == QQuickLoader::Error);
QVERIFY(loader->item() == 0);
QCOMPARE(loader->progress(), 0.0);
QCOMPARE(loader->property("did_load").toInt(), 123);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 0);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 0);
delete loader;
}
-void tst_QSGLoader::active()
+void tst_QQuickLoader::active()
{
// check that the item isn't instantiated until active is set to true
{
QDeclarativeComponent component(&engine, TEST_FILE("active.1.qml"));
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader->active() == false); // set manually to false
QVERIFY(loader->item() == 0);
QDeclarativeComponent component(&engine, TEST_FILE("active.2.qml"));
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader->active() == true); // active is true by default
- QCOMPARE(loader->status(), QSGLoader::Ready);
+ QCOMPARE(loader->status(), QQuickLoader::Ready);
int currStatusChangedCount = loader->property("statusChangedCount").toInt();
QMetaObject::invokeMethod(object, "doSetInactive");
- QCOMPARE(loader->status(), QSGLoader::Null);
+ QCOMPARE(loader->status(), QQuickLoader::Null);
QCOMPARE(loader->property("statusChangedCount").toInt(), (currStatusChangedCount+1));
delete object;
QDeclarativeComponent component(&engine, TEST_FILE("active.3.qml"));
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader->active() == true); // active is true by default
QVERIFY(!loader->source().isEmpty());
QDeclarativeComponent component(&engine, TEST_FILE("active.4.qml"));
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader->active() == true); // active is true by default
QVERIFY(loader->sourceComponent() != 0);
QDeclarativeComponent component(&engine, TEST_FILE("active.5.qml"));
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader->active() == true); // active is true by default
QVERIFY(loader->item() != 0);
QDeclarativeComponent component(&engine, TEST_FILE("active.6.qml"));
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader->active() == true); // active is true by default
loader->setActive(true); // no effect
}
}
-void tst_QSGLoader::initialPropertyValues_data()
+void tst_QQuickLoader::initialPropertyValues_data()
{
QTest::addColumn<QUrl>("qmlFile");
QTest::addColumn<QStringList>("expectedWarnings");
<< (QVariantList() << 6);
}
-void tst_QSGLoader::initialPropertyValues()
+void tst_QQuickLoader::initialPropertyValues()
{
QFETCH(QUrl, qmlFile);
QFETCH(QStringList, expectedWarnings);
delete object;
}
-void tst_QSGLoader::initialPropertyValuesBinding()
+void tst_QQuickLoader::initialPropertyValuesBinding()
{
QDeclarativeComponent component(&engine, TEST_FILE("initialPropertyValues.binding.qml"));
QObject *object = component.create();
delete object;
}
-void tst_QSGLoader::initialPropertyValuesError_data()
+void tst_QQuickLoader::initialPropertyValuesError_data()
{
QTest::addColumn<QUrl>("qmlFile");
QTest::addColumn<QStringList>("expectedWarnings");
<< QString(TEST_FILE("initialPropertyValues.error.4.qml").toString() + ":5: TypeError: Cannot read property 'canary' of null"));
}
-void tst_QSGLoader::initialPropertyValuesError()
+void tst_QQuickLoader::initialPropertyValuesError()
{
QFETCH(QUrl, qmlFile);
QFETCH(QStringList, expectedWarnings);
QDeclarativeComponent component(&engine, qmlFile);
QObject *object = component.create();
QVERIFY(object != 0);
- QSGLoader *loader = object->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = object->findChild<QQuickLoader*>("loader");
QVERIFY(loader != 0);
QVERIFY(loader->item() == 0);
delete object;
}
// QTBUG-9241
-void tst_QSGLoader::deleteComponentCrash()
+void tst_QQuickLoader::deleteComponentCrash()
{
QDeclarativeComponent component(&engine, TEST_FILE("crash.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
item->metaObject()->invokeMethod(item, "setLoaderSource");
- QSGLoader *loader = qobject_cast<QSGLoader*>(item->QSGItem::childItems().at(0));
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(item->QQuickItem::childItems().at(0));
QVERIFY(loader);
QVERIFY(loader->item());
QCOMPARE(loader->item()->objectName(), QLatin1String("blue"));
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(loader->status(), QSGLoader::Ready);
+ QCOMPARE(loader->status(), QQuickLoader::Ready);
qApp->processEvents(QEventLoop::DeferredDeletion);
- QTRY_COMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QTRY_COMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
QVERIFY(loader->source() == QUrl::fromLocalFile(TESTDATA("BlueRect.qml")));
delete item;
}
-void tst_QSGLoader::nonItem()
+void tst_QQuickLoader::nonItem()
{
QDeclarativeComponent component(&engine, TEST_FILE("nonItem.qml"));
QString err = QUrl::fromLocalFile(TESTDATA("nonItem.qml")).toString() + ":3:1: QML Loader: Loader does not support loading non-visual elements.";
QTest::ignoreMessage(QtWarningMsg, err.toLatin1().constData());
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader);
QVERIFY(loader->item() == 0);
delete loader;
}
-void tst_QSGLoader::vmeErrors()
+void tst_QQuickLoader::vmeErrors()
{
QDeclarativeComponent component(&engine, TEST_FILE("vmeErrors.qml"));
QString err = QUrl::fromLocalFile(TESTDATA("VmeError.qml")).toString() + ":6: Cannot assign object type QObject with no default method";
QTest::ignoreMessage(QtWarningMsg, err.toLatin1().constData());
- QSGLoader *loader = qobject_cast<QSGLoader*>(component.create());
+ QQuickLoader *loader = qobject_cast<QQuickLoader*>(component.create());
QVERIFY(loader);
QVERIFY(loader->item() == 0);
}
// QTBUG-13481
-void tst_QSGLoader::creationContext()
+void tst_QQuickLoader::creationContext()
{
QDeclarativeComponent component(&engine, TEST_FILE("creationContext.qml"));
delete o;
}
-void tst_QSGLoader::QTBUG_16928()
+void tst_QQuickLoader::QTBUG_16928()
{
QDeclarativeComponent component(&engine, TEST_FILE("QTBUG_16928.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(item->width(), 250.);
delete item;
}
-void tst_QSGLoader::implicitSize()
+void tst_QQuickLoader::implicitSize()
{
QDeclarativeComponent component(&engine, TEST_FILE("implicitSize.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(item->width(), 150.);
delete item;
}
-void tst_QSGLoader::QTBUG_17114()
+void tst_QQuickLoader::QTBUG_17114()
{
QDeclarativeComponent component(&engine, TEST_FILE("QTBUG_17114.qml"));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(item->property("loaderWidth").toReal(), 32.);
delete item;
}
-void tst_QSGLoader::asynchronous_data()
+void tst_QQuickLoader::asynchronous_data()
{
QTest::addColumn<QUrl>("qmlFile");
QTest::addColumn<QStringList>("expectedWarnings");
<< (QStringList() << QString(TEST_FILE("InvalidSourceComponent.qml").toString() + ":5:1: Syntax error"));
}
-void tst_QSGLoader::asynchronous()
+void tst_QQuickLoader::asynchronous()
{
QFETCH(QUrl, qmlFile);
QFETCH(QStringList, expectedWarnings);
if (!engine.incubationController())
engine.setIncubationController(new PeriodicIncubationController);
QDeclarativeComponent component(&engine, TEST_FILE("asynchronous.qml"));
- QSGItem *root = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *root = qobject_cast<QQuickItem*>(component.create());
QVERIFY(root);
- QSGLoader *loader = root->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = root->findChild<QQuickLoader*>("loader");
QVERIFY(loader);
foreach (const QString &warning, expectedWarnings)
QVERIFY(!loader->item());
if (expectedWarnings.isEmpty()) {
- QCOMPARE(loader->status(), QSGLoader::Loading);
+ QCOMPARE(loader->status(), QQuickLoader::Loading);
QCOMPARE(engine.incubationController()->incubatingObjectCount(), 1);
QTRY_VERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(loader->status(), QSGLoader::Ready);
+ QCOMPARE(loader->status(), QQuickLoader::Ready);
} else {
QCOMPARE(loader->progress(), 1.0);
- QTRY_COMPARE(loader->status(), QSGLoader::Error);
+ QTRY_COMPARE(loader->status(), QQuickLoader::Error);
}
delete root;
}
-void tst_QSGLoader::asynchronous_clear()
+void tst_QQuickLoader::asynchronous_clear()
{
if (!engine.incubationController())
engine.setIncubationController(new PeriodicIncubationController);
QDeclarativeComponent component(&engine, TEST_FILE("asynchronous.qml"));
- QSGItem *root = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *root = qobject_cast<QQuickItem*>(component.create());
QVERIFY(root);
- QSGLoader *loader = root->findChild<QSGLoader*>("loader");
+ QQuickLoader *loader = root->findChild<QQuickLoader*>("loader");
QVERIFY(loader);
QVERIFY(!loader->item());
QMetaObject::invokeMethod(root, "loadComponent");
QVERIFY(!loader->item());
- QCOMPARE(loader->status(), QSGLoader::Loading);
+ QCOMPARE(loader->status(), QQuickLoader::Loading);
QCOMPARE(engine.incubationController()->incubatingObjectCount(), 1);
// clear before component created
QCOMPARE(engine.incubationController()->incubatingObjectCount(), 0);
QCOMPARE(loader->progress(), 0.0);
- QCOMPARE(loader->status(), QSGLoader::Null);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 0);
+ QCOMPARE(loader->status(), QQuickLoader::Null);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 0);
// check loading component
root->setProperty("comp", "Rect120x60.qml");
QMetaObject::invokeMethod(root, "loadComponent");
QVERIFY(!loader->item());
- QCOMPARE(loader->status(), QSGLoader::Loading);
+ QCOMPARE(loader->status(), QQuickLoader::Loading);
QCOMPARE(engine.incubationController()->incubatingObjectCount(), 1);
QTRY_VERIFY(loader->item());
QCOMPARE(loader->progress(), 1.0);
- QCOMPARE(loader->status(), QSGLoader::Ready);
- QCOMPARE(static_cast<QSGItem*>(loader)->childItems().count(), 1);
+ QCOMPARE(loader->status(), QQuickLoader::Ready);
+ QCOMPARE(static_cast<QQuickItem*>(loader)->childItems().count(), 1);
}
-QTEST_MAIN(tst_QSGLoader)
+QTEST_MAIN(tst_QQuickLoader)
-#include "tst_qsgloader.moc"
+#include "tst_qquickloader.moc"
CONFIG += testcase
-TARGET = tst_qsgmousearea
+TARGET = tst_qquickmousearea
macx:CONFIG -= app_bundle
HEADERS += ../shared/testhttpserver.h
-SOURCES += tst_qsgmousearea.cpp ../shared/testhttpserver.cpp
+SOURCES += tst_qquickmousearea.cpp ../shared/testhttpserver.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtTest/QtTest>
#include <QtTest/QSignalSpy>
-#include <private/qsgmousearea_p.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgflickable_p.h>
-#include <QtDeclarative/qsgview.h>
+#include <private/qquickmousearea_p.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquickflickable_p.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtOpenGL/QGLShaderProgram>
//#define OLDWAY
-class tst_QSGMouseArea: public QObject
+class tst_QQuickMouseArea: public QObject
{
Q_OBJECT
private slots:
void hoverPropagation();
private:
- QSGView *createView();
+ QQuickView *createView();
};
-void tst_QSGMouseArea::initTestCase()
+void tst_QQuickMouseArea::initTestCase()
{
}
-void tst_QSGMouseArea::cleanupTestCase()
+void tst_QQuickMouseArea::cleanupTestCase()
{
}
-void tst_QSGMouseArea::dragProperties()
+void tst_QQuickMouseArea::dragProperties()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("dragproperties.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGMouseArea *mouseRegion = canvas->rootObject()->findChild<QSGMouseArea*>("mouseregion");
- QSGDrag *drag = mouseRegion->drag();
+ QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
- QSGItem *rootItem = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(rootItem != 0);
QSignalSpy targetSpy(drag, SIGNAL(targetChanged()));
drag->setTarget(rootItem);
QCOMPARE(targetSpy.count(),1);
// axis
- QCOMPARE(drag->axis(), QSGDrag::XandYAxis);
+ QCOMPARE(drag->axis(), QQuickDrag::XandYAxis);
QSignalSpy axisSpy(drag, SIGNAL(axisChanged()));
- drag->setAxis(QSGDrag::XAxis);
- QCOMPARE(drag->axis(), QSGDrag::XAxis);
+ drag->setAxis(QQuickDrag::XAxis);
+ QCOMPARE(drag->axis(), QQuickDrag::XAxis);
QCOMPARE(axisSpy.count(),1);
- drag->setAxis(QSGDrag::XAxis);
+ drag->setAxis(QQuickDrag::XAxis);
QCOMPARE(axisSpy.count(),1);
// minimum and maximum properties
delete canvas;
}
-void tst_QSGMouseArea::resetDrag()
+void tst_QQuickMouseArea::resetDrag()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->rootContext()->setContextProperty("haveTarget", QVariant(true));
canvas->setSource(QUrl::fromLocalFile(TESTDATA("dragreset.qml")));
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGMouseArea *mouseRegion = canvas->rootObject()->findChild<QSGMouseArea*>("mouseregion");
- QSGDrag *drag = mouseRegion->drag();
+ QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
- QSGItem *rootItem = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(rootItem != 0);
QSignalSpy targetSpy(drag, SIGNAL(targetChanged()));
QVERIFY(drag->target() != 0);
}
-void tst_QSGMouseArea::dragging()
+void tst_QQuickMouseArea::dragging()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("dragging.qml")));
canvas->show();
QTest::qWait(20);
QVERIFY(canvas->rootObject() != 0);
- QSGMouseArea *mouseRegion = canvas->rootObject()->findChild<QSGMouseArea*>("mouseregion");
- QSGDrag *drag = mouseRegion->drag();
+ QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
delete canvas;
}
-QSGView *tst_QSGMouseArea::createView()
+QQuickView *tst_QQuickMouseArea::createView()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setBaseSize(QSize(240,320));
return canvas;
}
-void tst_QSGMouseArea::updateMouseAreaPosOnClick()
+void tst_QQuickMouseArea::updateMouseAreaPosOnClick()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("updateMousePosOnClick.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGMouseArea *mouseRegion = canvas->rootObject()->findChild<QSGMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QVERIFY(mouseRegion != 0);
- QSGRectangle *rect = canvas->rootObject()->findChild<QSGRectangle*>("ball");
+ QQuickRectangle *rect = canvas->rootObject()->findChild<QQuickRectangle*>("ball");
QVERIFY(rect != 0);
QCOMPARE(mouseRegion->mouseX(), rect->x());
delete canvas;
}
-void tst_QSGMouseArea::updateMouseAreaPosOnResize()
+void tst_QQuickMouseArea::updateMouseAreaPosOnResize()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("updateMousePosOnResize.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGMouseArea *mouseRegion = canvas->rootObject()->findChild<QSGMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QVERIFY(mouseRegion != 0);
- QSGRectangle *rect = canvas->rootObject()->findChild<QSGRectangle*>("brother");
+ QQuickRectangle *rect = canvas->rootObject()->findChild<QQuickRectangle*>("brother");
QVERIFY(rect != 0);
QCOMPARE(mouseRegion->mouseX(), 0.0);
delete canvas;
}
-void tst_QSGMouseArea::noOnClickedWithPressAndHold()
+void tst_QQuickMouseArea::noOnClickedWithPressAndHold()
{
{
// We handle onPressAndHold, therefore no onClicked
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("clickandhold.qml")));
canvas->show();
canvas->requestActivateWindow();
{
// We do not handle onPressAndHold, therefore we get onClicked
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("noclickandhold.qml")));
canvas->show();
canvas->requestActivateWindow();
}
}
-void tst_QSGMouseArea::onMousePressRejected()
+void tst_QQuickMouseArea::onMousePressRejected()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("rejectEvent.qml")));
canvas->show();
canvas->requestActivateWindow();
delete canvas;
}
-void tst_QSGMouseArea::pressedCanceledOnWindowDeactivate()
+void tst_QQuickMouseArea::pressedCanceledOnWindowDeactivate()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pressedCanceled.qml")));
canvas->show();
canvas->requestActivateWindow();
delete canvas;
}
-void tst_QSGMouseArea::doubleClick()
+void tst_QQuickMouseArea::doubleClick()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("doubleclick.qml")));
canvas->show();
canvas->requestActivateWindow();
}
// QTBUG-14832
-void tst_QSGMouseArea::clickTwice()
+void tst_QQuickMouseArea::clickTwice()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("clicktwice.qml")));
canvas->show();
canvas->requestActivateWindow();
delete canvas;
}
-void tst_QSGMouseArea::pressedOrdering()
+void tst_QQuickMouseArea::pressedOrdering()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pressedOrdering.qml")));
canvas->show();
canvas->requestActivateWindow();
delete canvas;
}
-void tst_QSGMouseArea::preventStealing()
+void tst_QQuickMouseArea::preventStealing()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("preventstealing.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGFlickable *flickable = qobject_cast<QSGFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
QVERIFY(flickable != 0);
- QSGMouseArea *mouseArea = canvas->rootObject()->findChild<QSGMouseArea*>("mousearea");
+ QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea*>("mousearea");
QVERIFY(mouseArea != 0);
- QSignalSpy mousePositionSpy(mouseArea, SIGNAL(positionChanged(QSGMouseEvent*)));
+ QSignalSpy mousePositionSpy(mouseArea, SIGNAL(positionChanged(QQuickMouseEvent*)));
QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(80, 80));
delete canvas;
}
-void tst_QSGMouseArea::clickThrough()
+void tst_QQuickMouseArea::clickThrough()
{
//With no handlers defined click, doubleClick and PressAndHold should propagate to those with handlers
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("clickThrough.qml")));
canvas->show();
canvas->requestActivateWindow();
delete canvas;
}
-void tst_QSGMouseArea::testQtQuick11Attributes()
+void tst_QQuickMouseArea::testQtQuick11Attributes()
{
QFETCH(QString, code);
QFETCH(QString, warning);
delete obj;
}
-void tst_QSGMouseArea::testQtQuick11Attributes_data()
+void tst_QQuickMouseArea::testQtQuick11Attributes_data()
{
QTest::addColumn<QString>("code");
QTest::addColumn<QString>("warning");
<< ":1 \"MouseArea.preventStealing\" is not available in QtQuick 1.0.\n";
}
-void tst_QSGMouseArea::hoverPosition()
+void tst_QQuickMouseArea::hoverPosition()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("hoverPosition.qml")));
- QSGItem *root = canvas->rootObject();
+ QQuickItem *root = canvas->rootObject();
QVERIFY(root != 0);
QCOMPARE(root->property("mouseX").toReal(), qreal(0));
delete canvas;
}
-void tst_QSGMouseArea::hoverPropagation()
+void tst_QQuickMouseArea::hoverPropagation()
{
//QTBUG-18175, to behave like GV did.
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("hoverPropagation.qml")));
- QSGItem *root = canvas->rootObject();
+ QQuickItem *root = canvas->rootObject();
QVERIFY(root != 0);
QCOMPARE(root->property("point1").toBool(), false);
delete canvas;
}
-QTEST_MAIN(tst_QSGMouseArea)
+QTEST_MAIN(tst_QQuickMouseArea)
-#include "tst_qsgmousearea.moc"
+#include "tst_qquickmousearea.moc"
CONFIG += testcase
-TARGET = tst_qsgpathview
+TARGET = tst_qquickpathview
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgpathview.cpp
+SOURCES += tst_qquickpathview.cpp
testDataFiles.files = data
testDataFiles.path = .
****************************************************************************/
#include <QtTest/QtTest>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeexpression.h>
-#include <QtDeclarative/private/qsgpathview_p.h>
+#include <QtDeclarative/private/qquickpathview_p.h>
#include <QtDeclarative/private/qdeclarativepath_p.h>
-#include <QtDeclarative/private/qsgtext_p.h>
-#include <QtDeclarative/private/qsgrectangle_p.h>
+#include <QtDeclarative/private/qquicktext_p.h>
+#include <QtDeclarative/private/qquickrectangle_p.h>
#include <QtDeclarative/private/qdeclarativelistmodel_p.h>
#include <QtDeclarative/private/qdeclarativevaluetype_p.h>
#include <QAbstractListModel>
}
-class tst_QSGPathView : public QObject
+class tst_QQuickPathView : public QObject
{
Q_OBJECT
public:
- tst_QSGPathView();
+ tst_QQuickPathView();
private slots:
void initTestCase();
void creationContext();
private:
- QSGView *createView();
+ QQuickView *createView();
template<typename T>
- T *findItem(QSGItem *parent, const QString &objectName, int index=-1);
+ T *findItem(QQuickItem *parent, const QString &objectName, int index=-1);
template<typename T>
- QList<T*> findItems(QSGItem *parent, const QString &objectName);
+ QList<T*> findItems(QQuickItem *parent, const QString &objectName);
};
-void tst_QSGPathView::initTestCase()
+void tst_QQuickPathView::initTestCase()
{
}
-void tst_QSGPathView::cleanupTestCase()
+void tst_QQuickPathView::cleanupTestCase()
{
}
};
-tst_QSGPathView::tst_QSGPathView()
+tst_QQuickPathView::tst_QQuickPathView()
{
}
-void tst_QSGPathView::initValues()
+void tst_QQuickPathView::initValues()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathview1.qml")));
- QSGPathView *obj = qobject_cast<QSGPathView*>(c.create());
+ QQuickPathView *obj = qobject_cast<QQuickPathView*>(c.create());
QVERIFY(obj != 0);
QVERIFY(obj->path() == 0);
QCOMPARE(obj->pathItemCount(), -1);
}
-void tst_QSGPathView::items()
+void tst_QQuickPathView::items()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
TestModel model;
model.addItem("Fred", "12345");
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pathview0.qml")));
qApp->processEvents();
- QSGPathView *pathview = findItem<QSGPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
QVERIFY(pathview != 0);
QCOMPARE(pathview->count(), model.count());
QCOMPARE(pathview->childItems().count(), model.count()+1); // assumes all are visible, including highlight
for (int i = 0; i < model.count(); ++i) {
- QSGText *name = findItem<QSGText>(pathview, "textName", i);
+ QQuickText *name = findItem<QQuickText>(pathview, "textName", i);
QVERIFY(name != 0);
QCOMPARE(name->text(), model.name(i));
- QSGText *number = findItem<QSGText>(pathview, "textNumber", i);
+ QQuickText *number = findItem<QQuickText>(pathview, "textNumber", i);
QVERIFY(number != 0);
QCOMPARE(number->text(), model.number(i));
}
delete canvas;
}
-void tst_QSGPathView::pathview2()
+void tst_QQuickPathView::pathview2()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathview2.qml")));
- QSGPathView *obj = qobject_cast<QSGPathView*>(c.create());
+ QQuickPathView *obj = qobject_cast<QQuickPathView*>(c.create());
QVERIFY(obj != 0);
QVERIFY(obj->path() != 0);
QCOMPARE(obj->pathItemCount(), 10);
}
-void tst_QSGPathView::pathview3()
+void tst_QQuickPathView::pathview3()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathview3.qml")));
- QSGPathView *obj = qobject_cast<QSGPathView*>(c.create());
+ QQuickPathView *obj = qobject_cast<QQuickPathView*>(c.create());
QVERIFY(obj != 0);
QVERIFY(obj->path() != 0);
QCOMPARE(obj->pathItemCount(), 4);
}
-void tst_QSGPathView::path()
+void tst_QQuickPathView::path()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("pathtest.qml")));
QCOMPARE(cubic->control2Y(), 90.);
}
-void tst_QSGPathView::dataModel()
+void tst_QQuickPathView::dataModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
QDeclarativeContext *ctxt = canvas->rootContext();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("datamodel.qml")));
qApp->processEvents();
- QSGPathView *pathview = qobject_cast<QSGPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
QVERIFY(pathview != 0);
QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
QVERIFY(testObject->error() == false);
- QSGItem *item = findItem<QSGItem>(pathview, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(pathview, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->x(), 110.0);
QCOMPARE(item->y(), 10.0);
QTest::qWait(100);
QCOMPARE(canvas->rootObject()->property("viewCount").toInt(), model.count());
- QTRY_COMPARE(findItems<QSGItem>(pathview, "wrapper").count(), 14);
+ QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 14);
QVERIFY(pathview->currentIndex() == 0);
- QCOMPARE(pathview->currentItem(), findItem<QSGItem>(pathview, "wrapper", 0));
+ QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 0));
- QSGText *text = findItem<QSGText>(pathview, "myText", 4);
+ QQuickText *text = findItem<QQuickText>(pathview, "myText", 4);
QVERIFY(text);
QCOMPARE(text->text(), model.name(4));
model.removeItem(2);
QCOMPARE(canvas->rootObject()->property("viewCount").toInt(), model.count());
- text = findItem<QSGText>(pathview, "myText", 2);
+ text = findItem<QQuickText>(pathview, "myText", 2);
QVERIFY(text);
QCOMPARE(text->text(), model.name(2));
- QCOMPARE(pathview->currentItem(), findItem<QSGItem>(pathview, "wrapper", 0));
+ QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 0));
testObject->setPathItemCount(5);
QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
QVERIFY(testObject->error() == false);
- QTRY_COMPARE(findItems<QSGItem>(pathview, "wrapper").count(), 5);
+ QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 5);
- QSGRectangle *testItem = findItem<QSGRectangle>(pathview, "wrapper", 4);
+ QQuickRectangle *testItem = findItem<QQuickRectangle>(pathview, "wrapper", 4);
QVERIFY(testItem != 0);
- testItem = findItem<QSGRectangle>(pathview, "wrapper", 5);
+ testItem = findItem<QQuickRectangle>(pathview, "wrapper", 5);
QVERIFY(testItem == 0);
pathview->setCurrentIndex(1);
- QCOMPARE(pathview->currentItem(), findItem<QSGItem>(pathview, "wrapper", 1));
+ QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 1));
QTest::qWait(100);
model.insertItem(2, "pink", "2");
QTest::qWait(100);
- QTRY_COMPARE(findItems<QSGItem>(pathview, "wrapper").count(), 5);
+ QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 5);
QVERIFY(pathview->currentIndex() == 1);
- QCOMPARE(pathview->currentItem(), findItem<QSGItem>(pathview, "wrapper", 1));
+ QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 1));
- text = findItem<QSGText>(pathview, "myText", 2);
+ text = findItem<QQuickText>(pathview, "myText", 2);
QVERIFY(text);
QCOMPARE(text->text(), model.name(2));
model.removeItem(3);
- QTRY_COMPARE(findItems<QSGItem>(pathview, "wrapper").count(), 5);
- text = findItem<QSGText>(pathview, "myText", 3);
+ QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 5);
+ text = findItem<QQuickText>(pathview, "myText", 3);
QVERIFY(text);
QCOMPARE(text->text(), model.name(3));
- QCOMPARE(pathview->currentItem(), findItem<QSGItem>(pathview, "wrapper", 1));
+ QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 1));
model.moveItem(3, 5);
- QTRY_COMPARE(findItems<QSGItem>(pathview, "wrapper").count(), 5);
- QList<QSGItem*> items = findItems<QSGItem>(pathview, "wrapper");
- foreach (QSGItem *item, items) {
+ QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 5);
+ QList<QQuickItem*> items = findItems<QQuickItem>(pathview, "wrapper");
+ foreach (QQuickItem *item, items) {
QVERIFY(item->property("onPath").toBool());
}
- QCOMPARE(pathview->currentItem(), findItem<QSGItem>(pathview, "wrapper", 1));
+ QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 1));
// QTBUG-14199
pathview->setOffset(7);
pathview->setOffset(0);
- QCOMPARE(findItems<QSGItem>(pathview, "wrapper").count(), 5);
+ QCOMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 5);
pathview->setCurrentIndex(model.count()-1);
model.removeItem(model.count()-1);
delete testObject;
}
-void tst_QSGPathView::pathMoved()
+void tst_QQuickPathView::pathMoved()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pathview0.qml")));
qApp->processEvents();
- QSGPathView *pathview = findItem<QSGPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
QVERIFY(pathview != 0);
- QSGRectangle *firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ QQuickRectangle *firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QDeclarativePath *path = qobject_cast<QDeclarativePath*>(pathview->path());
QVERIFY(path);
pathview->setOffset(1.0);
for (int i=0; i<model.count(); i++) {
- QSGRectangle *curItem = findItem<QSGRectangle>(pathview, "wrapper", i);
+ QQuickRectangle *curItem = findItem<QQuickRectangle>(pathview, "wrapper", i);
QPointF itemPos(path->pointAt(0.25 + i*0.25));
QCOMPARE(curItem->pos() + offset, QPointF(qRound(itemPos.x()), qRound(itemPos.y())));
}
delete canvas;
}
-void tst_QSGPathView::setCurrentIndex()
+void tst_QQuickPathView::setCurrentIndex()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
TestModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pathview0.qml")));
qApp->processEvents();
- QSGPathView *pathview = findItem<QSGPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
QVERIFY(pathview != 0);
- QSGRectangle *firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ QQuickRectangle *firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QDeclarativePath *path = qobject_cast<QDeclarativePath*>(pathview->path());
QVERIFY(path);
pathview->setCurrentIndex(2);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 2);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 2);
QTRY_COMPARE(firstItem->pos() + offset, start);
QCOMPARE(canvas->rootObject()->property("currentA").toInt(), 2);
QCOMPARE(canvas->rootObject()->property("currentB").toInt(), 2);
pathview->decrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 1);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 1);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 1);
QVERIFY(firstItem);
QTRY_COMPARE(firstItem->pos() + offset, start);
QCOMPARE(pathview->currentItem(), firstItem);
pathview->decrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 0);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QTRY_COMPARE(firstItem->pos() + offset, start);
QCOMPARE(pathview->currentItem(), firstItem);
pathview->decrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 3);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 3);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 3);
QVERIFY(firstItem);
QTRY_COMPARE(firstItem->pos() + offset, start);
QCOMPARE(pathview->currentItem(), firstItem);
pathview->incrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 0);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QTRY_COMPARE(firstItem->pos() + offset, start);
QCOMPARE(pathview->currentItem(), firstItem);
// Check the current item is still created when outside the bounds of pathItemCount.
pathview->setPathItemCount(2);
- pathview->setHighlightRangeMode(QSGPathView::NoHighlightRange);
- QVERIFY(findItem<QSGRectangle>(pathview, "wrapper", 0));
- QVERIFY(findItem<QSGRectangle>(pathview, "wrapper", 1));
- QVERIFY(!findItem<QSGRectangle>(pathview, "wrapper", 2));
- QVERIFY(!findItem<QSGRectangle>(pathview, "wrapper", 3));
+ pathview->setHighlightRangeMode(QQuickPathView::NoHighlightRange);
+ QVERIFY(findItem<QQuickRectangle>(pathview, "wrapper", 0));
+ QVERIFY(findItem<QQuickRectangle>(pathview, "wrapper", 1));
+ QVERIFY(!findItem<QQuickRectangle>(pathview, "wrapper", 2));
+ QVERIFY(!findItem<QQuickRectangle>(pathview, "wrapper", 3));
pathview->setCurrentIndex(2);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 2);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 2);
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(false));
pathview->decrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 1);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 1);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 1);
QVERIFY(firstItem);
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(true));
pathview->decrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 0);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(true));
pathview->decrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 3);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 3);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 3);
QVERIFY(firstItem);
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(false));
pathview->incrementCurrentIndex();
QTRY_COMPARE(pathview->currentIndex(), 0);
- firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(true));
delete canvas;
}
-void tst_QSGPathView::resetModel()
+void tst_QQuickPathView::resetModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QStringList strings;
strings << "one" << "two" << "three";
canvas->setSource(QUrl::fromLocalFile(TESTDATA("displaypath.qml")));
qApp->processEvents();
- QSGPathView *pathview = findItem<QSGPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
QVERIFY(pathview != 0);
QCOMPARE(pathview->count(), model.rowCount());
for (int i = 0; i < model.rowCount(); ++i) {
- QSGText *display = findItem<QSGText>(pathview, "displayText", i);
+ QQuickText *display = findItem<QQuickText>(pathview, "displayText", i);
QVERIFY(display != 0);
QCOMPARE(display->text(), strings.at(i));
}
QCOMPARE(pathview->count(), model.rowCount());
for (int i = 0; i < model.rowCount(); ++i) {
- QSGText *display = findItem<QSGText>(pathview, "displayText", i);
+ QQuickText *display = findItem<QQuickText>(pathview, "displayText", i);
QVERIFY(display != 0);
QCOMPARE(display->text(), strings.at(i));
}
delete canvas;
}
-void tst_QSGPathView::propertyChanges()
+void tst_QQuickPathView::propertyChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychanges.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("pathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QSignalSpy snapPositionSpy(pathView, SIGNAL(preferredHighlightBeginChanged()));
delete canvas;
}
-void tst_QSGPathView::pathChanges()
+void tst_QQuickPathView::pathChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychanges.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("pathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QDeclarativePath *path = canvas->rootObject()->findChild<QDeclarativePath*>("path");
delete canvas;
}
-void tst_QSGPathView::componentChanges()
+void tst_QQuickPathView::componentChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychanges.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("pathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QDeclarativeComponent delegateComponent(canvas->engine());
delete canvas;
}
-void tst_QSGPathView::modelChanges()
+void tst_QQuickPathView::modelChanges()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("propertychanges.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("pathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QDeclarativeListModel *alternateModel = canvas->rootObject()->findChild<QDeclarativeListModel*>("alternateModel");
delete canvas;
}
-void tst_QSGPathView::pathUpdateOnStartChanged()
+void tst_QQuickPathView::pathUpdateOnStartChanged()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pathUpdateOnStartChanged.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("pathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QDeclarativePath *path = canvas->rootObject()->findChild<QDeclarativePath*>("path");
QCOMPARE(path->startX(), 400.0);
QCOMPARE(path->startY(), 300.0);
- QSGItem *item = findItem<QSGItem>(pathView, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(pathView, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->x(), path->startX() - item->width() / 2.0);
QCOMPARE(item->y(), path->startY() - item->height() / 2.0);
delete canvas;
}
-void tst_QSGPathView::package()
+void tst_QQuickPathView::package()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pathview_package.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("photoPathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("photoPathView");
QVERIFY(pathView);
- QSGItem *item = findItem<QSGItem>(pathView, "pathItem");
+ QQuickItem *item = findItem<QQuickItem>(pathView, "pathItem");
QVERIFY(item);
QVERIFY(item->scale() != 1.0);
}
//QTBUG-13017
-void tst_QSGPathView::emptyModel()
+void tst_QQuickPathView::emptyModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QStringListModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("emptymodel.qml")));
qApp->processEvents();
- QSGPathView *pathview = qobject_cast<QSGPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
QVERIFY(pathview != 0);
QCOMPARE(pathview->offset(), qreal(0.0));
delete canvas;
}
-void tst_QSGPathView::closed()
+void tst_QQuickPathView::closed()
{
QDeclarativeEngine engine;
}
// QTBUG-14239
-void tst_QSGPathView::pathUpdate()
+void tst_QQuickPathView::pathUpdate()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QVERIFY(canvas);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pathUpdate.qml")));
- QSGPathView *pathView = canvas->rootObject()->findChild<QSGPathView*>("pathView");
+ QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
- QSGItem *item = findItem<QSGItem>(pathView, "wrapper", 0);
+ QQuickItem *item = findItem<QQuickItem>(pathView, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->x(), 150.0);
delete canvas;
}
-void tst_QSGPathView::visualDataModel()
+void tst_QQuickPathView::visualDataModel()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("vdm.qml")));
- QSGPathView *obj = qobject_cast<QSGPathView*>(c.create());
+ QQuickPathView *obj = qobject_cast<QQuickPathView*>(c.create());
QVERIFY(obj != 0);
QCOMPARE(obj->count(), 3);
delete obj;
}
-void tst_QSGPathView::undefinedPath()
+void tst_QQuickPathView::undefinedPath()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("undefinedpath.qml")));
- QSGPathView *obj = qobject_cast<QSGPathView*>(c.create());
+ QQuickPathView *obj = qobject_cast<QQuickPathView*>(c.create());
QVERIFY(obj != 0);
QCOMPARE(obj->count(), 3);
delete obj;
}
-void tst_QSGPathView::mouseDrag()
+void tst_QQuickPathView::mouseDrag()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("dragpath.qml")));
canvas->show();
canvas->requestActivateWindow();
QTest::qWaitForWindowShown(canvas);
QTRY_COMPARE(canvas, qGuiApp->focusWindow());
- QSGPathView *pathview = qobject_cast<QSGPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
QVERIFY(pathview != 0);
int current = pathview->currentIndex();
delete canvas;
}
-void tst_QSGPathView::treeModel()
+void tst_QQuickPathView::treeModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->show();
QStandardItemModel model;
canvas->setSource(QUrl::fromLocalFile(TESTDATA("treemodel.qml")));
- QSGPathView *pathview = qobject_cast<QSGPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
QVERIFY(pathview != 0);
QCOMPARE(pathview->count(), 3);
- QSGText *item = findItem<QSGText>(pathview, "wrapper", 0);
+ QQuickText *item = findItem<QQuickText>(pathview, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->text(), QLatin1String("Row 1 Item"));
QVERIFY(QMetaObject::invokeMethod(pathview, "setRoot", Q_ARG(QVariant, 1)));
QCOMPARE(pathview->count(), 1);
- QTRY_VERIFY(item = findItem<QSGText>(pathview, "wrapper", 0));
+ QTRY_VERIFY(item = findItem<QQuickText>(pathview, "wrapper", 0));
QTRY_COMPARE(item->text(), QLatin1String("Row 2 Child Item"));
delete canvas;
}
-void tst_QSGPathView::changePreferredHighlight()
+void tst_QQuickPathView::changePreferredHighlight()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setGeometry(0,0,400,200);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("dragpath.qml")));
canvas->show();
QTest::qWaitForWindowShown(canvas);
QTRY_COMPARE(canvas, qGuiApp->focusWindow());
- QSGPathView *pathview = qobject_cast<QSGPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
QVERIFY(pathview != 0);
int current = pathview->currentIndex();
QCOMPARE(current, 0);
- QSGRectangle *firstItem = findItem<QSGRectangle>(pathview, "wrapper", 0);
+ QQuickRectangle *firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
QVERIFY(firstItem);
QDeclarativePath *path = qobject_cast<QDeclarativePath*>(pathview->path());
QVERIFY(path);
delete canvas;
}
-void tst_QSGPathView::creationContext()
+void tst_QQuickPathView::creationContext()
{
- QSGView canvas;
+ QQuickView canvas;
canvas.setGeometry(0,0,240,320);
canvas.setSource(QUrl::fromLocalFile(TESTDATA("creationContext.qml")));
- QSGItem *rootItem = qobject_cast<QSGItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
QVERIFY(rootItem);
QVERIFY(rootItem->property("count").toInt() > 0);
- QSGItem *item;
- QVERIFY(item = findItem<QSGItem>(rootItem, "listItem", 0));
+ QQuickItem *item;
+ QVERIFY(item = findItem<QQuickItem>(rootItem, "listItem", 0));
QCOMPARE(item->property("text").toString(), QString("Hello!"));
}
-QSGView *tst_QSGPathView::createView()
+QQuickView *tst_QQuickPathView::createView()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
return canvas;
item must also evaluate the {index} expression equal to index
*/
template<typename T>
-T *tst_QSGPathView::findItem(QSGItem *parent, const QString &objectName, int index)
+T *tst_QQuickPathView::findItem(QQuickItem *parent, const QString &objectName, int index)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
}
template<typename T>
-QList<T*> tst_QSGPathView::findItems(QSGItem *parent, const QString &objectName)
+QList<T*> tst_QQuickPathView::findItems(QQuickItem *parent, const QString &objectName)
{
QList<T*> items;
const QMetaObject &mo = T::staticMetaObject;
- //qDebug() << parent->QSGItem::children().count() << "children";
+ //qDebug() << parent->QQuickItem::children().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
return items;
}
-void tst_QSGPathView::missingPercent()
+void tst_QQuickPathView::missingPercent()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("missingPercent.qml")));
}
-QTEST_MAIN(tst_QSGPathView)
+QTEST_MAIN(tst_QQuickPathView)
-#include "tst_qsgpathview.moc"
+#include "tst_qquickpathview.moc"
CONFIG += testcase
-TARGET = tst_qsgpincharea
+TARGET = tst_qquickpincharea
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgpincharea.cpp
+SOURCES += tst_qquickpincharea.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtTest/QtTest>
#include <QtTest/QSignalSpy>
-#include <private/qsgpincharea_p.h>
-#include <private/qsgrectangle_p.h>
-#include <QtDeclarative/qsgview.h>
+#include <private/qquickpincharea_p.h>
+#include <private/qquickrectangle_p.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include "../shared/util.h"
-class tst_QSGPinchArea: public QObject
+class tst_QQuickPinchArea: public QObject
{
Q_OBJECT
private slots:
void retouch();
private:
- QSGView *createView();
+ QQuickView *createView();
};
-void tst_QSGPinchArea::initTestCase()
+void tst_QQuickPinchArea::initTestCase()
{
}
-void tst_QSGPinchArea::cleanupTestCase()
+void tst_QQuickPinchArea::cleanupTestCase()
{
}
-void tst_QSGPinchArea::pinchProperties()
+void tst_QQuickPinchArea::pinchProperties()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pinchproperties.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
- QSGPinchArea *pinchArea = canvas->rootObject()->findChild<QSGPinchArea*>("pincharea");
- QSGPinch *pinch = pinchArea->pinch();
+ QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == pinch->target());
- QSGItem *rootItem = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(rootItem != 0);
QSignalSpy targetSpy(pinch, SIGNAL(targetChanged()));
pinch->setTarget(rootItem);
QCOMPARE(targetSpy.count(),1);
// axis
- QCOMPARE(pinch->axis(), QSGPinch::XandYAxis);
+ QCOMPARE(pinch->axis(), QQuickPinch::XandYAxis);
QSignalSpy axisSpy(pinch, SIGNAL(dragAxisChanged()));
- pinch->setAxis(QSGPinch::XAxis);
- QCOMPARE(pinch->axis(), QSGPinch::XAxis);
+ pinch->setAxis(QQuickPinch::XAxis);
+ QCOMPARE(pinch->axis(), QQuickPinch::XAxis);
QCOMPARE(axisSpy.count(),1);
- pinch->setAxis(QSGPinch::XAxis);
+ pinch->setAxis(QQuickPinch::XAxis);
QCOMPARE(axisSpy.count(),1);
// minimum and maximum drag properties
delete canvas;
}
-QTouchEvent::TouchPoint makeTouchPoint(int id, QPoint p, QSGView *v, QSGItem *i)
+QTouchEvent::TouchPoint makeTouchPoint(int id, QPoint p, QQuickView *v, QQuickItem *i)
{
QTouchEvent::TouchPoint touchPoint(id);
touchPoint.setPos(i->mapFromScene(p));
return touchPoint;
}
-void tst_QSGPinchArea::scale()
+void tst_QQuickPinchArea::scale()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pinchproperties.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
qApp->processEvents();
- QSGPinchArea *pinchArea = canvas->rootObject()->findChild<QSGPinchArea*>("pincharea");
- QSGPinch *pinch = pinchArea->pinch();
+ QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root != 0);
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QPoint p1(80, 80);
delete canvas;
}
-void tst_QSGPinchArea::pan()
+void tst_QQuickPinchArea::pan()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pinchproperties.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
qApp->processEvents();
- QSGPinchArea *pinchArea = canvas->rootObject()->findChild<QSGPinchArea*>("pincharea");
- QSGPinch *pinch = pinchArea->pinch();
+ QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root != 0);
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QPoint p1(80, 80);
}
// test pinch, release one point, touch again to continue pinch
-void tst_QSGPinchArea::retouch()
+void tst_QQuickPinchArea::retouch()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
canvas->setSource(QUrl::fromLocalFile(TESTDATA("pinchproperties.qml")));
canvas->show();
canvas->requestActivateWindow();
QVERIFY(canvas->rootObject() != 0);
qApp->processEvents();
- QSGPinchArea *pinchArea = canvas->rootObject()->findChild<QSGPinchArea*>("pincharea");
- QSGPinch *pinch = pinchArea->pinch();
+ QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root != 0);
- QSignalSpy startedSpy(pinchArea, SIGNAL(pinchStarted(QSGPinchEvent *)));
- QSignalSpy finishedSpy(pinchArea, SIGNAL(pinchFinished(QSGPinchEvent *)));
+ QSignalSpy startedSpy(pinchArea, SIGNAL(pinchStarted(QQuickPinchEvent *)));
+ QSignalSpy finishedSpy(pinchArea, SIGNAL(pinchFinished(QQuickPinchEvent *)));
// target
- QSGItem *blackRect = canvas->rootObject()->findChild<QSGItem*>("blackrect");
+ QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QPoint p1(80, 80);
}
-QSGView *tst_QSGPinchArea::createView()
+QQuickView *tst_QQuickPinchArea::createView()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
return canvas;
}
-QTEST_MAIN(tst_QSGPinchArea)
+QTEST_MAIN(tst_QQuickPinchArea)
-#include "tst_qsgpincharea.moc"
+#include "tst_qquickpincharea.moc"
CONFIG += testcase
-TARGET = tst_qsgpositioners
-SOURCES += tst_qsgpositioners.cpp
+TARGET = tst_qquickpositioners
+SOURCES += tst_qquickpositioners.cpp
macx:CONFIG -= app_bundle
testDataFiles.files = data
****************************************************************************/
#include <QtTest/QtTest>
#include <private/qlistmodelinterface_p.h>
-#include <qsgview.h>
+#include <qquickview.h>
#include <qdeclarativeengine.h>
-#include <private/qsgrectangle_p.h>
-#include <private/qsgpositioners_p.h>
+#include <private/qquickrectangle_p.h>
+#include <private/qquickpositioners_p.h>
#include <private/qdeclarativetransition_p.h>
-#include <private/qsgitem_p.h>
+#include <private/qquickitem_p.h>
#include <qdeclarativeexpression.h>
#include "../shared/util.h"
-class tst_qsgpositioners : public QObject
+class tst_qquickpositioners : public QObject
{
Q_OBJECT
public:
- tst_qsgpositioners();
+ tst_qquickpositioners();
private slots:
void test_horizontal();
void test_attachedproperties_dynamic();
private:
- QSGView *createView(const QString &filename, bool wait=true);
+ QQuickView *createView(const QString &filename, bool wait=true);
};
-tst_qsgpositioners::tst_qsgpositioners()
+tst_qquickpositioners::tst_qquickpositioners()
{
}
-void tst_qsgpositioners::test_horizontal()
+void tst_qquickpositioners::test_horizontal()
{
- QSGView *canvas = createView(TESTDATA("horizontal.qml"));
+ QQuickView *canvas = createView(TESTDATA("horizontal.qml"));
canvas->rootObject()->setProperty("testRightToLeft", false);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 70.0);
QCOMPARE(three->y(), 0.0);
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 110.0);
QCOMPARE(row->height(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_horizontal_rtl()
+void tst_qquickpositioners::test_horizontal_rtl()
{
- QSGView *canvas = createView(TESTDATA("horizontal.qml"));
+ QQuickView *canvas = createView(TESTDATA("horizontal.qml"));
canvas->rootObject()->setProperty("testRightToLeft", true);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 60.0);
QCOMPARE(three->x(), 0.0);
QCOMPARE(three->y(), 0.0);
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 110.0);
QCOMPARE(row->height(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_horizontal_spacing()
+void tst_qquickpositioners::test_horizontal_spacing()
{
- QSGView *canvas = createView(TESTDATA("horizontal-spacing.qml"));
+ QQuickView *canvas = createView(TESTDATA("horizontal-spacing.qml"));
canvas->rootObject()->setProperty("testRightToLeft", false);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 90.0);
QCOMPARE(three->y(), 0.0);
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 130.0);
QCOMPARE(row->height(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_horizontal_spacing_rightToLeft()
+void tst_qquickpositioners::test_horizontal_spacing_rightToLeft()
{
- QSGView *canvas = createView(TESTDATA("horizontal-spacing.qml"));
+ QQuickView *canvas = createView(TESTDATA("horizontal-spacing.qml"));
canvas->rootObject()->setProperty("testRightToLeft", true);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 80.0);
QCOMPARE(three->x(), 00.0);
QCOMPARE(three->y(), 0.0);
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 130.0);
QCOMPARE(row->height(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_horizontal_animated()
+void tst_qquickpositioners::test_horizontal_animated()
{
- QSGView *canvas = createView(TESTDATA("horizontal-animated.qml"), false);
+ QQuickView *canvas = createView(TESTDATA("horizontal-animated.qml"), false);
canvas->rootObject()->setProperty("testRightToLeft", false);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
//Note that they animate in
QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QVERIFY(row);
QCOMPARE(row->width(), 100.0);
QCOMPARE(row->height(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_horizontal_animated_rightToLeft()
+void tst_qquickpositioners::test_horizontal_animated_rightToLeft()
{
- QSGView *canvas = createView(TESTDATA("horizontal-animated.qml"), false);
+ QQuickView *canvas = createView(TESTDATA("horizontal-animated.qml"), false);
canvas->rootObject()->setProperty("testRightToLeft", true);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
//Note that they animate in
QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QVERIFY(row);
QCOMPARE(row->width(), 100.0);
QCOMPARE(row->height(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_horizontal_animated_disabled()
+void tst_qquickpositioners::test_horizontal_animated_disabled()
{
- QSGView *canvas = createView(TESTDATA("horizontal-animated-disabled.qml"));
+ QQuickView *canvas = createView(TESTDATA("horizontal-animated-disabled.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGItem *row = canvas->rootObject()->findChild<QSGItem*>("row");
+ QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
QVERIFY(row);
qApp->processEvents();
delete canvas;
}
-void tst_qsgpositioners::test_vertical()
+void tst_qquickpositioners::test_vertical()
{
- QSGView *canvas = createView(TESTDATA("vertical.qml"));
+ QQuickView *canvas = createView(TESTDATA("vertical.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 0.0);
QCOMPARE(three->y(), 60.0);
- QSGItem *column = canvas->rootObject()->findChild<QSGItem*>("column");
+ QQuickItem *column = canvas->rootObject()->findChild<QQuickItem*>("column");
QVERIFY(column);
QCOMPARE(column->height(), 80.0);
QCOMPARE(column->width(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_vertical_spacing()
+void tst_qquickpositioners::test_vertical_spacing()
{
- QSGView *canvas = createView(TESTDATA("vertical-spacing.qml"));
+ QQuickView *canvas = createView(TESTDATA("vertical-spacing.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 0.0);
QCOMPARE(three->y(), 80.0);
- QSGItem *column = canvas->rootObject()->findChild<QSGItem*>("column");
+ QQuickItem *column = canvas->rootObject()->findChild<QQuickItem*>("column");
QCOMPARE(column->height(), 100.0);
QCOMPARE(column->width(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_vertical_animated()
+void tst_qquickpositioners::test_vertical_animated()
{
- QSGView *canvas = createView(TESTDATA("vertical-animated.qml"), false);
+ QQuickView *canvas = createView(TESTDATA("vertical-animated.qml"), false);
//Note that they animate in
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
QCOMPARE(one->y(), -100.0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
QCOMPARE(two->y(), -100.0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(three->y(), -100.0);
QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
- QSGItem *column = canvas->rootObject()->findChild<QSGItem*>("column");
+ QQuickItem *column = canvas->rootObject()->findChild<QQuickItem*>("column");
QVERIFY(column);
QCOMPARE(column->height(), 100.0);
QCOMPARE(column->width(), 50.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid()
+void tst_qquickpositioners::test_grid()
{
- QSGView *canvas = createView(TESTDATA("gridtest.qml"));
+ QQuickView *canvas = createView(TESTDATA("gridtest.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 50.0);
QCOMPARE(five->y(), 50.0);
- QSGGrid *grid = canvas->rootObject()->findChild<QSGGrid*>("grid");
- QCOMPARE(grid->flow(), QSGGrid::LeftToRight);
+ QQuickGrid *grid = canvas->rootObject()->findChild<QQuickGrid*>("grid");
+ QCOMPARE(grid->flow(), QQuickGrid::LeftToRight);
QCOMPARE(grid->width(), 100.0);
QCOMPARE(grid->height(), 100.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_topToBottom()
+void tst_qquickpositioners::test_grid_topToBottom()
{
- QSGView *canvas = createView(TESTDATA("grid-toptobottom.qml"));
+ QQuickView *canvas = createView(TESTDATA("grid-toptobottom.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 50.0);
QCOMPARE(five->y(), 50.0);
- QSGGrid *grid = canvas->rootObject()->findChild<QSGGrid*>("grid");
- QCOMPARE(grid->flow(), QSGGrid::TopToBottom);
+ QQuickGrid *grid = canvas->rootObject()->findChild<QQuickGrid*>("grid");
+ QCOMPARE(grid->flow(), QQuickGrid::TopToBottom);
QCOMPARE(grid->width(), 100.0);
QCOMPARE(grid->height(), 120.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_rightToLeft()
+void tst_qquickpositioners::test_grid_rightToLeft()
{
- QSGView *canvas = createView(TESTDATA("gridtest.qml"));
+ QQuickView *canvas = createView(TESTDATA("gridtest.qml"));
canvas->rootObject()->setProperty("testRightToLeft", true);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 50.0);
QCOMPARE(five->x(), 40.0);
QCOMPARE(five->y(), 50.0);
- QSGGrid *grid = canvas->rootObject()->findChild<QSGGrid*>("grid");
+ QQuickGrid *grid = canvas->rootObject()->findChild<QQuickGrid*>("grid");
QCOMPARE(grid->layoutDirection(), Qt::RightToLeft);
QCOMPARE(grid->width(), 100.0);
QCOMPARE(grid->height(), 100.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_spacing()
+void tst_qquickpositioners::test_grid_spacing()
{
- QSGView *canvas = createView(TESTDATA("grid-spacing.qml"));
+ QQuickView *canvas = createView(TESTDATA("grid-spacing.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 54.0);
QCOMPARE(five->y(), 54.0);
- QSGItem *grid = canvas->rootObject()->findChild<QSGItem*>("grid");
+ QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
QCOMPARE(grid->width(), 128.0);
QCOMPARE(grid->height(), 104.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_row_column_spacing()
+void tst_qquickpositioners::test_grid_row_column_spacing()
{
- QSGView *canvas = createView(TESTDATA("grid-row-column-spacing.qml"));
+ QQuickView *canvas = createView(TESTDATA("grid-row-column-spacing.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 61.0);
QCOMPARE(five->y(), 57.0);
- QSGItem *grid = canvas->rootObject()->findChild<QSGItem*>("grid");
+ QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
QCOMPARE(grid->width(), 142.0);
QCOMPARE(grid->height(), 107.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_animated()
+void tst_qquickpositioners::test_grid_animated()
{
- QSGView *canvas = createView(TESTDATA("grid-animated.qml"), false);
+ QQuickView *canvas = createView(TESTDATA("grid-animated.qml"), false);
canvas->rootObject()->setProperty("testRightToLeft", false);
//Note that all animate in
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
QCOMPARE(one->x(), -100.0);
QCOMPARE(one->y(), -100.0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
QCOMPARE(two->x(), -100.0);
QCOMPARE(two->y(), -100.0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(three->x(), -100.0);
QCOMPARE(three->y(), -100.0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
QCOMPARE(four->x(), -100.0);
QCOMPARE(four->y(), -100.0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(five->x(), -100.0);
QCOMPARE(five->y(), -100.0);
QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
- QSGItem *grid = canvas->rootObject()->findChild<QSGItem*>("grid");
+ QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
QVERIFY(grid);
QCOMPARE(grid->width(), 150.0);
QCOMPARE(grid->height(), 100.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_animated_rightToLeft()
+void tst_qquickpositioners::test_grid_animated_rightToLeft()
{
- QSGView *canvas = createView(TESTDATA("grid-animated.qml"), false);
+ QQuickView *canvas = createView(TESTDATA("grid-animated.qml"), false);
canvas->rootObject()->setProperty("testRightToLeft", true);
//Note that all animate in
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
QCOMPARE(one->x(), -100.0);
QCOMPARE(one->y(), -100.0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
QCOMPARE(two->x(), -100.0);
QCOMPARE(two->y(), -100.0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(three->x(), -100.0);
QCOMPARE(three->y(), -100.0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
QCOMPARE(four->x(), -100.0);
QCOMPARE(four->y(), -100.0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(five->x(), -100.0);
QCOMPARE(five->y(), -100.0);
QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
- QSGItem *grid = canvas->rootObject()->findChild<QSGItem*>("grid");
+ QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
QVERIFY(grid);
QCOMPARE(grid->width(), 150.0);
QCOMPARE(grid->height(), 100.0);
delete canvas;
}
-void tst_qsgpositioners::test_grid_zero_columns()
+void tst_qquickpositioners::test_grid_zero_columns()
{
- QSGView *canvas = createView(TESTDATA("gridzerocolumns.qml"));
+ QQuickView *canvas = createView(TESTDATA("gridzerocolumns.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 0.0);
QCOMPARE(five->y(), 50.0);
- QSGItem *grid = canvas->rootObject()->findChild<QSGItem*>("grid");
+ QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
QCOMPARE(grid->width(), 170.0);
QCOMPARE(grid->height(), 60.0);
delete canvas;
}
-void tst_qsgpositioners::test_propertychanges()
+void tst_qquickpositioners::test_propertychanges()
{
- QSGView *canvas = createView(TESTDATA("propertychangestest.qml"));
+ QQuickView *canvas = createView(TESTDATA("propertychangestest.qml"));
- QSGGrid *grid = qobject_cast<QSGGrid*>(canvas->rootObject());
+ QQuickGrid *grid = qobject_cast<QQuickGrid*>(canvas->rootObject());
QVERIFY(grid != 0);
QDeclarativeTransition *rowTransition = canvas->rootObject()->findChild<QDeclarativeTransition*>("rowTransition");
QDeclarativeTransition *columnTransition = canvas->rootObject()->findChild<QDeclarativeTransition*>("columnTransition");
delete canvas;
}
-void tst_qsgpositioners::test_repeater()
+void tst_qquickpositioners::test_repeater()
{
- QSGView *canvas = createView(TESTDATA("repeatertest.qml"));
+ QQuickView *canvas = createView(TESTDATA("repeatertest.qml"));
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
delete canvas;
}
-void tst_qsgpositioners::test_flow()
+void tst_qquickpositioners::test_flow()
{
- QSGView *canvas = createView(TESTDATA("flowtest.qml"));
+ QQuickView *canvas = createView(TESTDATA("flowtest.qml"));
canvas->rootObject()->setProperty("testRightToLeft", false);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 50.0);
QCOMPARE(five->y(), 70.0);
- QSGItem *flow = canvas->rootObject()->findChild<QSGItem*>("flow");
+ QQuickItem *flow = canvas->rootObject()->findChild<QQuickItem*>("flow");
QVERIFY(flow);
QCOMPARE(flow->width(), 90.0);
QCOMPARE(flow->height(), 120.0);
delete canvas;
}
-void tst_qsgpositioners::test_flow_rightToLeft()
+void tst_qquickpositioners::test_flow_rightToLeft()
{
- QSGView *canvas = createView(TESTDATA("flowtest.qml"));
+ QQuickView *canvas = createView(TESTDATA("flowtest.qml"));
canvas->rootObject()->setProperty("testRightToLeft", true);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 40.0);
QCOMPARE(five->x(), 30.0);
QCOMPARE(five->y(), 70.0);
- QSGItem *flow = canvas->rootObject()->findChild<QSGItem*>("flow");
+ QQuickItem *flow = canvas->rootObject()->findChild<QQuickItem*>("flow");
QVERIFY(flow);
QCOMPARE(flow->width(), 90.0);
QCOMPARE(flow->height(), 120.0);
delete canvas;
}
-void tst_qsgpositioners::test_flow_topToBottom()
+void tst_qquickpositioners::test_flow_topToBottom()
{
- QSGView *canvas = createView(TESTDATA("flowtest-toptobottom.qml"));
+ QQuickView *canvas = createView(TESTDATA("flowtest-toptobottom.qml"));
canvas->rootObject()->setProperty("testRightToLeft", false);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 100.0);
QCOMPARE(five->y(), 50.0);
- QSGItem *flow = canvas->rootObject()->findChild<QSGItem*>("flow");
+ QQuickItem *flow = canvas->rootObject()->findChild<QQuickItem*>("flow");
QVERIFY(flow);
QCOMPARE(flow->height(), 90.0);
QCOMPARE(flow->width(), 150.0);
delete canvas;
}
-void tst_qsgpositioners::test_flow_resize()
+void tst_qquickpositioners::test_flow_resize()
{
- QSGView *canvas = createView(TESTDATA("flowtest.qml"));
+ QQuickView *canvas = createView(TESTDATA("flowtest.qml"));
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root);
root->setWidth(125);
root->setProperty("testRightToLeft", false);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QTRY_COMPARE(one->x(), 0.0);
delete canvas;
}
-void tst_qsgpositioners::test_flow_resize_rightToLeft()
+void tst_qquickpositioners::test_flow_resize_rightToLeft()
{
- QSGView *canvas = createView(TESTDATA("flowtest.qml"));
+ QQuickView *canvas = createView(TESTDATA("flowtest.qml"));
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root);
root->setWidth(125);
root->setProperty("testRightToLeft", true);
- QSGRectangle *one = canvas->rootObject()->findChild<QSGRectangle*>("one");
+ QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
QTRY_VERIFY(one != 0);
- QSGRectangle *two = canvas->rootObject()->findChild<QSGRectangle*>("two");
+ QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QSGRectangle *three = canvas->rootObject()->findChild<QSGRectangle*>("three");
+ QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QSGRectangle *four = canvas->rootObject()->findChild<QSGRectangle*>("four");
+ QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QSGRectangle *five = canvas->rootObject()->findChild<QSGRectangle*>("five");
+ QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 75.0);
delete canvas;
}
-void tst_qsgpositioners::test_flow_implicit_resize()
+void tst_qquickpositioners::test_flow_implicit_resize()
{
- QSGView *canvas = createView(TESTDATA("flow-testimplicitsize.qml"));
+ QQuickView *canvas = createView(TESTDATA("flow-testimplicitsize.qml"));
QVERIFY(canvas->rootObject() != 0);
- QSGFlow *flow = canvas->rootObject()->findChild<QSGFlow*>("flow");
+ QQuickFlow *flow = canvas->rootObject()->findChild<QQuickFlow*>("flow");
QVERIFY(flow != 0);
QCOMPARE(flow->width(), 100.0);
QCOMPARE(flow->height(), 120.0);
canvas->rootObject()->setProperty("flowLayout", 0);
- QCOMPARE(flow->flow(), QSGFlow::LeftToRight);
+ QCOMPARE(flow->flow(), QQuickFlow::LeftToRight);
QCOMPARE(flow->width(), 220.0);
QCOMPARE(flow->height(), 50.0);
canvas->rootObject()->setProperty("flowLayout", 1);
- QCOMPARE(flow->flow(), QSGFlow::TopToBottom);
+ QCOMPARE(flow->flow(), QQuickFlow::TopToBottom);
QCOMPARE(flow->width(), 100.0);
QCOMPARE(flow->height(), 120.0);
warningMessage = msg;
}
-void tst_qsgpositioners::test_conflictinganchors()
+void tst_qquickpositioners::test_conflictinganchors()
{
QtMsgHandler oldMsgHandler = qInstallMsgHandler(interceptWarnings);
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine);
component.setData("import QtQuick 2.0\nColumn { Item {} }", QUrl::fromLocalFile(""));
- QSGItem *item = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QVERIFY(warningMessage.isEmpty());
delete item;
component.setData("import QtQuick 2.0\nRow { Item {} }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QVERIFY(warningMessage.isEmpty());
delete item;
component.setData("import QtQuick 2.0\nGrid { Item {} }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QVERIFY(warningMessage.isEmpty());
delete item;
component.setData("import QtQuick 2.0\nFlow { Item {} }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QVERIFY(warningMessage.isEmpty());
delete item;
component.setData("import QtQuick 2.0\nColumn { Item { anchors.top: parent.top } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Column: Cannot specify top, bottom, verticalCenter, fill or centerIn anchors for items inside Column"));
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nColumn { Item { anchors.centerIn: parent } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Column: Cannot specify top, bottom, verticalCenter, fill or centerIn anchors for items inside Column"));
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nColumn { Item { anchors.left: parent.left } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QVERIFY(warningMessage.isEmpty());
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nRow { Item { anchors.left: parent.left } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Row: Cannot specify left, right, horizontalCenter, fill or centerIn anchors for items inside Row"));
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nRow { Item { anchors.fill: parent } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Row: Cannot specify left, right, horizontalCenter, fill or centerIn anchors for items inside Row"));
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nRow { Item { anchors.top: parent.top } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QVERIFY(warningMessage.isEmpty());
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nGrid { Item { anchors.horizontalCenter: parent.horizontalCenter } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Grid: Cannot specify anchors for items inside Grid"));
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nGrid { Item { anchors.centerIn: parent } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Grid: Cannot specify anchors for items inside Grid"));
warningMessage.clear();
delete item;
component.setData("import QtQuick 2.0\nFlow { Item { anchors.verticalCenter: parent.verticalCenter } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Flow: Cannot specify anchors for items inside Flow"));
delete item;
component.setData("import QtQuick 2.0\nFlow { Item { anchors.fill: parent } }", QUrl::fromLocalFile(""));
- item = qobject_cast<QSGItem*>(component.create());
+ item = qobject_cast<QQuickItem*>(component.create());
QVERIFY(item);
QCOMPARE(warningMessage, QString("file::2:1: QML Flow: Cannot specify anchors for items inside Flow"));
qInstallMsgHandler(oldMsgHandler);
delete item;
}
-void tst_qsgpositioners::test_mirroring()
+void tst_qquickpositioners::test_mirroring()
{
QList<QString> qmlFiles;
qmlFiles << "horizontal.qml" << "gridtest.qml" << "flowtest.qml";
objectNames << "one" << "two" << "three" << "four" << "five";
foreach (const QString qmlFile, qmlFiles) {
- QSGView *canvasA = createView(TESTDATA(qmlFile));
- QSGItem *rootA = qobject_cast<QSGItem*>(canvasA->rootObject());
+ QQuickView *canvasA = createView(TESTDATA(qmlFile));
+ QQuickItem *rootA = qobject_cast<QQuickItem*>(canvasA->rootObject());
- QSGView *canvasB = createView(TESTDATA(qmlFile));
- QSGItem *rootB = qobject_cast<QSGItem*>(canvasB->rootObject());
+ QQuickView *canvasB = createView(TESTDATA(qmlFile));
+ QQuickItem *rootB = qobject_cast<QQuickItem*>(canvasB->rootObject());
rootA->setProperty("testRightToLeft", true); // layoutDirection: Qt.RightToLeft
// horizontal.qml only has three items
if (qmlFile == QString("horizontal.qml") && objectName == QString("four"))
break;
- QSGItem *itemA = rootA->findChild<QSGItem*>(objectName);
- QSGItem *itemB = rootB->findChild<QSGItem*>(objectName);
+ QQuickItem *itemA = rootA->findChild<QQuickItem*>(objectName);
+ QQuickItem *itemB = rootB->findChild<QQuickItem*>(objectName);
QTRY_VERIFY(itemA->x() != itemB->x());
}
- QSGItemPrivate* rootPrivateB = QSGItemPrivate::get(rootB);
+ QQuickItemPrivate* rootPrivateB = QQuickItemPrivate::get(rootB);
rootPrivateB->effectiveLayoutMirror = true; // LayoutMirroring.enabled: true
rootPrivateB->isMirrorImplicit = false;
// horizontal.qml only has three items
if (qmlFile == QString("horizontal.qml") && objectName == QString("four"))
break;
- QSGItem *itemA = rootA->findChild<QSGItem*>(objectName);
- QSGItem *itemB = rootB->findChild<QSGItem*>(objectName);
+ QQuickItem *itemA = rootA->findChild<QQuickItem*>(objectName);
+ QQuickItem *itemB = rootB->findChild<QQuickItem*>(objectName);
QTRY_COMPARE(itemA->x(), itemB->x());
}
// horizontal.qml only has three items
if (qmlFile == QString("horizontal.qml") && objectName == QString("four"))
break;
- QSGItem *itemA = rootA->findChild<QSGItem*>(objectName);
- QSGItem *itemB = rootB->findChild<QSGItem*>(objectName);
+ QQuickItem *itemA = rootA->findChild<QQuickItem*>(objectName);
+ QQuickItem *itemB = rootB->findChild<QQuickItem*>(objectName);
QTRY_COMPARE(itemA->x(), itemB->x());
}
delete canvasA;
}
}
-void tst_qsgpositioners::test_allInvisible()
+void tst_qquickpositioners::test_allInvisible()
{
//QTBUG-19361
- QSGView *canvas = createView(TESTDATA("allInvisible.qml"));
+ QQuickView *canvas = createView(TESTDATA("allInvisible.qml"));
- QSGItem *root = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(root);
- QSGRow *row = canvas->rootObject()->findChild<QSGRow*>("row");
+ QQuickRow *row = canvas->rootObject()->findChild<QQuickRow*>("row");
QVERIFY(row != 0);
QVERIFY(row->width() == 0);
QVERIFY(row->height() == 0);
- QSGColumn *column = canvas->rootObject()->findChild<QSGColumn*>("column");
+ QQuickColumn *column = canvas->rootObject()->findChild<QQuickColumn*>("column");
QVERIFY(column != 0);
QVERIFY(column->width() == 0);
QVERIFY(column->height() == 0);
}
-void tst_qsgpositioners::test_attachedproperties()
+void tst_qquickpositioners::test_attachedproperties()
{
QFETCH(QString, filename);
- QSGView *canvas = createView(filename);
+ QQuickView *canvas = createView(filename);
QVERIFY(canvas->rootObject() != 0);
- QSGRectangle *greenRect = canvas->rootObject()->findChild<QSGRectangle *>("greenRect");
+ QQuickRectangle *greenRect = canvas->rootObject()->findChild<QQuickRectangle *>("greenRect");
QVERIFY(greenRect != 0);
int posIndex = greenRect->property("posIndex").toInt();
bool isLast = greenRect->property("isLastItem").toBool();
QVERIFY(isLast == false);
- QSGRectangle *yellowRect = canvas->rootObject()->findChild<QSGRectangle *>("yellowRect");
+ QQuickRectangle *yellowRect = canvas->rootObject()->findChild<QQuickRectangle *>("yellowRect");
QVERIFY(yellowRect != 0);
posIndex = yellowRect->property("posIndex").toInt();
delete canvas;
}
-void tst_qsgpositioners::test_attachedproperties_data()
+void tst_qquickpositioners::test_attachedproperties_data()
{
QTest::addColumn<QString>("filename");
QTest::newRow("flow") << TESTDATA("attachedproperties-flow.qml");
}
-void tst_qsgpositioners::test_attachedproperties_dynamic()
+void tst_qquickpositioners::test_attachedproperties_dynamic()
{
QSKIP("QTBUG-21995 - Test crashes on exit");
- QSGView *canvas = createView(TESTDATA("attachedproperties-dynamic.qml"));
+ QQuickView *canvas = createView(TESTDATA("attachedproperties-dynamic.qml"));
QVERIFY(canvas->rootObject() != 0);
- QSGRow *row = canvas->rootObject()->findChild<QSGRow *>("pos");
+ QQuickRow *row = canvas->rootObject()->findChild<QQuickRow *>("pos");
QVERIFY(row != 0);
- QSGRectangle *rect0 = canvas->rootObject()->findChild<QSGRectangle *>("rect0");
+ QQuickRectangle *rect0 = canvas->rootObject()->findChild<QQuickRectangle *>("rect0");
QVERIFY(rect0 != 0);
int posIndex = rect0->property("index").toInt();
bool isLast = rect0->property("lastItem").toBool();
QVERIFY(isLast == false);
- QSGRectangle *rect1 = canvas->rootObject()->findChild<QSGRectangle *>("rect1");
+ QQuickRectangle *rect1 = canvas->rootObject()->findChild<QQuickRectangle *>("rect1");
QVERIFY(rect1 != 0);
posIndex = rect1->property("index").toInt();
QTRY_VERIFY(rect1->property("firstItem").toBool() == false);
QTRY_VERIFY(rect1->property("lastItem").toBool() == false);
- QSGRectangle *rect2 = canvas->rootObject()->findChild<QSGRectangle *>("rect2");
+ QQuickRectangle *rect2 = canvas->rootObject()->findChild<QQuickRectangle *>("rect2");
QVERIFY(rect2 != 0);
posIndex = rect2->property("index").toInt();
delete canvas;
}
-QSGView *tst_qsgpositioners::createView(const QString &filename, bool wait)
+QQuickView *tst_qquickpositioners::createView(const QString &filename, bool wait)
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(filename));
canvas->show();
}
-QTEST_MAIN(tst_qsgpositioners)
+QTEST_MAIN(tst_qquickpositioners)
-#include "tst_qsgpositioners.moc"
+#include "tst_qquickpositioners.moc"
CONFIG += testcase
-TARGET = tst_qsgrepeater
+TARGET = tst_qquickrepeater
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgrepeater.cpp
+SOURCES += tst_qquickrepeater.cpp
testFiles.files = data
testFiles.path = .
#include <QtTest/QSignalSpy>
#include <private/qlistmodelinterface_p.h>
#include <QtDeclarative/qdeclarativeengine.h>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickview.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeexpression.h>
-#include <private/qsgrepeater_p.h>
-#include <private/qsgtext_p.h>
+#include <private/qquickrepeater_p.h>
+#include <private/qquicktext_p.h>
#include "../shared/util.h"
return QUrl::fromLocalFile(TESTDATA(filename));
}
-class tst_QSGRepeater : public QObject
+class tst_QQuickRepeater : public QObject
{
Q_OBJECT
public:
- tst_QSGRepeater();
+ tst_QQuickRepeater();
private slots:
void numberModel();
void properties();
private:
- QSGView *createView();
+ QQuickView *createView();
template<typename T>
T *findItem(QObject *parent, const QString &objectName, int index);
template<typename T>
};
-tst_QSGRepeater::tst_QSGRepeater()
+tst_QQuickRepeater::tst_QQuickRepeater()
{
}
-void tst_QSGRepeater::numberModel()
+void tst_QQuickRepeater::numberModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
ctxt->setContextProperty("testData", 5);
canvas->setSource(TEST_FILE("intmodel.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
QCOMPARE(repeater->parentItem()->childItems().count(), 5+1);
int m_idx;
};
-void tst_QSGRepeater::objectList()
+void tst_QQuickRepeater::objectList()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QObjectList data;
for (int i=0; i<100; i++)
data << new MyObject(i);
canvas->setSource(TEST_FILE("objlist.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
QCOMPARE(repeater->property("errors").toInt(), 0);//If this fails either they are out of order or can't find the object's data
QCOMPARE(repeater->property("instantiated").toInt(), 100);
QCOMPARE(repeater->itemAt(i), repeater->parentItem()->childItems().at(i));
QVERIFY(!repeater->itemAt(data.count()));
- QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QSGItem*)));
- QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QSGItem*)));
+ QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
+ QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
ctxt->setContextProperty("testData", QVariant::fromValue(data));
QCOMPARE(addedSpy.count(), data.count());
QCOMPARE(removedSpy.count(), data.count());
stacking order. In this test we insert a repeater between two other Text
elements to test this.
*/
-void tst_QSGRepeater::stringList()
+void tst_QQuickRepeater::stringList()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QStringList data;
data << "One";
canvas->setSource(TEST_FILE("repeater1.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QSGItem *container = findItem<QSGItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), data.count() + 3);
for (int i = 0; i < container->childItems().count(); ++i) {
if (i == 0) {
- QSGText *name = qobject_cast<QSGText*>(container->childItems().at(i));
+ QQuickText *name = qobject_cast<QQuickText*>(container->childItems().at(i));
QVERIFY(name != 0);
QCOMPARE(name->text(), QLatin1String("Zero"));
} else if (i == container->childItems().count() - 2) {
// The repeater itself
- QSGRepeater *rep = qobject_cast<QSGRepeater*>(container->childItems().at(i));
+ QQuickRepeater *rep = qobject_cast<QQuickRepeater*>(container->childItems().at(i));
QCOMPARE(rep, repeater);
saw_repeater = true;
continue;
} else if (i == container->childItems().count() - 1) {
- QSGText *name = qobject_cast<QSGText*>(container->childItems().at(i));
+ QQuickText *name = qobject_cast<QQuickText*>(container->childItems().at(i));
QVERIFY(name != 0);
QCOMPARE(name->text(), QLatin1String("Last"));
} else {
- QSGText *name = qobject_cast<QSGText*>(container->childItems().at(i));
+ QQuickText *name = qobject_cast<QQuickText*>(container->childItems().at(i));
QVERIFY(name != 0);
QCOMPARE(name->text(), data.at(i-1));
}
delete canvas;
}
-void tst_QSGRepeater::dataModel_adding()
+void tst_QQuickRepeater::dataModel_adding()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
canvas->setSource(TEST_FILE("repeater2.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QSGItem *container = findItem<QSGItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
QVERIFY(container != 0);
QVERIFY(!repeater->itemAt(0));
QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
- QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QSGItem*)));
+ QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
// add to empty model
testModel.addItem("two", "2");
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(addedSpy.count(), 1);
QCOMPARE(addedSpy.at(0).at(0).toInt(), 0);
- QCOMPARE(addedSpy.at(0).at(1).value<QSGItem*>(), container->childItems().at(0));
+ QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(0));
addedSpy.clear();
// insert at start
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(addedSpy.count(), 1);
QCOMPARE(addedSpy.at(0).at(0).toInt(), 0);
- QCOMPARE(addedSpy.at(0).at(1).value<QSGItem*>(), container->childItems().at(0));
+ QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(0));
addedSpy.clear();
// insert at end
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(addedSpy.count(), 1);
QCOMPARE(addedSpy.at(0).at(0).toInt(), 2);
- QCOMPARE(addedSpy.at(0).at(1).value<QSGItem*>(), container->childItems().at(2));
+ QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(2));
addedSpy.clear();
// insert in middle
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(addedSpy.count(), 1);
QCOMPARE(addedSpy.at(0).at(0).toInt(), 2);
- QCOMPARE(addedSpy.at(0).at(1).value<QSGItem*>(), container->childItems().at(2));
+ QCOMPARE(addedSpy.at(0).at(1).value<QQuickItem*>(), container->childItems().at(2));
addedSpy.clear();
delete testObject;
delete canvas;
}
-void tst_QSGRepeater::dataModel_removing()
+void tst_QQuickRepeater::dataModel_removing()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
canvas->setSource(TEST_FILE("repeater2.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QSGItem *container = findItem<QSGItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), repeater->count()+1);
QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
- QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QSGItem*)));
+ QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
// remove at start
- QSGItem *item = repeater->itemAt(0);
+ QQuickItem *item = repeater->itemAt(0);
QCOMPARE(item, container->childItems().at(0));
testModel.removeItem(0);
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(removedSpy.count(), 1);
QCOMPARE(removedSpy.at(0).at(0).toInt(), 0);
- QCOMPARE(removedSpy.at(0).at(1).value<QSGItem*>(), item);
+ QCOMPARE(removedSpy.at(0).at(1).value<QQuickItem*>(), item);
removedSpy.clear();
// remove at end
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(removedSpy.count(), 1);
QCOMPARE(removedSpy.at(0).at(0).toInt(), lastIndex);
- QCOMPARE(removedSpy.at(0).at(1).value<QSGItem*>(), item);
+ QCOMPARE(removedSpy.at(0).at(1).value<QQuickItem*>(), item);
removedSpy.clear();
// remove from middle
QCOMPARE(countSpy.count(), 1); countSpy.clear();
QCOMPARE(removedSpy.count(), 1);
QCOMPARE(removedSpy.at(0).at(0).toInt(), 1);
- QCOMPARE(removedSpy.at(0).at(1).value<QSGItem*>(), item);
+ QCOMPARE(removedSpy.at(0).at(1).value<QQuickItem*>(), item);
removedSpy.clear();
delete testObject;
delete canvas;
}
-void tst_QSGRepeater::dataModel_changes()
+void tst_QQuickRepeater::dataModel_changes()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
canvas->setSource(TEST_FILE("repeater2.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QSGItem *container = findItem<QSGItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), repeater->count()+1);
// Check that model changes are propagated
- QSGText *text = findItem<QSGText>(canvas->rootObject(), "myName", 1);
+ QQuickText *text = findItem<QQuickText>(canvas->rootObject(), "myName", 1);
QVERIFY(text);
QCOMPARE(text->text(), QString("two"));
testModel.modifyItem(1, "Item two", "_2");
- text = findItem<QSGText>(canvas->rootObject(), "myName", 1);
+ text = findItem<QQuickText>(canvas->rootObject(), "myName", 1);
QVERIFY(text);
QCOMPARE(text->text(), QString("Item two"));
- text = findItem<QSGText>(canvas->rootObject(), "myNumber", 1);
+ text = findItem<QQuickText>(canvas->rootObject(), "myNumber", 1);
QVERIFY(text);
QCOMPARE(text->text(), QString("_2"));
delete canvas;
}
-void tst_QSGRepeater::itemModel()
+void tst_QQuickRepeater::itemModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QDeclarativeContext *ctxt = canvas->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
canvas->setSource(TEST_FILE("itemlist.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QSGItem *container = findItem<QSGItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), 1);
delete canvas;
}
-void tst_QSGRepeater::resetModel()
+void tst_QQuickRepeater::resetModel()
{
- QSGView *canvas = createView();
+ QQuickView *canvas = createView();
QStringList dataA;
for (int i=0; i<10; i++)
ctxt->setContextProperty("testData", dataA);
canvas->setSource(TEST_FILE("repeater1.qml"));
qApp->processEvents();
- QSGRepeater *repeater = findItem<QSGRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QSGItem *container = findItem<QSGItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(repeater->count(), dataA.count());
QSignalSpy modelChangedSpy(repeater, SIGNAL(modelChanged()));
QSignalSpy countSpy(repeater, SIGNAL(countChanged()));
- QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QSGItem*)));
- QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QSGItem*)));
+ QSignalSpy addedSpy(repeater, SIGNAL(itemAdded(int,QQuickItem*)));
+ QSignalSpy removedSpy(repeater, SIGNAL(itemRemoved(int,QQuickItem*)));
QStringList dataB;
for (int i=0; i<20; i++)
QCOMPARE(addedSpy.count(), dataB.count());
for (int i=0; i<dataB.count(); i++) {
QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
- QCOMPARE(addedSpy.at(i).at(1).value<QSGItem*>(), repeater->itemAt(i));
+ QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
}
modelChangedSpy.clear();
countSpy.clear();
QCOMPARE(addedSpy.count(), dataA.count());
for (int i=0; i<dataA.count(); i++) {
QCOMPARE(addedSpy.at(i).at(0).toInt(), i);
- QCOMPARE(addedSpy.at(i).at(1).value<QSGItem*>(), repeater->itemAt(i));
+ QCOMPARE(addedSpy.at(i).at(1).value<QQuickItem*>(), repeater->itemAt(i));
}
modelChangedSpy.clear();
}
// QTBUG-17156
-void tst_QSGRepeater::modelChanged()
+void tst_QQuickRepeater::modelChanged()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, TEST_FILE("modelChanged.qml"));
- QSGItem *rootObject = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
QVERIFY(rootObject);
- QSGRepeater *repeater = findItem<QSGRepeater>(rootObject, "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
QVERIFY(repeater);
repeater->setModel(4);
delete rootObject;
}
-void tst_QSGRepeater::properties()
+void tst_QQuickRepeater::properties()
{
QDeclarativeEngine engine;
QDeclarativeComponent component(&engine, TEST_FILE("properties.qml"));
- QSGItem *rootObject = qobject_cast<QSGItem*>(component.create());
+ QQuickItem *rootObject = qobject_cast<QQuickItem*>(component.create());
QVERIFY(rootObject);
- QSGRepeater *repeater = findItem<QSGRepeater>(rootObject, "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(rootObject, "repeater");
QVERIFY(repeater);
QSignalSpy modelSpy(repeater, SIGNAL(modelChanged()));
delete rootObject;
}
-QSGView *tst_QSGRepeater::createView()
+QQuickView *tst_QQuickRepeater::createView()
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setGeometry(0,0,240,320);
return canvas;
}
template<typename T>
-T *tst_QSGRepeater::findItem(QObject *parent, const QString &objectName, int index)
+T *tst_QQuickRepeater::findItem(QObject *parent, const QString &objectName, int index)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->children().count() << "children";
for (int i = 0; i < parent->children().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->children().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->children().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
}
template<typename T>
-T *tst_QSGRepeater::findItem(QObject *parent, const QString &objectName)
+T *tst_QQuickRepeater::findItem(QObject *parent, const QString &objectName)
{
const QMetaObject &mo = T::staticMetaObject;
if (mo.cast(parent) && (objectName.isEmpty() || parent->objectName() == objectName))
return static_cast<T*>(parent);
for (int i = 0; i < parent->children().count(); ++i) {
- QSGItem *child = qobject_cast<QSGItem*>(parent->children().at(i));
+ QQuickItem *child = qobject_cast<QQuickItem*>(parent->children().at(i));
if (!child)
continue;
- QSGItem *item = findItem<T>(child, objectName);
+ QQuickItem *item = findItem<T>(child, objectName);
if (item)
return static_cast<T*>(item);
}
return 0;
}
-QTEST_MAIN(tst_QSGRepeater)
+QTEST_MAIN(tst_QQuickRepeater)
-#include "tst_qsgrepeater.moc"
+#include "tst_qquickrepeater.moc"
CONFIG += testcase
-TARGET = tst_qsgtext
+TARGET = tst_qquicktext
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgtext.cpp
+SOURCES += tst_qquicktext.cpp
INCLUDEPATH += ../shared/
HEADERS += ../shared/testhttpserver.h
#include <QTextDocument>
#include <QtDeclarative/qdeclarativeengine.h>
#include <QtDeclarative/qdeclarativecomponent.h>
-#include <private/qsgtext_p.h>
-#include <private/qsgtext_p_p.h>
+#include <private/qquicktext_p.h>
+#include <private/qquicktext_p_p.h>
#include <private/qdeclarativevaluetype_p.h>
#include <private/qsgdistancefieldglyphcache_p.h>
#include <QFontMetrics>
#include <QGraphicsSceneMouseEvent>
#include <qmath.h>
-#include <QSGView>
+#include <QQuickView>
#include <private/qapplication_p.h>
#include <limits.h>
#include <QtGui/QMouseEvent>
DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
-class tst_qsgtext : public QObject
+class tst_qquicktext : public QObject
{
Q_OBJECT
public:
- tst_qsgtext();
+ tst_qquicktext();
private slots:
void initTestCase();
QList<Qt::Alignment> horizontalAlignmentments;
QStringList styleStrings;
- QList<QSGText::TextStyle> styles;
+ QList<QQuickText::TextStyle> styles;
QStringList colorStrings;
QDeclarativeEngine engine;
- QSGView *createView(const QString &filename);
+ QQuickView *createView(const QString &filename);
};
-void tst_qsgtext::initTestCase()
+void tst_qquicktext::initTestCase()
{
}
-void tst_qsgtext::cleanupTestCase()
+void tst_qquicktext::cleanupTestCase()
{
}
-tst_qsgtext::tst_qsgtext()
+tst_qquicktext::tst_qquicktext()
{
standard << "the quick brown fox jumped over the lazy dog"
<< "the quick brown fox\n jumped over the lazy dog";
<< "Raised"
<< "Sunken";
- styles << QSGText::Normal
- << QSGText::Outline
- << QSGText::Raised
- << QSGText::Sunken;
+ styles << QQuickText::Normal
+ << QQuickText::Outline
+ << QQuickText::Raised
+ << QQuickText::Sunken;
colorStrings << "aliceblue"
<< "antiquewhite"
//
}
-QSGView *tst_qsgtext::createView(const QString &filename)
+QQuickView *tst_qquicktext::createView(const QString &filename)
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(filename));
return canvas;
}
-void tst_qsgtext::text()
+void tst_qquicktext::text()
{
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nText { text: \"\" }", QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->text(), QString(""));
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->text(), standard.at(i));
QString componentStr = "import QtQuick 2.0\nText { text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QString expected = richText.at(i);
}
}
-void tst_qsgtext::width()
+void tst_qquicktext::width()
{
// uses Font metrics to find the width for standard and document to find the width for rich
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nText { text: \"\" }", QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->width(), 0.);
QString componentStr = "import QtQuick 2.0\nText { text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QVERIFY(textObject->boundingRect().width() > 0);
QCOMPARE(textObject->width(), qreal(metricWidth));
- QVERIFY(textObject->textFormat() == QSGText::AutoText); // setting text doesn't change format
+ QVERIFY(textObject->textFormat() == QQuickText::AutoText); // setting text doesn't change format
delete textObject;
}
QString componentStr = "import QtQuick 2.0\nText { text: \"" + richText.at(i) + "\"; textFormat: Text.RichText }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
- QSGTextPrivate *textPrivate = QSGTextPrivate::get(textObject);
+ QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(textObject);
QVERIFY(textPrivate != 0);
QTextDocument *doc = textPrivate->textDocument();
QVERIFY(doc != 0);
QCOMPARE(int(textObject->width()), int(doc->idealWidth()));
- QVERIFY(textObject->textFormat() == QSGText::RichText);
+ QVERIFY(textObject->textFormat() == QQuickText::RichText);
delete textObject;
}
}
-void tst_qsgtext::wrap()
+void tst_qquicktext::wrap()
{
int textHeight = 0;
// for specified width and wrap set true
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nText { text: \"Hello\"; wrapMode: Text.WordWrap; width: 300 }", QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
textHeight = textObject->height();
QVERIFY(textObject != 0);
- QVERIFY(textObject->wrapMode() == QSGText::WordWrap);
+ QVERIFY(textObject->wrapMode() == QQuickText::WordWrap);
QCOMPARE(textObject->width(), 300.);
delete textObject;
QString componentStr = "import QtQuick 2.0\nText { wrapMode: Text.WordWrap; width: 30; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->width(), 30.);
QString componentStr = "import QtQuick 2.0\nText { wrapMode: Text.WordWrap; width: 30; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->width(), 30.);
QString componentStr = "import QtQuick 2.0\nText { wrapMode: Text.WordWrap; width: 30; height: 50; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->width(), 30.);
}
}
-void tst_qsgtext::elide()
+void tst_qquicktext::elide()
{
- for (QSGText::TextElideMode m = QSGText::ElideLeft; m<=QSGText::ElideNone; m=QSGText::TextElideMode(int(m)+1)) {
+ for (QQuickText::TextElideMode m = QQuickText::ElideLeft; m<=QQuickText::ElideNone; m=QQuickText::TextElideMode(int(m)+1)) {
const char* elidename[]={"ElideLeft", "ElideRight", "ElideMiddle", "ElideNone"};
QString elide = "elide: Text." + QString(elidename[int(m)]) + ";";
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData(("import QtQuick 2.0\nText { text: \"\"; "+elide+" width: 100 }").toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->elideMode(), m);
QCOMPARE(textObject->width(), 100.);
QString componentStr = "import QtQuick 2.0\nText { "+elide+" width: 100; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->elideMode(), m);
QCOMPARE(textObject->width(), 100.);
QString componentStr = "import QtQuick 2.0\nText { "+elide+" width: 100; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->elideMode(), m);
QCOMPARE(textObject->width(), 100.);
}
}
-void tst_qsgtext::textFormat()
+void tst_qquicktext::textFormat()
{
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nText { text: \"Hello\"; textFormat: Text.RichText }", QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
- QVERIFY(textObject->textFormat() == QSGText::RichText);
+ QVERIFY(textObject->textFormat() == QQuickText::RichText);
- QSGTextPrivate *textPrivate = QSGTextPrivate::get(textObject);
+ QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(textObject);
QVERIFY(textPrivate != 0);
QVERIFY(textPrivate->richText == true);
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nText { text: \"<b>Hello</b>\" }", QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
- QVERIFY(textObject->textFormat() == QSGText::AutoText);
+ QVERIFY(textObject->textFormat() == QQuickText::AutoText);
- QSGTextPrivate *textPrivate = QSGTextPrivate::get(textObject);
+ QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(textObject);
QVERIFY(textPrivate != 0);
QVERIFY(textPrivate->styledText == true);
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nText { text: \"<b>Hello</b>\"; textFormat: Text.PlainText }", QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
- QVERIFY(textObject->textFormat() == QSGText::PlainText);
+ QVERIFY(textObject->textFormat() == QQuickText::PlainText);
delete textObject;
}
}
-void tst_qsgtext::alignments_data()
+void tst_qquicktext::alignments_data()
{
QTest::addColumn<int>("hAlign");
QTest::addColumn<int>("vAlign");
}
-void tst_qsgtext::alignments()
+void tst_qquicktext::alignments()
{
QSKIP("Text alignment pixmap comparison tests will not work with scenegraph");
#if (0)// No widgets in scenegraph
QApplication::setFont(fn);
#endif
- QSGView *canvas = createView(TESTDATA("alignments.qml"));
+ QQuickView *canvas = createView(TESTDATA("alignments.qml"));
canvas->show();
canvas->requestActivateWindow();
}
//the alignment tests may be trivial o.oa
-void tst_qsgtext::horizontalAlignment()
+void tst_qquicktext::horizontalAlignment()
{
//test one align each, and then test if two align fails.
QString componentStr = "import QtQuick 2.0\nText { horizontalAlignment: \"" + horizontalAlignmentmentStrings.at(j) + "\"; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE((int)textObject->hAlign(), (int)horizontalAlignmentments.at(j));
QString componentStr = "import QtQuick 2.0\nText { horizontalAlignment: \"" + horizontalAlignmentmentStrings.at(j) + "\"; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE((int)textObject->hAlign(), (int)horizontalAlignmentments.at(j));
}
-void tst_qsgtext::horizontalAlignment_RightToLeft()
+void tst_qquicktext::horizontalAlignment_RightToLeft()
{
- QSGView *canvas = createView(TESTDATA("horizontalAlignment_RightToLeft.qml"));
- QSGText *text = canvas->rootObject()->findChild<QSGText*>("text");
+ QQuickView *canvas = createView(TESTDATA("horizontalAlignment_RightToLeft.qml"));
+ QQuickText *text = canvas->rootObject()->findChild<QQuickText*>("text");
QVERIFY(text != 0);
canvas->show();
- QSGTextPrivate *textPrivate = QSGTextPrivate::get(text);
+ QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(text);
QVERIFY(textPrivate != 0);
// implicit alignment should follow the reading direction of RTL text
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
// explicitly left aligned text
- text->setHAlign(QSGText::AlignLeft);
- QCOMPARE(text->hAlign(), QSGText::AlignLeft);
+ text->setHAlign(QQuickText::AlignLeft);
+ QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
// explicitly right aligned text
- text->setHAlign(QSGText::AlignRight);
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
+ text->setHAlign(QQuickText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
// change to rich text
QString textString = text->text();
text->setText(QString("<i>") + textString + QString("</i>"));
- text->setTextFormat(QSGText::RichText);
+ text->setTextFormat(QQuickText::RichText);
text->resetHAlign();
// implicitly aligned rich text should follow the reading direction of text
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->textDocument()->defaultTextOption().alignment() & Qt::AlignLeft);
// explicitly left aligned rich text
- text->setHAlign(QSGText::AlignLeft);
- QCOMPARE(text->hAlign(), QSGText::AlignLeft);
+ text->setHAlign(QQuickText::AlignLeft);
+ QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->textDocument()->defaultTextOption().alignment() & Qt::AlignRight);
// explicitly right aligned rich text
- text->setHAlign(QSGText::AlignRight);
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
+ text->setHAlign(QQuickText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->textDocument()->defaultTextOption().alignment() & Qt::AlignLeft);
text->setText(textString);
- text->setTextFormat(QSGText::PlainText);
+ text->setTextFormat(QQuickText::PlainText);
// explicitly center aligned
- text->setHAlign(QSGText::AlignHCenter);
- QCOMPARE(text->hAlign(), QSGText::AlignHCenter);
+ text->setHAlign(QQuickText::AlignHCenter);
+ QCOMPARE(text->hAlign(), QQuickText::AlignHCenter);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().right() > canvas->width()/2);
// reseted alignment should go back to following the text reading direction
text->resetHAlign();
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
// mirror the text item
- QSGItemPrivate::get(text)->setLayoutMirror(true);
+ QQuickItemPrivate::get(text)->setLayoutMirror(true);
// mirrored implicit alignment should continue to follow the reading direction of the text
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
- QCOMPARE(text->effectiveHAlign(), QSGText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
+ QCOMPARE(text->effectiveHAlign(), QQuickText::AlignRight);
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
// mirrored explicitly right aligned behaves as left aligned
- text->setHAlign(QSGText::AlignRight);
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
- QCOMPARE(text->effectiveHAlign(), QSGText::AlignLeft);
+ text->setHAlign(QQuickText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
+ QCOMPARE(text->effectiveHAlign(), QQuickText::AlignLeft);
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
// mirrored explicitly left aligned behaves as right aligned
- text->setHAlign(QSGText::AlignLeft);
- QCOMPARE(text->hAlign(), QSGText::AlignLeft);
- QCOMPARE(text->effectiveHAlign(), QSGText::AlignRight);
+ text->setHAlign(QQuickText::AlignLeft);
+ QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
+ QCOMPARE(text->effectiveHAlign(), QQuickText::AlignRight);
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
// disable mirroring
- QSGItemPrivate::get(text)->setLayoutMirror(false);
+ QQuickItemPrivate::get(text)->setLayoutMirror(false);
text->resetHAlign();
// English text should be implicitly left aligned
text->setText("Hello world!");
- QCOMPARE(text->hAlign(), QSGText::AlignLeft);
+ QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
#ifndef Q_OS_MAC // QTBUG-18040
// keyboard input direction from QApplication::keyboardInputDirection
text->setText("");
QCOMPARE(text->hAlign(), QApplication::keyboardInputDirection() == Qt::LeftToRight ?
- QSGText::AlignLeft : QSGText::AlignRight);
- text->setHAlign(QSGText::AlignRight);
- QCOMPARE(text->hAlign(), QSGText::AlignRight);
+ QQuickText::AlignLeft : QQuickText::AlignRight);
+ text->setHAlign(QQuickText::AlignRight);
+ QCOMPARE(text->hAlign(), QQuickText::AlignRight);
#endif
delete canvas;
QString componentStr = "import QtQuick 2.0\nText {}";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->hAlign(), QApplication::keyboardInputDirection() == Qt::LeftToRight ?
- QSGText::AlignLeft : QSGText::AlignRight);
+ QQuickText::AlignLeft : QQuickText::AlignRight);
delete textObject;
#endif
}
-void tst_qsgtext::verticalAlignment()
+void tst_qquicktext::verticalAlignment()
{
//test one align each, and then test if two align fails.
QString componentStr = "import QtQuick 2.0\nText { verticalAlignment: \"" + verticalAlignmentmentStrings.at(j) + "\"; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->vAlign(), (int)verticalAlignmentments.at(j));
QString componentStr = "import QtQuick 2.0\nText { verticalAlignment: \"" + verticalAlignmentmentStrings.at(j) + "\"; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->vAlign(), (int)verticalAlignmentments.at(j));
}
-void tst_qsgtext::font()
+void tst_qquicktext::font()
{
//test size, then bold, then italic, then family
{
QString componentStr = "import QtQuick 2.0\nText { font.pointSize: 40; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->font().pointSize(), 40);
QCOMPARE(textObject->font().bold(), false);
QString componentStr = "import QtQuick 2.0\nText { font.pixelSize: 40; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->font().pixelSize(), 40);
QCOMPARE(textObject->font().bold(), false);
QString componentStr = "import QtQuick 2.0\nText { font.bold: true; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->font().bold(), true);
QCOMPARE(textObject->font().italic(), false);
QString componentStr = "import QtQuick 2.0\nText { font.italic: true; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->font().italic(), true);
QCOMPARE(textObject->font().bold(), false);
QString componentStr = "import QtQuick 2.0\nText { font.family: \"Helvetica\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->font().family(), QString("Helvetica"));
QCOMPARE(textObject->font().bold(), false);
QString componentStr = "import QtQuick 2.0\nText { font.family: \"\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->font().family(), QString(""));
}
}
-void tst_qsgtext::style()
+void tst_qquicktext::style()
{
//test style
for (int i = 0; i < styles.size(); i++)
QString componentStr = "import QtQuick 2.0\nText { style: \"" + styleStrings.at(i) + "\"; styleColor: \"white\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE((int)textObject->style(), (int)styles.at(i));
QCOMPARE(textObject->styleColor(), QColor("white"));
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QRectF brPre = textObject->boundingRect();
- textObject->setStyle(QSGText::Outline);
+ textObject->setStyle(QQuickText::Outline);
QRectF brPost = textObject->boundingRect();
QVERIFY(brPre.width() < brPost.width());
delete textObject;
}
-void tst_qsgtext::color()
+void tst_qquicktext::color()
{
//test style
for (int i = 0; i < colorStrings.size(); i++)
QString componentStr = "import QtQuick 2.0\nText { color: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->color(), QColor(colorStrings.at(i)));
QCOMPARE(textObject->styleColor(), QColor());
QString componentStr = "import QtQuick 2.0\nText { styleColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->styleColor(), QColor(colorStrings.at(i)));
// default color to black?
QString componentStr = "import QtQuick 2.0\nText { color: \"" + colorStrings.at(i) + "\"; styleColor: \"" + colorStrings.at(j) + "\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->color(), QColor(colorStrings.at(i)));
QCOMPARE(textObject->styleColor(), QColor(colorStrings.at(j)));
QString componentStr = "import QtQuick 2.0\nText { color: \"" + colorStr + "\"; text: \"Hello World\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->color(), testColor);
}
}
-void tst_qsgtext::smooth()
+void tst_qquicktext::smooth()
{
for (int i = 0; i < standard.size(); i++)
{
QString componentStr = "import QtQuick 2.0\nText { smooth: true; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->smooth(), true);
delete textObject;
QString componentStr = "import QtQuick 2.0\nText { text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->smooth(), false);
delete textObject;
QString componentStr = "import QtQuick 2.0\nText { smooth: true; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->smooth(), true);
delete textObject;
QString componentStr = "import QtQuick 2.0\nText { text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QCOMPARE(textObject->smooth(), false);
delete textObject;
}
}
-void tst_qsgtext::weight()
+void tst_qquicktext::weight()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().weight(), (int)QDeclarativeFontValueType::Normal);
QString componentStr = "import QtQuick 2.0\nText { font.weight: \"Bold\"; text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().weight(), (int)QDeclarativeFontValueType::Bold);
}
}
-void tst_qsgtext::underline()
+void tst_qquicktext::underline()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().underline(), false);
QString componentStr = "import QtQuick 2.0\nText { font.underline: true; text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().underline(), true);
}
}
-void tst_qsgtext::overline()
+void tst_qquicktext::overline()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().overline(), false);
QString componentStr = "import QtQuick 2.0\nText { font.overline: true; text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().overline(), true);
}
}
-void tst_qsgtext::strikeout()
+void tst_qquicktext::strikeout()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().strikeOut(), false);
QString componentStr = "import QtQuick 2.0\nText { font.strikeout: true; text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().strikeOut(), true);
}
}
-void tst_qsgtext::capitalization()
+void tst_qquicktext::capitalization()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().capitalization(), (int)QDeclarativeFontValueType::MixedCase);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.capitalization: \"AllUppercase\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().capitalization(), (int)QDeclarativeFontValueType::AllUppercase);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.capitalization: \"AllLowercase\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().capitalization(), (int)QDeclarativeFontValueType::AllLowercase);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.capitalization: \"SmallCaps\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().capitalization(), (int)QDeclarativeFontValueType::SmallCaps);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.capitalization: \"Capitalize\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE((int)textObject->font().capitalization(), (int)QDeclarativeFontValueType::Capitalize);
}
}
-void tst_qsgtext::letterSpacing()
+void tst_qquicktext::letterSpacing()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().letterSpacing(), 0.0);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.letterSpacing: -2 }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().letterSpacing(), -2.);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.letterSpacing: 3 }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().letterSpacing(), 3.);
}
}
-void tst_qsgtext::wordSpacing()
+void tst_qquicktext::wordSpacing()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().wordSpacing(), 0.0);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.wordSpacing: -50 }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().wordSpacing(), -50.);
QString componentStr = "import QtQuick 2.0\nText { text: \"Hello world!\"; font.wordSpacing: 200 }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
QCOMPARE(textObject->font().wordSpacing(), 200.);
-class EventSender : public QSGItem
+class EventSender : public QQuickItem
{
public:
void sendEvent(QMouseEvent *event) {
void linkClicked(QString l) { link = l; }
};
-void tst_qsgtext::clickLink()
+void tst_qquicktext::clickLink()
{
{
QString componentStr = "import QtQuick 2.0\nText { text: \"<a href=\\\"http://qt.nokia.com\\\">Hello world!</a>\" }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
{
QMouseEvent me(QEvent::MouseButtonPress,QPointF(textObject->x()/2, textObject->y()/2), Qt::LeftButton, Qt::NoButton, Qt::NoModifier);
- static_cast<EventSender*>(static_cast<QSGItem*>(textObject))->sendEvent(&me);
+ static_cast<EventSender*>(static_cast<QQuickItem*>(textObject))->sendEvent(&me);
}
{
QMouseEvent me(QEvent::MouseButtonRelease,QPointF(textObject->x()/2, textObject->y()/2), Qt::LeftButton, Qt::NoButton, Qt::NoModifier);
- static_cast<EventSender*>(static_cast<QSGItem*>(textObject))->sendEvent(&me);
+ static_cast<EventSender*>(static_cast<QQuickItem*>(textObject))->sendEvent(&me);
}
}
}
-void tst_qsgtext::embeddedImages_data()
+void tst_qquicktext::embeddedImages_data()
{
QTest::addColumn<QUrl>("qmlfile");
QTest::addColumn<QString>("error");
<< QUrl::fromLocalFile(TESTDATA("embeddedImagesRemoteError.qml")).toString()+":3:1: QML Text: Error downloading http://127.0.0.1:14453/notexists.png - server replied: Not found";
}
-void tst_qsgtext::embeddedImages()
+void tst_qquicktext::embeddedImages()
{
// Tests QTBUG-9900
QTest::ignoreMessage(QtWarningMsg, error.toLatin1());
QDeclarativeComponent textComponent(&engine, qmlfile);
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject != 0);
delete textObject;
}
-void tst_qsgtext::lineCount()
+void tst_qquicktext::lineCount()
{
- QSGView *canvas = createView(TESTDATA("lineCount.qml"));
+ QQuickView *canvas = createView(TESTDATA("lineCount.qml"));
- QSGText *myText = canvas->rootObject()->findChild<QSGText*>("myText");
+ QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QVERIFY(myText->lineCount() > 1);
QCOMPARE(myText->maximumLineCount(), INT_MAX);
QCOMPARE(myText->truncated(), false);
- myText->setElideMode(QSGText::ElideRight);
+ myText->setElideMode(QQuickText::ElideRight);
myText->setMaximumLineCount(2);
QCOMPARE(myText->lineCount(), 2);
QCOMPARE(myText->truncated(), true);
delete canvas;
}
-void tst_qsgtext::lineHeight()
+void tst_qquicktext::lineHeight()
{
- QSGView *canvas = createView(TESTDATA("lineHeight.qml"));
+ QQuickView *canvas = createView(TESTDATA("lineHeight.qml"));
- QSGText *myText = canvas->rootObject()->findChild<QSGText*>("myText");
+ QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QVERIFY(myText->lineHeight() == 1);
- QVERIFY(myText->lineHeightMode() == QSGText::ProportionalHeight);
+ QVERIFY(myText->lineHeightMode() == QQuickText::ProportionalHeight);
qreal h = myText->height();
myText->setLineHeight(1.5);
#endif
QVERIFY(myText->height() == h * 1.5);
- myText->setLineHeightMode(QSGText::FixedHeight);
+ myText->setLineHeightMode(QQuickText::FixedHeight);
myText->setLineHeight(20);
QCOMPARE(myText->height(), myText->lineCount() * 20.0);
myText->setText("Lorem ipsum sit <b>amet</b>, consectetur adipiscing elit. Integer felis nisl, varius in pretium nec, venenatis non erat. Proin lobortis interdum dictum.");
- myText->setLineHeightMode(QSGText::ProportionalHeight);
+ myText->setLineHeightMode(QQuickText::ProportionalHeight);
myText->setLineHeight(1.0);
qreal h2 = myText->height();
myText->setLineHeight(2.0);
QVERIFY(myText->height() == h2 * 2.0);
- myText->setLineHeightMode(QSGText::FixedHeight);
+ myText->setLineHeightMode(QQuickText::FixedHeight);
myText->setLineHeight(10);
QCOMPARE(myText->height(), myText->lineCount() * 10.0);
delete canvas;
}
-void tst_qsgtext::implicitSize_data()
+void tst_qquicktext::implicitSize_data()
{
QTest::addColumn<QString>("text");
QTest::addColumn<QString>("wrap");
QTest::newRow("richtext_wrap") << "<b>The quick red fox jumped over the lazy brown dog</b>" << "Text.Wrap";
}
-void tst_qsgtext::implicitSize()
+void tst_qquicktext::implicitSize()
{
QFETCH(QString, text);
QFETCH(QString, wrap);
QString componentStr = "import QtQuick 2.0\nText { text: \"" + text + "\"; width: 50; wrapMode: " + wrap + " }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGText *textObject = qobject_cast<QSGText*>(textComponent.create());
+ QQuickText *textObject = qobject_cast<QQuickText*>(textComponent.create());
QVERIFY(textObject->width() < textObject->implicitWidth());
QVERIFY(textObject->height() == textObject->implicitHeight());
delete textObject;
}
-void tst_qsgtext::lineLaidOut()
+void tst_qquicktext::lineLaidOut()
{
- QSGView *canvas = createView(TESTDATA("lineLayout.qml"));
+ QQuickView *canvas = createView(TESTDATA("lineLayout.qml"));
- QSGText *myText = canvas->rootObject()->findChild<QSGText*>("myText");
+ QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
- QSGTextPrivate *textPrivate = QSGTextPrivate::get(myText);
+ QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(myText);
QVERIFY(textPrivate != 0);
QTextDocument *doc = textPrivate->textDocument();
}
}
-QTEST_MAIN(tst_qsgtext)
+QTEST_MAIN(tst_qquicktext)
-#include "tst_qsgtext.moc"
+#include "tst_qquicktext.moc"
CONFIG += testcase
-TARGET = tst_qsgtextedit
+TARGET = tst_qquicktextedit
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgtextedit.cpp ../shared/testhttpserver.cpp
+SOURCES += tst_qquicktextedit.cpp ../shared/testhttpserver.cpp
HEADERS += ../shared/testhttpserver.h
testDataFiles.files = data
#include <QtDeclarative/qdeclarativeexpression.h>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtGui/qguiapplication.h>
-#include <private/qsgtextedit_p.h>
-#include <private/qsgtextedit_p_p.h>
+#include <private/qquicktextedit_p.h>
+#include <private/qquicktextedit_p_p.h>
#include <private/qsgdistancefieldglyphcache_p.h>
#include <QFontMetrics>
-#include <QSGView>
+#include <QQuickView>
#include <QDir>
#include <QStyle>
#include <QInputContext>
#define QTBUG_21691
#define QTBUG_21691_MESSAGE "QTBUG-21691: The test needs to be rewritten to not use QInputContext"
-Q_DECLARE_METATYPE(QSGTextEdit::SelectionMode)
+Q_DECLARE_METATYPE(QQuickTextEdit::SelectionMode)
DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
QString createExpectedFileIfNotFound(const QString& filebasename, const QImage& actual)
}
-class tst_qsgtextedit : public QObject
+class tst_qquicktextedit : public QObject
{
Q_OBJECT
public:
- tst_qsgtextedit();
+ tst_qquicktextedit();
private slots:
void initTestCase();
void emptytags_QTBUG_22058();
private:
- void simulateKey(QSGView *, int key, Qt::KeyboardModifiers modifiers = 0);
+ void simulateKey(QQuickView *, int key, Qt::KeyboardModifiers modifiers = 0);
QStringList standard;
QStringList richText;
QDeclarativeEngine engine;
};
-void tst_qsgtextedit::initTestCase()
+void tst_qquicktextedit::initTestCase()
{
}
-void tst_qsgtextedit::cleanupTestCase()
+void tst_qquicktextedit::cleanupTestCase()
{
}
-tst_qsgtextedit::tst_qsgtextedit()
+tst_qquicktextedit::tst_qquicktextedit()
{
standard << "the quick brown fox jumped over the lazy dog"
<< "the quick brown fox\n jumped over the lazy dog"
//
}
-void tst_qsgtextedit::text()
+void tst_qquicktextedit::text()
{
{
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData("import QtQuick 2.0\nTextEdit { text: \"\" }", QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->text(), QString(""));
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->text(), standard.at(i));
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QString actual = textEditObject->text();
}
}
-void tst_qsgtextedit::width()
+void tst_qquicktextedit::width()
{
// uses Font metrics to find the width for standard and document to find the width for rich
{
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData("import QtQuick 2.0\nTextEdit { text: \"\" }", QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->width(), 0.0);
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->width(), qreal(metricWidth));
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->width(), qreal(documentWidth));
}
}
-void tst_qsgtextedit::wrap()
+void tst_qquicktextedit::wrap()
{
// for specified width and wrap set true
{
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData("import QtQuick 2.0\nTextEdit { text: \"\"; wrapMode: TextEdit.WordWrap; width: 300 }", QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->width(), 300.);
QString componentStr = "import QtQuick 2.0\nTextEdit { wrapMode: TextEdit.WordWrap; width: 300; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->width(), 300.);
QString componentStr = "import QtQuick 2.0\nTextEdit { wrapMode: TextEdit.WordWrap; width: 300; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->width(), 300.);
}
-void tst_qsgtextedit::textFormat()
+void tst_qquicktextedit::textFormat()
{
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nTextEdit { text: \"Hello\"; textFormat: Text.RichText }", QUrl::fromLocalFile(""));
- QSGTextEdit *textObject = qobject_cast<QSGTextEdit*>(textComponent.create());
+ QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(textComponent.create());
QVERIFY(textObject != 0);
- QVERIFY(textObject->textFormat() == QSGTextEdit::RichText);
+ QVERIFY(textObject->textFormat() == QQuickTextEdit::RichText);
}
{
QDeclarativeComponent textComponent(&engine);
textComponent.setData("import QtQuick 2.0\nTextEdit { text: \"<b>Hello</b>\"; textFormat: Text.PlainText }", QUrl::fromLocalFile(""));
- QSGTextEdit *textObject = qobject_cast<QSGTextEdit*>(textComponent.create());
+ QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(textComponent.create());
QVERIFY(textObject != 0);
- QVERIFY(textObject->textFormat() == QSGTextEdit::PlainText);
+ QVERIFY(textObject->textFormat() == QQuickTextEdit::PlainText);
}
}
-void tst_qsgtextedit::alignments_data()
+void tst_qquicktextedit::alignments_data()
{
QTest::addColumn<int>("hAlign");
QTest::addColumn<int>("vAlign");
}
-void tst_qsgtextedit::alignments()
+void tst_qquicktextedit::alignments()
{
QSKIP("Image comparison of text is almost guaranteed to fail during development");
QFETCH(int, vAlign);
QFETCH(QString, expectfile);
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("alignments.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("alignments.qml")));
canvas.show();
canvas.requestActivateWindow();
//the alignment tests may be trivial o.oa
-void tst_qsgtextedit::hAlign()
+void tst_qquicktextedit::hAlign()
{
//test one align each, and then test if two align fails.
QString componentStr = "import QtQuick 2.0\nTextEdit { horizontalAlignment: \"" + hAlignmentStrings.at(j) + "\"; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE((int)textEditObject->hAlign(), (int)hAlignments.at(j));
QString componentStr = "import QtQuick 2.0\nTextEdit { horizontalAlignment: \"" + hAlignmentStrings.at(j) + "\"; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE((int)textEditObject->hAlign(), (int)hAlignments.at(j));
}
-void tst_qsgtextedit::hAlign_RightToLeft()
+void tst_qquicktextedit::hAlign_RightToLeft()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("horizontalAlignment_RightToLeft.qml")));
- QSGTextEdit *textEdit = canvas.rootObject()->findChild<QSGTextEdit*>("text");
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("horizontalAlignment_RightToLeft.qml")));
+ QQuickTextEdit *textEdit = canvas.rootObject()->findChild<QQuickTextEdit*>("text");
QVERIFY(textEdit != 0);
canvas.show();
const QString rtlText = textEdit->text();
// implicit alignment should follow the reading direction of text
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
// explicitly left aligned
- textEdit->setHAlign(QSGTextEdit::AlignLeft);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignLeft);
+ textEdit->setHAlign(QQuickTextEdit::AlignLeft);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
// explicitly right aligned
- textEdit->setHAlign(QSGTextEdit::AlignRight);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ textEdit->setHAlign(QQuickTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
QString textString = textEdit->text();
textEdit->resetHAlign();
// implicitly aligned rich text should follow the reading direction of RTL text
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign());
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
// explicitly left aligned rich text
- textEdit->setHAlign(QSGTextEdit::AlignLeft);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignLeft);
+ textEdit->setHAlign(QQuickTextEdit::AlignLeft);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign());
QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
// explicitly right aligned rich text
- textEdit->setHAlign(QSGTextEdit::AlignRight);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ textEdit->setHAlign(QQuickTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign());
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
textEdit->setText(textString);
// explicitly center aligned
- textEdit->setHAlign(QSGTextEdit::AlignHCenter);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignHCenter);
+ textEdit->setHAlign(QQuickTextEdit::AlignHCenter);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignHCenter);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
// reseted alignment should go back to following the text reading direction
textEdit->resetHAlign();
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
// mirror the text item
- QSGItemPrivate::get(textEdit)->setLayoutMirror(true);
+ QQuickItemPrivate::get(textEdit)->setLayoutMirror(true);
// mirrored implicit alignment should continue to follow the reading direction of the text
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
- QCOMPARE(textEdit->effectiveHAlign(), QSGTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
+ QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
// mirrored explicitly right aligned behaves as left aligned
- textEdit->setHAlign(QSGTextEdit::AlignRight);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
- QCOMPARE(textEdit->effectiveHAlign(), QSGTextEdit::AlignLeft);
+ textEdit->setHAlign(QQuickTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
+ QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignLeft);
QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
// mirrored explicitly left aligned behaves as right aligned
- textEdit->setHAlign(QSGTextEdit::AlignLeft);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignLeft);
- QCOMPARE(textEdit->effectiveHAlign(), QSGTextEdit::AlignRight);
+ textEdit->setHAlign(QQuickTextEdit::AlignLeft);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
+ QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
// disable mirroring
- QSGItemPrivate::get(textEdit)->setLayoutMirror(false);
+ QQuickItemPrivate::get(textEdit)->setLayoutMirror(false);
textEdit->resetHAlign();
// English text should be implicitly left aligned
textEdit->setText("Hello world!");
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignLeft);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
canvas.requestActivateWindow();
textEdit->setText(QString());
{ QInputMethodEvent ev(rtlText, QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(&canvas, &ev); }
QEXPECT_FAIL("", "QTBUG-21691", Abort);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
{ QInputMethodEvent ev("Hello world!", QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(&canvas, &ev); }
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignLeft);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
#ifndef Q_OS_MAC // QTBUG-18040
// empty text with implicit alignment follows the system locale-based
// keyboard input direction from QGuiApplication::keyboardInputDirection
textEdit->setText("");
QCOMPARE(textEdit->hAlign(), QGuiApplication::keyboardInputDirection() == Qt::LeftToRight ?
- QSGTextEdit::AlignLeft : QSGTextEdit::AlignRight);
+ QQuickTextEdit::AlignLeft : QQuickTextEdit::AlignRight);
if (QGuiApplication::keyboardInputDirection() == Qt::LeftToRight)
QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
else
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
- textEdit->setHAlign(QSGTextEdit::AlignRight);
- QCOMPARE(textEdit->hAlign(), QSGTextEdit::AlignRight);
+ textEdit->setHAlign(QQuickTextEdit::AlignRight);
+ QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
#endif
QString componentStr = "import QtQuick 2.0\nTextEdit {}";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGTextEdit *textObject = qobject_cast<QSGTextEdit*>(textComponent.create());
+ QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(textComponent.create());
QCOMPARE(textObject->hAlign(), QGuiApplication::keyboardInputDirection() == Qt::LeftToRight ?
- QSGTextEdit::AlignLeft : QSGTextEdit::AlignRight);
+ QQuickTextEdit::AlignLeft : QQuickTextEdit::AlignRight);
delete textObject;
#endif
}
-void tst_qsgtextedit::vAlign()
+void tst_qquicktextedit::vAlign()
{
//test one align each, and then test if two align fails.
QString componentStr = "import QtQuick 2.0\nTextEdit { verticalAlignment: \"" + vAlignmentStrings.at(j) + "\"; text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE((int)textEditObject->vAlign(), (int)vAlignments.at(j));
QString componentStr = "import QtQuick 2.0\nTextEdit { verticalAlignment: \"" + vAlignmentStrings.at(j) + "\"; text: \"" + richText.at(i) + "\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE((int)textEditObject->vAlign(), (int)vAlignments.at(j));
}
-void tst_qsgtextedit::font()
+void tst_qquicktextedit::font()
{
//test size, then bold, then italic, then family
{
QString componentStr = "import QtQuick 2.0\nTextEdit { font.pointSize: 40; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->font().pointSize(), 40);
QString componentStr = "import QtQuick 2.0\nTextEdit { font.bold: true; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->font().bold(), true);
QString componentStr = "import QtQuick 2.0\nTextEdit { font.italic: true; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->font().italic(), true);
QCOMPARE(textEditObject->font().bold(), false);
}
-
+
{
QString componentStr = "import QtQuick 2.0\nTextEdit { font.family: \"Helvetica\"; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->font().family(), QString("Helvetica"));
QString componentStr = "import QtQuick 2.0\nTextEdit { font.family: \"\"; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->font().family(), QString(""));
}
}
-void tst_qsgtextedit::color()
+void tst_qquicktextedit::color()
{
//test initial color
{
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
- QSGTextEditPrivate *textEditPrivate = static_cast<QSGTextEditPrivate*>(QSGItemPrivate::get(textEditObject));
+ QQuickTextEditPrivate *textEditPrivate = static_cast<QQuickTextEditPrivate*>(QQuickItemPrivate::get(textEditObject));
QVERIFY(textEditObject);
QVERIFY(textEditPrivate);
QString componentStr = "import QtQuick 2.0\nTextEdit { color: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
//qDebug() << "textEditObject: " << textEditObject->color() << "vs. " << QColor(colorStrings.at(i));
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->color(), QColor(colorStrings.at(i)));
QString componentStr = "import QtQuick 2.0\nTextEdit { selectionColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->selectionColor(), QColor(colorStrings.at(i)));
}
QString componentStr = "import QtQuick 2.0\nTextEdit { selectedTextColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->selectedTextColor(), QColor(colorStrings.at(i)));
}
QString componentStr = "import QtQuick 2.0\nTextEdit { color: \"" + colorStr + "\"; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->color(), testColor);
}
}
-void tst_qsgtextedit::textMargin()
+void tst_qquicktextedit::textMargin()
{
for (qreal i=0; i<=10; i+=0.3) {
QString componentStr = "import QtQuick 2.0\nTextEdit { textMargin: " + QString::number(i) + "; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->textMargin(), i);
}
}
-void tst_qsgtextedit::persistentSelection()
+void tst_qquicktextedit::persistentSelection()
{
{
QString componentStr = "import QtQuick 2.0\nTextEdit { persistentSelection: true; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->persistentSelection(), true);
}
QString componentStr = "import QtQuick 2.0\nTextEdit { persistentSelection: false; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->persistentSelection(), false);
}
}
-void tst_qsgtextedit::focusOnPress()
+void tst_qquicktextedit::focusOnPress()
{
{
QString componentStr = "import QtQuick 2.0\nTextEdit { activeFocusOnPress: true; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->focusOnPress(), true);
}
QString componentStr = "import QtQuick 2.0\nTextEdit { activeFocusOnPress: false; text: \"Hello World\" }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QCOMPARE(textEditObject->focusOnPress(), false);
}
}
-void tst_qsgtextedit::selection()
+void tst_qquicktextedit::selection()
{
QString testStr = standard[0];//TODO: What should happen for multiline/rich text?
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \""+ testStr +"\"; }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(textEditObject != 0);
QVERIFY(textEditObject->selectedText().isNull());
}
-void tst_qsgtextedit::isRightToLeft_data()
+void tst_qquicktextedit::isRightToLeft_data()
{
QTest::addColumn<QString>("text");
QTest::addColumn<bool>("emptyString");
QTest::newRow("Bidi LTR + RTL + LTR") << QString("Hello world") + QString::fromUtf16(arabic_str, 11) + QString("Hello world") << false << false << false << true << false << false << false;
}
-void tst_qsgtextedit::isRightToLeft()
+void tst_qquicktextedit::isRightToLeft()
{
QFETCH(QString, text);
QFETCH(bool, emptyString);
QFETCH(bool, midString);
QFETCH(bool, endString);
- QSGTextEdit textEdit;
+ QQuickTextEdit textEdit;
textEdit.setText(text);
// first test that the right string is delivered to the QString::isRightToLeft()
QCOMPARE(textEdit.isRightToLeft(3*text.count()/4,text.count()-1), endString);
}
-void tst_qsgtextedit::keySelection()
+void tst_qquicktextedit::keySelection()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
QVERIFY(canvas.rootObject() != 0);
- QSGTextEdit *input = qobject_cast<QSGTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
QCOMPARE(spy.count(), 4);
}
-void tst_qsgtextedit::moveCursorSelection_data()
+void tst_qquicktextedit::moveCursorSelection_data()
{
QTest::addColumn<QString>("testStr");
QTest::addColumn<int>("cursorPosition");
QTest::addColumn<int>("movePosition");
- QTest::addColumn<QSGTextEdit::SelectionMode>("mode");
+ QTest::addColumn<QQuickTextEdit::SelectionMode>("mode");
QTest::addColumn<int>("selectionStart");
QTest::addColumn<int>("selectionEnd");
QTest::addColumn<bool>("reversible");
QTest::newRow("(t)he|characters")
- << standard[0] << 0 << 1 << QSGTextEdit::SelectCharacters << 0 << 1 << true;
+ << standard[0] << 0 << 1 << QQuickTextEdit::SelectCharacters << 0 << 1 << true;
QTest::newRow("do(g)|characters")
- << standard[0] << 43 << 44 << QSGTextEdit::SelectCharacters << 43 << 44 << true;
+ << standard[0] << 43 << 44 << QQuickTextEdit::SelectCharacters << 43 << 44 << true;
QTest::newRow("jum(p)ed|characters")
- << standard[0] << 23 << 24 << QSGTextEdit::SelectCharacters << 23 << 24 << true;
+ << standard[0] << 23 << 24 << QQuickTextEdit::SelectCharacters << 23 << 24 << true;
QTest::newRow("jumped( )over|characters")
- << standard[0] << 26 << 27 << QSGTextEdit::SelectCharacters << 26 << 27 << true;
+ << standard[0] << 26 << 27 << QQuickTextEdit::SelectCharacters << 26 << 27 << true;
QTest::newRow("(the )|characters")
- << standard[0] << 0 << 4 << QSGTextEdit::SelectCharacters << 0 << 4 << true;
+ << standard[0] << 0 << 4 << QQuickTextEdit::SelectCharacters << 0 << 4 << true;
QTest::newRow("( dog)|characters")
- << standard[0] << 40 << 44 << QSGTextEdit::SelectCharacters << 40 << 44 << true;
+ << standard[0] << 40 << 44 << QQuickTextEdit::SelectCharacters << 40 << 44 << true;
QTest::newRow("( jumped )|characters")
- << standard[0] << 19 << 27 << QSGTextEdit::SelectCharacters << 19 << 27 << true;
+ << standard[0] << 19 << 27 << QQuickTextEdit::SelectCharacters << 19 << 27 << true;
QTest::newRow("th(e qu)ick|characters")
- << standard[0] << 2 << 6 << QSGTextEdit::SelectCharacters << 2 << 6 << true;
+ << standard[0] << 2 << 6 << QQuickTextEdit::SelectCharacters << 2 << 6 << true;
QTest::newRow("la(zy d)og|characters")
- << standard[0] << 38 << 42 << QSGTextEdit::SelectCharacters << 38 << 42 << true;
+ << standard[0] << 38 << 42 << QQuickTextEdit::SelectCharacters << 38 << 42 << true;
QTest::newRow("jum(ped ov)er|characters")
- << standard[0] << 23 << 29 << QSGTextEdit::SelectCharacters << 23 << 29 << true;
+ << standard[0] << 23 << 29 << QQuickTextEdit::SelectCharacters << 23 << 29 << true;
QTest::newRow("()the|characters")
- << standard[0] << 0 << 0 << QSGTextEdit::SelectCharacters << 0 << 0 << true;
+ << standard[0] << 0 << 0 << QQuickTextEdit::SelectCharacters << 0 << 0 << true;
QTest::newRow("dog()|characters")
- << standard[0] << 44 << 44 << QSGTextEdit::SelectCharacters << 44 << 44 << true;
+ << standard[0] << 44 << 44 << QQuickTextEdit::SelectCharacters << 44 << 44 << true;
QTest::newRow("jum()ped|characters")
- << standard[0] << 23 << 23 << QSGTextEdit::SelectCharacters << 23 << 23 << true;
+ << standard[0] << 23 << 23 << QQuickTextEdit::SelectCharacters << 23 << 23 << true;
QTest::newRow("<(t)he>|words")
- << standard[0] << 0 << 1 << QSGTextEdit::SelectWords << 0 << 3 << true;
+ << standard[0] << 0 << 1 << QQuickTextEdit::SelectWords << 0 << 3 << true;
QTest::newRow("<do(g)>|words")
- << standard[0] << 43 << 44 << QSGTextEdit::SelectWords << 41 << 44 << true;
+ << standard[0] << 43 << 44 << QQuickTextEdit::SelectWords << 41 << 44 << true;
QTest::newRow("<jum(p)ed>|words")
- << standard[0] << 23 << 24 << QSGTextEdit::SelectWords << 20 << 26 << true;
+ << standard[0] << 23 << 24 << QQuickTextEdit::SelectWords << 20 << 26 << true;
QTest::newRow("<jumped( )>over|words")
- << standard[0] << 26 << 27 << QSGTextEdit::SelectWords << 20 << 27 << false;
+ << standard[0] << 26 << 27 << QQuickTextEdit::SelectWords << 20 << 27 << false;
QTest::newRow("jumped<( )over>|words,reversed")
- << standard[0] << 27 << 26 << QSGTextEdit::SelectWords << 26 << 31 << false;
+ << standard[0] << 27 << 26 << QQuickTextEdit::SelectWords << 26 << 31 << false;
QTest::newRow("<(the )>quick|words")
- << standard[0] << 0 << 4 << QSGTextEdit::SelectWords << 0 << 4 << false;
+ << standard[0] << 0 << 4 << QQuickTextEdit::SelectWords << 0 << 4 << false;
QTest::newRow("<(the )quick>|words,reversed")
- << standard[0] << 4 << 0 << QSGTextEdit::SelectWords << 0 << 9 << false;
+ << standard[0] << 4 << 0 << QQuickTextEdit::SelectWords << 0 << 9 << false;
QTest::newRow("<lazy( dog)>|words")
- << standard[0] << 40 << 44 << QSGTextEdit::SelectWords << 36 << 44 << false;
+ << standard[0] << 40 << 44 << QQuickTextEdit::SelectWords << 36 << 44 << false;
QTest::newRow("lazy<( dog)>|words,reversed")
- << standard[0] << 44 << 40 << QSGTextEdit::SelectWords << 40 << 44 << false;
+ << standard[0] << 44 << 40 << QQuickTextEdit::SelectWords << 40 << 44 << false;
QTest::newRow("<fox( jumped )>over|words")
- << standard[0] << 19 << 27 << QSGTextEdit::SelectWords << 16 << 27 << false;
+ << standard[0] << 19 << 27 << QQuickTextEdit::SelectWords << 16 << 27 << false;
QTest::newRow("fox<( jumped )over>|words,reversed")
- << standard[0] << 27 << 19 << QSGTextEdit::SelectWords << 19 << 31 << false;
+ << standard[0] << 27 << 19 << QQuickTextEdit::SelectWords << 19 << 31 << false;
QTest::newRow("<th(e qu)ick>|words")
- << standard[0] << 2 << 6 << QSGTextEdit::SelectWords << 0 << 9 << true;
+ << standard[0] << 2 << 6 << QQuickTextEdit::SelectWords << 0 << 9 << true;
QTest::newRow("<la(zy d)og|words>")
- << standard[0] << 38 << 42 << QSGTextEdit::SelectWords << 36 << 44 << true;
+ << standard[0] << 38 << 42 << QQuickTextEdit::SelectWords << 36 << 44 << true;
QTest::newRow("<jum(ped ov)er>|words")
- << standard[0] << 23 << 29 << QSGTextEdit::SelectWords << 20 << 31 << true;
+ << standard[0] << 23 << 29 << QQuickTextEdit::SelectWords << 20 << 31 << true;
QTest::newRow("<()>the|words")
- << standard[0] << 0 << 0 << QSGTextEdit::SelectWords << 0 << 0 << true;
+ << standard[0] << 0 << 0 << QQuickTextEdit::SelectWords << 0 << 0 << true;
QTest::newRow("dog<()>|words")
- << standard[0] << 44 << 44 << QSGTextEdit::SelectWords << 44 << 44 << true;
+ << standard[0] << 44 << 44 << QQuickTextEdit::SelectWords << 44 << 44 << true;
QTest::newRow("jum<()>ped|words")
- << standard[0] << 23 << 23 << QSGTextEdit::SelectWords << 23 << 23 << true;
+ << standard[0] << 23 << 23 << QQuickTextEdit::SelectWords << 23 << 23 << true;
QTest::newRow("Hello<(,)> |words")
- << standard[2] << 5 << 6 << QSGTextEdit::SelectWords << 5 << 6 << true;
+ << standard[2] << 5 << 6 << QQuickTextEdit::SelectWords << 5 << 6 << true;
QTest::newRow("Hello<(, )>world|words")
- << standard[2] << 5 << 7 << QSGTextEdit::SelectWords << 5 << 7 << false;
+ << standard[2] << 5 << 7 << QQuickTextEdit::SelectWords << 5 << 7 << false;
QTest::newRow("Hello<(, )world>|words,reversed")
- << standard[2] << 7 << 5 << QSGTextEdit::SelectWords << 5 << 12 << false;
+ << standard[2] << 7 << 5 << QQuickTextEdit::SelectWords << 5 << 12 << false;
QTest::newRow("<Hel(lo, )>world|words")
- << standard[2] << 3 << 7 << QSGTextEdit::SelectWords << 0 << 7 << false;
+ << standard[2] << 3 << 7 << QQuickTextEdit::SelectWords << 0 << 7 << false;
QTest::newRow("<Hel(lo, )world>|words,reversed")
- << standard[2] << 7 << 3 << QSGTextEdit::SelectWords << 0 << 12 << false;
+ << standard[2] << 7 << 3 << QQuickTextEdit::SelectWords << 0 << 12 << false;
QTest::newRow("<Hel(lo)>,|words")
- << standard[2] << 3 << 5 << QSGTextEdit::SelectWords << 0 << 5 << true;
+ << standard[2] << 3 << 5 << QQuickTextEdit::SelectWords << 0 << 5 << true;
QTest::newRow("Hello<()>,|words")
- << standard[2] << 5 << 5 << QSGTextEdit::SelectWords << 5 << 5 << true;
+ << standard[2] << 5 << 5 << QQuickTextEdit::SelectWords << 5 << 5 << true;
QTest::newRow("Hello,<()>|words")
- << standard[2] << 6 << 6 << QSGTextEdit::SelectWords << 6 << 6 << true;
+ << standard[2] << 6 << 6 << QQuickTextEdit::SelectWords << 6 << 6 << true;
QTest::newRow("Hello<,( )>world|words")
- << standard[2] << 6 << 7 << QSGTextEdit::SelectWords << 5 << 7 << false;
+ << standard[2] << 6 << 7 << QQuickTextEdit::SelectWords << 5 << 7 << false;
QTest::newRow("Hello,<( )world>|words,reversed")
- << standard[2] << 7 << 6 << QSGTextEdit::SelectWords << 6 << 12 << false;
+ << standard[2] << 7 << 6 << QQuickTextEdit::SelectWords << 6 << 12 << false;
QTest::newRow("Hello<,( world)>|words")
- << standard[2] << 6 << 12 << QSGTextEdit::SelectWords << 5 << 12 << false;
+ << standard[2] << 6 << 12 << QQuickTextEdit::SelectWords << 5 << 12 << false;
QTest::newRow("Hello,<( world)>|words,reversed")
- << standard[2] << 12 << 6 << QSGTextEdit::SelectWords << 6 << 12 << false;
+ << standard[2] << 12 << 6 << QQuickTextEdit::SelectWords << 6 << 12 << false;
QTest::newRow("Hello<,( world!)>|words")
- << standard[2] << 6 << 13 << QSGTextEdit::SelectWords << 5 << 13 << false;
+ << standard[2] << 6 << 13 << QQuickTextEdit::SelectWords << 5 << 13 << false;
QTest::newRow("Hello,<( world!)>|words,reversed")
- << standard[2] << 13 << 6 << QSGTextEdit::SelectWords << 6 << 13 << false;
+ << standard[2] << 13 << 6 << QQuickTextEdit::SelectWords << 6 << 13 << false;
QTest::newRow("Hello<(, world!)>|words")
- << standard[2] << 5 << 13 << QSGTextEdit::SelectWords << 5 << 13 << true;
+ << standard[2] << 5 << 13 << QQuickTextEdit::SelectWords << 5 << 13 << true;
QTest::newRow("world<(!)>|words")
- << standard[2] << 12 << 13 << QSGTextEdit::SelectWords << 12 << 13 << true;
+ << standard[2] << 12 << 13 << QQuickTextEdit::SelectWords << 12 << 13 << true;
QTest::newRow("world!<()>)|words")
- << standard[2] << 13 << 13 << QSGTextEdit::SelectWords << 13 << 13 << true;
+ << standard[2] << 13 << 13 << QQuickTextEdit::SelectWords << 13 << 13 << true;
QTest::newRow("world<()>!)|words")
- << standard[2] << 12 << 12 << QSGTextEdit::SelectWords << 12 << 12 << true;
+ << standard[2] << 12 << 12 << QQuickTextEdit::SelectWords << 12 << 12 << true;
QTest::newRow("<(,)>olleH |words")
- << standard[3] << 7 << 8 << QSGTextEdit::SelectWords << 7 << 8 << true;
+ << standard[3] << 7 << 8 << QQuickTextEdit::SelectWords << 7 << 8 << true;
QTest::newRow("<dlrow( ,)>olleH|words")
- << standard[3] << 6 << 8 << QSGTextEdit::SelectWords << 1 << 8 << false;
+ << standard[3] << 6 << 8 << QQuickTextEdit::SelectWords << 1 << 8 << false;
QTest::newRow("dlrow<( ,)>olleH|words,reversed")
- << standard[3] << 8 << 6 << QSGTextEdit::SelectWords << 6 << 8 << false;
+ << standard[3] << 8 << 6 << QQuickTextEdit::SelectWords << 6 << 8 << false;
QTest::newRow("<dlrow( ,ol)leH>|words")
- << standard[3] << 6 << 10 << QSGTextEdit::SelectWords << 1 << 13 << false;
+ << standard[3] << 6 << 10 << QQuickTextEdit::SelectWords << 1 << 13 << false;
QTest::newRow("dlrow<( ,ol)leH>|words,reversed")
- << standard[3] << 10 << 6 << QSGTextEdit::SelectWords << 6 << 13 << false;
+ << standard[3] << 10 << 6 << QQuickTextEdit::SelectWords << 6 << 13 << false;
QTest::newRow(",<(ol)leH>,|words")
- << standard[3] << 8 << 10 << QSGTextEdit::SelectWords << 8 << 13 << true;
+ << standard[3] << 8 << 10 << QQuickTextEdit::SelectWords << 8 << 13 << true;
QTest::newRow(",<()>olleH|words")
- << standard[3] << 8 << 8 << QSGTextEdit::SelectWords << 8 << 8 << true;
+ << standard[3] << 8 << 8 << QQuickTextEdit::SelectWords << 8 << 8 << true;
QTest::newRow("<()>,olleH|words")
- << standard[3] << 7 << 7 << QSGTextEdit::SelectWords << 7 << 7 << true;
+ << standard[3] << 7 << 7 << QQuickTextEdit::SelectWords << 7 << 7 << true;
QTest::newRow("<dlrow( )>,olleH|words")
- << standard[3] << 6 << 7 << QSGTextEdit::SelectWords << 1 << 7 << false;
+ << standard[3] << 6 << 7 << QQuickTextEdit::SelectWords << 1 << 7 << false;
QTest::newRow("dlrow<( ),>olleH|words,reversed")
- << standard[3] << 7 << 6 << QSGTextEdit::SelectWords << 6 << 8 << false;
+ << standard[3] << 7 << 6 << QQuickTextEdit::SelectWords << 6 << 8 << false;
QTest::newRow("<(dlrow )>,olleH|words")
- << standard[3] << 1 << 7 << QSGTextEdit::SelectWords << 1 << 7 << false;
+ << standard[3] << 1 << 7 << QQuickTextEdit::SelectWords << 1 << 7 << false;
QTest::newRow("<(dlrow ),>olleH|words,reversed")
- << standard[3] << 7 << 1 << QSGTextEdit::SelectWords << 1 << 8 << false;
+ << standard[3] << 7 << 1 << QQuickTextEdit::SelectWords << 1 << 8 << false;
QTest::newRow("<(!dlrow )>,olleH|words")
- << standard[3] << 0 << 7 << QSGTextEdit::SelectWords << 0 << 7 << false;
+ << standard[3] << 0 << 7 << QQuickTextEdit::SelectWords << 0 << 7 << false;
QTest::newRow("<(!dlrow ),>olleH|words,reversed")
- << standard[3] << 7 << 0 << QSGTextEdit::SelectWords << 0 << 8 << false;
+ << standard[3] << 7 << 0 << QQuickTextEdit::SelectWords << 0 << 8 << false;
QTest::newRow("(!dlrow ,)olleH|words")
- << standard[3] << 0 << 8 << QSGTextEdit::SelectWords << 0 << 8 << true;
+ << standard[3] << 0 << 8 << QQuickTextEdit::SelectWords << 0 << 8 << true;
QTest::newRow("<(!)>dlrow|words")
- << standard[3] << 0 << 1 << QSGTextEdit::SelectWords << 0 << 1 << true;
+ << standard[3] << 0 << 1 << QQuickTextEdit::SelectWords << 0 << 1 << true;
QTest::newRow("<()>!dlrow|words")
- << standard[3] << 0 << 0 << QSGTextEdit::SelectWords << 0 << 0 << true;
+ << standard[3] << 0 << 0 << QQuickTextEdit::SelectWords << 0 << 0 << true;
QTest::newRow("!<()>dlrow|words")
- << standard[3] << 1 << 1 << QSGTextEdit::SelectWords << 1 << 1 << true;
+ << standard[3] << 1 << 1 << QQuickTextEdit::SelectWords << 1 << 1 << true;
}
-void tst_qsgtextedit::moveCursorSelection()
+void tst_qquicktextedit::moveCursorSelection()
{
QFETCH(QString, testStr);
QFETCH(int, cursorPosition);
QFETCH(int, movePosition);
- QFETCH(QSGTextEdit::SelectionMode, mode);
+ QFETCH(QQuickTextEdit::SelectionMode, mode);
QFETCH(int, selectionStart);
QFETCH(int, selectionEnd);
QFETCH(bool, reversible);
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \""+ testStr +"\"; }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *texteditObject = qobject_cast<QSGTextEdit*>(textinputComponent.create());
+ QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit*>(textinputComponent.create());
QVERIFY(texteditObject != 0);
texteditObject->setCursorPosition(cursorPosition);
}
}
-void tst_qsgtextedit::moveCursorSelectionSequence_data()
+void tst_qquicktextedit::moveCursorSelectionSequence_data()
{
QTest::addColumn<QString>("testStr");
QTest::addColumn<int>("cursorPosition");
<< 1 << 13;
}
-void tst_qsgtextedit::moveCursorSelectionSequence()
+void tst_qquicktextedit::moveCursorSelectionSequence()
{
QFETCH(QString, testStr);
QFETCH(int, cursorPosition);
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \""+ testStr +"\"; }";
QDeclarativeComponent texteditComponent(&engine);
texteditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *texteditObject = qobject_cast<QSGTextEdit*>(texteditComponent.create());
+ QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit*>(texteditComponent.create());
QVERIFY(texteditObject != 0);
texteditObject->setCursorPosition(cursorPosition);
- texteditObject->moveCursorSelection(movePosition1, QSGTextEdit::SelectWords);
+ texteditObject->moveCursorSelection(movePosition1, QQuickTextEdit::SelectWords);
QCOMPARE(texteditObject->selectedText(), testStr.mid(selection1Start, selection1End - selection1Start));
QCOMPARE(texteditObject->selectionStart(), selection1Start);
QCOMPARE(texteditObject->selectionEnd(), selection1End);
- texteditObject->moveCursorSelection(movePosition2, QSGTextEdit::SelectWords);
+ texteditObject->moveCursorSelection(movePosition2, QQuickTextEdit::SelectWords);
QCOMPARE(texteditObject->selectedText(), testStr.mid(selection2Start, selection2End - selection2Start));
QCOMPARE(texteditObject->selectionStart(), selection2Start);
QCOMPARE(texteditObject->selectionEnd(), selection2End);
}
-void tst_qsgtextedit::mouseSelection_data()
+void tst_qquicktextedit::mouseSelection_data()
{
QTest::addColumn<QString>("qmlfile");
QTest::addColumn<int>("from");
QTest::newRow("on word selection (30,9)") << TESTDATA("mouseselection_true_words.qml") << 30 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ";
}
-void tst_qsgtextedit::mouseSelection()
+void tst_qquicktextedit::mouseSelection()
{
QFETCH(QString, qmlfile);
QFETCH(int, from);
QFETCH(int, to);
QFETCH(QString, selectedText);
- QSGView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView canvas(QUrl::fromLocalFile(qmlfile));
canvas.show();
canvas.requestActivateWindow();
QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
QVERIFY(canvas.rootObject() != 0);
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
QVERIFY(textEditObject != 0);
// press-and-drag-and-release from x1 to x2
QTRY_COMPARE(textEditObject->selectedText(), selectedText);
}
-void tst_qsgtextedit::dragMouseSelection()
+void tst_qquicktextedit::dragMouseSelection()
{
QString qmlfile = TESTDATA("mouseselection_true.qml");
- QSGView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView canvas(QUrl::fromLocalFile(qmlfile));
canvas.show();
canvas.requestActivateWindow();
QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
QVERIFY(canvas.rootObject() != 0);
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
QVERIFY(textEditObject != 0);
// press-and-drag-and-release from x1 to x2
QVERIFY(str1 != str2); // Verify the second press and drag is a new selection and not the first moved.
}
-void tst_qsgtextedit::mouseSelectionMode_data()
+void tst_qquicktextedit::mouseSelectionMode_data()
{
QTest::addColumn<QString>("qmlfile");
QTest::addColumn<bool>("selectWords");
QTest::newRow("default") << TESTDATA("mouseselectionmode_default.qml") << false;
}
-void tst_qsgtextedit::mouseSelectionMode()
+void tst_qquicktextedit::mouseSelectionMode()
{
QFETCH(QString, qmlfile);
QFETCH(bool, selectWords);
QString text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
- QSGView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView canvas(QUrl::fromLocalFile(qmlfile));
canvas.show();
canvas.requestActivateWindow();
QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
QVERIFY(canvas.rootObject() != 0);
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
QVERIFY(textEditObject != 0);
// press-and-drag-and-release from x1 to x2
}
}
-void tst_qsgtextedit::inputMethodHints()
+void tst_qquicktextedit::inputMethodHints()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("inputmethodhints.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("inputmethodhints.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextEdit *textEditObject = qobject_cast<QSGTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
QVERIFY(textEditObject != 0);
QVERIFY(textEditObject->inputMethodHints() & Qt::ImhNoPredictiveText);
textEditObject->setInputMethodHints(Qt::ImhUppercaseOnly);
QVERIFY(textEditObject->inputMethodHints() & Qt::ImhUppercaseOnly);
}
-void tst_qsgtextedit::positionAt()
+void tst_qquicktextedit::positionAt()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("positionAt.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("positionAt.qml")));
QVERIFY(canvas.rootObject() != 0);
canvas.show();
canvas.requestActivateWindow();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
- QSGTextEdit *texteditObject = qobject_cast<QSGTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
QVERIFY(texteditObject != 0);
QFontMetrics fm(texteditObject->font());
QVERIFY(texteditObject->positionAt(x0 / 2, y1) > 0);
}
-void tst_qsgtextedit::cursorDelegate()
+void tst_qquicktextedit::cursorDelegate()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("cursorTest.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("cursorTest.qml")));
view.show();
view.requestActivateWindow();
- QSGTextEdit *textEditObject = view.rootObject()->findChild<QSGTextEdit*>("textEditObject");
+ QQuickTextEdit *textEditObject = view.rootObject()->findChild<QQuickTextEdit*>("textEditObject");
QVERIFY(textEditObject != 0);
- QVERIFY(textEditObject->findChild<QSGItem*>("cursorInstance"));
+ QVERIFY(textEditObject->findChild<QQuickItem*>("cursorInstance"));
//Test Delegate gets created
textEditObject->setFocus(true);
- QSGItem* delegateObject = textEditObject->findChild<QSGItem*>("cursorInstance");
+ QQuickItem* delegateObject = textEditObject->findChild<QQuickItem*>("cursorInstance");
QVERIFY(delegateObject);
QCOMPARE(delegateObject->property("localProperty").toString(), QString("Hello"));
//Test Delegate gets moved
QCOMPARE(textEditObject->cursorRectangle().y(), qRound(delegateObject->y()));
//Test Delegate gets deleted
textEditObject->setCursorDelegate(0);
- QVERIFY(!textEditObject->findChild<QSGItem*>("cursorInstance"));
+ QVERIFY(!textEditObject->findChild<QQuickItem*>("cursorInstance"));
}
-void tst_qsgtextedit::cursorVisible()
+void tst_qquicktextedit::cursorVisible()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("cursorVisible.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("cursorVisible.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextEdit edit;
+ QQuickTextEdit edit;
QSignalSpy spy(&edit, SIGNAL(cursorVisibleChanged(bool)));
QCOMPARE(edit.isCursorVisible(), false);
#endif
}
-void tst_qsgtextedit::delegateLoading_data()
+void tst_qquicktextedit::delegateLoading_data()
{
QTest::addColumn<QString>("qmlfile");
QTest::addColumn<QString>("error");
QTest::newRow("fail2") << "cursorHttpTestFail2.qml" << "http://localhost:42332/ErrItem.qml:4:5: Fungus is not a type ";
}
-void tst_qsgtextedit::delegateLoading()
+void tst_qquicktextedit::delegateLoading()
{
QFETCH(QString, qmlfile);
QFETCH(QString, error);
server.serveDirectory(TESTDATA("httpslow"), TestHTTPServer::Delay);
server.serveDirectory(TESTDATA("http"));
- QSGView view(QUrl(QLatin1String("http://localhost:42332/") + qmlfile));
+ QQuickView view(QUrl(QLatin1String("http://localhost:42332/") + qmlfile));
view.show();
view.requestActivateWindow();
if (!error.isEmpty()) {
QTest::ignoreMessage(QtWarningMsg, error.toUtf8());
- QTRY_VERIFY(view.status()==QSGView::Error);
+ QTRY_VERIFY(view.status()==QQuickView::Error);
QTRY_VERIFY(!view.rootObject()); // there is fail item inside this test
} else {
QTRY_VERIFY(view.rootObject());//Wait for loading to finish.
- QSGTextEdit *textEditObject = view.rootObject()->findChild<QSGTextEdit*>("textEditObject");
+ QQuickTextEdit *textEditObject = view.rootObject()->findChild<QQuickTextEdit*>("textEditObject");
// view.rootObject()->dumpObjectTree();
QVERIFY(textEditObject != 0);
textEditObject->setFocus(true);
- QSGItem *delegate;
- delegate = view.rootObject()->findChild<QSGItem*>("delegateOkay");
+ QQuickItem *delegate;
+ delegate = view.rootObject()->findChild<QQuickItem*>("delegateOkay");
QVERIFY(delegate);
- delegate = view.rootObject()->findChild<QSGItem*>("delegateSlow");
+ delegate = view.rootObject()->findChild<QQuickItem*>("delegateSlow");
QVERIFY(delegate);
delete delegate;
//A test should be added here with a component which is ready but component.create() returns null
- //Not sure how to accomplish this with QSGTextEdits cursor delegate
+ //Not sure how to accomplish this with QQuickTextEdits cursor delegate
//###This was only needed for code coverage, and could be a case of overzealous defensive programming
- //delegate = view.rootObject()->findChild<QSGItem*>("delegateErrorB");
+ //delegate = view.rootObject()->findChild<QQuickItem*>("delegateErrorB");
//QVERIFY(!delegate);
}
TextEdit element should only handle left/right keys until the cursor reaches
the extent of the text, then they should ignore the keys.
*/
-void tst_qsgtextedit::navigation()
+void tst_qquicktextedit::navigation()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGItem *input = qobject_cast<QSGItem *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickItem *input = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
QVERIFY(input->hasActiveFocus() == true);
}
-void tst_qsgtextedit::copyAndPaste() {
+void tst_qquicktextedit::copyAndPaste() {
#ifndef QT_NO_CLIPBOARD
#ifdef Q_WS_MAC
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello world!\" }";
QDeclarativeComponent textEditComponent(&engine);
textEditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEdit = qobject_cast<QSGTextEdit*>(textEditComponent.create());
+ QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
// copy and paste
// QTBUG-12339
// test that document and internal text attribute are in sync
- QSGItemPrivate* pri = QSGItemPrivate::get(textEdit);
- QSGTextEditPrivate *editPrivate = static_cast<QSGTextEditPrivate*>(pri);
+ QQuickItemPrivate* pri = QQuickItemPrivate::get(textEdit);
+ QQuickTextEditPrivate *editPrivate = static_cast<QQuickTextEditPrivate*>(pri);
QCOMPARE(textEdit->text(), editPrivate->text);
// select word
#endif
}
-void tst_qsgtextedit::canPaste() {
+void tst_qquicktextedit::canPaste() {
#ifndef QT_NO_CLIPBOARD
QGuiApplication::clipboard()->setText("Some text");
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello world!\" }";
QDeclarativeComponent textEditComponent(&engine);
textEditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEdit = qobject_cast<QSGTextEdit*>(textEditComponent.create());
+ QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
// check initial value - QTBUG-17765
#endif
}
-void tst_qsgtextedit::canPasteEmpty() {
+void tst_qquicktextedit::canPasteEmpty() {
#ifndef QT_NO_CLIPBOARD
QGuiApplication::clipboard()->clear();
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello world!\" }";
QDeclarativeComponent textEditComponent(&engine);
textEditComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextEdit *textEdit = qobject_cast<QSGTextEdit*>(textEditComponent.create());
+ QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
// check initial value - QTBUG-17765
#endif
}
-void tst_qsgtextedit::readOnly()
+void tst_qquicktextedit::readOnly()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("readOnly.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("readOnly.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextEdit *edit = qobject_cast<QSGTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(edit != 0);
QTRY_VERIFY(edit->hasActiveFocus() == true);
QCOMPARE(edit->cursorPosition(), edit->text().length());
}
-void tst_qsgtextedit::simulateKey(QSGView *view, int key, Qt::KeyboardModifiers modifiers)
+void tst_qquicktextedit::simulateKey(QQuickView *view, int key, Qt::KeyboardModifiers modifiers)
{
QKeyEvent press(QKeyEvent::KeyPress, key, modifiers);
QKeyEvent release(QKeyEvent::KeyRelease, key, modifiers);
};
#endif
-void tst_qsgtextedit::textInput()
+void tst_qquicktextedit::textInput()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputMethodEvent.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputMethodEvent.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextEdit *edit = qobject_cast<QSGTextEdit *>(view.rootObject());
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(view.rootObject());
QVERIFY(edit);
QVERIFY(edit->hasActiveFocus() == true);
// QTBUG-12339
// test that document and internal text attribute are in sync
- QSGTextEditPrivate *editPrivate = static_cast<QSGTextEditPrivate*>(QSGItemPrivate::get(edit));
+ QQuickTextEditPrivate *editPrivate = static_cast<QQuickTextEditPrivate*>(QQuickItemPrivate::get(edit));
QCOMPARE(editPrivate->text, QString("Hello world!"));
}
-void tst_qsgtextedit::openInputPanel()
+void tst_qquicktextedit::openInputPanel()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("openInputPanel.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("openInputPanel.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextEdit *edit = qobject_cast<QSGTextEdit *>(view.rootObject());
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(view.rootObject());
QVERIFY(edit);
// check default values
// input panel should stay visible if focus is lost to another text editor
QSignalSpy inputPanelVisibilitySpy(qApp->inputPanel(), SIGNAL(visibleChanged()));
- QSGTextEdit anotherEdit;
+ QQuickTextEdit anotherEdit;
anotherEdit.setParentItem(view.rootObject());
anotherEdit.setFocus(true);
QCOMPARE(qApp->inputPanel()->visible(), true);
anotherEdit.setFocus(true);
// input item should be null if focus is lost to an item that doesn't accept inputs
- QSGItem item;
+ QQuickItem item;
item.setParentItem(view.rootObject());
item.setFocus(true);
QCOMPARE(qApp->inputPanel()->inputItem(), static_cast<QObject*>(0));
QCOMPARE(qApp->inputPanel()->visible(), false);
}
-void tst_qsgtextedit::geometrySignals()
+void tst_qquicktextedit::geometrySignals()
{
QDeclarativeComponent component(&engine, TESTDATA("geometrySignals.qml"));
QObject *o = component.create();
delete o;
}
-void tst_qsgtextedit::pastingRichText_QTBUG_14003()
+void tst_qquicktextedit::pastingRichText_QTBUG_14003()
{
#ifndef QT_NO_CLIPBOARD
QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.PlainText }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGTextEdit *obj = qobject_cast<QSGTextEdit*>(component.create());
+ QQuickTextEdit *obj = qobject_cast<QQuickTextEdit*>(component.create());
QTRY_VERIFY(obj != 0);
- QTRY_VERIFY(obj->textFormat() == QSGTextEdit::PlainText);
+ QTRY_VERIFY(obj->textFormat() == QQuickTextEdit::PlainText);
QMimeData *mData = new QMimeData;
mData->setHtml("<font color=\"red\">Hello</font>");
obj->paste();
QTRY_VERIFY(obj->text() == "");
- QTRY_VERIFY(obj->textFormat() == QSGTextEdit::PlainText);
+ QTRY_VERIFY(obj->textFormat() == QQuickTextEdit::PlainText);
#endif
}
-void tst_qsgtextedit::implicitSize_data()
+void tst_qquicktextedit::implicitSize_data()
{
QTest::addColumn<QString>("text");
QTest::addColumn<QString>("wrap");
QTest::newRow("richtext_wrap") << "<b>The quick red fox jumped over the lazy brown dog</b>" << "TextEdit.Wrap";
}
-void tst_qsgtextedit::implicitSize()
+void tst_qquicktextedit::implicitSize()
{
QFETCH(QString, text);
QFETCH(QString, wrap);
QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + text + "\"; width: 50; wrapMode: " + wrap + " }";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGTextEdit *textObject = qobject_cast<QSGTextEdit*>(textComponent.create());
+ QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(textComponent.create());
QVERIFY(textObject->width() < textObject->implicitWidth());
QVERIFY(textObject->height() == textObject->implicitHeight());
QVERIFY(textObject->height() == textObject->implicitHeight());
}
-void tst_qsgtextedit::testQtQuick11Attributes()
+void tst_qquicktextedit::testQtQuick11Attributes()
{
QFETCH(QString, code);
QFETCH(QString, warning);
delete obj;
}
-void tst_qsgtextedit::testQtQuick11Attributes_data()
+void tst_qquicktextedit::testQtQuick11Attributes_data()
{
QTest::addColumn<QString>("code");
QTest::addColumn<QString>("warning");
<< ":1 \"TextEdit.onLinkActivated\" is not available in QtQuick 1.0.\n";
}
-void tst_qsgtextedit::preeditMicroFocus()
+void tst_qquicktextedit::preeditMicroFocus()
{
#ifdef QTBUG_21691
QEXPECT_FAIL("", QTBUG_21691_MESSAGE, Abort);
#else
QString preeditText = "super";
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputMethodEvent.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputMethodEvent.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextEdit *edit = qobject_cast<QSGTextEdit *>(view.rootObject());
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(view.rootObject());
QVERIFY(edit);
QSignalSpy cursorRectangleSpy(edit, SIGNAL(cursorRectangleChanged()));
#endif
}
-void tst_qsgtextedit::inputContextMouseHandler()
+void tst_qquicktextedit::inputContextMouseHandler()
{
#ifdef QTBUG_21691
#else
QString text = "supercalifragisiticexpialidocious!";
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
MyInputContext ic;
- // QSGCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has focus
+ // QQuickCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has focus
// and QWidget won't allow an input context to be set when the flag is not set.
view.setAttribute(Qt::WA_InputMethodEnabled, true);
view.setInputContext(&ic);
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextEdit *edit = qobject_cast<QSGTextEdit *>(view.rootObject());
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(view.rootObject());
QVERIFY(edit);
edit->setCursorPosition(12);
#endif
}
-void tst_qsgtextedit::inputMethodComposing()
+void tst_qquicktextedit::inputMethodComposing()
{
QString text = "supercalifragisiticexpialidocious!";
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextEdit *edit = qobject_cast<QSGTextEdit *>(view.rootObject());
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(view.rootObject());
QVERIFY(edit);
QSignalSpy spy(edit, SIGNAL(inputMethodComposingChanged()));
edit->setCursorPosition(12);
QCOMPARE(spy.count(), 2);
}
-void tst_qsgtextedit::cursorRectangleSize()
+void tst_qquicktextedit::cursorRectangleSize()
{
- QSGView *canvas = new QSGView(QUrl::fromLocalFile(TESTDATA("CursorRect.qml")));
+ QQuickView *canvas = new QQuickView(QUrl::fromLocalFile(TESTDATA("CursorRect.qml")));
QVERIFY(canvas->rootObject() != 0);
canvas->show();
canvas->requestActivateWindow();
QTest::qWaitForWindowShown(canvas);
- QSGTextEdit *textEdit = qobject_cast<QSGTextEdit *>(canvas->rootObject());
+ QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit *>(canvas->rootObject());
QVERIFY(textEdit != 0);
textEdit->setFocus(Qt::OtherFocusReason);
QRectF cursorRect = textEdit->positionToRectangle(textEdit->cursorPosition());
delete canvas;
}
-void tst_qsgtextedit::emptytags_QTBUG_22058()
+void tst_qquicktextedit::emptytags_QTBUG_22058()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("qtbug-22058.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("qtbug-22058.qml")));
QVERIFY(canvas.rootObject() != 0);
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
- QSGTextEdit *input = qobject_cast<QSGTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("inputField")));
+ QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("inputField")));
QVERIFY(input->hasActiveFocus());
QInputMethodEvent event("", QList<QInputMethodEvent::Attribute>());
QCOMPARE(input->text(), QString("<b>Bold<>"));
}
-QTEST_MAIN(tst_qsgtextedit)
+QTEST_MAIN(tst_qquicktextedit)
-#include "tst_qsgtextedit.moc"
+#include "tst_qquicktextedit.moc"
CONFIG += testcase
-TARGET = tst_qsgtextinput
+TARGET = tst_qquicktextinput
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgtextinput.cpp
+SOURCES += tst_qquicktextinput.cpp
testDataFiles.files = data
testDataFiles.path = .
#include "../shared/util.h"
#include <QtDeclarative/qdeclarativeengine.h>
#include <QFile>
-#include <QtDeclarative/qsgview.h>
+#include <QtDeclarative/qquickview.h>
#include <QtGui/qguiapplication.h>
#include <QInputPanel>
-#include <private/qsgtextinput_p.h>
-#include <private/qsgtextinput_p_p.h>
+#include <private/qquicktextinput_p.h>
+#include <private/qquicktextinput_p_p.h>
#include <QDebug>
#include <QDir>
#include <QStyle>
#include "qplatformdefs.h"
-Q_DECLARE_METATYPE(QSGTextInput::SelectionMode)
+Q_DECLARE_METATYPE(QQuickTextInput::SelectionMode)
DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
#define QTBUG_21691
return expectfile;
}
-class tst_qsgtextinput : public QObject
+class tst_qquicktextinput : public QObject
{
Q_OBJECT
public:
- tst_qsgtextinput();
+ tst_qquicktextinput();
private slots:
void initTestCase();
void QTBUG_19956_regexp();
private:
- void simulateKey(QSGView *, int key);
+ void simulateKey(QQuickView *, int key);
QDeclarativeEngine engine;
QStringList standard;
QStringList colorStrings;
};
-void tst_qsgtextinput::initTestCase()
+void tst_qquicktextinput::initTestCase()
{
}
-void tst_qsgtextinput::cleanupTestCase()
+void tst_qquicktextinput::cleanupTestCase()
{
}
-tst_qsgtextinput::tst_qsgtextinput()
+tst_qquicktextinput::tst_qquicktextinput()
{
standard << "the quick brown fox jumped over the lazy dog"
<< "It's supercalifragisiticexpialidocious!"
<< "#2AC05F";
}
-void tst_qsgtextinput::text()
+void tst_qquicktextinput::text()
{
{
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData("import QtQuick 2.0\nTextInput { text: \"\" }", QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->text(), QString(""));
QString componentStr = "import QtQuick 2.0\nTextInput { text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->text(), standard.at(i));
}
-void tst_qsgtextinput::width()
+void tst_qquicktextinput::width()
{
// uses Font metrics to find the width for standard
{
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData("import QtQuick 2.0\nTextInput { text: \"\" }", QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->width(), 0.0);
QString componentStr = "import QtQuick 2.0\nTextInput { text: \"" + standard.at(i) + "\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
int delta = abs(int(int(textinputObject->width()) - metricWidth));
}
}
-void tst_qsgtextinput::font()
+void tst_qquicktextinput::font()
{
//test size, then bold, then italic, then family
{
QString componentStr = "import QtQuick 2.0\nTextInput { font.pointSize: 40; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->font().pointSize(), 40);
QString componentStr = "import QtQuick 2.0\nTextInput { font.bold: true; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->font().bold(), true);
QString componentStr = "import QtQuick 2.0\nTextInput { font.italic: true; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->font().italic(), true);
QString componentStr = "import QtQuick 2.0\nTextInput { font.family: \"Helvetica\"; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->font().family(), QString("Helvetica"));
QString componentStr = "import QtQuick 2.0\nTextInput { font.family: \"\"; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->font().family(), QString(""));
}
}
-void tst_qsgtextinput::color()
+void tst_qquicktextinput::color()
{
//test color
for (int i = 0; i < colorStrings.size(); i++)
QString componentStr = "import QtQuick 2.0\nTextInput { color: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->color(), QColor(colorStrings.at(i)));
QString componentStr = "import QtQuick 2.0\nTextInput { selectionColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->selectionColor(), QColor(colorStrings.at(i)));
QString componentStr = "import QtQuick 2.0\nTextInput { selectedTextColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->selectedTextColor(), QColor(colorStrings.at(i)));
QString componentStr = "import QtQuick 2.0\nTextInput { color: \"" + colorStr + "\"; text: \"Hello World\" }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
QCOMPARE(textinputObject->color(), testColor);
}
}
-void tst_qsgtextinput::selection()
+void tst_qquicktextinput::selection()
{
QString testStr = standard[0];
QString componentStr = "import QtQuick 2.0\nTextInput { text: \""+ testStr +"\"; }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
delete textinputObject;
}
-void tst_qsgtextinput::isRightToLeft_data()
+void tst_qquicktextinput::isRightToLeft_data()
{
QTest::addColumn<QString>("text");
QTest::addColumn<bool>("emptyString");
QTest::newRow("Bidi LTR + RTL + LTR") << QString("Hello world") + QString::fromUtf16(arabic_str, 11) + QString("Hello world") << false << false << false << true << false << false << false;
}
-void tst_qsgtextinput::isRightToLeft()
+void tst_qquicktextinput::isRightToLeft()
{
QFETCH(QString, text);
QFETCH(bool, emptyString);
QFETCH(bool, midString);
QFETCH(bool, endString);
- QSGTextInput textInput;
+ QQuickTextInput textInput;
textInput.setText(text);
// first test that the right string is delivered to the QString::isRightToLeft()
QCOMPARE(textInput.isRightToLeft(3*text.count()/4,text.count()-1), endString);
}
-void tst_qsgtextinput::moveCursorSelection_data()
+void tst_qquicktextinput::moveCursorSelection_data()
{
QTest::addColumn<QString>("testStr");
QTest::addColumn<int>("cursorPosition");
QTest::addColumn<int>("movePosition");
- QTest::addColumn<QSGTextInput::SelectionMode>("mode");
+ QTest::addColumn<QQuickTextInput::SelectionMode>("mode");
QTest::addColumn<int>("selectionStart");
QTest::addColumn<int>("selectionEnd");
QTest::addColumn<bool>("reversible");
// <> contains the actual selection.
QTest::newRow("(t)he|characters")
- << standard[0] << 0 << 1 << QSGTextInput::SelectCharacters << 0 << 1 << true;
+ << standard[0] << 0 << 1 << QQuickTextInput::SelectCharacters << 0 << 1 << true;
QTest::newRow("do(g)|characters")
- << standard[0] << 43 << 44 << QSGTextInput::SelectCharacters << 43 << 44 << true;
+ << standard[0] << 43 << 44 << QQuickTextInput::SelectCharacters << 43 << 44 << true;
QTest::newRow("jum(p)ed|characters")
- << standard[0] << 23 << 24 << QSGTextInput::SelectCharacters << 23 << 24 << true;
+ << standard[0] << 23 << 24 << QQuickTextInput::SelectCharacters << 23 << 24 << true;
QTest::newRow("jumped( )over|characters")
- << standard[0] << 26 << 27 << QSGTextInput::SelectCharacters << 26 << 27 << true;
+ << standard[0] << 26 << 27 << QQuickTextInput::SelectCharacters << 26 << 27 << true;
QTest::newRow("(the )|characters")
- << standard[0] << 0 << 4 << QSGTextInput::SelectCharacters << 0 << 4 << true;
+ << standard[0] << 0 << 4 << QQuickTextInput::SelectCharacters << 0 << 4 << true;
QTest::newRow("( dog)|characters")
- << standard[0] << 40 << 44 << QSGTextInput::SelectCharacters << 40 << 44 << true;
+ << standard[0] << 40 << 44 << QQuickTextInput::SelectCharacters << 40 << 44 << true;
QTest::newRow("( jumped )|characters")
- << standard[0] << 19 << 27 << QSGTextInput::SelectCharacters << 19 << 27 << true;
+ << standard[0] << 19 << 27 << QQuickTextInput::SelectCharacters << 19 << 27 << true;
QTest::newRow("th(e qu)ick|characters")
- << standard[0] << 2 << 6 << QSGTextInput::SelectCharacters << 2 << 6 << true;
+ << standard[0] << 2 << 6 << QQuickTextInput::SelectCharacters << 2 << 6 << true;
QTest::newRow("la(zy d)og|characters")
- << standard[0] << 38 << 42 << QSGTextInput::SelectCharacters << 38 << 42 << true;
+ << standard[0] << 38 << 42 << QQuickTextInput::SelectCharacters << 38 << 42 << true;
QTest::newRow("jum(ped ov)er|characters")
- << standard[0] << 23 << 29 << QSGTextInput::SelectCharacters << 23 << 29 << true;
+ << standard[0] << 23 << 29 << QQuickTextInput::SelectCharacters << 23 << 29 << true;
QTest::newRow("()the|characters")
- << standard[0] << 0 << 0 << QSGTextInput::SelectCharacters << 0 << 0 << true;
+ << standard[0] << 0 << 0 << QQuickTextInput::SelectCharacters << 0 << 0 << true;
QTest::newRow("dog()|characters")
- << standard[0] << 44 << 44 << QSGTextInput::SelectCharacters << 44 << 44 << true;
+ << standard[0] << 44 << 44 << QQuickTextInput::SelectCharacters << 44 << 44 << true;
QTest::newRow("jum()ped|characters")
- << standard[0] << 23 << 23 << QSGTextInput::SelectCharacters << 23 << 23 << true;
+ << standard[0] << 23 << 23 << QQuickTextInput::SelectCharacters << 23 << 23 << true;
QTest::newRow("<(t)he>|words")
- << standard[0] << 0 << 1 << QSGTextInput::SelectWords << 0 << 3 << true;
+ << standard[0] << 0 << 1 << QQuickTextInput::SelectWords << 0 << 3 << true;
QTest::newRow("<do(g)>|words")
- << standard[0] << 43 << 44 << QSGTextInput::SelectWords << 41 << 44 << true;
+ << standard[0] << 43 << 44 << QQuickTextInput::SelectWords << 41 << 44 << true;
QTest::newRow("<jum(p)ed>|words")
- << standard[0] << 23 << 24 << QSGTextInput::SelectWords << 20 << 26 << true;
+ << standard[0] << 23 << 24 << QQuickTextInput::SelectWords << 20 << 26 << true;
QTest::newRow("<jumped( )>over|words,ltr")
- << standard[0] << 26 << 27 << QSGTextInput::SelectWords << 20 << 27 << false;
+ << standard[0] << 26 << 27 << QQuickTextInput::SelectWords << 20 << 27 << false;
QTest::newRow("jumped<( )over>|words,rtl")
- << standard[0] << 27 << 26 << QSGTextInput::SelectWords << 26 << 31 << false;
+ << standard[0] << 27 << 26 << QQuickTextInput::SelectWords << 26 << 31 << false;
QTest::newRow("<(the )>quick|words,ltr")
- << standard[0] << 0 << 4 << QSGTextInput::SelectWords << 0 << 4 << false;
+ << standard[0] << 0 << 4 << QQuickTextInput::SelectWords << 0 << 4 << false;
QTest::newRow("<(the )quick>|words,rtl")
- << standard[0] << 4 << 0 << QSGTextInput::SelectWords << 0 << 9 << false;
+ << standard[0] << 4 << 0 << QQuickTextInput::SelectWords << 0 << 9 << false;
QTest::newRow("<lazy( dog)>|words,ltr")
- << standard[0] << 40 << 44 << QSGTextInput::SelectWords << 36 << 44 << false;
+ << standard[0] << 40 << 44 << QQuickTextInput::SelectWords << 36 << 44 << false;
QTest::newRow("lazy<( dog)>|words,rtl")
- << standard[0] << 44 << 40 << QSGTextInput::SelectWords << 40 << 44 << false;
+ << standard[0] << 44 << 40 << QQuickTextInput::SelectWords << 40 << 44 << false;
QTest::newRow("<fox( jumped )>over|words,ltr")
- << standard[0] << 19 << 27 << QSGTextInput::SelectWords << 16 << 27 << false;
+ << standard[0] << 19 << 27 << QQuickTextInput::SelectWords << 16 << 27 << false;
QTest::newRow("fox<( jumped )over>|words,rtl")
- << standard[0] << 27 << 19 << QSGTextInput::SelectWords << 19 << 31 << false;
+ << standard[0] << 27 << 19 << QQuickTextInput::SelectWords << 19 << 31 << false;
QTest::newRow("<th(e qu)ick>|words")
- << standard[0] << 2 << 6 << QSGTextInput::SelectWords << 0 << 9 << true;
+ << standard[0] << 2 << 6 << QQuickTextInput::SelectWords << 0 << 9 << true;
QTest::newRow("<la(zy d)og|words>")
- << standard[0] << 38 << 42 << QSGTextInput::SelectWords << 36 << 44 << true;
+ << standard[0] << 38 << 42 << QQuickTextInput::SelectWords << 36 << 44 << true;
QTest::newRow("<jum(ped ov)er>|words")
- << standard[0] << 23 << 29 << QSGTextInput::SelectWords << 20 << 31 << true;
+ << standard[0] << 23 << 29 << QQuickTextInput::SelectWords << 20 << 31 << true;
QTest::newRow("<()>the|words")
- << standard[0] << 0 << 0 << QSGTextInput::SelectWords << 0 << 0 << true;
+ << standard[0] << 0 << 0 << QQuickTextInput::SelectWords << 0 << 0 << true;
QTest::newRow("dog<()>|words")
- << standard[0] << 44 << 44 << QSGTextInput::SelectWords << 44 << 44 << true;
+ << standard[0] << 44 << 44 << QQuickTextInput::SelectWords << 44 << 44 << true;
QTest::newRow("jum<()>ped|words")
- << standard[0] << 23 << 23 << QSGTextInput::SelectWords << 23 << 23 << true;
+ << standard[0] << 23 << 23 << QQuickTextInput::SelectWords << 23 << 23 << true;
QTest::newRow("Hello<(,)> |words")
- << standard[2] << 5 << 6 << QSGTextInput::SelectWords << 5 << 6 << true;
+ << standard[2] << 5 << 6 << QQuickTextInput::SelectWords << 5 << 6 << true;
QTest::newRow("Hello<(, )>world|words,ltr")
- << standard[2] << 5 << 7 << QSGTextInput::SelectWords << 5 << 7 << false;
+ << standard[2] << 5 << 7 << QQuickTextInput::SelectWords << 5 << 7 << false;
QTest::newRow("Hello<(, )world>|words,rtl")
- << standard[2] << 7 << 5 << QSGTextInput::SelectWords << 5 << 12 << false;
+ << standard[2] << 7 << 5 << QQuickTextInput::SelectWords << 5 << 12 << false;
QTest::newRow("<Hel(lo, )>world|words,ltr")
- << standard[2] << 3 << 7 << QSGTextInput::SelectWords << 0 << 7 << false;
+ << standard[2] << 3 << 7 << QQuickTextInput::SelectWords << 0 << 7 << false;
QTest::newRow("<Hel(lo, )world>|words,rtl")
- << standard[2] << 7 << 3 << QSGTextInput::SelectWords << 0 << 12 << false;
+ << standard[2] << 7 << 3 << QQuickTextInput::SelectWords << 0 << 12 << false;
QTest::newRow("<Hel(lo)>,|words")
- << standard[2] << 3 << 5 << QSGTextInput::SelectWords << 0 << 5 << true;
+ << standard[2] << 3 << 5 << QQuickTextInput::SelectWords << 0 << 5 << true;
QTest::newRow("Hello<()>,|words")
- << standard[2] << 5 << 5 << QSGTextInput::SelectWords << 5 << 5 << true;
+ << standard[2] << 5 << 5 << QQuickTextInput::SelectWords << 5 << 5 << true;
QTest::newRow("Hello,<()>|words")
- << standard[2] << 6 << 6 << QSGTextInput::SelectWords << 6 << 6 << true;
+ << standard[2] << 6 << 6 << QQuickTextInput::SelectWords << 6 << 6 << true;
QTest::newRow("Hello<,( )>world|words,ltr")
- << standard[2] << 6 << 7 << QSGTextInput::SelectWords << 5 << 7 << false;
+ << standard[2] << 6 << 7 << QQuickTextInput::SelectWords << 5 << 7 << false;
QTest::newRow("Hello,<( )world>|words,rtl")
- << standard[2] << 7 << 6 << QSGTextInput::SelectWords << 6 << 12 << false;
+ << standard[2] << 7 << 6 << QQuickTextInput::SelectWords << 6 << 12 << false;
QTest::newRow("Hello<,( world)>|words,ltr")
- << standard[2] << 6 << 12 << QSGTextInput::SelectWords << 5 << 12 << false;
+ << standard[2] << 6 << 12 << QQuickTextInput::SelectWords << 5 << 12 << false;
QTest::newRow("Hello,<( world)>|words,rtl")
- << standard[2] << 12 << 6 << QSGTextInput::SelectWords << 6 << 12 << false;
+ << standard[2] << 12 << 6 << QQuickTextInput::SelectWords << 6 << 12 << false;
QTest::newRow("Hello<,( world!)>|words,ltr")
- << standard[2] << 6 << 13 << QSGTextInput::SelectWords << 5 << 13 << false;
+ << standard[2] << 6 << 13 << QQuickTextInput::SelectWords << 5 << 13 << false;
QTest::newRow("Hello,<( world!)>|words,rtl")
- << standard[2] << 13 << 6 << QSGTextInput::SelectWords << 6 << 13 << false;
+ << standard[2] << 13 << 6 << QQuickTextInput::SelectWords << 6 << 13 << false;
QTest::newRow("Hello<(, world!)>|words")
- << standard[2] << 5 << 13 << QSGTextInput::SelectWords << 5 << 13 << true;
+ << standard[2] << 5 << 13 << QQuickTextInput::SelectWords << 5 << 13 << true;
// Fails due to an issue with QTextBoundaryFinder and punctuation at the end of strings.
// QTBUG-11365
// QTest::newRow("world<(!)>|words")
- // << standard[2] << 12 << 13 << QSGTextInput::SelectWords << 12 << 13 << true;
+ // << standard[2] << 12 << 13 << QQuickTextInput::SelectWords << 12 << 13 << true;
QTest::newRow("world!<()>)|words")
- << standard[2] << 13 << 13 << QSGTextInput::SelectWords << 13 << 13 << true;
+ << standard[2] << 13 << 13 << QQuickTextInput::SelectWords << 13 << 13 << true;
QTest::newRow("world<()>!)|words")
- << standard[2] << 12 << 12 << QSGTextInput::SelectWords << 12 << 12 << true;
+ << standard[2] << 12 << 12 << QQuickTextInput::SelectWords << 12 << 12 << true;
QTest::newRow("<(,)>olleH |words")
- << standard[3] << 7 << 8 << QSGTextInput::SelectWords << 7 << 8 << true;
+ << standard[3] << 7 << 8 << QQuickTextInput::SelectWords << 7 << 8 << true;
QTest::newRow("<dlrow( ,)>olleH|words,ltr")
- << standard[3] << 6 << 8 << QSGTextInput::SelectWords << 1 << 8 << false;
+ << standard[3] << 6 << 8 << QQuickTextInput::SelectWords << 1 << 8 << false;
QTest::newRow("dlrow<( ,)>olleH|words,rtl")
- << standard[3] << 8 << 6 << QSGTextInput::SelectWords << 6 << 8 << false;
+ << standard[3] << 8 << 6 << QQuickTextInput::SelectWords << 6 << 8 << false;
QTest::newRow("<dlrow( ,ol)leH>|words,ltr")
- << standard[3] << 6 << 10 << QSGTextInput::SelectWords << 1 << 13 << false;
+ << standard[3] << 6 << 10 << QQuickTextInput::SelectWords << 1 << 13 << false;
QTest::newRow("dlrow<( ,ol)leH>|words,rtl")
- << standard[3] << 10 << 6 << QSGTextInput::SelectWords << 6 << 13 << false;
+ << standard[3] << 10 << 6 << QQuickTextInput::SelectWords << 6 << 13 << false;
QTest::newRow(",<(ol)leH>,|words")
- << standard[3] << 8 << 10 << QSGTextInput::SelectWords << 8 << 13 << true;
+ << standard[3] << 8 << 10 << QQuickTextInput::SelectWords << 8 << 13 << true;
QTest::newRow(",<()>olleH|words")
- << standard[3] << 8 << 8 << QSGTextInput::SelectWords << 8 << 8 << true;
+ << standard[3] << 8 << 8 << QQuickTextInput::SelectWords << 8 << 8 << true;
QTest::newRow("<()>,olleH|words")
- << standard[3] << 7 << 7 << QSGTextInput::SelectWords << 7 << 7 << true;
+ << standard[3] << 7 << 7 << QQuickTextInput::SelectWords << 7 << 7 << true;
QTest::newRow("<dlrow( )>,olleH|words,ltr")
- << standard[3] << 6 << 7 << QSGTextInput::SelectWords << 1 << 7 << false;
+ << standard[3] << 6 << 7 << QQuickTextInput::SelectWords << 1 << 7 << false;
QTest::newRow("dlrow<( ),>olleH|words,rtl")
- << standard[3] << 7 << 6 << QSGTextInput::SelectWords << 6 << 8 << false;
+ << standard[3] << 7 << 6 << QQuickTextInput::SelectWords << 6 << 8 << false;
QTest::newRow("<(dlrow )>,olleH|words,ltr")
- << standard[3] << 1 << 7 << QSGTextInput::SelectWords << 1 << 7 << false;
+ << standard[3] << 1 << 7 << QQuickTextInput::SelectWords << 1 << 7 << false;
QTest::newRow("<(dlrow ),>olleH|words,rtl")
- << standard[3] << 7 << 1 << QSGTextInput::SelectWords << 1 << 8 << false;
+ << standard[3] << 7 << 1 << QQuickTextInput::SelectWords << 1 << 8 << false;
QTest::newRow("<(!dlrow )>,olleH|words,ltr")
- << standard[3] << 0 << 7 << QSGTextInput::SelectWords << 0 << 7 << false;
+ << standard[3] << 0 << 7 << QQuickTextInput::SelectWords << 0 << 7 << false;
QTest::newRow("<(!dlrow ),>olleH|words,rtl")
- << standard[3] << 7 << 0 << QSGTextInput::SelectWords << 0 << 8 << false;
+ << standard[3] << 7 << 0 << QQuickTextInput::SelectWords << 0 << 8 << false;
QTest::newRow("(!dlrow ,)olleH|words")
- << standard[3] << 0 << 8 << QSGTextInput::SelectWords << 0 << 8 << true;
+ << standard[3] << 0 << 8 << QQuickTextInput::SelectWords << 0 << 8 << true;
QTest::newRow("<(!)>dlrow|words")
- << standard[3] << 0 << 1 << QSGTextInput::SelectWords << 0 << 1 << true;
+ << standard[3] << 0 << 1 << QQuickTextInput::SelectWords << 0 << 1 << true;
QTest::newRow("<()>!dlrow|words")
- << standard[3] << 0 << 0 << QSGTextInput::SelectWords << 0 << 0 << true;
+ << standard[3] << 0 << 0 << QQuickTextInput::SelectWords << 0 << 0 << true;
QTest::newRow("!<()>dlrow|words")
- << standard[3] << 1 << 1 << QSGTextInput::SelectWords << 1 << 1 << true;
+ << standard[3] << 1 << 1 << QQuickTextInput::SelectWords << 1 << 1 << true;
QTest::newRow(" <s(pac)ey> text |words")
- << standard[4] << 1 << 4 << QSGTextInput::SelectWords << 1 << 7 << true;
+ << standard[4] << 1 << 4 << QQuickTextInput::SelectWords << 1 << 7 << true;
QTest::newRow(" spacey <t(ex)t> |words")
- << standard[4] << 11 << 13 << QSGTextInput::SelectWords << 10 << 14 << false; // Should be reversible. QTBUG-11365
+ << standard[4] << 11 << 13 << QQuickTextInput::SelectWords << 10 << 14 << false; // Should be reversible. QTBUG-11365
QTest::newRow("<( )>spacey text |words|ltr")
- << standard[4] << 0 << 1 << QSGTextInput::SelectWords << 0 << 1 << false;
+ << standard[4] << 0 << 1 << QQuickTextInput::SelectWords << 0 << 1 << false;
QTest::newRow("<( )spacey> text |words|rtl")
- << standard[4] << 1 << 0 << QSGTextInput::SelectWords << 0 << 7 << false;
+ << standard[4] << 1 << 0 << QQuickTextInput::SelectWords << 0 << 7 << false;
QTest::newRow("spacey <text( )>|words|ltr")
- << standard[4] << 14 << 15 << QSGTextInput::SelectWords << 10 << 15 << false;
+ << standard[4] << 14 << 15 << QQuickTextInput::SelectWords << 10 << 15 << false;
// QTBUG-11365
// QTest::newRow("spacey text<( )>|words|rtl")
-// << standard[4] << 15 << 14 << QSGTextInput::SelectWords << 14 << 15 << false;
+// << standard[4] << 15 << 14 << QQuickTextInput::SelectWords << 14 << 15 << false;
QTest::newRow("<()> spacey text |words")
- << standard[4] << 0 << 0 << QSGTextInput::SelectWords << 0 << 0 << false;
+ << standard[4] << 0 << 0 << QQuickTextInput::SelectWords << 0 << 0 << false;
QTest::newRow(" spacey text <()>|words")
- << standard[4] << 15 << 15 << QSGTextInput::SelectWords << 15 << 15 << false;
+ << standard[4] << 15 << 15 << QQuickTextInput::SelectWords << 15 << 15 << false;
}
-void tst_qsgtextinput::moveCursorSelection()
+void tst_qquicktextinput::moveCursorSelection()
{
QFETCH(QString, testStr);
QFETCH(int, cursorPosition);
QFETCH(int, movePosition);
- QFETCH(QSGTextInput::SelectionMode, mode);
+ QFETCH(QQuickTextInput::SelectionMode, mode);
QFETCH(int, selectionStart);
QFETCH(int, selectionEnd);
QFETCH(bool, reversible);
QString componentStr = "import QtQuick 2.0\nTextInput { text: \""+ testStr +"\"; }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
textinputObject->setCursorPosition(cursorPosition);
delete textinputObject;
}
-void tst_qsgtextinput::moveCursorSelectionSequence_data()
+void tst_qquicktextinput::moveCursorSelectionSequence_data()
{
QTest::addColumn<QString>("testStr");
QTest::addColumn<int>("cursorPosition");
// << 10 << 14;
}
-void tst_qsgtextinput::moveCursorSelectionSequence()
+void tst_qquicktextinput::moveCursorSelectionSequence()
{
QFETCH(QString, testStr);
QFETCH(int, cursorPosition);
QString componentStr = "import QtQuick 2.0\nTextInput { text: \""+ testStr +"\"; }";
QDeclarativeComponent textinputComponent(&engine);
textinputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput*>(textinputComponent.create());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput*>(textinputComponent.create());
QVERIFY(textinputObject != 0);
textinputObject->setCursorPosition(cursorPosition);
- textinputObject->moveCursorSelection(movePosition1, QSGTextInput::SelectWords);
+ textinputObject->moveCursorSelection(movePosition1, QQuickTextInput::SelectWords);
QCOMPARE(textinputObject->selectedText(), testStr.mid(selection1Start, selection1End - selection1Start));
QCOMPARE(textinputObject->selectionStart(), selection1Start);
QCOMPARE(textinputObject->selectionEnd(), selection1End);
- textinputObject->moveCursorSelection(movePosition2, QSGTextInput::SelectWords);
+ textinputObject->moveCursorSelection(movePosition2, QQuickTextInput::SelectWords);
QCOMPARE(textinputObject->selectedText(), testStr.mid(selection2Start, selection2End - selection2Start));
QCOMPARE(textinputObject->selectionStart(), selection2Start);
QCOMPARE(textinputObject->selectionEnd(), selection2End);
delete textinputObject;
}
-void tst_qsgtextinput::dragMouseSelection()
+void tst_qquicktextinput::dragMouseSelection()
{
QString qmlfile = TESTDATA("mouseselection_true.qml");
- QSGView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView canvas(QUrl::fromLocalFile(qmlfile));
canvas.show();
canvas.requestActivateWindow();
QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *textInputObject = qobject_cast<QSGTextInput *>(canvas.rootObject());
+ QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
QVERIFY(textInputObject != 0);
// press-and-drag-and-release from x1 to x2
QVERIFY(str1 != str2);
}
-void tst_qsgtextinput::mouseSelectionMode_data()
+void tst_qquicktextinput::mouseSelectionMode_data()
{
QTest::addColumn<QString>("qmlfile");
QTest::addColumn<bool>("selectWords");
QTest::newRow("default") << TESTDATA("mouseselectionmode_default.qml") << false;
}
-void tst_qsgtextinput::mouseSelectionMode()
+void tst_qquicktextinput::mouseSelectionMode()
{
QFETCH(QString, qmlfile);
QFETCH(bool, selectWords);
QString text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
- QSGView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView canvas(QUrl::fromLocalFile(qmlfile));
canvas.show();
canvas.requestActivateWindow();
QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *textInputObject = qobject_cast<QSGTextInput *>(canvas.rootObject());
+ QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
QVERIFY(textInputObject != 0);
// press-and-drag-and-release from x1 to x2
}
}
-void tst_qsgtextinput::horizontalAlignment_data()
+void tst_qquicktextinput::horizontalAlignment_data()
{
QTest::addColumn<int>("hAlign");
QTest::addColumn<QString>("expectfile");
QTest::newRow("C") << int(Qt::AlignHCenter) << "halign_center";
}
-void tst_qsgtextinput::horizontalAlignment()
+void tst_qquicktextinput::horizontalAlignment()
{
QSKIP("Image comparison of text is almost guaranteed to fail during development");
QFETCH(int, hAlign);
QFETCH(QString, expectfile);
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("horizontalAlignment.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("horizontalAlignment.qml")));
canvas.show();
canvas.requestActivateWindow();
QCOMPARE(actual,expect);
}
-void tst_qsgtextinput::horizontalAlignment_RightToLeft()
+void tst_qquicktextinput::horizontalAlignment_RightToLeft()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("horizontalAlignment_RightToLeft.qml")));
- QSGTextInput *textInput = canvas.rootObject()->findChild<QSGTextInput*>("text");
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("horizontalAlignment_RightToLeft.qml")));
+ QQuickTextInput *textInput = canvas.rootObject()->findChild<QQuickTextInput*>("text");
QVERIFY(textInput != 0);
canvas.show();
const QString rtlText = textInput->text();
- QSGTextInputPrivate *textInputPrivate = QSGTextInputPrivate::get(textInput);
+ QQuickTextInputPrivate *textInputPrivate = QQuickTextInputPrivate::get(textInput);
QVERIFY(textInputPrivate != 0);
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
// implicit alignment should follow the reading direction of RTL text
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
// explicitly left aligned
- textInput->setHAlign(QSGTextInput::AlignLeft);
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignLeft);
+ textInput->setHAlign(QQuickTextInput::AlignLeft);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
QVERIFY(-textInputPrivate->hscroll < canvas.width()/2);
// explicitly right aligned
- textInput->setHAlign(QSGTextInput::AlignRight);
+ textInput->setHAlign(QQuickTextInput::AlignRight);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
// explicitly center aligned
- textInput->setHAlign(QSGTextInput::AlignHCenter);
+ textInput->setHAlign(QQuickTextInput::AlignHCenter);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignHCenter);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignHCenter);
QVERIFY(-textInputPrivate->hscroll < canvas.width()/2);
QVERIFY(-textInputPrivate->hscroll + textInputPrivate->width > canvas.width()/2);
// reseted alignment should go back to following the text reading direction
textInput->resetHAlign();
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
// mirror the text item
- QSGItemPrivate::get(textInput)->setLayoutMirror(true);
+ QQuickItemPrivate::get(textInput)->setLayoutMirror(true);
// mirrored implicit alignment should continue to follow the reading direction of the text
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
// explicitly right aligned behaves as left aligned
- textInput->setHAlign(QSGTextInput::AlignRight);
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
- QCOMPARE(textInput->effectiveHAlign(), QSGTextInput::AlignLeft);
+ textInput->setHAlign(QQuickTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
+ QCOMPARE(textInput->effectiveHAlign(), QQuickTextInput::AlignLeft);
QVERIFY(-textInputPrivate->hscroll < canvas.width()/2);
// mirrored explicitly left aligned behaves as right aligned
- textInput->setHAlign(QSGTextInput::AlignLeft);
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignLeft);
- QCOMPARE(textInput->effectiveHAlign(), QSGTextInput::AlignRight);
+ textInput->setHAlign(QQuickTextInput::AlignLeft);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
+ QCOMPARE(textInput->effectiveHAlign(), QQuickTextInput::AlignRight);
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
// disable mirroring
- QSGItemPrivate::get(textInput)->setLayoutMirror(false);
+ QQuickItemPrivate::get(textInput)->setLayoutMirror(false);
QCOMPARE(textInput->effectiveHAlign(), textInput->hAlign());
textInput->resetHAlign();
// English text should be implicitly left aligned
textInput->setText("Hello world!");
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignLeft);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
QVERIFY(-textInputPrivate->hscroll < canvas.width()/2);
canvas.requestActivateWindow();
textInput->setText(QString());
{ QInputMethodEvent ev(rtlText, QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(&canvas, &ev); }
QEXPECT_FAIL("", "QTBUG-21691", Continue);
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
{ QInputMethodEvent ev("Hello world!", QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(&canvas, &ev); }
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignLeft);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
#ifndef Q_OS_MAC // QTBUG-18040
// empty text with implicit alignment follows the system locale-based
// keyboard input direction from QGuiApplication::keyboardInputDirection
textInput->setText("");
QCOMPARE(textInput->hAlign(), QGuiApplication::keyboardInputDirection() == Qt::LeftToRight ?
- QSGTextInput::AlignLeft : QSGTextInput::AlignRight);
+ QQuickTextInput::AlignLeft : QQuickTextInput::AlignRight);
if (QGuiApplication::keyboardInputDirection() == Qt::LeftToRight)
QVERIFY(-textInputPrivate->hscroll < canvas.width()/2);
else
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
- textInput->setHAlign(QSGTextInput::AlignRight);
- QCOMPARE(textInput->hAlign(), QSGTextInput::AlignRight);
+ textInput->setHAlign(QQuickTextInput::AlignRight);
+ QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
QVERIFY(-textInputPrivate->hscroll > canvas.width()/2);
#endif
QString componentStr = "import QtQuick 2.0\nTextInput {}";
QDeclarativeComponent textComponent(&engine);
textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
- QSGTextInput *textObject = qobject_cast<QSGTextInput*>(textComponent.create());
+ QQuickTextInput *textObject = qobject_cast<QQuickTextInput*>(textComponent.create());
QCOMPARE(textObject->hAlign(), QGuiApplication::keyboardInputDirection() == Qt::LeftToRight ?
- QSGTextInput::AlignLeft : QSGTextInput::AlignRight);
+ QQuickTextInput::AlignLeft : QQuickTextInput::AlignRight);
delete textObject;
#endif
}
-void tst_qsgtextinput::positionAt()
+void tst_qquicktextinput::positionAt()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("positionAt.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("positionAt.qml")));
QVERIFY(canvas.rootObject() != 0);
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput *>(canvas.rootObject());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
QVERIFY(textinputObject != 0);
// Check autoscrolled...
#endif
int x = textinputObject->positionToRectangle(pos + 1).x() - 1;
- QCOMPARE(textinputObject->positionAt(x, QSGTextInput::CursorBetweenCharacters), pos + 1);
- QCOMPARE(textinputObject->positionAt(x, QSGTextInput::CursorOnCharacter), pos);
+ QCOMPARE(textinputObject->positionAt(x, QQuickTextInput::CursorBetweenCharacters), pos + 1);
+ QCOMPARE(textinputObject->positionAt(x, QQuickTextInput::CursorOnCharacter), pos);
// Check without autoscroll...
textinputObject->setAutoScroll(false);
#endif
x = textinputObject->positionToRectangle(pos + 1).x() - 1;
- QCOMPARE(textinputObject->positionAt(x, QSGTextInput::CursorBetweenCharacters), pos + 1);
- QCOMPARE(textinputObject->positionAt(x, QSGTextInput::CursorOnCharacter), pos);
+ QCOMPARE(textinputObject->positionAt(x, QQuickTextInput::CursorBetweenCharacters), pos + 1);
+ QCOMPARE(textinputObject->positionAt(x, QQuickTextInput::CursorOnCharacter), pos);
const qreal x0 = textinputObject->positionToRectangle(pos).x();
const qreal x1 = textinputObject->positionToRectangle(pos + 1).x();
QCOMPARE(textinputObject->positionToRectangle(1).x(), x1);
}
-void tst_qsgtextinput::maxLength()
+void tst_qquicktextinput::maxLength()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("maxLength.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("maxLength.qml")));
QVERIFY(canvas.rootObject() != 0);
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput *>(canvas.rootObject());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
QVERIFY(textinputObject != 0);
QVERIFY(textinputObject->text().isEmpty());
QVERIFY(textinputObject->maxLength() == 10);
}
}
-void tst_qsgtextinput::masks()
+void tst_qquicktextinput::masks()
{
//Not a comprehensive test of the possible masks, that's done elsewhere (QLineEdit)
//QString componentStr = "import QtQuick 2.0\nTextInput { inputMask: 'HHHHhhhh'; }";
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("masks.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("masks.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *textinputObject = qobject_cast<QSGTextInput *>(canvas.rootObject());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
QVERIFY(textinputObject != 0);
QTRY_VERIFY(textinputObject->hasActiveFocus() == true);
QVERIFY(textinputObject->text().length() == 0);
}
}
-void tst_qsgtextinput::validators()
+void tst_qquicktextinput::validators()
{
// Note that this test assumes that the validators are working properly
// so you may need to run their tests first. All validators are checked
// here to ensure that their exposure to QML is working.
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("validators.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("validators.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *intInput = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("intInput")));
+ QQuickTextInput *intInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("intInput")));
QVERIFY(intInput);
intInput->setFocus(true);
QTRY_VERIFY(intInput->hasActiveFocus());
QCOMPARE(intInput->text(), QLatin1String("11"));
QCOMPARE(intInput->hasAcceptableInput(), true);
- QSGTextInput *dblInput = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("dblInput")));
+ QQuickTextInput *dblInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("dblInput")));
QTRY_VERIFY(dblInput);
dblInput->setFocus(true);
QVERIFY(dblInput->hasActiveFocus() == true);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QSGTextInput *strInput = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("strInput")));
+ QQuickTextInput *strInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("strInput")));
QTRY_VERIFY(strInput);
strInput->setFocus(true);
QVERIFY(strInput->hasActiveFocus() == true);
QCOMPARE(strInput->hasAcceptableInput(), true);
}
-void tst_qsgtextinput::inputMethods()
+void tst_qquicktextinput::inputMethods()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("inputmethods.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("inputmethods.qml")));
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
// test input method hints
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput *>(canvas.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(canvas.rootObject());
QVERIFY(input != 0);
QVERIFY(input->inputMethodHints() & Qt::ImhNoPredictiveText);
input->setInputMethodHints(Qt::ImhUppercaseOnly);
the extent of the text, then they should ignore the keys.
*/
-void tst_qsgtextinput::navigation()
+void tst_qquicktextinput::navigation()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(input != 0);
input->setCursorPosition(0);
QCOMPARE(input->cursorPosition(),2);
}
-void tst_qsgtextinput::navigation_RTL()
+void tst_qquicktextinput::navigation_RTL()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("navigation.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(input != 0);
const quint16 arabic_str[] = { 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0647};
QVERIFY(input->hasActiveFocus() == true);
}
-void tst_qsgtextinput::copyAndPaste() {
+void tst_qquicktextinput::copyAndPaste() {
#ifndef QT_NO_CLIPBOARD
#ifdef Q_WS_MAC
QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\" }";
QDeclarativeComponent textInputComponent(&engine);
textInputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textInput = qobject_cast<QSGTextInput*>(textInputComponent.create());
+ QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
// copy and paste
// when echo mode is set to hide text/password mode
int index = 0;
while (index < 4) {
- QSGTextInput::EchoMode echoMode = QSGTextInput::EchoMode(index);
+ QQuickTextInput::EchoMode echoMode = QQuickTextInput::EchoMode(index);
textInput->setEchoMode(echoMode);
textInput->setText("My password");
textInput->select(0, textInput->text().length());;
textInput->copy();
- if (echoMode == QSGTextInput::Normal) {
+ if (echoMode == QQuickTextInput::Normal) {
QVERIFY(!clipboard->text().isEmpty());
QCOMPARE(clipboard->text(), QString("My password"));
clipboard->clear();
#endif
}
-void tst_qsgtextinput::canPasteEmpty() {
+void tst_qquicktextinput::canPasteEmpty() {
#ifndef QT_NO_CLIPBOARD
QGuiApplication::clipboard()->clear();
QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\" }";
QDeclarativeComponent textInputComponent(&engine);
textInputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textInput = qobject_cast<QSGTextInput*>(textInputComponent.create());
+ QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
QLineControl lc;
#endif
}
-void tst_qsgtextinput::canPaste() {
+void tst_qquicktextinput::canPaste() {
#ifndef QT_NO_CLIPBOARD
QGuiApplication::clipboard()->setText("Some text");
QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\" }";
QDeclarativeComponent textInputComponent(&engine);
textInputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textInput = qobject_cast<QSGTextInput*>(textInputComponent.create());
+ QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
QLineControl lc;
#endif
}
-void tst_qsgtextinput::passwordCharacter()
+void tst_qquicktextinput::passwordCharacter()
{
QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\"; font.family: \"Helvetica\"; echoMode: TextInput.Password }";
QDeclarativeComponent textInputComponent(&engine);
textInputComponent.setData(componentStr.toLatin1(), QUrl());
- QSGTextInput *textInput = qobject_cast<QSGTextInput*>(textInputComponent.create());
+ QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
textInput->setPasswordCharacter("X");
delete textInput;
}
-void tst_qsgtextinput::cursorDelegate()
+void tst_qquicktextinput::cursorDelegate()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("cursorTest.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("cursorTest.qml")));
view.show();
view.requestActivateWindow();
- QSGTextInput *textInputObject = view.rootObject()->findChild<QSGTextInput*>("textInputObject");
+ QQuickTextInput *textInputObject = view.rootObject()->findChild<QQuickTextInput*>("textInputObject");
QVERIFY(textInputObject != 0);
- QVERIFY(textInputObject->findChild<QSGItem*>("cursorInstance"));
+ QVERIFY(textInputObject->findChild<QQuickItem*>("cursorInstance"));
//Test Delegate gets created
textInputObject->setFocus(true);
- QSGItem* delegateObject = textInputObject->findChild<QSGItem*>("cursorInstance");
+ QQuickItem* delegateObject = textInputObject->findChild<QQuickItem*>("cursorInstance");
QVERIFY(delegateObject);
QCOMPARE(delegateObject->property("localProperty").toString(), QString("Hello"));
//Test Delegate gets moved
QCOMPARE(textInputObject->cursorRectangle().y(), qRound(delegateObject->y()));
//Test Delegate gets deleted
textInputObject->setCursorDelegate(0);
- QVERIFY(!textInputObject->findChild<QSGItem*>("cursorInstance"));
+ QVERIFY(!textInputObject->findChild<QQuickItem*>("cursorInstance"));
}
-void tst_qsgtextinput::cursorVisible()
+void tst_qquicktextinput::cursorVisible()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("cursorVisible.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("cursorVisible.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput input;
+ QQuickTextInput input;
QSignalSpy spy(&input, SIGNAL(cursorVisibleChanged(bool)));
QCOMPARE(input.isCursorVisible(), false);
#endif
}
-void tst_qsgtextinput::cursorRectangle()
+void tst_qquicktextinput::cursorRectangle()
{
QSKIP("QTBUG-21689");
QString text = "Hello World!";
- QSGTextInput input;
+ QQuickTextInput input;
input.setText(text);
QFontMetricsF fm(input.font());
input.setWidth(fm.width(text.mid(0, 5)));
}
input.setText("Hi!");
- input.setHAlign(QSGTextInput::AlignRight);
+ input.setHAlign(QQuickTextInput::AlignRight);
r = input.cursorRectangle();
QVERIFY(r.left() < input.boundingRect().width());
QVERIFY(r.right() >= input.width() - error);
}
-void tst_qsgtextinput::readOnly()
+void tst_qquicktextinput::readOnly()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("readOnly.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("readOnly.qml")));
canvas.show();
canvas.requestActivateWindow();
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
QCOMPARE(input->cursorPosition(), input->text().length());
}
-void tst_qsgtextinput::echoMode()
+void tst_qquicktextinput::echoMode()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("echoMode.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("echoMode.qml")));
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
QString initial = input->text();
Qt::InputMethodHints ref;
QCOMPARE(initial, QLatin1String("ABCDefgh"));
- QCOMPARE(input->echoMode(), QSGTextInput::Normal);
+ QCOMPARE(input->echoMode(), QQuickTextInput::Normal);
QCOMPARE(input->displayText(), input->text());
//Normal
ref &= ~Qt::ImhHiddenText;
ref &= ~(Qt::ImhNoAutoUppercase | Qt::ImhNoPredictiveText);
QCOMPARE(input->inputMethodHints(), ref);
- input->setEchoMode(QSGTextInput::NoEcho);
+ input->setEchoMode(QQuickTextInput::NoEcho);
QCOMPARE(input->text(), initial);
QCOMPARE(input->displayText(), QLatin1String(""));
QCOMPARE(input->passwordCharacter(), QLatin1String("*"));
ref |= Qt::ImhHiddenText;
ref |= (Qt::ImhNoAutoUppercase | Qt::ImhNoPredictiveText);
QCOMPARE(input->inputMethodHints(), ref);
- input->setEchoMode(QSGTextInput::Password);
+ input->setEchoMode(QQuickTextInput::Password);
//Password
ref |= Qt::ImhHiddenText;
ref |= (Qt::ImhNoAutoUppercase | Qt::ImhNoPredictiveText);
QCOMPARE(input->passwordCharacter(), QLatin1String("Q"));
QCOMPARE(input->text(), initial);
QCOMPARE(input->displayText(), QLatin1String("QQQQQQQQ"));
- input->setEchoMode(QSGTextInput::PasswordEchoOnEdit);
+ input->setEchoMode(QQuickTextInput::PasswordEchoOnEdit);
//PasswordEchoOnEdit
ref &= ~Qt::ImhHiddenText;
ref |= (Qt::ImhNoAutoUppercase | Qt::ImhNoPredictiveText);
#ifdef QT_GUI_PASSWORD_ECHO_DELAY
void tst_qdeclarativetextinput::passwordEchoDelay()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("echoMode.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("echoMode.qml")));
canvas.show();
canvas.setFocus();
QGuiApplication::setActiveWindow(&canvas);
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
QChar fillChar = QLatin1Char('*');
#endif
-void tst_qsgtextinput::simulateKey(QSGView *view, int key)
+void tst_qquicktextinput::simulateKey(QQuickView *view, int key)
{
QKeyEvent press(QKeyEvent::KeyPress, key, 0);
QKeyEvent release(QKeyEvent::KeyRelease, key, 0);
};
#endif
-void tst_qsgtextinput::openInputPanel()
+void tst_qquicktextinput::openInputPanel()
{
- QSGView view(QUrl::fromLocalFile(TESTDATA("openInputPanel.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("openInputPanel.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput *input = qobject_cast<QSGTextInput *>(view.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
QVERIFY(input);
// check default values
// input panel should stay visible if focus is lost to another text inputor
QSignalSpy inputPanelVisibilitySpy(qApp->inputPanel(), SIGNAL(visibleChanged()));
- QSGTextInput anotherInput;
+ QQuickTextInput anotherInput;
anotherInput.setParentItem(view.rootObject());
anotherInput.setFocus(true);
QCOMPARE(qApp->inputPanel()->visible(), true);
anotherInput.setFocus(true);
// input item should be null if focus is lost to an item that doesn't accept inputs
- QSGItem item;
+ QQuickItem item;
item.setParentItem(view.rootObject());
item.setFocus(true);
QCOMPARE(qApp->inputPanel()->inputItem(), static_cast<QObject*>(0));
QCOMPARE(qApp->inputPanel()->visible(), false);
}
-class MyTextInput : public QSGTextInput
+class MyTextInput : public QQuickTextInput
{
public:
- MyTextInput(QSGItem *parent = 0) : QSGTextInput(parent)
+ MyTextInput(QQuickItem *parent = 0) : QQuickTextInput(parent)
{
nbPaint = 0;
}
virtual QSGNode *updatePaintNode(QSGNode *node, UpdatePaintNodeData *data)
{
nbPaint++;
- return QSGTextInput::updatePaintNode(node, data);
+ return QQuickTextInput::updatePaintNode(node, data);
}
int nbPaint;
};
-void tst_qsgtextinput::setHAlignClearCache()
+void tst_qquicktextinput::setHAlignClearCache()
{
- QSGView view;
+ QQuickView view;
MyTextInput input;
input.setText("Hello world");
input.setParentItem(view.rootItem());
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(input.nbPaint, 1);
- input.setHAlign(QSGTextInput::AlignRight);
+ input.setHAlign(QQuickTextInput::AlignRight);
//Changing the alignment should trigger a repaint
QTRY_COMPARE(input.nbPaint, 2);
}
-void tst_qsgtextinput::focusOutClearSelection()
+void tst_qquicktextinput::focusOutClearSelection()
{
- QSGView view;
- QSGTextInput input;
- QSGTextInput input2;
+ QQuickView view;
+ QQuickTextInput input;
+ QQuickTextInput input2;
input.setText(QLatin1String("Hello world"));
input.setFocus(true);
input2.setParentItem(view.rootItem());
QTRY_COMPARE(input.selectedText(), QLatin1String(""));
}
-void tst_qsgtextinput::geometrySignals()
+void tst_qquicktextinput::geometrySignals()
{
QDeclarativeComponent component(&engine, TESTDATA("geometrySignals.qml"));
QObject *o = component.create();
delete o;
}
-void tst_qsgtextinput::testQtQuick11Attributes()
+void tst_qquicktextinput::testQtQuick11Attributes()
{
QFETCH(QString, code);
QFETCH(QString, warning);
delete obj;
}
-void tst_qsgtextinput::testQtQuick11Attributes_data()
+void tst_qquicktextinput::testQtQuick11Attributes_data()
{
QTest::addColumn<QString>("code");
QTest::addColumn<QString>("warning");
<< "";
}
-void tst_qsgtextinput::preeditAutoScroll()
+void tst_qquicktextinput::preeditAutoScroll()
{
#ifdef QTBUG_21691
QEXPECT_FAIL("", QTBUG_21691_MESSAGE, Abort);
#else
QString preeditText = "califragisiticexpialidocious!";
- QSGView view(QUrl::fromLocalFile(TESTDATA("preeditAutoScroll.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("preeditAutoScroll.qml")));
MyInputContext ic;
- // QSGCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has active focus
+ // QQuickCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has active focus
// and QWidget won't allow an input context to be set when the flag is not set.
view.setAttribute(Qt::WA_InputMethodEnabled, true);
view.setInputContext(&ic);
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput *input = qobject_cast<QSGTextInput *>(view.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
QVERIFY(input);
QSignalSpy cursorRectangleSpy(input, SIGNAL(cursorRectangleChanged()));
#endif
}
-void tst_qsgtextinput::preeditMicroFocus()
+void tst_qquicktextinput::preeditMicroFocus()
{
#ifdef QTBUG_21691
QEXPECT_FAIL("", QTBUG_21691_MESSAGE, Abort);
#else
QString preeditText = "super";
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputMethodEvent.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputMethodEvent.qml")));
MyInputContext ic;
- // QSGCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has active focus
+ // QQuickCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has active focus
// and QWidget won't allow an input context to be set when the flag is not set.
view.setAttribute(Qt::WA_InputMethodEnabled, true);
view.setInputContext(&ic);
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput *input = qobject_cast<QSGTextInput *>(view.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
QVERIFY(input);
QRect currentRect;
#endif
}
-void tst_qsgtextinput::inputContextMouseHandler()
+void tst_qquicktextinput::inputContextMouseHandler()
{
#ifdef QTBUG_21691
QEXPECT_FAIL("", QTBUG_21691_MESSAGE, Abort);
#else
QString text = "supercalifragisiticexpialidocious!";
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
MyInputContext ic;
- // QSGCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has active focus
+ // QQuickCanvas won't set the Qt::WA_InputMethodEnabled flag unless a suitable item has active focus
// and QWidget won't allow an input context to be set when the flag is not set.
view.setAttribute(Qt::WA_InputMethodEnabled, true);
view.setInputContext(&ic);
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput *input = qobject_cast<QSGTextInput *>(view.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
QVERIFY(input);
QFontMetricsF fm(input->font());
#endif
}
-void tst_qsgtextinput::inputMethodComposing()
+void tst_qquicktextinput::inputMethodComposing()
{
QString text = "supercalifragisiticexpialidocious!";
- QSGView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
+ QQuickView view(QUrl::fromLocalFile(TESTDATA("inputContext.qml")));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput *input = qobject_cast<QSGTextInput *>(view.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
QVERIFY(input);
QSignalSpy spy(input, SIGNAL(inputMethodComposingChanged()));
QCOMPARE(spy.count(), 2);
}
-void tst_qsgtextinput::cursorRectangleSize()
+void tst_qquicktextinput::cursorRectangleSize()
{
- QSGView *canvas = new QSGView(QUrl::fromLocalFile(TESTDATA("positionAt.qml")));
+ QQuickView *canvas = new QQuickView(QUrl::fromLocalFile(TESTDATA("positionAt.qml")));
QVERIFY(canvas->rootObject() != 0);
canvas->show();
canvas->requestActivateWindow();
QTest::qWaitForWindowShown(canvas);
- QSGTextInput *textInput = qobject_cast<QSGTextInput *>(canvas->rootObject());
+ QQuickTextInput *textInput = qobject_cast<QQuickTextInput *>(canvas->rootObject());
QVERIFY(textInput != 0);
textInput->setFocus(Qt::OtherFocusReason);
QRectF cursorRect = textInput->positionToRectangle(textInput->cursorPosition());
delete canvas;
}
-void tst_qsgtextinput::tripleClickSelectsAll()
+void tst_qquicktextinput::tripleClickSelectsAll()
{
QString qmlfile = TESTDATA("positionAt.qml");
- QSGView view(QUrl::fromLocalFile(qmlfile));
+ QQuickView view(QUrl::fromLocalFile(qmlfile));
view.show();
view.requestActivateWindow();
QTest::qWaitForWindowShown(&view);
QTRY_COMPARE(&view, qGuiApp->focusWindow());
- QSGTextInput* input = qobject_cast<QSGTextInput*>(view.rootObject());
+ QQuickTextInput* input = qobject_cast<QQuickTextInput*>(view.rootObject());
QVERIFY(input);
QLatin1String hello("Hello world!");
QVERIFY(input->selectedText().isEmpty());
}
-void tst_qsgtextinput::QTBUG_19956_data()
+void tst_qquicktextinput::QTBUG_19956_data()
{
QTest::addColumn<QString>("url");
QTest::newRow("intvalidator") << "qtbug-19956int.qml";
QTest::newRow("doublevalidator") << "qtbug-19956double.qml";
}
-void tst_qsgtextinput::QTBUG_19956()
+void tst_qquicktextinput::QTBUG_19956()
{
QFETCH(QString, url);
- QSGView canvas(QUrl::fromLocalFile(TESTDATA(url)));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA(url)));
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput*>(canvas.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput*>(canvas.rootObject());
QVERIFY(input);
input->setFocus(true);
QVERIFY(input->hasActiveFocus());
QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
}
-void tst_qsgtextinput::QTBUG_19956_regexp()
+void tst_qquicktextinput::QTBUG_19956_regexp()
{
- QSGView canvas(QUrl::fromLocalFile(TESTDATA("qtbug-19956regexp.qml")));
+ QQuickView canvas(QUrl::fromLocalFile(TESTDATA("qtbug-19956regexp.qml")));
canvas.show();
canvas.requestActivateWindow();
QTest::qWaitForWindowShown(&canvas);
QVERIFY(canvas.rootObject() != 0);
- QSGTextInput *input = qobject_cast<QSGTextInput*>(canvas.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput*>(canvas.rootObject());
QVERIFY(input);
input->setFocus(true);
QVERIFY(input->hasActiveFocus());
QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
}
-QTEST_MAIN(tst_qsgtextinput)
+QTEST_MAIN(tst_qquicktextinput)
-#include "tst_qsgtextinput.moc"
+#include "tst_qquicktextinput.moc"
CONFIG += testcase
-TARGET = tst_qsgview
+TARGET = tst_qquickview
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgview.cpp
+SOURCES += tst_qquickview.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtTest/QSignalSpy>
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativecontext.h>
-#include <QtDeclarative/qsgview.h>
-#include <QtDeclarative/qsgitem.h>
+#include <QtDeclarative/qquickview.h>
+#include <QtDeclarative/qquickitem.h>
#include "../shared/util.h"
#include <QtGui/QWindow>
#include <QtCore/QDebug>
-class tst_QSGView : public QObject
+class tst_QQuickView : public QObject
{
Q_OBJECT
public:
- tst_QSGView();
+ tst_QQuickView();
private slots:
void resizemodeitem();
};
-tst_QSGView::tst_QSGView()
+tst_QQuickView::tst_QQuickView()
{
}
-void tst_QSGView::resizemodeitem()
+void tst_QQuickView::resizemodeitem()
{
QWindow window;
window.setGeometry(0, 0, 400, 400);
- QSGView *canvas = new QSGView(&window);
+ QQuickView *canvas = new QQuickView(&window);
QVERIFY(canvas);
- canvas->setResizeMode(QSGView::SizeRootObjectToView);
+ canvas->setResizeMode(QQuickView::SizeRootObjectToView);
QCOMPARE(QSize(0,0), canvas->initialSize());
canvas->setSource(QUrl::fromLocalFile(TESTDATA("resizemodeitem.qml")));
- QSGItem* item = qobject_cast<QSGItem*>(canvas->rootObject());
+ QQuickItem* item = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(item);
window.show();
QCOMPARE(canvas->size(), QSize(80, 100));
QCOMPARE(canvas->size(), canvas->sizeHint());
- canvas->setResizeMode(QSGView::SizeViewToRootObject);
+ canvas->setResizeMode(QQuickView::SizeViewToRootObject);
// size update from view disabled
canvas->resize(QSize(60,80));
// reset canvas
window.hide();
delete canvas;
- canvas = new QSGView(&window);
+ canvas = new QQuickView(&window);
QVERIFY(canvas);
- canvas->setResizeMode(QSGView::SizeViewToRootObject);
+ canvas->setResizeMode(QQuickView::SizeViewToRootObject);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("resizemodeitem.qml")));
- item = qobject_cast<QSGItem*>(canvas->rootObject());
+ item = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(item);
window.show();
QCOMPARE(canvas->size(), canvas->sizeHint());
// size update from root object disabled
- canvas->setResizeMode(QSGView::SizeRootObjectToView);
+ canvas->setResizeMode(QQuickView::SizeRootObjectToView);
item->setWidth(60);
item->setHeight(80);
QCOMPARE(canvas->width(), 80);
// if we set a specific size for the view then it should keep that size
// for SizeRootObjectToView mode.
- canvas = new QSGView(&window);
+ canvas = new QQuickView(&window);
canvas->resize(300, 300);
- canvas->setResizeMode(QSGView::SizeRootObjectToView);
+ canvas->setResizeMode(QQuickView::SizeRootObjectToView);
QCOMPARE(QSize(0,0), canvas->initialSize());
canvas->setSource(QUrl::fromLocalFile(TESTDATA("resizemodeitem.qml")));
canvas->resize(300, 300);
- item = qobject_cast<QSGItem*>(canvas->rootObject());
+ item = qobject_cast<QQuickItem*>(canvas->rootObject());
QVERIFY(item);
window.show();
{
}
-void tst_QSGView::errors()
+void tst_QQuickView::errors()
{
- QSGView *canvas = new QSGView;
+ QQuickView *canvas = new QQuickView;
QVERIFY(canvas);
QtMsgHandler old = qInstallMsgHandler(silentErrorsMsgHandler);
canvas->setSource(QUrl::fromLocalFile(TESTDATA("error1.qml")));
qInstallMsgHandler(old);
- QVERIFY(canvas->status() == QSGView::Error);
+ QVERIFY(canvas->status() == QQuickView::Error);
QVERIFY(canvas->errors().count() == 1);
delete canvas;
}
-QTEST_MAIN(tst_QSGView)
+QTEST_MAIN(tst_QQuickView)
-#include "tst_qsgview.moc"
+#include "tst_qquickview.moc"
CONFIG += testcase
-TARGET = tst_qsgvisualdatamodel
+TARGET = tst_qquickvisualdatamodel
macx:CONFIG -= app_bundle
-SOURCES += tst_qsgvisualdatamodel.cpp
+SOURCES += tst_qquickvisualdatamodel.cpp
testDataFiles.files = data
testDataFiles.path = .
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <QtDeclarative/qdeclarativeexpression.h>
-#include <QtDeclarative/qsgview.h>
-#include <private/qsglistview_p.h>
-#include <private/qsgtext_p.h>
-#include <private/qsgvisualdatamodel_p.h>
+#include <QtDeclarative/qquickview.h>
+#include <private/qquicklistview_p.h>
+#include <private/qquicktext_p.h>
+#include <private/qquickvisualdatamodel_p.h>
#include <private/qdeclarativevaluetype_p.h>
#include <private/qdeclarativechangeset_p.h>
#include <private/qdeclarativeengine_p.h>
};
-class tst_qsgvisualdatamodel : public QObject
+class tst_qquickvisualdatamodel : public QObject
{
Q_OBJECT
public:
- tst_qsgvisualdatamodel();
+ tst_qquickvisualdatamodel();
private slots:
void initTestCase();
private:
template <int N> void groups_verify(
const SingleRoleModel &model,
- QSGItem *contentItem,
+ QQuickItem *contentItem,
const int (&mIndex)[N],
const int (&iIndex)[N],
const int (&vIndex)[N],
template <int N> void get_verify(
const SingleRoleModel &model,
- QSGVisualDataModel *visualModel,
- QSGVisualDataGroup *visibleItems,
- QSGVisualDataGroup *selectedItems,
+ QQuickVisualDataModel *visualModel,
+ QQuickVisualDataGroup *visibleItems,
+ QQuickVisualDataGroup *selectedItems,
const int (&mIndex)[N],
const int (&iIndex)[N],
const int (&vIndex)[N],
bool failed;
QDeclarativeEngine engine;
template<typename T>
- T *findItem(QSGItem *parent, const QString &objectName, int index);
+ T *findItem(QQuickItem *parent, const QString &objectName, int index);
};
Q_DECLARE_METATYPE(QDeclarativeChangeSet)
-void tst_qsgvisualdatamodel::initTestCase()
+void tst_qquickvisualdatamodel::initTestCase()
{
qRegisterMetaType<QDeclarativeChangeSet>();
}
-void tst_qsgvisualdatamodel::cleanupTestCase()
+void tst_qquickvisualdatamodel::cleanupTestCase()
{
}
qWarning() << expr.error().toString();
}
-tst_qsgvisualdatamodel::tst_qsgvisualdatamodel()
+tst_qquickvisualdatamodel::tst_qquickvisualdatamodel()
{
}
-void tst_qsgvisualdatamodel::rootIndex()
+void tst_qquickvisualdatamodel::rootIndex()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, QUrl::fromLocalFile(TESTDATA("visualdatamodel.qml")));
engine.rootContext()->setContextProperty("myModel", &model);
- QSGVisualDataModel *obj = qobject_cast<QSGVisualDataModel*>(c.create());
+ QQuickVisualDataModel *obj = qobject_cast<QQuickVisualDataModel*>(c.create());
QVERIFY(obj != 0);
QMetaObject::invokeMethod(obj, "setRoot");
delete obj;
}
-void tst_qsgvisualdatamodel::updateLayout()
+void tst_qquickvisualdatamodel::updateLayout()
{
- QSGView view;
+ QQuickView view;
QStandardItemModel model;
initStandardTreeModel(&model);
view.setSource(QUrl::fromLocalFile(TESTDATA("datalist.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGText *name = findItem<QSGText>(contentItem, "display", 0);
+ QQuickText *name = findItem<QQuickText>(contentItem, "display", 0);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 1 Item"));
- name = findItem<QSGText>(contentItem, "display", 1);
+ name = findItem<QQuickText>(contentItem, "display", 1);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 2 Item"));
- name = findItem<QSGText>(contentItem, "display", 2);
+ name = findItem<QQuickText>(contentItem, "display", 2);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 3 Item"));
model.invisibleRootItem()->sortChildren(0, Qt::DescendingOrder);
- name = findItem<QSGText>(contentItem, "display", 0);
+ name = findItem<QQuickText>(contentItem, "display", 0);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 3 Item"));
- name = findItem<QSGText>(contentItem, "display", 1);
+ name = findItem<QQuickText>(contentItem, "display", 1);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 2 Item"));
- name = findItem<QSGText>(contentItem, "display", 2);
+ name = findItem<QQuickText>(contentItem, "display", 2);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 1 Item"));
}
-void tst_qsgvisualdatamodel::childChanged()
+void tst_qquickvisualdatamodel::childChanged()
{
- QSGView view;
+ QQuickView view;
QStandardItemModel model;
initStandardTreeModel(&model);
view.setSource(QUrl::fromLocalFile(TESTDATA("datalist.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGVisualDataModel *vdm = listview->findChild<QSGVisualDataModel*>("visualModel");
+ QQuickVisualDataModel *vdm = listview->findChild<QQuickVisualDataModel*>("visualModel");
vdm->setRootIndex(QVariant::fromValue(model.indexFromItem(model.item(1,0))));
QCOMPARE(listview->count(), 1);
- QSGText *name = findItem<QSGText>(contentItem, "display", 0);
+ QQuickText *name = findItem<QQuickText>(contentItem, "display", 0);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 2 Child Item"));
model.item(1,0)->child(0,0)->setText("Row 2 updated child");
- name = findItem<QSGText>(contentItem, "display", 0);
+ name = findItem<QQuickText>(contentItem, "display", 0);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 2 updated child"));
model.item(1,0)->appendRow(new QStandardItem(QLatin1String("Row 2 Child Item 2")));
QCOMPARE(listview->count(), 2);
- name = findItem<QSGText>(contentItem, "display", 1);
+ name = findItem<QQuickText>(contentItem, "display", 1);
QVERIFY(name != 0);
QCOMPARE(name->text(), QString("Row 2 Child Item 2"));
model.item(1,0)->takeRow(1);
- name = findItem<QSGText>(contentItem, "display", 1);
+ name = findItem<QQuickText>(contentItem, "display", 1);
QVERIFY(name == 0);
vdm->setRootIndex(QVariant::fromValue(QModelIndex()));
QCOMPARE(listview->count(), 3);
- name = findItem<QSGText>(contentItem, "display", 0);
+ name = findItem<QQuickText>(contentItem, "display", 0);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 1 Item"));
- name = findItem<QSGText>(contentItem, "display", 1);
+ name = findItem<QQuickText>(contentItem, "display", 1);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 2 Item"));
- name = findItem<QSGText>(contentItem, "display", 2);
+ name = findItem<QQuickText>(contentItem, "display", 2);
QVERIFY(name);
QCOMPARE(name->text(), QString("Row 3 Item"));
}
-void tst_qsgvisualdatamodel::objectListModel()
+void tst_qquickvisualdatamodel::objectListModel()
{
- QSGView view;
+ QQuickView view;
QList<QObject*> dataList;
dataList.append(new DataObject("Item 1", "red"));
view.setSource(QUrl::fromLocalFile(TESTDATA("objectlist.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGText *name = findItem<QSGText>(contentItem, "name", 0);
+ QQuickText *name = findItem<QQuickText>(contentItem, "name", 0);
QCOMPARE(name->text(), QString("Item 1"));
- QSGText *section = findItem<QSGText>(contentItem, "section", 0);
+ QQuickText *section = findItem<QQuickText>(contentItem, "section", 0);
QCOMPARE(section->text(), QString("Item 1"));
dataList[0]->setProperty("name", QLatin1String("Changed"));
QCOMPARE(name->text(), QString("Changed"));
}
-void tst_qsgvisualdatamodel::singleRole()
+void tst_qquickvisualdatamodel::singleRole()
{
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
view.setSource(QUrl::fromLocalFile(TESTDATA("singlerole1.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGText *name = findItem<QSGText>(contentItem, "name", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "name", 1);
QCOMPARE(name->text(), QString("two"));
model.set(1, "Changed");
QCOMPARE(name->text(), QString("Changed"));
}
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
view.setSource(QUrl::fromLocalFile(TESTDATA("singlerole2.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGText *name = findItem<QSGText>(contentItem, "name", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "name", 1);
QCOMPARE(name->text(), QString("two"));
model.set(1, "Changed");
QCOMPARE(name->text(), QString("Changed"));
}
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model("modelData");
view.setSource(QUrl::fromLocalFile(TESTDATA("singlerole2.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGText *name = findItem<QSGText>(contentItem, "name", 1);
+ QQuickText *name = findItem<QQuickText>(contentItem, "name", 1);
QCOMPARE(name->text(), QString("two"));
model.set(1, "Changed");
}
}
-void tst_qsgvisualdatamodel::modelProperties()
+void tst_qquickvisualdatamodel::modelProperties()
{
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
view.setSource(QUrl::fromLocalFile(TESTDATA("modelproperties.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", 1);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", 1);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(),QString("two"));
QCOMPARE(delegate->property("test2").toString(),QString("two"));
}
{
- QSGView view;
+ QQuickView view;
QList<QObject*> dataList;
dataList.append(new DataObject("Item 1", "red"));
view.setSource(QUrl::fromLocalFile(TESTDATA("modelproperties.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", 1);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", 1);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(),QString("Item 2"));
QCOMPARE(delegate->property("test2").toString(),QString("Item 2"));
}
{
- QSGView view;
+ QQuickView view;
QStandardItemModel model;
initStandardTreeModel(&model);
view.setSource(source);
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", 1);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", 1);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(),QString("Row 2 Item"));
QCOMPARE(delegate->property("test2").toString(),QString("Row 2 Item"));
//### should also test QStringList and QVariantList
}
-void tst_qsgvisualdatamodel::noDelegate()
+void tst_qquickvisualdatamodel::noDelegate()
{
- QSGView view;
+ QQuickView view;
QStandardItemModel model;
initStandardTreeModel(&model);
view.setSource(QUrl::fromLocalFile(TESTDATA("datalist.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGVisualDataModel *vdm = listview->findChild<QSGVisualDataModel*>("visualModel");
+ QQuickVisualDataModel *vdm = listview->findChild<QQuickVisualDataModel*>("visualModel");
QVERIFY(vdm != 0);
QCOMPARE(vdm->count(), 3);
}
-void tst_qsgvisualdatamodel::qaimRowsMoved()
+void tst_qquickvisualdatamodel::qaimRowsMoved()
{
// Test parameters passed in QAIM::rowsMoved() signal are converted correctly
// when translated and emitted as the QListModelInterface::itemsMoved() signal
model.list << ("item " + i);
engine.rootContext()->setContextProperty("myModel", &model);
- QSGVisualDataModel *obj = qobject_cast<QSGVisualDataModel*>(c.create());
+ QQuickVisualDataModel *obj = qobject_cast<QQuickVisualDataModel*>(c.create());
QVERIFY(obj != 0);
QSignalSpy spy(obj, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)));
delete obj;
}
-void tst_qsgvisualdatamodel::qaimRowsMoved_data()
+void tst_qquickvisualdatamodel::qaimRowsMoved_data()
{
QTest::addColumn<int>("sourceFirst");
QTest::addColumn<int>("sourceLast");
<< 10 << 1 << 5;
}
-void tst_qsgvisualdatamodel::remove()
+void tst_qquickvisualdatamodel::remove()
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
model.list = QStringList()
view.setSource(QUrl::fromLocalFile(TESTDATA("groups.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGVisualDataModel *visualModel = qobject_cast<QSGVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
+ QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
{
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
}
}
-void tst_qsgvisualdatamodel::move()
+void tst_qquickvisualdatamodel::move()
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
model.list = QStringList()
view.setSource(QUrl::fromLocalFile(TESTDATA("groups.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGVisualDataModel *visualModel = qobject_cast<QSGVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
+ QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
{
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
static const int iIndex[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 };
for (int i = 0; i < lengthOf(mIndex); ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt(), mIndex[i]);
}
-template <int N> void tst_qsgvisualdatamodel::groups_verify(
+template <int N> void tst_qquickvisualdatamodel::groups_verify(
const SingleRoleModel &model,
- QSGItem *contentItem,
+ QQuickItem *contentItem,
const int (&mIndex)[N],
const int (&iIndex)[N],
const int (&vIndex)[N],
{
failed = true;
for (int i = 0; i < N; ++i) {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", mIndex[i]);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", mIndex[i]);
QVERIFY(delegate);
QCOMPARE(delegate->property("test1").toString(), model.list.at(mIndex[i]));
QCOMPARE(delegate->property("test2").toInt() , mIndex[i]);
QVERIFY(!failed)
-void tst_qsgvisualdatamodel::groups()
+void tst_qquickvisualdatamodel::groups()
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
model.list = QStringList()
view.setSource(QUrl::fromLocalFile(TESTDATA("groups.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGVisualDataModel *visualModel = qobject_cast<QSGVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
+ QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
- QSGVisualDataGroup *visibleItems = visualModel->findChild<QSGVisualDataGroup *>("visibleItems");
+ QQuickVisualDataGroup *visibleItems = visualModel->findChild<QQuickVisualDataGroup *>("visibleItems");
QVERIFY(visibleItems);
- QSGVisualDataGroup *selectedItems = visualModel->findChild<QSGVisualDataGroup *>("selectedItems");
+ QQuickVisualDataGroup *selectedItems = visualModel->findChild<QQuickVisualDataGroup *>("selectedItems");
QVERIFY(selectedItems);
const bool f = false;
QCOMPARE(visibleItems->count(), 9);
QCOMPARE(selectedItems->count(), 2);
} {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", 5);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", 5);
QVERIFY(delegate);
evaluate<void>(delegate, "hide()");
static const bool sMember[] = { f, f, f, f, f, f, f, f, t, t, f, f };
VERIFY_GROUPS;
} {
- QSGItem *delegate = findItem<QSGItem>(contentItem, "delegate", 5);
+ QQuickItem *delegate = findItem<QQuickItem>(contentItem, "delegate", 5);
QVERIFY(delegate);
evaluate<void>(delegate, "select()");
}
}
-template <int N> void tst_qsgvisualdatamodel::get_verify(
+template <int N> void tst_qquickvisualdatamodel::get_verify(
const SingleRoleModel &model,
- QSGVisualDataModel *visualModel,
- QSGVisualDataGroup *visibleItems,
- QSGVisualDataGroup *selectedItems,
+ QQuickVisualDataModel *visualModel,
+ QQuickVisualDataGroup *visibleItems,
+ QQuickVisualDataGroup *selectedItems,
const int (&mIndex)[N],
const int (&iIndex)[N],
const int (&vIndex)[N],
get_verify(model, visualModel, visibleItems, selectedItems, mIndex, iIndex, vIndex, sIndex, vMember, sMember); \
QVERIFY(!failed)
-void tst_qsgvisualdatamodel::get()
+void tst_qquickvisualdatamodel::get()
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
model.list = QStringList()
view.setSource(QUrl::fromLocalFile(TESTDATA("groups.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGVisualDataModel *visualModel = qobject_cast<QSGVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
+ QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
- QSGVisualDataGroup *visibleItems = visualModel->findChild<QSGVisualDataGroup *>("visibleItems");
+ QQuickVisualDataGroup *visibleItems = visualModel->findChild<QQuickVisualDataGroup *>("visibleItems");
QVERIFY(visibleItems);
- QSGVisualDataGroup *selectedItems = visualModel->findChild<QSGVisualDataGroup *>("selectedItems");
+ QQuickVisualDataGroup *selectedItems = visualModel->findChild<QQuickVisualDataGroup *>("selectedItems");
QVERIFY(selectedItems);
QV8Engine *v8Engine = QDeclarativeEnginePrivate::getV8Engine(ctxt->engine());
}
}
-void tst_qsgvisualdatamodel::create()
+void tst_qquickvisualdatamodel::create()
{
- QSGView view;
+ QQuickView view;
SingleRoleModel model;
model.list = QStringList()
view.setSource(QUrl::fromLocalFile(TESTDATA("create.qml")));
- QSGListView *listview = qobject_cast<QSGListView*>(view.rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
- QSGItem *contentItem = listview->contentItem();
+ QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
- QSGVisualDataModel *visualModel = qobject_cast<QSGVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
+ QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
QCOMPARE(listview->count(), 20);
- QSGItem *delegate;
+ QQuickItem *delegate;
// Request an item instantiated by the view.
- QVERIFY(findItem<QSGItem>(contentItem, "delegate", 1));
- QVERIFY(delegate = qobject_cast<QSGItem *>(evaluate<QObject *>(visualModel, "items.create(1)")));
- QCOMPARE(delegate, findItem<QSGItem>(contentItem, "delegate", 1));
+ QVERIFY(findItem<QQuickItem>(contentItem, "delegate", 1));
+ QVERIFY(delegate = qobject_cast<QQuickItem *>(evaluate<QObject *>(visualModel, "items.create(1)")));
+ QCOMPARE(delegate, findItem<QQuickItem>(contentItem, "delegate", 1));
QCOMPARE(evaluate<bool>(delegate, "VisualDataModel.inPersistedItems"), true);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 1);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 0);
// Request an item not instantiated by the view.
- QVERIFY(!findItem<QSGItem>(contentItem, "delegate", 15));
- QVERIFY(delegate = qobject_cast<QSGItem *>(evaluate<QObject *>(visualModel, "items.create(15)")));
- QCOMPARE(delegate, findItem<QSGItem>(contentItem, "delegate", 15));
+ QVERIFY(!findItem<QQuickItem>(contentItem, "delegate", 15));
+ QVERIFY(delegate = qobject_cast<QQuickItem *>(evaluate<QObject *>(visualModel, "items.create(15)")));
+ QCOMPARE(delegate, findItem<QQuickItem>(contentItem, "delegate", 15));
QCOMPARE(evaluate<bool>(delegate, "VisualDataModel.inPersistedItems"), true);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 1);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 0);
// Request an item not instantiated by the view, then scroll the view so it will request it.
- QVERIFY(!findItem<QSGItem>(contentItem, "delegate", 16));
- QVERIFY(delegate = qobject_cast<QSGItem *>(evaluate<QObject *>(visualModel, "items.create(16)")));
- QCOMPARE(delegate, findItem<QSGItem>(contentItem, "delegate", 16));
+ QVERIFY(!findItem<QQuickItem>(contentItem, "delegate", 16));
+ QVERIFY(delegate = qobject_cast<QQuickItem *>(evaluate<QObject *>(visualModel, "items.create(16)")));
+ QCOMPARE(delegate, findItem<QQuickItem>(contentItem, "delegate", 16));
QCOMPARE(evaluate<bool>(delegate, "VisualDataModel.inPersistedItems"), true);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 1);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 0);
// Request and release an item instantiated by the view, then scroll the view so it releases it.
- QVERIFY(findItem<QSGItem>(contentItem, "delegate", 17));
- QVERIFY(delegate = qobject_cast<QSGItem *>(evaluate<QObject *>(visualModel, "items.create(17)")));
- QCOMPARE(delegate, findItem<QSGItem>(contentItem, "delegate", 17));
+ QVERIFY(findItem<QQuickItem>(contentItem, "delegate", 17));
+ QVERIFY(delegate = qobject_cast<QQuickItem *>(evaluate<QObject *>(visualModel, "items.create(17)")));
+ QCOMPARE(delegate, findItem<QQuickItem>(contentItem, "delegate", 17));
QCOMPARE(evaluate<bool>(delegate, "VisualDataModel.inPersistedItems"), true);
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 1);
// the view it will be persisted.
evaluate<void>(visualModel, "items.addGroups(18, \"persistedItems\")");
QCOMPARE(evaluate<int>(visualModel, "persistedItems.count"), 1);
- QVERIFY(!findItem<QSGItem>(contentItem, "delegate", 18));
+ QVERIFY(!findItem<QQuickItem>(contentItem, "delegate", 18));
evaluate<void>(listview, "positionViewAtIndex(19, ListView.End)");
QCOMPARE(listview->count(), 20);
- QVERIFY(delegate = findItem<QSGItem>(contentItem, "delegate", 18));
+ QVERIFY(delegate = findItem<QQuickItem>(contentItem, "delegate", 18));
QCOMPARE(evaluate<bool>(delegate, "VisualDataModel.inPersistedItems"), true);
QCOMPARE(evaluate<bool>(delegate, "destroyed"), false);
evaluate<void>(listview, "positionViewAtIndex(1, ListView.Beginning)");
}
template<typename T>
-T *tst_qsgvisualdatamodel::findItem(QSGItem *parent, const QString &objectName, int index)
+T *tst_qquickvisualdatamodel::findItem(QQuickItem *parent, const QString &objectName, int index)
{
const QMetaObject &mo = T::staticMetaObject;
//qDebug() << parent->childItems().count() << "children";
for (int i = 0; i < parent->childItems().count(); ++i) {
- QSGItem *item = qobject_cast<QSGItem*>(parent->childItems().at(i));
+ QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
//qDebug() << "try" << item;
return 0;
}
-QTEST_MAIN(tst_qsgvisualdatamodel)
+QTEST_MAIN(tst_qquickvisualdatamodel)
-#include "tst_qsgvisualdatamodel.moc"
+#include "tst_qquickvisualdatamodel.moc"
void tst_qsgage::test_kill()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/kill.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/kill.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgage::test_jump()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/jump.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/jump.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgage::test_onceOff()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/onceoff.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/onceoff.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgage::test_sustained()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/sustained.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/sustained.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
//TODO: Ensure some particles have lived to 0.4s point despite unified timer
void tst_qsgangleddirection::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgcumulativedirection::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgcustomaffector::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgcustomparticle::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QVERIFY(view);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgellipseextruder::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgfriction::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsggravity::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgimageparticle::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgimageparticle::test_colored()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/colored.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/colored.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgimageparticle::test_deformed()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/deformed.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/deformed.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgimageparticle::test_tabled()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/tabled.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/tabled.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgimageparticle::test_sprite()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/sprite.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/sprite.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
#include <QtTest/QtTest>
#include "../shared/particlestestsshared.h"
#include <private/qsgparticlesystem_p.h>
-#include <private/qsgimage_p.h>
+#include <private/qquickimage_p.h>
#include <private/qabstractanimation_p.h>
class tst_qsgitemparticle : public QObject
void tst_qsgitemparticle::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
if (d->t < ((qreal)system->timeInt/1000.0) - 0.45)//Delegates cleared on death
continue;
QVERIFY(d->delegate);
- QVERIFY(qobject_cast<QSGImage*>(d->delegate));
+ QVERIFY(qobject_cast<QQuickImage*>(d->delegate));
}
}
void tst_qsglineextruder::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgmaskextruder::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgparticlegroup::test_instantTransition()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgparticlesystem::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgpointattractor::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgpointdirection::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgrectangleextruder::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgtargetdirection::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgtrailemitter::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgturbulence::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
void tst_qsgwander::test_basic()
{
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml", 600);
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
#ifndef PARTICLES_TESTS_SHARED
#define PARTICLES_TESTS_SHARED
-#include <QSGView>
+#include <QQuickView>
#include <QtTest>
#include <QAbstractAnimation>
const qreal EPSILON = 0.0001;
return (a + EPSILON > b);
}
-QSGView* createView(const QString &filename, int additionalWait=0)
+QQuickView* createView(const QString &filename, int additionalWait=0)
{
- QSGView *canvas = new QSGView(0);
+ QQuickView *canvas = new QQuickView(0);
canvas->setSource(QUrl::fromLocalFile(filename));
- if (canvas->status() != QSGView::Ready)
+ if (canvas->status() != QQuickView::Ready)
return 0;
canvas->show();
QTest::qWaitForWindowShown(canvas);
function test_invalidSciFile() {
- ignoreWarning("QSGGridScaledImage: Invalid tile rule specified. Using Stretch.") // for "Roun"
- ignoreWarning("QSGGridScaledImage: Invalid tile rule specified. Using Stretch.") // for "Repea"
+ ignoreWarning("QQuickGridScaledImage: Invalid tile rule specified. Using Stretch.") // for "Roun"
+ ignoreWarning("QQuickGridScaledImage: Invalid tile rule specified. Using Stretch.") // for "Repea"
var component = Qt.createComponent("InvalidSciFile.qml")
var invalidSciFile = component.createObject(top)
void tst_affectors::test_basic()
{
QFETCH(int, dt);
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml");
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml");
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
//Pretend we're running, but we manually advance the simulation
system->m_running = true;
void tst_affectors::test_filtered()
{
QFETCH(int, dt);
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/filtered.qml");
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/filtered.qml");
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
//Pretend we're running, but we manually advance the simulation
system->m_running = true;
void tst_emission::test_basic()
{
QFETCH(int, dt);
- QSGView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml");
+ QQuickView* view = createView(QCoreApplication::applicationDirPath() + "/data/basic.qml");
QSGParticleSystem* system = view->rootObject()->findChild<QSGParticleSystem*>("system");
//Pretend we're running, but we manually advance the simulation
system->m_running = true;
#include <QtDeclarative/QtDeclarative>
#include <QtDeclarative/private/qdeclarativemetatype_p.h>
#include <QtDeclarative/private/qdeclarativeopenmetaobject_p.h>
-#include <QtDeclarative/private/qsgevents_p_p.h>
-#include <QtDeclarative/private/qsgpincharea_p.h>
+#include <QtDeclarative/private/qquickevents_p_p.h>
+#include <QtDeclarative/private/qquickpincharea_p.h>
#include <QtWidgets/QApplication>
QList<QDeclarativeType *> defaultTypes = QDeclarativeMetaType::qmlTypes();
// add some otherwise unreachable QMetaObjects
- defaultReachable.insert(&QSGMouseEvent::staticMetaObject);
- // QSGKeyEvent, QSGPinchEvent, QSGDropEvent are not exported
+ defaultReachable.insert(&QQuickMouseEvent::staticMetaObject);
+ // QQuickKeyEvent, QQuickPinchEvent, QQuickDropEvent are not exported
// this will hold the meta objects we want to dump information of
QSet<const QMetaObject *> metas;
#include <QtDeclarative/qdeclarativecontext.h>
// ### This should be private API
-#include <qsgitem.h>
-#include <qsgview.h>
+#include <qquickitem.h>
+#include <qquickview.h>
#define QT_NO_SCENEGRAPHITEM
}
#endif
-class MyQSGView : public QSGView
+class MyQQuickView : public QQuickView
{
public:
- MyQSGView() : QSGView()
+ MyQQuickView() : QQuickView()
{
- setResizeMode(QSGView::SizeRootObjectToView);
+ setResizeMode(QQuickView::SizeRootObjectToView);
}
};
#endif
if (options.versionDetection)
checkAndAdaptVersion(options.file);
- QSGView *qxView = new MyQSGView();
+ QQuickView *qxView = new MyQQuickView();
qxView->setVSyncAnimations(options.vsync);
engine = qxView->engine();
for (int i = 0; i < imports.size(); ++i)
projects / profile / ivi / qtdeclarative.git / commitdiff
