Qt 4.8
qdeclarativevmemetaobject.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the QtDeclarative module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 #include "private/qdeclarativevmemetaobject_p.h"
43 
44 #include "qdeclarative.h"
45 #include "private/qdeclarativerefcount_p.h"
46 #include "qdeclarativeexpression.h"
47 #include "private/qdeclarativeexpression_p.h"
48 #include "private/qdeclarativecontext_p.h"
49 #include "private/qdeclarativebinding_p.h"
50 
52 
54 
56 {
57 public:
58  inline QDeclarativeVMEVariant();
59  inline ~QDeclarativeVMEVariant();
60 
61  inline const void *dataPtr() const;
62  inline void *dataPtr();
63  inline int dataType() const;
64 
65  inline QObject *asQObject();
66  inline const QVariant &asQVariant();
67  inline int asInt();
68  inline bool asBool();
69  inline double asDouble();
70  inline const QString &asQString();
71  inline const QUrl &asQUrl();
72  inline const QColor &asQColor();
73  inline const QTime &asQTime();
74  inline const QDate &asQDate();
75  inline const QDateTime &asQDateTime();
76  inline const QScriptValue &asQScriptValue();
77 
78  inline void setValue(QObject *);
79  inline void setValue(const QVariant &);
80  inline void setValue(int);
81  inline void setValue(bool);
82  inline void setValue(double);
83  inline void setValue(const QString &);
84  inline void setValue(const QUrl &);
85  inline void setValue(const QColor &);
86  inline void setValue(const QTime &);
87  inline void setValue(const QDate &);
88  inline void setValue(const QDateTime &);
89  inline void setValue(const QScriptValue &);
90 private:
91  int type;
92  void *data[4]; // Large enough to hold all types
93 
94  inline void cleanup();
95 };
96 
99 {
100 }
101 
103 {
104  cleanup();
105 }
106 
108 {
109  if (type == QVariant::Invalid) {
110  } else if (type == QMetaType::Int ||
111  type == QMetaType::Bool ||
112  type == QMetaType::Double) {
114  } else if (type == QMetaType::QObjectStar) {
117  } else if (type == QMetaType::QString) {
118  ((QString *)dataPtr())->~QString();
120  } else if (type == QMetaType::QUrl) {
121  ((QUrl *)dataPtr())->~QUrl();
123  } else if (type == QMetaType::QColor) {
124  ((QColor *)dataPtr())->~QColor();
126  } else if (type == QMetaType::QTime) {
127  ((QTime *)dataPtr())->~QTime();
129  } else if (type == QMetaType::QDate) {
130  ((QDate *)dataPtr())->~QDate();
132  } else if (type == QMetaType::QDateTime) {
133  ((QDateTime *)dataPtr())->~QDateTime();
135  } else if (type == qMetaTypeId<QVariant>()) {
136  ((QVariant *)dataPtr())->~QVariant();
138  } else if (type == qMetaTypeId<QScriptValue>()) {
139  ((QScriptValue *)dataPtr())->~QScriptValue();
141  }
142 
143 }
144 
146 {
147  return type;
148 }
149 
151 {
152  return &data;
153 }
154 
156 {
157  return &data;
158 }
159 
161 {
163  setValue((QObject *)0);
164 
165  return *(QDeclarativeGuard<QObject> *)(dataPtr());
166 }
167 
169 {
170  if (type != QMetaType::QVariant)
171  setValue(QVariant());
172 
173  return *(QVariant *)(dataPtr());
174 }
175 
177 {
178  if (type != QMetaType::Int)
179  setValue(int(0));
180 
181  return *(int *)(dataPtr());
182 }
183 
185 {
186  if (type != QMetaType::Bool)
187  setValue(bool(false));
188 
189  return *(bool *)(dataPtr());
190 }
191 
193 {
194  if (type != QMetaType::Double)
195  setValue(double(0));
196 
197  return *(double *)(dataPtr());
198 }
199 
201 {
202  if (type != QMetaType::QString)
203  setValue(QString());
204 
205  return *(QString *)(dataPtr());
206 }
207 
209 {
210  if (type != QMetaType::QUrl)
211  setValue(QUrl());
212 
213  return *(QUrl *)(dataPtr());
214 }
215 
217 {
218  if (type != QMetaType::QColor)
219  setValue(QColor());
220 
221  return *(QColor *)(dataPtr());
222 }
223 
225 {
226  if (type != QMetaType::QTime)
227  setValue(QTime());
228 
229  return *(QTime *)(dataPtr());
230 }
231 
233 {
234  if (type != QMetaType::QDate)
235  setValue(QDate());
236 
237  return *(QDate *)(dataPtr());
238 }
239 
241 {
242  if (type != QMetaType::QDateTime)
243  setValue(QDateTime());
244 
245  return *(QDateTime *)(dataPtr());
246 }
247 
249 {
250  if (type != qMetaTypeId<QScriptValue>())
252 
253  return *(QScriptValue *)(dataPtr());
254 }
255 
257 {
258  if (type != QMetaType::QObjectStar) {
259  cleanup();
262  }
264 }
265 
267 {
268  if (type != qMetaTypeId<QVariant>()) {
269  cleanup();
270  type = qMetaTypeId<QVariant>();
271  new (dataPtr()) QVariant(v);
272  } else {
273  *(QVariant *)(dataPtr()) = v;
274  }
275 }
276 
278 {
279  if (type != QMetaType::Int) {
280  cleanup();
282  }
283  *(int *)(dataPtr()) = v;
284 }
285 
287 {
288  if (type != QMetaType::Bool) {
289  cleanup();
291  }
292  *(bool *)(dataPtr()) = v;
293 }
294 
296 {
297  if (type != QMetaType::Double) {
298  cleanup();
300  }
301  *(double *)(dataPtr()) = v;
302 }
303 
305 {
306  if (type != QMetaType::QString) {
307  cleanup();
309  new (dataPtr()) QString(v);
310  } else {
311  *(QString *)(dataPtr()) = v;
312  }
313 }
314 
316 {
317  if (type != QMetaType::QUrl) {
318  cleanup();
320  new (dataPtr()) QUrl(v);
321  } else {
322  *(QUrl *)(dataPtr()) = v;
323  }
324 }
325 
327 {
328  if (type != QMetaType::QColor) {
329  cleanup();
331  new (dataPtr()) QColor(v);
332  } else {
333  *(QColor *)(dataPtr()) = v;
334  }
335 }
336 
338 {
339  if (type != QMetaType::QTime) {
340  cleanup();
342  new (dataPtr()) QTime(v);
343  } else {
344  *(QTime *)(dataPtr()) = v;
345  }
346 }
347 
349 {
350  if (type != QMetaType::QDate) {
351  cleanup();
353  new (dataPtr()) QDate(v);
354  } else {
355  *(QDate *)(dataPtr()) = v;
356  }
357 }
358 
360 {
361  if (type != QMetaType::QDateTime) {
362  cleanup();
364  new (dataPtr()) QDateTime(v);
365  } else {
366  *(QDateTime *)(dataPtr()) = v;
367  }
368 }
369 
371 {
372  if (type != qMetaTypeId<QScriptValue>()) {
373  cleanup();
374  type = qMetaTypeId<QScriptValue>();
375  new (dataPtr()) QScriptValue(v);
376  } else {
377  *(QScriptValue *)(dataPtr()) = v;
378  }
379 }
380 
382  const QMetaObject *other,
383  const QDeclarativeVMEMetaData *meta,
385 : object(obj), compiledData(cdata), ctxt(QDeclarativeData::get(obj, true)->outerContext),
386  metaData(meta), data(0), methods(0), parent(0)
387 {
388  compiledData->addref();
389 
390  *static_cast<QMetaObject *>(this) = *other;
391  this->d.superdata = obj->metaObject();
392 
394  if (op->metaObject)
395  parent = static_cast<QAbstractDynamicMetaObject*>(op->metaObject);
396  op->metaObject = this;
397 
400 
402 
404  int list_type = qMetaTypeId<QDeclarativeListProperty<QObject> >();
405 
406  // ### Optimize
407  for (int ii = 0; ii < metaData->propertyCount; ++ii) {
408  int t = (metaData->propertyData() + ii)->propertyType;
409  if (t == list_type) {
410  listProperties.append(List(methodOffset + ii));
411  data[ii].setValue(listProperties.count() - 1);
412  }
413  }
414 }
415 
417 {
419  delete parent;
420  delete [] data;
421  delete [] methods;
422 }
423 
425 {
426  int id = _id;
427  if(c == QMetaObject::WriteProperty) {
428  int flags = *reinterpret_cast<int*>(a[3]);
430  && !aInterceptors.isEmpty()
431  && aInterceptors.testBit(id)) {
433  int valueIndex = pair.first;
435  int type = property(id).userType();
436 
437  if (type != QVariant::Invalid) {
438  if (valueIndex != -1) {
440  QDeclarativeValueType *valueType = 0;
441  if (ep) valueType = ep->valueTypes[type];
442  else valueType = QDeclarativeValueTypeFactory::valueType(type);
443  Q_ASSERT(valueType);
444 
445  valueType->setValue(QVariant(type, a[0]));
446  QMetaProperty valueProp = valueType->metaObject()->property(valueIndex);
447  vi->write(valueProp.read(valueType));
448 
449  if (!ep) delete valueType;
450  return -1;
451  } else {
452  vi->write(QVariant(type, a[0]));
453  return -1;
454  }
455  }
456  }
457  }
459  if (id >= propOffset) {
460  id -= propOffset;
461 
462  if (id < metaData->propertyCount) {
463  int t = (metaData->propertyData() + id)->propertyType;
464  bool needActivate = false;
465 
466  if (t == -1) {
467 
468  if (c == QMetaObject::ReadProperty) {
469  *reinterpret_cast<QVariant *>(a[0]) = readVarPropertyAsVariant(id);
470  } else if (c == QMetaObject::WriteProperty) {
471  writeVarProperty(id, *reinterpret_cast<QVariant *>(a[0]));
472  }
473 
474  } else {
475 
476  if (c == QMetaObject::ReadProperty) {
477  switch(t) {
478  case QVariant::Int:
479  *reinterpret_cast<int *>(a[0]) = data[id].asInt();
480  break;
481  case QVariant::Bool:
482  *reinterpret_cast<bool *>(a[0]) = data[id].asBool();
483  break;
484  case QVariant::Double:
485  *reinterpret_cast<double *>(a[0]) = data[id].asDouble();
486  break;
487  case QVariant::String:
488  *reinterpret_cast<QString *>(a[0]) = data[id].asQString();
489  break;
490  case QVariant::Url:
491  *reinterpret_cast<QUrl *>(a[0]) = data[id].asQUrl();
492  break;
493  case QVariant::Color:
494  *reinterpret_cast<QColor *>(a[0]) = data[id].asQColor();
495  break;
496  case QVariant::Date:
497  *reinterpret_cast<QDate *>(a[0]) = data[id].asQDate();
498  break;
499  case QVariant::DateTime:
500  *reinterpret_cast<QDateTime *>(a[0]) = data[id].asQDateTime();
501  break;
503  *reinterpret_cast<QObject **>(a[0]) = data[id].asQObject();
504  break;
505  default:
506  break;
507  }
509  int listIndex = data[id].asInt();
510  const List *list = &listProperties.at(listIndex);
511  *reinterpret_cast<QDeclarativeListProperty<QObject> *>(a[0]) =
512  QDeclarativeListProperty<QObject>(object, (void *)list,
514  list_clear);
515  }
516 
517  } else if (c == QMetaObject::WriteProperty) {
518 
519  switch(t) {
520  case QVariant::Int:
521  needActivate = *reinterpret_cast<int *>(a[0]) != data[id].asInt();
522  data[id].setValue(*reinterpret_cast<int *>(a[0]));
523  break;
524  case QVariant::Bool:
525  needActivate = *reinterpret_cast<bool *>(a[0]) != data[id].asBool();
526  data[id].setValue(*reinterpret_cast<bool *>(a[0]));
527  break;
528  case QVariant::Double:
529  needActivate = *reinterpret_cast<double *>(a[0]) != data[id].asDouble();
530  data[id].setValue(*reinterpret_cast<double *>(a[0]));
531  break;
532  case QVariant::String:
533  needActivate = *reinterpret_cast<QString *>(a[0]) != data[id].asQString();
534  data[id].setValue(*reinterpret_cast<QString *>(a[0]));
535  break;
536  case QVariant::Url:
537  needActivate = *reinterpret_cast<QUrl *>(a[0]) != data[id].asQUrl();
538  data[id].setValue(*reinterpret_cast<QUrl *>(a[0]));
539  break;
540  case QVariant::Color:
541  needActivate = *reinterpret_cast<QColor *>(a[0]) != data[id].asQColor();
542  data[id].setValue(*reinterpret_cast<QColor *>(a[0]));
543  break;
544  case QVariant::Date:
545  needActivate = *reinterpret_cast<QDate *>(a[0]) != data[id].asQDate();
546  data[id].setValue(*reinterpret_cast<QDate *>(a[0]));
547  break;
548  case QVariant::DateTime:
549  needActivate = *reinterpret_cast<QDateTime *>(a[0]) != data[id].asQDateTime();
550  data[id].setValue(*reinterpret_cast<QDateTime *>(a[0]));
551  break;
553  needActivate = *reinterpret_cast<QObject **>(a[0]) != data[id].asQObject();
554  data[id].setValue(*reinterpret_cast<QObject **>(a[0]));
555  break;
556  default:
557  break;
558  }
559  }
560 
561  }
562 
563  if (c == QMetaObject::WriteProperty && needActivate) {
564  activate(object, methodOffset + id, 0);
565  }
566 
567  return -1;
568  }
569 
570  id -= metaData->propertyCount;
571 
572  if (id < metaData->aliasCount) {
573 
575 
577  *reinterpret_cast<void **>(a[0]) = 0;
578 
579  if (!ctxt) return -1;
580 
583 
584  QObject *target = ctxtPriv->data->idValues[d->contextIdx].data();
585  if (!target)
586  return -1;
587 
588  connectAlias(id);
589 
590  if (d->isObjectAlias()) {
591  *reinterpret_cast<QObject **>(a[0]) = target;
592  return -1;
593  }
594 
595  // Remove binding (if any) on write
596  if(c == QMetaObject::WriteProperty) {
597  int flags = *reinterpret_cast<int*>(a[3]);
599  QDeclarativeData *targetData = QDeclarativeData::get(target);
600  if (targetData && targetData->hasBindingBit(d->propertyIndex())) {
602  if (binding) binding->destroy();
603  }
604  }
605  }
606 
607  if (d->isValueTypeAlias()) {
608  // Value type property
610 
611  QDeclarativeValueType *valueType = ep->valueTypes[d->valueType()];
612  Q_ASSERT(valueType);
613 
614  valueType->read(target, d->propertyIndex());
615  int rv = QMetaObject::metacall(valueType, c, d->valueTypeIndex(), a);
616 
618  valueType->write(target, d->propertyIndex(), 0x00);
619 
620  return rv;
621 
622  } else {
623  return QMetaObject::metacall(target, c, d->propertyIndex(), a);
624  }
625 
626  }
627  return -1;
628 
629  }
630 
631  } else if(c == QMetaObject::InvokeMetaMethod) {
632 
633  if (id >= methodOffset) {
634 
635  id -= methodOffset;
636  int plainSignals = metaData->signalCount + metaData->propertyCount +
638  if (id < plainSignals) {
639  QMetaObject::activate(object, _id, a);
640  return -1;
641  }
642 
643  id -= plainSignals;
644 
645  if (id < metaData->methodCount) {
646  if (!ctxt->engine)
647  return -1; // We can't run the method
648 
650 
651  QScriptValue function = method(id);
652 
653  QScriptValueList args;
655  if (data->parameterCount) {
656  for (int ii = 0; ii < data->parameterCount; ++ii) {
657  args << ep->scriptValueFromVariant(*(QVariant *)a[ii + 1]);
658  }
659  }
660  QScriptValue rv = function.call(ep->objectClass->newQObject(object), args);
661 
662  if (a[0]) *reinterpret_cast<QVariant *>(a[0]) = ep->scriptValueToVariant(rv);
663 
664  return -1;
665  }
666  return -1;
667  }
668  }
669 
670  if (parent)
671  return parent->metaCall(c, _id, a);
672  else
673  return object->qt_metacall(c, _id, a);
674 }
675 
677 {
678  if (!methods)
680 
681  if (!methods[index].isValid()) {
683 
684  const QChar *body =
685  (const QChar *)(((const char*)metaData) + data->bodyOffset);
686 
687  QString code = QString::fromRawData(body, data->bodyLength);
688 
689  // XXX Use QScriptProgram
690  // XXX We should evaluate all methods in a single big script block to
691  // improve the call time between dynamic methods defined on the same
692  // object
694  data->lineNumber, 0);
695  }
696 
697  return methods[index];
698 }
699 
701 {
702  if (data[id].dataType() == qMetaTypeId<QScriptValue>())
703  return data[id].asQScriptValue();
704  else if (data[id].dataType() == QMetaType::QObjectStar)
706  else
708 }
709 
711 {
712  if (data[id].dataType() == qMetaTypeId<QScriptValue>())
713  return QDeclarativeEnginePrivate::get(ctxt->engine)->scriptValueToVariant(data[id].asQScriptValue());
714  else if (data[id].dataType() == QMetaType::QObjectStar)
715  return QVariant::fromValue(data[id].asQObject());
716  else
717  return data[id].asQVariant();
718 }
719 
721 {
722  data[id].setValue(value);
723  activate(object, methodOffset + id, 0);
724 }
725 
727 {
728  bool needActivate = false;
729  if (value.userType() == QMetaType::QObjectStar) {
730  QObject *o = qvariant_cast<QObject *>(value);
731  needActivate = (data[id].dataType() != QMetaType::QObjectStar || data[id].asQObject() != o);
732  data[id].setValue(qvariant_cast<QObject *>(value));
733  } else {
734  needActivate = (data[id].dataType() != qMetaTypeId<QVariant>() ||
735  data[id].asQVariant().userType() != value.userType() ||
736  data[id].asQVariant() != value);
737  data[id].setValue(value);
738  }
739  if (needActivate)
740  activate(object, methodOffset + id, 0);
741 }
742 
744 {
745  activate(object, methodOffset + id, 0);
746 }
747 
749 {
750  List *list = static_cast<List *>(prop->data);
751  list->append(o);
752  QMetaObject::activate(prop->object, list->notifyIndex, 0);
753 }
754 
756 {
757  return static_cast<List *>(prop->data)->count();
758 }
759 
761 {
762  return static_cast<List *>(prop->data)->at(index);
763 }
764 
766 {
767  List *list = static_cast<List *>(prop->data);
768  list->clear();
769  QMetaObject::activate(prop->object, list->notifyIndex, 0);
770 }
771 
773 {
774  if (aInterceptors.isEmpty())
776  aInterceptors.setBit(index);
777  interceptors.insert(index, qMakePair(valueIndex, interceptor));
778 }
779 
781 {
782  if (index < methodOffset) {
783  Q_ASSERT(parent);
784  return static_cast<QDeclarativeVMEMetaObject *>(parent)->vmeMethodLineNumber(index);
785  }
786 
787  int plainSignals = metaData->signalCount + metaData->propertyCount + metaData->aliasCount;
788  Q_ASSERT(index >= (methodOffset + plainSignals) && index < (methodOffset + plainSignals + metaData->methodCount));
789 
790  int rawIndex = index - methodOffset - plainSignals;
791 
793  return data->lineNumber;
794 }
795 
797 {
798  if (index < methodOffset) {
799  Q_ASSERT(parent);
800  return static_cast<QDeclarativeVMEMetaObject *>(parent)->vmeMethod(index);
801  }
802  int plainSignals = metaData->signalCount + metaData->propertyCount + metaData->aliasCount;
803  Q_ASSERT(index >= (methodOffset + plainSignals) && index < (methodOffset + plainSignals + metaData->methodCount));
804  return method(index - methodOffset - plainSignals);
805 }
806 
808 {
809  if (index < methodOffset) {
810  Q_ASSERT(parent);
811  return static_cast<QDeclarativeVMEMetaObject *>(parent)->setVmeMethod(index, value);
812  }
813  int plainSignals = metaData->signalCount + metaData->propertyCount + metaData->aliasCount;
814  Q_ASSERT(index >= (methodOffset + plainSignals) && index < (methodOffset + plainSignals + metaData->methodCount));
815 
816  if (!methods)
818  methods[index - methodOffset - plainSignals] = value;
819 }
820 
822 {
823  if (index < propOffset) {
824  Q_ASSERT(parent);
825  return static_cast<QDeclarativeVMEMetaObject *>(parent)->vmeProperty(index);
826  }
827  return readVarProperty(index - propOffset);
828 }
829 
831 {
832  if (index < propOffset) {
833  Q_ASSERT(parent);
834  static_cast<QDeclarativeVMEMetaObject *>(parent)->setVMEProperty(index, v);
835  }
836  return writeVarProperty(index - propOffset, v);
837 }
838 
839 bool QDeclarativeVMEMetaObject::aliasTarget(int index, QObject **target, int *coreIndex, int *valueTypeIndex) const
840 {
842 
843  *target = 0;
844  *coreIndex = -1;
845  *valueTypeIndex = -1;
846 
847  if (!ctxt)
848  return false;
849 
853 
854  *target = ctxtPriv->data->idValues[d->contextIdx].data();
855  if (!*target)
856  return false;
857 
858  if (d->isObjectAlias()) {
859  } else if (d->isValueTypeAlias()) {
860  *coreIndex = d->propertyIndex();
861  *valueTypeIndex = d->valueTypeIndex();
862  } else {
863  *coreIndex = d->propertyIndex();
864  }
865 
866  return true;
867 }
868 
870 {
871  if (!aConnected.testBit(aliasId)) {
872  aConnected.setBit(aliasId);
873 
876 
878 
879  QObject *target = ctxtPriv->data->idValues[d->contextIdx].data();
880  if (!target)
881  return;
882 
883  int sigIdx = methodOffset + aliasId + metaData->propertyCount;
884  QMetaObject::connect(context, d->contextIdx + ctxtPriv->notifyIndex, object, sigIdx);
885 
886  if (!d->isObjectAlias()) {
887  QMetaProperty prop = target->metaObject()->property(d->propertyIndex());
888  if (prop.hasNotifySignal())
890  }
891  }
892 }
893 
895 {
896  int aliasId = (index - methodOffset) - metaData->propertyCount;
897  if (aliasId < 0 || aliasId >= metaData->aliasCount)
898  return;
899 
900  connectAlias(aliasId);
901 }
902 
The QVariant class acts like a union for the most common Qt data types.
Definition: qvariant.h:92
QDeclarativeCompiledData * compiledData
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
void writeVarProperty(int, const QScriptValue &)
The QMetaObject class contains meta-information about Qt objects.
Definition: qobjectdefs.h:304
QDeclarativeVMEMetaObject(QObject *obj, const QMetaObject *other, const QDeclarativeVMEMetaData *data, QDeclarativeCompiledData *compiledData)
static QObject * list_at(QDeclarativeListProperty< QObject > *, int)
static QDeclarativeData * get(const QObject *object, bool create=false)
virtual int metaCall(QMetaObject::Call _c, int _id, void **_a)
int type
Definition: qmetatype.cpp:239
unsigned char c[8]
Definition: qnumeric_p.h:62
static bool connect(const QObject *sender, int signal_index, const QObject *receiver, int method_index, int type=0, int *types=0)
Definition: qobject.cpp:3194
void setBit(int i)
Sets the bit at index position i to 1.
Definition: qbitarray.h:128
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
QString toString(FormattingOptions options=None) const
Returns the human-displayable string representation of the URL.
Definition: qurl.cpp:5896
QDeclarativeEngine * engine
int notifySignalIndex() const
Returns the index of the property change notifying signal if one was specified, otherwise returns -1...
static int metacall(QObject *, Call, int, void **)
static QDeclarativeValueType * valueType(int)
#define at(className, varName)
virtual void destroy(DestroyMode mode=DisconnectBinding)
Destroy the binding.
T1 first
Definition: qpair.h:65
T2 second
Definition: qpair.h:66
QAbstractDynamicMetaObject * parent
void registerInterceptor(int index, int valueIndex, QDeclarativePropertyValueInterceptor *interceptor)
int qMetaTypeId()
Definition: qmetatype.h:224
static bool connect(QObject *sender, int signal_index, const QObject *receiver, int method_index, int type=0, int *types=0)
Connect sender signal_index to receiver method_index with the specified type and types.
static void list_clear(QDeclarativeListProperty< QObject > *)
PropertyData * propertyData() const
The QDate class provides date functions.
Definition: qdatetime.h:55
long ASN1_INTEGER_get ASN1_INTEGER * a
virtual void write(QObject *, int, QDeclarativePropertyPrivate::WriteFlags flags)=0
void setVmeMethod(int index, const QScriptValue &)
QHash< int, QPair< int, QDeclarativePropertyValueInterceptor * > > interceptors
virtual void write(const QVariant &value)=0
This method will be called when a new value is assigned to the property being intercepted.
int propertyCount() const
Returns the number of properties in this class, including the number of properties provided by each b...
The QUrl class provides a convenient interface for working with URLs.
Definition: qurl.h:61
The QString class provides a Unicode character string.
Definition: qstring.h:83
bool testBit(int i) const
Returns true if the bit at index position i is 1; otherwise returns false.
Definition: qbitarray.h:124
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
The QObject class is the base class of all Qt objects.
Definition: qobject.h:111
bool hasBindingBit(int) const
static QDeclarativeEnginePrivate * get(QDeclarativeEngine *e)
static QObjectPrivate * get(QObject *o)
Definition: qobject_p.h:177
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72
static QString fromRawData(const QChar *, int size)
Constructs a QString that uses the first size Unicode characters in the array unicode.
Definition: qstring.cpp:7673
const T value(const Key &key) const
Returns the value associated with the key.
Definition: qhash.h:606
iterator insert(const Key &key, const T &value)
Inserts a new item with the key and a value of value.
Definition: qhash.h:753
QScriptValue newQObject(QObject *, int type=QMetaType::QObjectStar)
QVariant scriptValueToVariant(const QScriptValue &, int hint=QVariant::Invalid)
virtual int metaCall(QMetaObject::Call, int _id, void **)
Definition: qobject_p.h:336
const QDeclarativeVMEMetaData * metaData
void append(const T &t)
Inserts value at the end of the list.
Definition: qlist.h:507
void setVMEProperty(int index, const QScriptValue &)
The QTime class provides clock time functions.
Definition: qdatetime.h:148
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
QDeclarativeContextData * data
static QScriptValue evalInObjectScope(QDeclarativeContextData *, QObject *, const QString &, const QString &, int, QScriptValue *)
int methodOffset() const
Returns the method offset for this class; i.e.
int userType() const
Returns this property&#39;s user type.
virtual void setValue(QVariant)=0
const QScriptValue & asQScriptValue()
void resize(int size)
Resizes the bit array to size bits.
Definition: qbitarray.cpp:214
QScriptValue scriptValueFromVariant(const QVariant &)
void clear()
Removes all items from the list.
Definition: qlist.h:764
static QDeclarativeAbstractBinding * setBinding(QObject *, int coreIndex, int valueTypeIndex, QDeclarativeAbstractBinding *, WriteFlags flags=DontRemoveBinding)
static QVariant fromValue(const T &value)
Returns a QVariant containing a copy of value.
Definition: qvariant.h:336
Q_DECLARE_METATYPE(QScriptValue)
QDeclarativeObjectScriptClass * objectClass
static QDeclarativeContextPrivate * get(QDeclarativeContext *context)
int userType() const
Returns the storage type of the value stored in the variant.
Definition: qvariant.cpp:1913
The QDateTime class provides date and time functions.
Definition: qdatetime.h:216
static int list_count(QDeclarativeListProperty< QObject > *)
QDeclarativeValueTypeFactory valueTypes
static void activate(QObject *sender, int signal_index, void **argv)
Definition: qobject.cpp:3690
QDeclarativeContext * asQDeclarativeContext()
Q_OUTOFLINE_TEMPLATE QPair< T1, T2 > qMakePair(const T1 &x, const T2 &y)
Definition: qpair.h:102
QMetaObject * metaObject
Definition: qobject.h:107
static void list_append(QDeclarativeListProperty< QObject > *, QObject *)
if(void) toggleToolbarShown
struct QMetaObject::@38 d
QVariant read(const QObject *obj) const
Reads the property&#39;s value from the given object.
bool aliasTarget(int index, QObject **target, int *coreIndex, int *valueTypeIndex) const
static const char * get(QDBusError::ErrorType code)
Definition: qdbuserror.cpp:141
T qvariant_cast(const QVariant &)
Definition: qvariant.h:571
The QDeclarativeContext class defines a context within a QML engine.
quint16 index
#define QML_ALIAS_FLAG_PTR
The QMetaProperty class provides meta-data about a property.
Definition: qmetaobject.h:176
int propertyOffset() const
Returns the property offset for this class; i.e.
QDeclarativeGuardedContextData ctxt
bool hasNotifySignal() const
Returns true if this property has a corresponding change notify signal; otherwise returns false...
The QScriptValue class acts as a container for the Qt Script data types.
Definition: qscriptvalue.h:57
int methodCount() const
Returns the number of methods known to the meta-object system in this class, including the number of ...
The QDeclarativePropertyValueInterceptor class is inherited by property interceptors such as Behavior...
QScriptValue call(const QScriptValue &thisObject=QScriptValue(), const QScriptValueList &args=QScriptValueList())
Calls this QScriptValue as a function, using thisObject as the `this&#39; object in the function call...
bool isEmpty() const
Returns true if this bit array has size 0; otherwise returns false.
Definition: qbitarray.h:78
virtual const QMetaObject * metaObject() const
Returns a pointer to the meta-object of this object.
QMetaProperty property(int index) const
Returns the meta-data for the property with the given index.
virtual void read(QObject *, int)=0