FCL/sf/mw/qt: comparison src/declarative/graphicsitems/qdeclarativeitem.cpp

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 #include <QtCore/qnumeric.h>
 #include <QtScript/qscriptengine.h>
 #include <QtGui/qgraphicstransform.h>
 #include <qlistmodelinterface_p.h>
+#include <float.h>
 QT_BEGIN_NAMESPACE
-#ifndef FLT_MAX
-#define FLT_MAX 1E+37
-#endif
 /*!
 \qmlclass Transform QGraphicsTransform
 \since 4.7
 \brief The Transform elements provide a way of building advanced transformations on Items.
 \endlist
 The Transform elements let you create and control advanced transformations that can be configured
 independently using specialized properties.
-You can assign any number of Transform elements to an Item. Each Transform is applied in order,
+You can assign any number of Transform elements to an \l Item. Each Transform is applied in order,
-one at a time, to the Item it's assigned to.
+one at a time.
 */
 /*!
-\qmlclass Translate QGraphicsTranslate
+\qmlclass Translate QDeclarativeTranslate
 \since 4.7
 \brief The Translate object provides a way to move an Item without changing its x or y properties.
 The Translate object provides independent control over position in addition to the Item's x and y properties.
-The following example moves the Y axis of the Rectangles while still allowing the Row element
+The following example moves the Y axis of the \l Rectangle elements while still allowing the \l Row element
 to lay the items out as if they had not been transformed:
 \qml
+import Qt 4.7
 Row {
 Rectangle {
 width: 100; height: 100
 color: "blue"
 transform: Translate { y: 20 }
 color: "red"
 transform: Translate { y: -20 }
 }
 }
 \endqml
+\image translate.png
 */
 /*!
 \qmlproperty real Translate::x
 */
 /*!
 \qmlclass Scale QGraphicsScale
 \since 4.7
-\brief The Scale object provides a way to scale an Item.
+\brief The Scale element provides a way to scale an Item.
-The Scale object gives more control over scaling than using Item's scale property. Specifically,
+The Scale element gives more control over scaling than using \l Item's \l{Item::scale}{scale} property. Specifically,
 it allows a different scale for the x and y axes, and allows the scale to be relative to an
 arbitrary point.
 The following example scales the X axis of the Rectangle, relative to its interior point 25, 25:
 \qml
 width: 100; height: 100
 color: "blue"
 transform: Scale { origin.x: 25; origin.y: 25; xScale: 3}
 }
 \endqml
+\sa Rotation, Translate
 */
 /*!
 \qmlproperty real Scale::origin.x
 \qmlproperty real Scale::origin.y
 /*!
 \qmlclass Rotation QGraphicsRotation
 \since 4.7
 \brief The Rotation object provides a way to rotate an Item.
-The Rotation object gives more control over rotation than using Item's rotation property.
+The Rotation object gives more control over rotation than using \l Item's \l{Item::rotation}{rotation} property.
 Specifically, it allows (z axis) rotation to be relative to an arbitrary point.
 The following example rotates a Rectangle around its interior point 25, 25:
 \qml
 Rectangle {
 The following example shows various 3D-like rotations applied to an \l Image.
 \snippet doc/src/snippets/declarative/rotation.qml 0
 \image axisrotation.png
+\sa {declarative/ui-components/dialcontrol}{Dial Control example}, {declarative/toys/clocks}{Clocks example}
 */
 /*!
 \qmlproperty real Rotation::origin.x
 \qmlproperty real Rotation::origin.y
 \internal
 \class QDeclarativeContents
 \brief The QDeclarativeContents class gives access to the height and width of an item's contents.
 */
