-
Matthew Vogt authored
Change-Id: Iad2f07b989b25349fd2d4fff010e24dcd5a1688f
0284817d
qquickitem_p.h 29.00 KiB
/******************************************************************************** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).** Contact: http://www.qt-project.org/**** This file is part of the QtQml module of the Qt Toolkit.**** $QT_BEGIN_LICENSE:LGPL$** GNU Lesser General Public License Usage** This file may be used under the terms of the GNU Lesser General Public** License version 2.1 as published by the Free Software Foundation and** appearing in the file LICENSE.LGPL included in the packaging of this** file. Please review the following information to ensure the GNU Lesser** General Public License version 2.1 requirements will be met:** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.**** In addition, as a special exception, Nokia gives you certain additional** rights. These rights are described in the Nokia Qt LGPL Exception** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.**** GNU General Public License Usage** Alternatively, this file may be used under the terms of the GNU General** Public License version 3.0 as published by the Free Software Foundation** and appearing in the file LICENSE.GPL included in the packaging of this** file. Please review the following information to ensure the GNU General** Public License version 3.0 requirements will be met:** http://www.gnu.org/copyleft/gpl.html.**** Other Usage** Alternatively, this file may be used in accordance with the terms and** conditions contained in a signed written agreement between you and Nokia.************** $QT_END_LICENSE$******************************************************************************/#ifndef QQUICKITEM_P_H#define QQUICKITEM_P_H//// W A R N I N G// -------------//// This file is not part of the Qt API. It exists purely as an// implementation detail. This header file may change from version to// version without notice, or even be removed.//// We mean it.//#include "qquickitem.h"#include "qquickanchors_p.h"#include "qquickanchors_p_p.h"#include "qquickitemchangelistener_p.h"#include "qquickcanvas_p.h"#include <QtQuick/qsgnode.h>#include "qquickclipnode_p.h"#include <private/qpodvector_p.h>#include <QtQuick/private/qquickstate_p.h>#include <private/qqmlnullablevalue_p_p.h>#include <private/qqmlnotifier_p.h>7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
#include <private/qqmlglobal_p.h>
#include <private/qlazilyallocated_p.h>
#include <qqml.h>
#include <qqmlcontext.h>
#include <QtCore/qlist.h>
#include <QtCore/qdebug.h>
#include <QtCore/qelapsedtimer.h>
#include <QtQuick/private/qquickshadereffectsource_p.h>
#include <QtQuick/private/qquickshadereffect_p.h>
QT_BEGIN_NAMESPACE
class QNetworkReply;
class QQuickItemKeyFilter;
class QQuickLayoutMirroringAttached;
class QQuickScreenAttached;
class QQuickContents : public QQuickItemChangeListener
{
public:
QQuickContents(QQuickItem *item);
~QQuickContents();
QRectF rectF() const { return QRectF(m_x, m_y, m_width, m_height); }
inline void calcGeometry(QQuickItem *changed = 0);
void complete();
protected:
void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
void itemDestroyed(QQuickItem *item);
void itemChildAdded(QQuickItem *, QQuickItem *);
void itemChildRemoved(QQuickItem *, QQuickItem *);
//void itemVisibilityChanged(QQuickItem *item)
private:
bool calcHeight(QQuickItem *changed = 0);
bool calcWidth(QQuickItem *changed = 0);
void updateRect();
QQuickItem *m_item;
qreal m_x;
qreal m_y;
qreal m_width;
qreal m_height;
};
void QQuickContents::calcGeometry(QQuickItem *changed)
{
bool wChanged = calcWidth(changed);
bool hChanged = calcHeight(changed);
if (wChanged || hChanged)
updateRect();
}
class QQuickTransformPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QQuickTransform);
public:
static QQuickTransformPrivate* get(QQuickTransform *transform) { return transform->d_func(); }
QQuickTransformPrivate();
QList<QQuickItem *> items;
};
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
class QQuickItemLayer : public QObject, public QQuickItemChangeListener
{
Q_OBJECT
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
Q_PROPERTY(QSize textureSize READ size WRITE setSize NOTIFY sizeChanged)
Q_PROPERTY(QRectF sourceRect READ sourceRect WRITE setSourceRect NOTIFY sourceRectChanged)
Q_PROPERTY(bool mipmap READ mipmap WRITE setMipmap NOTIFY mipmapChanged)
Q_PROPERTY(bool smooth READ smooth WRITE setSmooth NOTIFY smoothChanged)
Q_PROPERTY(QQuickShaderEffectSource::WrapMode wrapMode READ wrapMode WRITE setWrapMode NOTIFY wrapModeChanged)
Q_PROPERTY(QQuickShaderEffectSource::Format format READ format WRITE setFormat NOTIFY formatChanged)
Q_PROPERTY(QByteArray samplerName READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(QQmlComponent *effect READ effect WRITE setEffect NOTIFY effectChanged)
public:
QQuickItemLayer(QQuickItem *item);
~QQuickItemLayer();
void classBegin();
void componentComplete();
bool enabled() const { return m_enabled; }
void setEnabled(bool enabled);
bool mipmap() const { return m_mipmap; }
void setMipmap(bool mipmap);
bool smooth() const { return m_smooth; }
void setSmooth(bool s);
QSize size() const { return m_size; }
void setSize(const QSize &size);
QQuickShaderEffectSource::Format format() const { return m_format; }
void setFormat(QQuickShaderEffectSource::Format f);
QRectF sourceRect() const { return m_sourceRect; }
void setSourceRect(const QRectF &sourceRect);
QQuickShaderEffectSource::WrapMode wrapMode() const { return m_wrapMode; }
void setWrapMode(QQuickShaderEffectSource::WrapMode mode);
QByteArray name() const { return m_name; }
void setName(const QByteArray &name);
QQmlComponent *effect() const { return m_effectComponent; }
void setEffect(QQmlComponent *effect);
QQuickShaderEffectSource *effectSource() const { return m_effectSource; }
void itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &);
void itemOpacityChanged(QQuickItem *);
void itemParentChanged(QQuickItem *, QQuickItem *);
void itemSiblingOrderChanged(QQuickItem *);
void itemVisibilityChanged(QQuickItem *);
void updateMatrix();
void updateGeometry();
void updateOpacity();
void updateZ();
signals:
void enabledChanged(bool enabled);
void sizeChanged(const QSize &size);
void mipmapChanged(bool mipmap);
void wrapModeChanged(QQuickShaderEffectSource::WrapMode mode);
void nameChanged(const QByteArray &name);
void effectChanged(QQmlComponent *component);
void smoothChanged(bool smooth);
void formatChanged(QQuickShaderEffectSource::Format format);
void sourceRectChanged(const QRectF &sourceRect);
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
private:
void activate();
void deactivate();
void activateEffect();
void deactivateEffect();
QQuickItem *m_item;
bool m_enabled;
bool m_mipmap;
bool m_smooth;
bool m_componentComplete;
QQuickShaderEffectSource::WrapMode m_wrapMode;
QQuickShaderEffectSource::Format m_format;
QSize m_size;
QRectF m_sourceRect;
QByteArray m_name;
QQmlComponent *m_effectComponent;
QQuickItem *m_effect;
QQuickShaderEffectSource *m_effectSource;
};
class Q_QUICK_EXPORT QQuickItemPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QQuickItem)
public:
static QQuickItemPrivate* get(QQuickItem *item) { return item->d_func(); }
static const QQuickItemPrivate* get(const QQuickItem *item) { return item->d_func(); }
static void registerAccessorProperties();
QQuickItemPrivate();
~QQuickItemPrivate();
void init(QQuickItem *parent);
QQmlListProperty<QObject> data();
QQmlListProperty<QObject> resources();
QQmlListProperty<QQuickItem> children();
QQmlListProperty<QQuickItem> visibleChildren();
QQmlListProperty<QQuickState> states();
QQmlListProperty<QQuickTransition> transitions();
QString state() const;
void setState(const QString &);
QQuickAnchorLine left() const;
QQuickAnchorLine right() const;
QQuickAnchorLine horizontalCenter() const;
QQuickAnchorLine top() const;
QQuickAnchorLine bottom() const;
QQuickAnchorLine verticalCenter() const;
QQuickAnchorLine baseline() const;
QQuickItemLayer *layer() const;
// data property
static void data_append(QQmlListProperty<QObject> *, QObject *);
static int data_count(QQmlListProperty<QObject> *);
static QObject *data_at(QQmlListProperty<QObject> *, int);
static void data_clear(QQmlListProperty<QObject> *);
// resources property
static QObject *resources_at(QQmlListProperty<QObject> *, int);
static void resources_append(QQmlListProperty<QObject> *, QObject *);
static int resources_count(QQmlListProperty<QObject> *);
static void resources_clear(QQmlListProperty<QObject> *);
// children property
static void children_append(QQmlListProperty<QQuickItem> *, QQuickItem *);
281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350
static int children_count(QQmlListProperty<QQuickItem> *);
static QQuickItem *children_at(QQmlListProperty<QQuickItem> *, int);
static void children_clear(QQmlListProperty<QQuickItem> *);
// visibleChildren property
static void visibleChildren_append(QQmlListProperty<QQuickItem> *prop, QQuickItem *o);
static int visibleChildren_count(QQmlListProperty<QQuickItem> *prop);
static QQuickItem *visibleChildren_at(QQmlListProperty<QQuickItem> *prop, int index);
// transform property
static int transform_count(QQmlListProperty<QQuickTransform> *list);
static void transform_append(QQmlListProperty<QQuickTransform> *list, QQuickTransform *);
static QQuickTransform *transform_at(QQmlListProperty<QQuickTransform> *list, int);
static void transform_clear(QQmlListProperty<QQuickTransform> *list);
enum ChangeType {
Geometry = 0x01,
SiblingOrder = 0x02,
Visibility = 0x04,
Opacity = 0x08,
Destroyed = 0x10,
Parent = 0x20,
Children = 0x40,
Rotation = 0x80,
};
Q_DECLARE_FLAGS(ChangeTypes, ChangeType)
enum GeometryChangeType {
NoChange = 0,
XChange = 0x01,
YChange = 0x02,
WidthChange = 0x04,
HeightChange = 0x08,
SizeChange = WidthChange | HeightChange,
GeometryChange = XChange | YChange | SizeChange
};
Q_DECLARE_FLAGS(GeometryChangeTypes, GeometryChangeType)
struct ChangeListener {
ChangeListener(QQuickItemChangeListener *l, QQuickItemPrivate::ChangeTypes t) : listener(l), types(t), gTypes(GeometryChange) {}
ChangeListener(QQuickItemChangeListener *l, QQuickItemPrivate::GeometryChangeTypes gt) : listener(l), types(Geometry), gTypes(gt) {}
QQuickItemChangeListener *listener;
QQuickItemPrivate::ChangeTypes types;
QQuickItemPrivate::GeometryChangeTypes gTypes; //NOTE: not used for ==
bool operator==(const ChangeListener &other) const { return listener == other.listener && types == other.types; }
};
struct ExtraData {
ExtraData();
qreal z;
qreal scale;
qreal rotation;
qreal opacity;
QQuickContents *contents;
QQuickScreenAttached *screenAttached;
QQuickLayoutMirroringAttached* layoutDirectionAttached;
QQuickItemKeyFilter *keyHandler;
mutable QQuickItemLayer *layer;
QPointF userTransformOriginPoint;
int effectRefCount;
int hideRefCount;
QSGOpacityNode *opacityNode;
QQuickDefaultClipNode *clipNode;
QSGRootNode *rootNode;
351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
QSGNode *beforePaintNode;
// Although acceptedMouseButtons is inside ExtraData, we actually store
// the LeftButton flag in the extra.flag() bit. This is because it is
// extremely common to set acceptedMouseButtons to LeftButton, but very
// rare to use any of the other buttons.
Qt::MouseButtons acceptedMouseButtons;
QQuickItem::TransformOrigin origin:5;
};
QLazilyAllocated<ExtraData> extra;
QQuickAnchors *anchors() const;
mutable QQuickAnchors *_anchors;
inline Qt::MouseButtons acceptedMouseButtons() const;
QPODVector<QQuickItemPrivate::ChangeListener,4> changeListeners;
void addItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types);
void removeItemChangeListener(QQuickItemChangeListener *, ChangeTypes types);
void updateOrAddGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types);
void updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types);
QQuickStateGroup *_states();
QQuickStateGroup *_stateGroup;
inline QQuickItem::TransformOrigin origin() const;
// Bit 0
quint32 flags:5;
bool widthValid:1;
bool heightValid:1;
bool baselineOffsetValid:1;
bool componentComplete:1;
bool keepMouse:1;
bool keepTouch:1;
bool hoverEnabled:1;
bool smooth:1;
bool focus:1;
bool activeFocus:1;
bool notifiedFocus:1;
// Bit 16
bool notifiedActiveFocus:1;
bool filtersChildMouseEvents:1;
bool explicitVisible:1;
bool effectiveVisible:1;
bool explicitEnable:1;
bool effectiveEnable:1;
bool polishScheduled:1;
bool inheritedLayoutMirror:1;
bool effectiveLayoutMirror:1;
bool isMirrorImplicit:1;
bool inheritMirrorFromParent:1;
bool inheritMirrorFromItem:1;
bool childrenDoNotOverlap:1;
bool staticSubtreeGeometry:1;
bool isAccessible:1;
// bool dummy:1
// Bit 32
enum DirtyType {
TransformOrigin = 0x00000001,
Transform = 0x00000002,
BasicTransform = 0x00000004,
Position = 0x00000008,
Size = 0x00000010,
ZValue = 0x00000020,
Content = 0x00000040,
421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490
Smooth = 0x00000080,
OpacityValue = 0x00000100,
ChildrenChanged = 0x00000200,
ChildrenStackingChanged = 0x00000400,
ParentChanged = 0x00000800,
Clip = 0x00001000,
Canvas = 0x00002000,
EffectReference = 0x00008000,
Visible = 0x00010000,
HideReference = 0x00020000,
PerformanceHints = 0x00040000,
// When you add an attribute here, don't forget to update
// dirtyToString()
TransformUpdateMask = TransformOrigin | Transform | BasicTransform | Position |
Size | Canvas,
ComplexTransformUpdateMask = Transform | Canvas,
ContentUpdateMask = Size | Content | Smooth | Canvas,
ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Canvas
};
quint32 dirtyAttributes;
QString dirtyToString() const;
void dirty(DirtyType);
void addToDirtyList();
void removeFromDirtyList();
QQuickItem *nextDirtyItem;
QQuickItem**prevDirtyItem;
QQuickCanvas *canvas;
inline QSGContext *sceneGraphContext() const;
QQuickItem *parentItem;
QQmlNotifier parentNotifier;
QList<QQuickItem *> childItems;
mutable QList<QQuickItem *> *sortedChildItems;
QList<QQuickItem *> paintOrderChildItems() const;
void addChild(QQuickItem *);
void removeChild(QQuickItem *);
void siblingOrderChanged();
inline void markSortedChildrenDirty(QQuickItem *child);
class InitializationState {
public:
QQuickItem *getFocusScope(QQuickItem *item);
void clear();
void clear(QQuickItem *focusScope);
private:
QQuickItem *focusScope;
};
void initCanvas(InitializationState *, QQuickCanvas *);
QQuickItem *subFocusItem;
QTransform canvasToItemTransform() const;
QTransform itemToCanvasTransform() const;
void itemToParentTransform(QTransform &) const;
qreal x;
qreal y;
qreal width;
qreal height;
qreal implicitWidth;
qreal implicitHeight;
qreal baselineOffset;
491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560
QList<QQuickTransform *> transforms;
inline qreal z() const { return extra.isAllocated()?extra->z:0; }
inline qreal scale() const { return extra.isAllocated()?extra->scale:1; }
inline qreal rotation() const { return extra.isAllocated()?extra->rotation:0; }
inline qreal opacity() const { return extra.isAllocated()?extra->opacity:1; }
void setAccessibleFlagAndListener();
virtual qreal getImplicitWidth() const;
virtual qreal getImplicitHeight() const;
virtual void implicitWidthChanged();
virtual void implicitHeightChanged();
void resolveLayoutMirror();
void setImplicitLayoutMirror(bool mirror, bool inherit);
void setLayoutMirror(bool mirror);
bool isMirrored() const {
return effectiveLayoutMirror;
}
void emitChildrenRectChanged(const QRectF &rect) {
Q_Q(QQuickItem);
emit q->childrenRectChanged(rect);
}
QPointF computeTransformOrigin() const;
virtual void transformChanged();
void deliverKeyEvent(QKeyEvent *);
void deliverInputMethodEvent(QInputMethodEvent *);
void deliverFocusEvent(QFocusEvent *);
void deliverMouseEvent(QMouseEvent *);
void deliverWheelEvent(QWheelEvent *);
void deliverTouchEvent(QTouchEvent *);
void deliverHoverEvent(QHoverEvent *);
void deliverDragEvent(QEvent *);
bool calcEffectiveVisible() const;
bool setEffectiveVisibleRecur(bool);
bool calcEffectiveEnable() const;
void setEffectiveEnableRecur(QQuickItem *scope, bool);
inline QSGTransformNode *itemNode();
inline QSGNode *childContainerNode();
/*
QSGNode order is:
- itemNode
- (opacityNode)
- (clipNode)
- (effectNode)
- groupNode
*/
QSGOpacityNode *opacityNode() const { return extra.isAllocated()?extra->opacityNode:0; }
QQuickDefaultClipNode *clipNode() const { return extra.isAllocated()?extra->clipNode:0; }
QSGRootNode *rootNode() const { return extra.isAllocated()?extra->rootNode:0; }
QSGTransformNode *itemNodeInstance;
QSGNode *groupNode;
QSGNode *paintNode;
virtual QSGTransformNode *createTransformNode();
// A reference from an effect item means that this item is used by the effect, so
// it should insert a root node.
void refFromEffectItem(bool hide);
561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630
void derefFromEffectItem(bool unhide);
void itemChange(QQuickItem::ItemChange, const QQuickItem::ItemChangeData &);
virtual void mirrorChange() {}
static qint64 consistentTime;
static void setConsistentTime(qint64 t);
static void start(QElapsedTimer &);
static qint64 elapsed(QElapsedTimer &);
static qint64 restart(QElapsedTimer &);
};
/*
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 QQuickItemKeyFilter
{
public:
QQuickItemKeyFilter(QQuickItem * = 0);
virtual ~QQuickItemKeyFilter();
virtual void keyPressed(QKeyEvent *event, bool post);
virtual void keyReleased(QKeyEvent *event, bool post);
virtual void inputMethodEvent(QInputMethodEvent *event, bool post);
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
virtual void componentComplete();
bool m_processPost;
private:
QQuickItemKeyFilter *m_next;
};
class QQuickKeyNavigationAttachedPrivate : public QObjectPrivate
{
public:
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) {}
QQuickItem *left;
QQuickItem *right;
QQuickItem *up;
QQuickItem *down;
QQuickItem *tab;
QQuickItem *backtab;
bool leftSet : 1;
bool rightSet : 1;
bool upSet : 1;
bool downSet : 1;
bool tabSet : 1;
bool backtabSet : 1;
};
class QQuickKeyNavigationAttached : public QObject, public QQuickItemKeyFilter
{
Q_OBJECT
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)
631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700
Q_PROPERTY(QQuickItem *backtab READ backtab WRITE setBacktab NOTIFY backtabChanged)
Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
Q_ENUMS(Priority)
public:
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 QQuickKeyNavigationAttached *qmlAttachedProperties(QObject *);
Q_SIGNALS:
void leftChanged();
void rightChanged();
void upChanged();
void downChanged();
void tabChanged();
void backtabChanged();
void priorityChanged();
private:
virtual void keyPressed(QKeyEvent *event, bool post);
virtual void keyReleased(QKeyEvent *event, bool post);
void setFocusNavigation(QQuickItem *currentItem, const char *dir);
};
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 QQuickLayoutMirroringAttached(QObject *parent = 0);
bool enabled() const;
void setEnabled(bool);
void resetEnabled();
bool childrenInherit() const;
void setChildrenInherit(bool);
static QQuickLayoutMirroringAttached *qmlAttachedProperties(QObject *);
Q_SIGNALS:
void enabledChanged();
void childrenInheritChanged();
private:
friend class QQuickItemPrivate;
QQuickItemPrivate *itemPrivate;
};
class QQuickKeysAttachedPrivate : public QObjectPrivate
{
public:
701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770
QQuickKeysAttachedPrivate()
: QObjectPrivate(), inPress(false), inRelease(false)
, inIM(false), enabled(true), imeItem(0), item(0)
{}
bool isConnected(const char *signalName);
//loop detection
bool inPress:1;
bool inRelease:1;
bool inIM:1;
bool enabled : 1;
QQuickItem *imeItem;
QList<QQuickItem *> targets;
QQuickItem *item;
};
class QQuickKeysAttached : public QObject, public QQuickItemKeyFilter
{
Q_OBJECT
Q_DECLARE_PRIVATE(QQuickKeysAttached)
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
Q_PROPERTY(QQmlListProperty<QQuickItem> forwardTo READ forwardTo)
Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
Q_ENUMS(Priority)
public:
QQuickKeysAttached(QObject *parent=0);
~QQuickKeysAttached();
bool enabled() const { Q_D(const QQuickKeysAttached); return d->enabled; }
void setEnabled(bool enabled) {
Q_D(QQuickKeysAttached);
if (enabled != d->enabled) {
d->enabled = enabled;
emit enabledChanged();
}
}
enum Priority { BeforeItem, AfterItem};
Priority priority() const;
void setPriority(Priority);
QQmlListProperty<QQuickItem> forwardTo() {
Q_D(QQuickKeysAttached);
return QQmlListProperty<QQuickItem>(this, d->targets);
}
virtual void componentComplete();
static QQuickKeysAttached *qmlAttachedProperties(QObject *);
Q_SIGNALS:
void enabledChanged();
void priorityChanged();
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);
771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840
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);
virtual void keyReleased(QKeyEvent *event, bool post);
virtual void inputMethodEvent(QInputMethodEvent *, bool post);
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
const QByteArray keyToSignal(int key) {
QByteArray keySignal;
if (key >= Qt::Key_0 && key <= Qt::Key_9) {
keySignal = "digit0Pressed";
keySignal[5] = '0' + (key - Qt::Key_0);
} else {
int i = 0;
while (sigMap[i].key && sigMap[i].key != key)
++i;
keySignal = sigMap[i].sig;
}
return keySignal;
}
struct SigMap {
int key;
const char *sig;
};
static const SigMap sigMap[];
};
Qt::MouseButtons QQuickItemPrivate::acceptedMouseButtons() const
{
return ((extra.flag() ? Qt::LeftButton : Qt::MouseButton(0)) |
(extra.isAllocated() ? extra->acceptedMouseButtons : Qt::MouseButtons(0)));
}
QSGContext *QQuickItemPrivate::sceneGraphContext() const
{
Q_ASSERT(canvas);
return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context;
841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906
}
void QQuickItemPrivate::markSortedChildrenDirty(QQuickItem *child)
{
// If sortedChildItems == &childItems then all in childItems have z == 0
// and we don't need to invalidate if the changed item also has z == 0.
if (child->z() != 0. || sortedChildItems != &childItems) {
if (sortedChildItems != &childItems)
delete sortedChildItems;
sortedChildItems = 0;
}
}
QQuickItem::TransformOrigin QQuickItemPrivate::origin() const
{
return extra.isAllocated()?extra->origin:QQuickItem::Center;
}
QSGTransformNode *QQuickItemPrivate::itemNode()
{
if (!itemNodeInstance) {
itemNodeInstance = createTransformNode();
itemNodeInstance->setFlag(QSGNode::OwnedByParent, false);
#ifdef QML_RUNTIME_TESTING
Q_Q(QQuickItem);
itemNodeInstance->description = QString::fromLatin1("QQuickItem(%1)").arg(QString::fromLatin1(q->metaObject()->className()));
#endif
}
return itemNodeInstance;
}
QSGNode *QQuickItemPrivate::childContainerNode()
{
if (!groupNode) {
groupNode = new QSGNode();
if (rootNode())
rootNode()->appendChildNode(groupNode);
else if (clipNode())
clipNode()->appendChildNode(groupNode);
else if (opacityNode())
opacityNode()->appendChildNode(groupNode);
else
itemNode()->appendChildNode(groupNode);
groupNode->setFlag(QSGNode::ChildrenDoNotOverlap, childrenDoNotOverlap);
groupNode->setFlag(QSGNode::StaticSubtreeGeometry, staticSubtreeGeometry);
#ifdef QML_RUNTIME_TESTING
groupNode->description = QLatin1String("group");
#endif
}
return groupNode;
}
Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickItemPrivate::ChangeTypes);
QT_END_NAMESPACE
QML_DECLARE_TYPE(QQuickItemLayer)
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 // QQUICKITEM_P_H