/**************************************************************************** | |
** | |
** Copyright (C) 2011 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$ | |
** | |
****************************************************************************/ | |
#ifndef QDECLARATIVEITEM_P_H | |
#define QDECLARATIVEITEM_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 "qdeclarativeitem.h" | |
#include "private/qdeclarativeanchors_p.h" | |
#include "private/qdeclarativeanchors_p_p.h" | |
#include "private/qdeclarativeitemchangelistener_p.h" | |
#include <private/qpodvector_p.h> | |
#include <private/qdeclarativestate_p.h> | |
#include <private/qdeclarativenullablevalue_p_p.h> | |
#include <private/qdeclarativenotifier_p.h> | |
#include <private/qdeclarativeglobal_p.h> | |
#include <qdeclarative.h> | |
#include <qdeclarativecontext.h> | |
#include <QtCore/qlist.h> | |
#include <QtCore/qdebug.h> | |
#include <private/qgraphicsitem_p.h> | |
QT_BEGIN_NAMESPACE | |
class QNetworkReply; | |
class QDeclarativeItemKeyFilter; | |
class QDeclarativeLayoutMirroringAttached; | |
//### merge into private? | |
class QDeclarativeContents : public QObject, public QDeclarativeItemChangeListener | |
{ | |
Q_OBJECT | |
public: | |
QDeclarativeContents(QDeclarativeItem *item); | |
~QDeclarativeContents(); | |
QRectF rectF() const; | |
void childRemoved(QDeclarativeItem *item); | |
void childAdded(QDeclarativeItem *item); | |
void calcGeometry() { calcWidth(); calcHeight(); } | |
void complete(); | |
Q_SIGNALS: | |
void rectChanged(QRectF); | |
protected: | |
void itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeometry, const QRectF &oldGeometry); | |
void itemDestroyed(QDeclarativeItem *item); | |
//void itemVisibilityChanged(QDeclarativeItem *item) | |
private: | |
void calcHeight(QDeclarativeItem *changed = 0); | |
void calcWidth(QDeclarativeItem *changed = 0); | |
QDeclarativeItem *m_item; | |
qreal m_x; | |
qreal m_y; | |
qreal m_width; | |
qreal m_height; | |
}; | |
class Q_DECLARATIVE_EXPORT QDeclarativeItemPrivate : public QGraphicsItemPrivate | |
{ | |
Q_DECLARE_PUBLIC(QDeclarativeItem) | |
public: | |
QDeclarativeItemPrivate() | |
: _anchors(0), _contents(0), | |
baselineOffset(0), | |
_anchorLines(0), | |
_stateGroup(0), origin(QDeclarativeItem::Center), | |
widthValid(false), heightValid(false), | |
componentComplete(true), keepMouse(false), | |
smooth(false), transformOriginDirty(true), doneEventPreHandler(false), | |
inheritedLayoutMirror(false), effectiveLayoutMirror(false), isMirrorImplicit(true), | |
inheritMirrorFromParent(false), inheritMirrorFromItem(false), keyHandler(0), | |
mWidth(0), mHeight(0), mImplicitWidth(0), mImplicitHeight(0), attachedLayoutDirection(0), hadSubFocusItem(false) | |
{ | |
QGraphicsItemPrivate::acceptedMouseButtons = 0; | |
isDeclarativeItem = 1; | |
QGraphicsItemPrivate::flags = QGraphicsItem::GraphicsItemFlags( | |
QGraphicsItem::ItemHasNoContents | |
| QGraphicsItem::ItemIsFocusable | |
| QGraphicsItem::ItemNegativeZStacksBehindParent); | |
} | |
void init(QDeclarativeItem *parent) | |
{ | |
Q_Q(QDeclarativeItem); | |
if (parent) { | |
QDeclarative_setParent_noEvent(q, parent); | |
q->setParentItem(parent); | |
QDeclarativeItemPrivate *parentPrivate = QDeclarativeItemPrivate::get(parent); | |
setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent); | |
} | |
baselineOffset.invalidate(); | |
mouseSetsFocus = false; | |
} | |
bool isMirrored() const { | |
return effectiveLayoutMirror; | |
} | |
// Private Properties | |
qreal width() const; | |
void setWidth(qreal); | |
void resetWidth(); | |
qreal height() const; | |
void setHeight(qreal); | |
void resetHeight(); | |
virtual qreal implicitWidth() const; | |
virtual qreal implicitHeight() const; | |
virtual void implicitWidthChanged(); | |
virtual void implicitHeightChanged(); | |
void resolveLayoutMirror(); | |
void setImplicitLayoutMirror(bool mirror, bool inherit); | |
void setLayoutMirror(bool mirror); | |
QDeclarativeListProperty<QObject> data(); | |
QDeclarativeListProperty<QObject> resources(); | |
QDeclarativeListProperty<QDeclarativeState> states(); | |
QDeclarativeListProperty<QDeclarativeTransition> transitions(); | |
QString state() const; | |
void setState(const QString &); | |
QDeclarativeAnchorLine left() const; | |
QDeclarativeAnchorLine right() const; | |
QDeclarativeAnchorLine horizontalCenter() const; | |
QDeclarativeAnchorLine top() const; | |
QDeclarativeAnchorLine bottom() const; | |
QDeclarativeAnchorLine verticalCenter() const; | |
QDeclarativeAnchorLine baseline() const; | |
// data property | |
static void data_append(QDeclarativeListProperty<QObject> *, QObject *); | |
static int data_count(QDeclarativeListProperty<QObject> *); | |
static QObject *data_at(QDeclarativeListProperty<QObject> *, int); | |
static void data_clear(QDeclarativeListProperty<QObject> *); | |
// resources property | |
static QObject *resources_at(QDeclarativeListProperty<QObject> *, int); | |
static void resources_append(QDeclarativeListProperty<QObject> *, QObject *); | |
static int resources_count(QDeclarativeListProperty<QObject> *); | |
static void resources_clear(QDeclarativeListProperty<QObject> *); | |
// transform property | |
static int transform_count(QDeclarativeListProperty<QGraphicsTransform> *list); | |
static void transform_append(QDeclarativeListProperty<QGraphicsTransform> *list, QGraphicsTransform *); | |
static QGraphicsTransform *transform_at(QDeclarativeListProperty<QGraphicsTransform> *list, int); | |
static void transform_clear(QDeclarativeListProperty<QGraphicsTransform> *list); | |
static QDeclarativeItemPrivate* get(QDeclarativeItem *item) | |
{ | |
return item->d_func(); | |
} | |
// Accelerated property accessors | |
QDeclarativeNotifier parentNotifier; | |
static void parentProperty(QObject *o, void *rv, QDeclarativeNotifierEndpoint *e); | |
QDeclarativeAnchors *anchors() { | |
if (!_anchors) { | |
Q_Q(QDeclarativeItem); | |
_anchors = new QDeclarativeAnchors(q); | |
if (!componentComplete) | |
_anchors->classBegin(); | |
} | |
return _anchors; | |
} | |
QDeclarativeAnchors *_anchors; | |
QDeclarativeContents *_contents; | |
QDeclarativeNullableValue<qreal> baselineOffset; | |
struct AnchorLines { | |
AnchorLines(QGraphicsObject *); | |
QDeclarativeAnchorLine left; | |
QDeclarativeAnchorLine right; | |
QDeclarativeAnchorLine hCenter; | |
QDeclarativeAnchorLine top; | |
QDeclarativeAnchorLine bottom; | |
QDeclarativeAnchorLine vCenter; | |
QDeclarativeAnchorLine baseline; | |
}; | |
mutable AnchorLines *_anchorLines; | |
AnchorLines *anchorLines() const { | |
Q_Q(const QDeclarativeItem); | |
if (!_anchorLines) _anchorLines = | |
new AnchorLines(const_cast<QDeclarativeItem *>(q)); | |
return _anchorLines; | |
} | |
enum ChangeType { | |
Geometry = 0x01, | |
SiblingOrder = 0x02, | |
Visibility = 0x04, | |
Opacity = 0x08, | |
Destroyed = 0x10 | |
}; | |
Q_DECLARE_FLAGS(ChangeTypes, ChangeType) | |
struct ChangeListener { | |
ChangeListener(QDeclarativeItemChangeListener *l, QDeclarativeItemPrivate::ChangeTypes t) : listener(l), types(t) {} | |
QDeclarativeItemChangeListener *listener; | |
QDeclarativeItemPrivate::ChangeTypes types; | |
bool operator==(const ChangeListener &other) const { return listener == other.listener && types == other.types; } | |
}; | |
void addItemChangeListener(QDeclarativeItemChangeListener *listener, ChangeTypes types) { | |
changeListeners.append(ChangeListener(listener, types)); | |
} | |
void removeItemChangeListener(QDeclarativeItemChangeListener *, ChangeTypes types); | |
QPODVector<ChangeListener,4> changeListeners; | |
QDeclarativeStateGroup *_states(); | |
QDeclarativeStateGroup *_stateGroup; | |
QDeclarativeItem::TransformOrigin origin:5; | |
bool widthValid:1; | |
bool heightValid:1; | |
bool componentComplete:1; | |
bool keepMouse:1; | |
bool smooth:1; | |
bool transformOriginDirty : 1; | |
bool doneEventPreHandler : 1; | |
bool inheritedLayoutMirror:1; | |
bool effectiveLayoutMirror:1; | |
bool isMirrorImplicit:1; | |
bool inheritMirrorFromParent:1; | |
bool inheritMirrorFromItem:1; | |
QDeclarativeItemKeyFilter *keyHandler; | |
qreal mWidth; | |
qreal mHeight; | |
qreal mImplicitWidth; | |
qreal mImplicitHeight; | |
QDeclarativeLayoutMirroringAttached* attachedLayoutDirection; | |
bool hadSubFocusItem; | |
QPointF computeTransformOrigin() const; | |
virtual void setPosHelper(const QPointF &pos) | |
{ | |
Q_Q(QDeclarativeItem); | |
QRectF oldGeometry(this->pos.x(), this->pos.y(), mWidth, mHeight); | |
QGraphicsItemPrivate::setPosHelper(pos); | |
q->geometryChanged(QRectF(this->pos.x(), this->pos.y(), mWidth, mHeight), oldGeometry); | |
} | |
// Reimplemented from QGraphicsItemPrivate | |
virtual void subFocusItemChange() | |
{ | |
bool hasSubFocusItem = subFocusItem != 0; | |
if (((flags & QGraphicsItem::ItemIsFocusScope) || !parent) && hasSubFocusItem != hadSubFocusItem) | |
emit q_func()->activeFocusChanged(hasSubFocusItem); | |
//see also QDeclarativeItemPrivate::focusChanged | |
hadSubFocusItem = hasSubFocusItem; | |
} | |
// Reimplemented from QGraphicsItemPrivate | |
virtual void focusScopeItemChange(bool isSubFocusItem) | |
{ | |
emit q_func()->focusChanged(isSubFocusItem); | |
} | |
// Reimplemented from QGraphicsItemPrivate | |
virtual void siblingOrderChange() | |
{ | |
Q_Q(QDeclarativeItem); | |
for(int ii = 0; ii < changeListeners.count(); ++ii) { | |
const QDeclarativeItemPrivate::ChangeListener &change = changeListeners.at(ii); | |
if (change.types & QDeclarativeItemPrivate::SiblingOrder) { | |
change.listener->itemSiblingOrderChanged(q); | |
} | |
} | |
} | |
// Reimplemented from QGraphicsItemPrivate | |
virtual void transformChanged(); | |
virtual void focusChanged(bool); | |
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 QDeclarativeItem, 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 QDeclarativeItemKeyFilter | |
{ | |
public: | |
QDeclarativeItemKeyFilter(QDeclarativeItem * = 0); | |
virtual ~QDeclarativeItemKeyFilter(); | |
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: | |
QDeclarativeItemKeyFilter *m_next; | |
}; | |
class QDeclarativeKeyNavigationAttachedPrivate : public QObjectPrivate | |
{ | |
public: | |
QDeclarativeKeyNavigationAttachedPrivate() | |
: QObjectPrivate(), left(0), right(0), up(0), down(0), tab(0), backtab(0) {} | |
QDeclarativeItem *left; | |
QDeclarativeItem *right; | |
QDeclarativeItem *up; | |
QDeclarativeItem *down; | |
QDeclarativeItem *tab; | |
QDeclarativeItem *backtab; | |
}; | |
class QDeclarativeKeyNavigationAttached : public QObject, public QDeclarativeItemKeyFilter | |
{ | |
Q_OBJECT | |
Q_DECLARE_PRIVATE(QDeclarativeKeyNavigationAttached) | |
Q_PROPERTY(QDeclarativeItem *left READ left WRITE setLeft NOTIFY leftChanged) | |
Q_PROPERTY(QDeclarativeItem *right READ right WRITE setRight NOTIFY rightChanged) | |
Q_PROPERTY(QDeclarativeItem *up READ up WRITE setUp NOTIFY upChanged) | |
Q_PROPERTY(QDeclarativeItem *down READ down WRITE setDown NOTIFY downChanged) | |
Q_PROPERTY(QDeclarativeItem *tab READ tab WRITE setTab NOTIFY tabChanged) | |
Q_PROPERTY(QDeclarativeItem *backtab READ backtab WRITE setBacktab NOTIFY backtabChanged) | |
Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged) | |
Q_ENUMS(Priority) | |
public: | |
QDeclarativeKeyNavigationAttached(QObject * = 0); | |
QDeclarativeItem *left() const; | |
void setLeft(QDeclarativeItem *); | |
QDeclarativeItem *right() const; | |
void setRight(QDeclarativeItem *); | |
QDeclarativeItem *up() const; | |
void setUp(QDeclarativeItem *); | |
QDeclarativeItem *down() const; | |
void setDown(QDeclarativeItem *); | |
QDeclarativeItem *tab() const; | |
void setTab(QDeclarativeItem *); | |
QDeclarativeItem *backtab() const; | |
void setBacktab(QDeclarativeItem *); | |
enum Priority { BeforeItem, AfterItem }; | |
Priority priority() const; | |
void setPriority(Priority); | |
static QDeclarativeKeyNavigationAttached *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(QDeclarativeItem *currentItem, const char *dir); | |
}; | |
class QDeclarativeLayoutMirroringAttached : 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 QDeclarativeLayoutMirroringAttached(QObject *parent = 0); | |
bool enabled() const; | |
void setEnabled(bool); | |
void resetEnabled(); | |
bool childrenInherit() const; | |
void setChildrenInherit(bool); | |
static QDeclarativeLayoutMirroringAttached *qmlAttachedProperties(QObject *); | |
Q_SIGNALS: | |
void enabledChanged(); | |
void childrenInheritChanged(); | |
private: | |
friend class QDeclarativeItemPrivate; | |
QDeclarativeItemPrivate *itemPrivate; | |
}; | |
class QDeclarativeKeysAttachedPrivate : public QObjectPrivate | |
{ | |
public: | |
QDeclarativeKeysAttachedPrivate() | |
: QObjectPrivate(), inPress(false), inRelease(false) | |
, inIM(false), enabled(true), imeItem(0), item(0) | |
{} | |
bool isConnected(const char *signalName); | |
QGraphicsItem *finalFocusProxy(QGraphicsItem *item) const | |
{ | |
QGraphicsItem *fp; | |
while ((fp = item->focusProxy())) | |
item = fp; | |
return item; | |
} | |
//loop detection | |
bool inPress:1; | |
bool inRelease:1; | |
bool inIM:1; | |
bool enabled : 1; | |
QGraphicsItem *imeItem; | |
QList<QDeclarativeItem *> targets; | |
QDeclarativeItem *item; | |
}; | |
class QDeclarativeKeysAttached : public QObject, public QDeclarativeItemKeyFilter | |
{ | |
Q_OBJECT | |
Q_DECLARE_PRIVATE(QDeclarativeKeysAttached) | |
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged) | |
Q_PROPERTY(QDeclarativeListProperty<QDeclarativeItem> forwardTo READ forwardTo) | |
Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged) | |
Q_ENUMS(Priority) | |
public: | |
QDeclarativeKeysAttached(QObject *parent=0); | |
~QDeclarativeKeysAttached(); | |
bool enabled() const { Q_D(const QDeclarativeKeysAttached); return d->enabled; } | |
void setEnabled(bool enabled) { | |
Q_D(QDeclarativeKeysAttached); | |
if (enabled != d->enabled) { | |
d->enabled = enabled; | |
emit enabledChanged(); | |
} | |
} | |
enum Priority { BeforeItem, AfterItem}; | |
Priority priority() const; | |
void setPriority(Priority); | |
QDeclarativeListProperty<QDeclarativeItem> forwardTo() { | |
Q_D(QDeclarativeKeysAttached); | |
return QDeclarativeListProperty<QDeclarativeItem>(this, d->targets); | |
} | |
virtual void componentComplete(); | |
static QDeclarativeKeysAttached *qmlAttachedProperties(QObject *); | |
Q_SIGNALS: | |
void enabledChanged(); | |
void priorityChanged(); | |
void pressed(QDeclarativeKeyEvent *event); | |
void released(QDeclarativeKeyEvent *event); | |
void digit0Pressed(QDeclarativeKeyEvent *event); | |
void digit1Pressed(QDeclarativeKeyEvent *event); | |
void digit2Pressed(QDeclarativeKeyEvent *event); | |
void digit3Pressed(QDeclarativeKeyEvent *event); | |
void digit4Pressed(QDeclarativeKeyEvent *event); | |
void digit5Pressed(QDeclarativeKeyEvent *event); | |
void digit6Pressed(QDeclarativeKeyEvent *event); | |
void digit7Pressed(QDeclarativeKeyEvent *event); | |
void digit8Pressed(QDeclarativeKeyEvent *event); | |
void digit9Pressed(QDeclarativeKeyEvent *event); | |
void leftPressed(QDeclarativeKeyEvent *event); | |
void rightPressed(QDeclarativeKeyEvent *event); | |
void upPressed(QDeclarativeKeyEvent *event); | |
void downPressed(QDeclarativeKeyEvent *event); | |
void tabPressed(QDeclarativeKeyEvent *event); | |
void backtabPressed(QDeclarativeKeyEvent *event); | |
void asteriskPressed(QDeclarativeKeyEvent *event); | |
void numberSignPressed(QDeclarativeKeyEvent *event); | |
void escapePressed(QDeclarativeKeyEvent *event); | |
void returnPressed(QDeclarativeKeyEvent *event); | |
void enterPressed(QDeclarativeKeyEvent *event); | |
void deletePressed(QDeclarativeKeyEvent *event); | |
void spacePressed(QDeclarativeKeyEvent *event); | |
void backPressed(QDeclarativeKeyEvent *event); | |
void cancelPressed(QDeclarativeKeyEvent *event); | |
void selectPressed(QDeclarativeKeyEvent *event); | |
void yesPressed(QDeclarativeKeyEvent *event); | |
void noPressed(QDeclarativeKeyEvent *event); | |
void context1Pressed(QDeclarativeKeyEvent *event); | |
void context2Pressed(QDeclarativeKeyEvent *event); | |
void context3Pressed(QDeclarativeKeyEvent *event); | |
void context4Pressed(QDeclarativeKeyEvent *event); | |
void callPressed(QDeclarativeKeyEvent *event); | |
void hangupPressed(QDeclarativeKeyEvent *event); | |
void flipPressed(QDeclarativeKeyEvent *event); | |
void menuPressed(QDeclarativeKeyEvent *event); | |
void volumeUpPressed(QDeclarativeKeyEvent *event); | |
void volumeDownPressed(QDeclarativeKeyEvent *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[]; | |
}; | |
Q_DECLARE_OPERATORS_FOR_FLAGS(QDeclarativeItemPrivate::ChangeTypes); | |
QT_END_NAMESPACE | |
QML_DECLARE_TYPE(QDeclarativeKeysAttached) | |
QML_DECLARE_TYPEINFO(QDeclarativeKeysAttached, QML_HAS_ATTACHED_PROPERTIES) | |
QML_DECLARE_TYPE(QDeclarativeKeyNavigationAttached) | |
QML_DECLARE_TYPEINFO(QDeclarativeKeyNavigationAttached, QML_HAS_ATTACHED_PROPERTIES) | |
QML_DECLARE_TYPE(QDeclarativeLayoutMirroringAttached) | |
QML_DECLARE_TYPEINFO(QDeclarativeLayoutMirroringAttached, QML_HAS_ATTACHED_PROPERTIES) | |
#endif // QDECLARATIVEITEM_P_H |