+QDeclarativeContents::QDeclarativeContents(QDeclarativeItem *item) : m_item(item), m_x(0), m_y(0), m_width(0), m_height(0)
-QDeclarativeContents::QDeclarativeContents() : m_x(0), m_y(0), m_width(0), m_height(0)
+{
-{
+//### optimize
+connect(this, SIGNAL(rectChanged(QRectF)), m_item, SIGNAL(childrenRectChanged(QRectF)));
 }
 QDeclarativeContents::~QDeclarativeContents()
 {
 QList<QGraphicsItem *> children = m_item->childItems();
 if (m_width != oldwidth || m_x != oldx)
 emit rectChanged(rectF());
 }
-void QDeclarativeContents::setItem(QDeclarativeItem *item)
+void QDeclarativeContents::complete()
 {
-m_item = item;
-//### optimize
-connect(this, SIGNAL(rectChanged(QRectF)), m_item, SIGNAL(childrenRectChanged(QRectF)));
 QList<QGraphicsItem *> children = m_item->childItems();
 for (int i = 0; i < children.count(); ++i) {
 QDeclarativeItem *child = qobject_cast<QDeclarativeItem *>(children.at(i));
 if(!child)//### Should this be ignoring non-QDeclarativeItem graphicsobjects?
 continue;
 QDeclarativeItemPrivate::get(child)->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry | QDeclarativeItemPrivate::Destroyed);
 //###what about changes to visibility?
 }
-//### defer until componentComplete
+calcGeometry();
-calcHeight();
-calcWidth();
 }
 void QDeclarativeContents::itemGeometryChanged(QDeclarativeItem *changed, const QRectF &newGeometry, const QRectF &oldGeometry)
 {
-if (newGeometry.width() != oldGeometry.width())
+Q_UNUSED(changed)
-calcWidth(changed);
+//### we can only pass changed if the left edge has moved left, or the right edge has moved right
-if (newGeometry.height() != oldGeometry.height())
+if (newGeometry.width() != oldGeometry.width() || newGeometry.x() != oldGeometry.x())
-calcHeight(changed);
+calcWidth(/*changed*/);
+if (newGeometry.height() != oldGeometry.height() || newGeometry.y() != oldGeometry.y())
+calcHeight(/*changed*/);
 }
 void QDeclarativeContents::itemDestroyed(QDeclarativeItem *item)
 {
 if (item)
 QDeclarativeItemPrivate::get(item)->removeItemChangeListener(this, QDeclarativeItemPrivate::Geometry | QDeclarativeItemPrivate::Destroyed);
-calcWidth();
+calcGeometry();
-calcHeight();
 }
 void QDeclarativeContents::childRemoved(QDeclarativeItem *item)
 {
 if (item)
 QDeclarativeItemPrivate::get(item)->removeItemChangeListener(this, QDeclarativeItemPrivate::Geometry | QDeclarativeItemPrivate::Destroyed);
-calcWidth();
+calcGeometry();
-calcHeight();
 }
 void QDeclarativeContents::childAdded(QDeclarativeItem *item)
 {
 if (item)
 if (m_next) m_next->componentComplete();
 }
 /*!
-\qmlclass KeyNavigation
+\qmlclass KeyNavigation QDeclarativeKeyNavigationAttached
 \since 4.7
 \brief The KeyNavigation attached property supports key navigation by arrow keys.
 It is common in key-based UIs to use arrow keys to navigate
 between focussed items.  The KeyNavigation property provides a
 if (!event->isAccepted()) QDeclarativeItemKeyFilter::keyReleased(event, post);
 }
 /*!
-\qmlclass Keys
+\qmlclass Keys QDeclarativeKeysAttached
 \since 4.7
 \brief The Keys attached property provides key handling to Items.
 All visual primitives support key handling via the \e Keys
 attached property.  Keys can be handled via the \e onPressed
 and \e onReleased signal properties.
 The signal properties have a \l KeyEvent parameter, named
 \e event which contains details of the event.  If a key is
 handled \e event.accepted should be set to true to prevent the
-event from propagating up the item heirarchy.
+event from propagating up the item hierarchy.
 \code
 Item {
 focus: true
 Keys.onPressed: {
 to add a touch of imperative logic to your application (when absolutely
 necessary).
 */
 /*!
-\property QDeclarativeItem::baseline
-\internal
-*/
-/*!
-\property QDeclarativeItem::focus
-\internal
-*/
-/*!
-\property QDeclarativeItem::wantsFocus
-\internal
-*/
-/*!
-\property QDeclarativeItem::transformOrigin
-\internal
-*/
-/*!
 \fn void QDeclarativeItem::childrenRectChanged(const QRectF &)
 \internal
 */
 /*!
 \fn void QDeclarativeItem::focusChanged(bool)
 \internal
 */
 /*!
-\fn void QDeclarativeItem::wantsFocusChanged(bool)
+\fn void QDeclarativeItem::activeFocusChanged(bool)
 \internal
 */
 // ### Must fix
 struct RegisterAnchorLineAtStartup {
 rotation: 45
 }
 \endqml
 The default transform origin is \c Item.Center.
+To set an arbitrary transform origin point use the \l Scale or \l Rotation
+transform elements.
 */
 /*!
 \qmlproperty Item Item::parent
 This property holds the parent of the item.
 /*!
 Returns true if construction of the QML component is complete; otherwise
 returns false.
-It is often desireable to delay some processing until the component is
+It is often desirable to delay some processing until the component is
 completed.
 \sa componentComplete()
 */
 bool QDeclarativeItem::isComponentComplete() const
 {
 Q_D(const QDeclarativeItem);
-return d->_componentComplete;
+return d->componentComplete;
 }
 void QDeclarativeItemPrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
 {
 if (!o)
 }
 }
 QObject *QDeclarativeItemPrivate::resources_at(QDeclarativeListProperty<QObject> *prop, int index)
 {
-QObjectList children = prop->object->children();
+const QObjectList children = prop->object->children();
 if (index < children.count())
 return children.at(index);
 else
 return 0;
 }
 */
 QRectF QDeclarativeItem::childrenRect()
 {
 Q_D(QDeclarativeItem);
 if (!d->_contents) {
-d->_contents = new QDeclarativeContents;
+d->_contents = new QDeclarativeContents(this);
-d->_contents->setItem(this);
+if (d->componentComplete)
+d->_contents->complete();
 }
 return d->_contents->rectF();
 }
 bool QDeclarativeItem::clip() const
 v = QGraphicsObject::inputMethodQuery(query);
 return v;
 }
+/*!
+\internal
+*/
 void QDeclarativeItem::keyPressPreHandler(QKeyEvent *event)
 {
 Q_D(QDeclarativeItem);
 if (d->keyHandler && !d->doneEventPreHandler)
 d->keyHandler->keyPressed(event, false);
 else
 event->ignore();
 d->doneEventPreHandler = true;
 }
+/*!
+\internal
+*/
 void QDeclarativeItem::keyReleasePreHandler(QKeyEvent *event)
 {
 Q_D(QDeclarativeItem);
 if (d->keyHandler && !d->doneEventPreHandler)
 d->keyHandler->keyReleased(event, false);
 else
 event->ignore();
 d->doneEventPreHandler = true;
 }
+/*!
+\internal
+*/
 void QDeclarativeItem::inputMethodPreHandler(QInputMethodEvent *event)
 {
 Q_D(QDeclarativeItem);
 if (d->keyHandler && !d->doneEventPreHandler)
 d->keyHandler->inputMethodEvent(event, false);
 else
 event->ignore();
 d->doneEventPreHandler = true;
 }
 /*!
 \internal
 */
 QDeclarativeAnchorLine QDeclarativeItemPrivate::left() const
 {
 */
 QDeclarativeAnchorLine QDeclarativeItemPrivate::baseline() const
 {
 return anchorLines()->baseline;
 }
-/*!
-\qmlproperty AnchorLine Item::top
-\qmlproperty AnchorLine Item::bottom
-\qmlproperty AnchorLine Item::left
-\qmlproperty AnchorLine Item::right
-\qmlproperty AnchorLine Item::horizontalCenter
-\qmlproperty AnchorLine Item::verticalCenter
-\qmlproperty AnchorLine Item::baseline
-The anchor lines of the item.
-For more information see \l {anchor-layout}{Anchor Layouts}.
-*/
 /*!
 \qmlproperty AnchorLine Item::anchors.top
 \qmlproperty AnchorLine Item::anchors.bottom
 \qmlproperty AnchorLine Item::anchors.left
 Anchors provide a way to position an item by specifying its
 relationship with other items.
 Margins apply to top, bottom, left, right, and fill anchors.
-The margins property can be used to set all of the various margins at once, to the same value.
+The \c anchors.margins property can be used to set all of the various margins at once, to the same value.
 Offsets apply for horizontal center, vertical center, and baseline anchors.
 \table
 \row
 ...
 }
 \endqml
 \endtable
-anchors.fill provides a convenient way for one item to have the
+\c anchors.fill provides a convenient way for one item to have the
 same geometry as another item, and is equivalent to connecting all
 four directional anchors.
+To clear an anchor value, set it to \c undefined.
 \note You can only anchor an item to siblings or a parent.
 For more information see \l {anchor-layout}{Anchor Layouts}.
 */
 /*!
 \property QDeclarativeItem::baselineOffset
 \brief The position of the item's baseline in local coordinates.
-The baseline of a Text item is the imaginary line on which the text
+The baseline of a \l Text item is the imaginary line on which the text
 sits. Controls containing text usually set their baseline to the
 baseline of their text.
 For non-text items, a default baseline offset of 0 is used.
 */
 qreal QDeclarativeItem::baselineOffset() const
 {
 Q_D(const QDeclarativeItem);
-if (!d->_baselineOffset.isValid()) {
+if (!d->baselineOffset.isValid()) {
 return 0.0;
 } else
-return d->_baselineOffset;
+return d->baselineOffset;
 }
 void QDeclarativeItem::setBaselineOffset(qreal offset)
 {
 Q_D(QDeclarativeItem);
-if (offset == d->_baselineOffset)
+if (offset == d->baselineOffset)
 return;
-d->_baselineOffset = offset;
+d->baselineOffset = offset;
 for(int ii = 0; ii < d->changeListeners.count(); ++ii) {
 const QDeclarativeItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
 if (change.types & QDeclarativeItemPrivate::Geometry) {
 QDeclarativeAnchorsPrivate *anchor = change.listener->anchorPrivate();
 rotation: 30
 }
 }
 \endqml
 \endtable
+\sa transform, Rotation
 */
 /*!
 \qmlproperty real Item::scale
 This property holds the scale of the item.
 scale: 1.4
 }
 }
 \endqml
 \endtable
+\sa transform, Scale
 */
 /*!
 \qmlproperty real Item::opacity
 \sa setKeepMouseGrab()
 */
 bool QDeclarativeItem::keepMouseGrab() const
 {
 Q_D(const QDeclarativeItem);
-return d->_keepMouse;
+return d->keepMouse;
 }
 /*!
 The flag indicating whether the mouse should remain
 with this item is set to \a keep.
 \sa keepMouseGrab()
 */
 void QDeclarativeItem::setKeepMouseGrab(bool keep)
 {
 Q_D(QDeclarativeItem);
-d->_keepMouse = keep;
+d->keepMouse = keep;
 }
 /*!
 \qmlmethod object Item::mapFromItem(Item item, real x, real y)
 sv.setProperty(QLatin1String("y"), p.y());
 return sv;
 }
 /*!
-\qmlmethod Item::forceFocus()
+\qmlmethod Item::forceActiveFocus()
-Force the focus on the item.
+Force active focus on the item.
-This method sets the focus on the item and makes sure that all the focus scopes higher in the object hierarchy are given focus.
+This method sets focus on the item and makes sure that all the focus scopes higher in the object hierarchy are also given focus.
 */
-void QDeclarativeItem::forceFocus()
+void QDeclarativeItem::forceActiveFocus()
 {
 setFocus(true);
 QGraphicsItem *parent = parentItem();
 while (parent) {
 if (parent->flags() & QGraphicsItem::ItemIsFocusScope)
 parent->setFocus(Qt::OtherFocusReason);
 parent = parent->parentItem();
 }
 }
+/*!
+\qmlmethod Item::childAt(real x, real y)
+Returns the visible child item at point (\a x, \a y), which is in this
+item's coordinate system, or \c null if there is no such item.
+*/
+QDeclarativeItem *QDeclarativeItem::childAt(qreal x, qreal y) const
+{
+const QList<QGraphicsItem *> children = childItems();
+for (int i = children.count()-1; i >= 0; --i) {
+if (QDeclarativeItem *child = qobject_cast<QDeclarativeItem *>(children.at(i))) {
+if (child->isVisible() && child->x() <= x
+&& child->x() + child->width() >= x
+&& child->y() <= y
+&& child->y() + child->height() >= y)
+return child;
+}
+}
+return 0;
+}
 void QDeclarativeItemPrivate::focusChanged(bool flag)
 {
 Q_Q(QDeclarativeItem);
-emit q->focusChanged(flag);
+if (!(flags & QGraphicsItem::ItemIsFocusScope) && parent)
+emit q->activeFocusChanged(flag);   //see also QDeclarativeItemPrivate::subFocusItemChange()
+bool inScope = false;
+QGraphicsItem *p = parent;
+while (p) {
+if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+inScope = true;
+break;
+}
+p = p->parentItem();
+}
+if (!inScope)
+emit q->focusChanged(flag);
 }
 /*! \internal */
 QDeclarativeListProperty<QObject> QDeclarativeItemPrivate::resources()
 {
 /*!
 \qmlproperty bool Item::clip
 This property holds whether clipping is enabled.
-if clipping is enabled, an item will clip its own painting, as well
+If clipping is enabled, an item will clip its own painting, as well
 as the painting of its children, to its bounding rectangle.
 Non-rectangular clipping regions are not supported for performance reasons.
 */
 item to its base state by setting its current state to \c ''.
 \sa {qmlstates}{States}
 */
-/*!
-\property QDeclarativeItem::state
-\internal
-*/
 /*! \internal */
 QString QDeclarativeItemPrivate::state() const
 {
 if (!_stateGroup)
 return QString();
 This property holds the list of transformations to apply.
 For more information see \l Transform.
 */
-/*!
-\property QDeclarativeItem::transform
-\internal
-*/
 /*! \internal */
 QDeclarativeListProperty<QGraphicsTransform> QDeclarativeItem::transform()
 {
 Q_D(QDeclarativeItem);
 return QDeclarativeListProperty<QGraphicsTransform>(this, 0, d->transform_append, d->transform_count,
 \sa componentComplete(), isComponentComplete()
 */
 void QDeclarativeItem::classBegin()
 {
 Q_D(QDeclarativeItem);
-d->_componentComplete = false;
+d->componentComplete = false;
 if (d->_stateGroup)
 d->_stateGroup->classBegin();
 if (d->_anchors)
 d->_anchors->classBegin();
 }
 /*!
 \internal
 componentComplete() is called when all items in the component
-have been constructed.  It is often desireable to delay some
+have been constructed.  It is often desirable to delay some
 processing until the component is complete an all bindings in the
 component have been resolved.
 */
 void QDeclarativeItem::componentComplete()
 {
 Q_D(QDeclarativeItem);
-d->_componentComplete = true;
+d->componentComplete = true;
 if (d->_stateGroup)
 d->_stateGroup->componentComplete();
 if (d->_anchors) {
 d->_anchors->componentComplete();
 d->_anchors->d_func()->updateOnComplete();
 }
 if (d->keyHandler)
 d->keyHandler->componentComplete();
+if (d->_contents)
+d->_contents->complete();
 }
 QDeclarativeStateGroup *QDeclarativeItemPrivate::_states()
 {
 Q_Q(QDeclarativeItem);
 if (!_stateGroup) {
 _stateGroup = new QDeclarativeStateGroup;
-if (!_componentComplete)
+if (!componentComplete)
 _stateGroup->classBegin();
 QObject::connect(_stateGroup, SIGNAL(stateChanged(QString)),
 q, SIGNAL(stateChanged(QString)));
 }
 } else {
 bool rv = QGraphicsItem::sceneEvent(event);
 if (event->type() == QEvent::FocusIn ||
 event->type() == QEvent::FocusOut) {
-d->focusChanged(hasFocus());
+d->focusChanged(hasActiveFocus());
 }
 return rv;
 }
 }
 /*!
-\reimp
+\internal
 Note that unlike QGraphicsItems, QDeclarativeItem::itemChange() is \e not called
 during initial widget polishing. Items wishing to optimize start-up construction
 should instead consider using componentComplete().
 */
 emit smoothChanged(smooth);
 update();
 }
 /*!
+\property QDeclarativeItem::focus
+\internal
+*/
+/*!
+\property QDeclarativeItem::transform
+\internal
+*/
+/*!
+\property QDeclarativeItem::transformOrigin
+\internal
+*/
+/*!
+\property QDeclarativeItem::activeFocus
+\internal
+*/
+/*!
 \internal
 Return the width of the item
 */
 qreal QDeclarativeItem::width() const
 {
 geometryChanged(QRectF(x(), y(), width(), height()),
 QRectF(x(), y(), oldWidth, oldHeight));
 }
 /*!
-\qmlproperty bool Item::wantsFocus
+\qmlproperty bool Item::activeFocus
-This property indicates whether the item has has an active focus request.
+This property indicates whether the item has active focus.
-\sa {qmlfocus}{Keyboard Focus}
+An item with active focus will receive keyboard input,
+or is a FocusScope ancestor of the item that will receive keyboard input.
+Usually, activeFocus is gained by setting focus on an item and its enclosing
+FocusScopes. In the following example \c input will have activeFocus.
+\qml
+Rectangle {
+FocusScope {
+focus: true
+TextInput {
+id: input
+focus: true
+}
+}
+}
+\endqml
+\sa focus, {qmlfocus}{Keyboard Focus}
 */
 /*! \internal */
-bool QDeclarativeItem::wantsFocus() const
+bool QDeclarativeItem::hasActiveFocus() const
 {
-return focusItem() != 0;
+Q_D(const QDeclarativeItem);
+return focusItem() == this ||
+(d->flags & QGraphicsItem::ItemIsFocusScope && focusItem() != 0) ||
+(!parentItem() && focusItem() != 0);
 }
 /*!
 \qmlproperty bool Item::focus
-This property indicates whether the item has keyboard input focus. Set this
+This property indicates whether the item has focus within the enclosing focus scope. If true, this item
-property to true to request focus.
+will gain active focus when the enclosing focus scope gains active focus.
+In the following example, \c input will be given active focus when \c scope gains active focus.
-\sa {qmlfocus}{Keyboard Focus}
+\qml
+Rectangle {
+FocusScope {
+id: scope
+TextInput {
+id: input
+focus: true
+}
+}
+}
+\endqml
+For the purposes of this property, the top level item in the scene
+is assumed to act like a focus scope, and to always have active focus
+when the scene has focus. On a practical level, that means the following
+QML will give active focus to \c input on startup.
+\qml
+Rectangle {
+TextInput {
+id: input
+focus: true
+}
+}
+\endqml
+\sa activeFocus, {qmlfocus}{Keyboard Focus}
 */
 /*! \internal */
 bool QDeclarativeItem::hasFocus() const
 {
-return QGraphicsItem::hasFocus();
+Q_D(const QDeclarativeItem);
+QGraphicsItem *p = d->parent;
+while (p) {
+if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+return p->focusScopeItem() == this;
+}
+p = p->parentItem();
+}
+return hasActiveFocus() ? true : (!QGraphicsItem::parentItem() ? true : false);
 }
 /*! \internal */
 void QDeclarativeItem::setFocus(bool focus)
 {
 }
 return QGraphicsObject::event(ev);
 }
+#ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug debug, QDeclarativeItem *item)
 {
 if (!item) {
 debug << "QDeclarativeItem(0)";
 return debug;
 << ", parent =" << ((void*)item->parentItem())
 << ", geometry =" << QRectF(item->pos(), QSizeF(item->width(), item->height()))
 << ", z =" << item->zValue() << ')';
 return debug;
 }
+#endif
-int QDeclarativeItemPrivate::consistentTime = -1;
-void QDeclarativeItemPrivate::setConsistentTime(int t)
+qint64 QDeclarativeItemPrivate::consistentTime = -1;
+void QDeclarativeItemPrivate::setConsistentTime(qint64 t)
 {
 consistentTime = t;
 }
-QTime QDeclarativeItemPrivate::currentTime()
+class QElapsedTimerConsistentTimeHack
 {
-if (consistentTime == -1)
+public:
-return QTime::currentTime();
+void start() {
+t1 = QDeclarativeItemPrivate::consistentTime;
+t2 = 0;
+}
+qint64 elapsed() {
+return QDeclarativeItemPrivate::consistentTime - t1;
+}
+qint64 restart() {
+qint64 val = QDeclarativeItemPrivate::consistentTime - t1;
+t1 = QDeclarativeItemPrivate::consistentTime;
+t2 = 0;
+return val;
+}
+private:
+qint64 t1;
+qint64 t2;
+};
+void QDeclarativeItemPrivate::start(QElapsedTimer &t)
+{
+if (QDeclarativeItemPrivate::consistentTime == -1)
+t.start();
 else
-return QTime(0, 0).addMSecs(consistentTime);
+((QElapsedTimerConsistentTimeHack*)&t)->start();
 }
-void QDeclarativeItemPrivate::start(QTime &t)
+qint64 QDeclarativeItemPrivate::elapsed(QElapsedTimer &t)
 {
-t = currentTime();
+if (QDeclarativeItemPrivate::consistentTime == -1)
-}
+return t.elapsed();
+else
-int QDeclarativeItemPrivate::elapsed(QTime &t)
+return ((QElapsedTimerConsistentTimeHack*)&t)->elapsed();
-{
+}
-int n = t.msecsTo(currentTime());
-if (n < 0)                                // passed midnight
+qint64 QDeclarativeItemPrivate::restart(QElapsedTimer &t)
-n += 86400 * 1000;
+{
-return n;
+if (QDeclarativeItemPrivate::consistentTime == -1)
-}
+return t.restart();
+else
-int QDeclarativeItemPrivate::restart(QTime &t)
+return ((QElapsedTimerConsistentTimeHack*)&t)->restart();
-{
-QTime time = currentTime();
-int n = t.msecsTo(time);
-if (n < 0)                                // passed midnight
-n += 86400*1000;
-t = time;
-return n;
 }
 QT_END_NAMESPACE
 #include <moc_qdeclarativeitem.cpp>

changeset 33	3e2da88830cd
parent 30	5dc02b23752f
child 37	758a864f9613