qmetaobject.cpp

i < metaObject->methodCount()	Description
TRUE	evaluated 244 times by 2 tests Evaluated by: tst_QDBusInterface tst_QMetaObject
FALSE	evaluated 10 times by 2 tests Evaluated by: tst_QDBusInterface tst_QMetaObject

10-244

1354

const QMetaMethod method = metaObject->method(i);

1355

if (method.name() == memberByteArray)

method.name() ...emberByteArray	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QMetaObject
FALSE	evaluated 240 times by 2 tests Evaluated by: tst_QDBusInterface tst_QMetaObject

4-240

1356

candidateMessage .append(+= " " + method.methodSignature() + '\n');;

executed 4 times by 1 test: candidateMessage += " " + method.methodSignature() + '\n';

Executed by:

tst_QMetaObject

1357

}

executed 244 times by 2 tests: end of block

Executed by:

tst_QDBusInterface
tst_QMetaObject

244

1358

if (!candidateMessage.isEmpty()) {

!candidateMessage.isEmpty()	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QMetaObject
FALSE	evaluated 6 times by 2 tests Evaluated by: tst_QDBusInterface tst_QMetaObject

4-6

1359

candidateMessage.prepend("\nCandidates are:\n");

1360

candidateMessage.chop(1);

1361

}

executed 4 times by 1 test: end of block

Executed by:

tst_QMetaObject

1362

return candidateMessage;

executed 10 times by 2 tests: return candidateMessage;

Executed by:

tst_QDBusInterface
tst_QMetaObject

}

/*!

Invokes the \a member (a signal or a slot name) on the object \a

1367

obj. Returns \c true if the member could be invoked. Returns \c false

1368

if there is no such member or the parameters did not match.

1369

1370

The invocation can be either synchronous or asynchronous,

1371

depending on \a type:

1372

1373

\list

1374

\li If \a type is Qt::DirectConnection, the member will be invoked immediately.

1375

1376

\li If \a type is Qt::QueuedConnection,

1377

a QEvent will be sent and the member is invoked as soon as the application

1378

enters the main event loop.

1379

1380

\li If \a type is Qt::BlockingQueuedConnection, the method will be invoked in

1381

the same way as for Qt::QueuedConnection, except that the current thread

1382

will block until the event is delivered. Using this connection type to

1383

communicate between objects in the same thread will lead to deadlocks.

1384

1385

\li If \a type is Qt::AutoConnection, the member is invoked

1386

synchronously if \a obj lives in the same thread as the

1387

caller; otherwise it will invoke the member asynchronously.

1388

\endlist

1389

1390

The return value of the \a member function call is placed in \a

1391

ret. If the invocation is asynchronous, the return value cannot

1392

be evaluated. You can pass up to ten arguments (\a val0, \a val1,

1393

\a val2, \a val3, \a val4, \a val5, \a val6, \a val7, \a val8,

1394

and \a val9) to the \a member function.

1395

1396

QGenericArgument and QGenericReturnArgument are internal

1397

helper classes. Because signals and slots can be dynamically

1398

invoked, you must enclose the arguments using the Q_ARG() and

1399

Q_RETURN_ARG() macros. Q_ARG() takes a type name and a

1400

const reference of that type; Q_RETURN_ARG() takes a type name

1401

and a non-const reference.

1402

1403

You only need to pass the name of the signal or slot to this function,

1404

not the entire signature. For example, to asynchronously invoke

1405

the \l{QThread::quit()}{quit()} slot on a

1406

QThread, use the following code:

1407

1408

\snippet code/src_corelib_kernel_qmetaobject.cpp 2

1409

1410

With asynchronous method invocations, the parameters must be of

1411

types that are known to Qt's meta-object system, because Qt needs

1412

to copy the arguments to store them in an event behind the

1413

scenes. If you try to use a queued connection and get the error

1414

message

1415

1416

\snippet code/src_corelib_kernel_qmetaobject.cpp 3

1417

1418

call qRegisterMetaType() to register the data type before you

1419

call invokeMethod().

1420

1421

To synchronously invoke the \c compute(QString, int, double) slot on

1422

some arbitrary object \c obj retrieve its return value:

1423

1424

\snippet code/src_corelib_kernel_qmetaobject.cpp 4

1425

1426

If the "compute" slot does not take exactly one QString, one int

1427

and one double in the specified order, the call will fail.

1428

1429

\sa Q_ARG(), Q_RETURN_ARG(), qRegisterMetaType(), QMetaMethod::invoke()

1430

1431

bool QMetaObject::invokeMethod(QObject *obj,

1432

const char *member,

1433

Qt::ConnectionType type,

1434

QGenericReturnArgument ret,

1435

QGenericArgument val0,

1436

QGenericArgument val1,

1437

QGenericArgument val2,

1438

QGenericArgument val3,

1439

QGenericArgument val4,

1440

QGenericArgument val5,

1441

QGenericArgument val6,

1442

QGenericArgument val7,

1443

QGenericArgument val8,

1444

QGenericArgument val9)

{

if (!obj)

return false;

QVarLengthArray<char, 512> sig;

1450

int len = qstrlen(member);

1451

if (len <= 0)

1452

return false;

1453

sig.append(member, len);

1454

sig.append('(');

1455

1456

const char *typeNames[] = {ret.name(), val0.name(), val1.name(), val2.name(), val3.name(),

1457

val4.name(), val5.name(), val6.name(), val7.name(), val8.name(),

val9.name()};

int paramCount;

for (paramCount = 1; paramCount < MaximumParamCount; ++paramCount) {

1462

len = qstrlen(typeNames[paramCount]);

1463

if (len <= 0)

1464

break;

1465

sig.append(typeNames[paramCount], len);

sig.append(',');

}

if (paramCount == 1)

sig.append(')'); // no parameters

1470

else

1471

sig[sig.size() - 1] = ')';

1472

sig.append('\0');

1473

1474

const QMetaObject *meta = obj->metaObject();

1475

int idx = meta->indexOfMethod(sig.constData());

1476

if (idx < 0) {

1477

QByteArray norm = QMetaObject::normalizedSignature(sig.constData());

1478

idx = meta->indexOfMethod(norm.constData());

1479

}

1480

1481

if (idx < 0 || idx >= meta->methodCount()) {

1482

// This method doesn't belong to us; print out a nice warning with candidates.

1483

qWarning("QMetaObject::invokeMethod: No such method %s::%s%s",

1484

meta->className(), sig.constData(), findMethodCandidates(meta, member).constData());

1485

return false;

1486

}

1487

QMetaMethod method = meta->method(idx);

1488

return method.invoke(obj, type, ret,

1489

val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);

1490

}

1491

1492

/*! \fn bool QMetaObject::invokeMethod(QObject *obj, const char *member,

1493

QGenericReturnArgument ret,

1494

QGenericArgument val0 = QGenericArgument(0),

1495

QGenericArgument val1 = QGenericArgument(),

1496

QGenericArgument val2 = QGenericArgument(),

1497

QGenericArgument val3 = QGenericArgument(),

1498

QGenericArgument val4 = QGenericArgument(),

1499

QGenericArgument val5 = QGenericArgument(),

1500

QGenericArgument val6 = QGenericArgument(),

1501

QGenericArgument val7 = QGenericArgument(),

1502

QGenericArgument val8 = QGenericArgument(),

1503

QGenericArgument val9 = QGenericArgument());

1504

\overload invokeMethod()

1505

1506

This overload always invokes the member using the connection type Qt::AutoConnection.

1507

1508

1509

/*! \fn bool QMetaObject::invokeMethod(QObject *obj, const char *member,

1510

Qt::ConnectionType type,

1511

QGenericArgument val0 = QGenericArgument(0),

1512

QGenericArgument val1 = QGenericArgument(),

1513

QGenericArgument val2 = QGenericArgument(),

1514

QGenericArgument val3 = QGenericArgument(),

1515

QGenericArgument val4 = QGenericArgument(),

1516

QGenericArgument val5 = QGenericArgument(),

1517

QGenericArgument val6 = QGenericArgument(),

1518

QGenericArgument val7 = QGenericArgument(),

1519

QGenericArgument val8 = QGenericArgument(),

1520

QGenericArgument val9 = QGenericArgument())

1521

1522

\overload invokeMethod()

1523

1524

This overload can be used if the return value of the member is of no interest.

/*!

\fn bool QMetaObject::invokeMethod(QObject *obj, const char *member,

1529

QGenericArgument val0 = QGenericArgument(0),

1530

QGenericArgument val1 = QGenericArgument(),

1531

QGenericArgument val2 = QGenericArgument(),

1532

QGenericArgument val3 = QGenericArgument(),

1533

QGenericArgument val4 = QGenericArgument(),

1534

QGenericArgument val5 = QGenericArgument(),

1535

QGenericArgument val6 = QGenericArgument(),

1536

QGenericArgument val7 = QGenericArgument(),

1537

QGenericArgument val8 = QGenericArgument(),

1538

QGenericArgument val9 = QGenericArgument())

1539

1540

\overload invokeMethod()

1541

1542

This overload invokes the member using the connection type Qt::AutoConnection and

1543

ignores return values.

/*!

\fn QMetaObject::Connection::Connection(const Connection &other)

1548

1549

Constructs a copy of \a other.

/*!

\fn QMetaObject::Connection::Connection &operator=(const Connection &other)

1554

1555

Assigns \a other to this connection and returns a reference to this connection.

/*!

\fn QMetaObject::Connection &QMetaObject::Connection::operator=(Connection &&other)

1560

1561

Move-assigns \a other to this object, and returns a reference.

1562

1563

/*!

1564

\fn QMetaObject::Connection::Connection(Connection &&o)

1565

1566

Move-constructs a Connection instance, making it point to the same object

1567

that \a o was pointing to.

/*!

\class QMetaMethod

\inmodule QtCore

\brief The QMetaMethod class provides meta-data about a member

function.

\ingroup objectmodel

A QMetaMethod has a methodType(), a methodSignature(), a list of

1580

parameterTypes() and parameterNames(), a return typeName(), a

1581

tag(), and an access() specifier. You can use invoke() to invoke

1582

the method on an arbitrary QObject.

1583

1584

\sa QMetaObject, QMetaEnum, QMetaProperty, {Qt's Property System}

/*!

\enum QMetaMethod::Attributes

\internal

\value Compatibility

\value Cloned

\value Scriptable

/*!

\fn bool QMetaMethod::isValid() const

1599

\since 5.0

1600

1601

Returns \c true if this method is valid (can be introspected and

1602

invoked), otherwise returns \c false.

1603

1604

1605

/*! \fn bool operator==(const QMetaMethod &m1, const QMetaMethod &m2)

\since 5.0

\relates QMetaMethod

\overload

Returns \c true if method \a m1 is equal to method \a m2,

1611

otherwise returns \c false.

1612

1613

1614

/*! \fn bool operator!=(const QMetaMethod &m1, const QMetaMethod &m2)

\since 5.0

\relates QMetaMethod

\overload

Returns \c true if method \a m1 is not equal to method \a m2,

1620

otherwise returns \c false.

/*!

\fn const QMetaObject *QMetaMethod::enclosingMetaObject() const

\internal

/*!

\enum QMetaMethod::MethodType

1630

1631

\value Method The function is a plain member function.

1632

\value Signal The function is a signal.

1633

\value Slot The function is a slot.

1634

\value Constructor The function is a constructor.

/*!

\fn QMetaMethod::QMetaMethod()

\internal

/*!

\macro Q_METAMETHOD_INVOKE_MAX_ARGS

1644

\relates QMetaMethod

1645

1646

Equals maximum number of arguments available for

1647

execution of the method via QMetaMethod::invoke()

1648

1649

1650

QByteArray QMetaMethodPrivate::signature() const

1651

{

1652

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

QByteArray result;

result.reserve(256);

result += name();

result += '(';

QList<QByteArray> argTypes = parameterTypes();

1658

for (int i = 0; i < argTypes.size(); ++i) {

1659

if (i)

1660

result += ',';

1661

result += argTypes.at(i);

}

result += ')';

return result;

}

QByteArray QMetaMethodPrivate::name() const

1668

{

1669

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1670

return stringData(mobj, mobj->d.data[handle]);

1671

}

1672

1673

int QMetaMethodPrivate::typesDataIndex() const

1674

{

1675

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1676

return mobj->d.data[handle + 2];

1677

}

1678

1679

const char *QMetaMethodPrivate::rawReturnTypeName() const

1680

{

1681

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1682

uint typeInfo = mobj->d.data[typesDataIndex()];

1683

if (typeInfo & IsUnresolvedType)

1684

return rawStringData(mobj, typeInfo & TypeNameIndexMask);

1685

else

1686

return QMetaType::typeName(typeInfo);

1687

}

1688

1689

int QMetaMethodPrivate::returnType() const

1690

{

1691

return parameterType(-1);

1692

}

1693

1694

int QMetaMethodPrivate::parameterCount() const

1695

{

1696

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1697

return mobj->d.data[handle + 1];

1698

}

1699

1700

int QMetaMethodPrivate::parametersDataIndex() const

1701

{

1702

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1703

return typesDataIndex() + 1;

1704

}

1705

1706

uint QMetaMethodPrivate::parameterTypeInfo(int index) const

1707

{

1708

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1709

return mobj->d.data[parametersDataIndex() + index];

1710

}

1711

1712

int QMetaMethodPrivate::parameterType(int index) const

1713

{

1714

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1715

return typeFromTypeInfo(mobj, parameterTypeInfo(index));

1716

}

1717

1718

void QMetaMethodPrivate::getParameterTypes(int *types) const

1719

{

1720

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1721

int dataIndex = parametersDataIndex();

1722

int argc = parameterCount();

1723

for (int i = 0; i < argc; ++i) {

1724

int id = typeFromTypeInfo(mobj, mobj->d.data[dataIndex++]);

*(types++) = id;

}

}

QList<QByteArray> QMetaMethodPrivate::parameterTypes() const

1730

{

1731

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1732

int argc = parameterCount();

1733

QList<QByteArray> list;

1734

list.reserve(argc);

1735

int paramsIndex = parametersDataIndex();

1736

for (int i = 0; i < argc; ++i)

1737

list += typeNameFromTypeInfo(mobj, mobj->d.data[paramsIndex + i]);

return list;

}

QList<QByteArray> QMetaMethodPrivate::parameterNames() const

1742

{

1743

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1744

int argc = parameterCount();

1745

QList<QByteArray> list;

1746

list.reserve(argc);

1747

int namesIndex = parametersDataIndex() + argc;

1748

for (int i = 0; i < argc; ++i)

1749

list += stringData(mobj, mobj->d.data[namesIndex + i]);

return list;

}

QByteArray QMetaMethodPrivate::tag() const

1754

{

1755

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

1756

return stringData(mobj, mobj->d.data[handle + 3]);

1757

}

1758

1759

int QMetaMethodPrivate::ownMethodIndex() const

1760

{

1761

// recompute the methodIndex by reversing the arithmetic in QMetaObject::property()

1762

return (handle - priv(mobj->d.data)->methodData) / 5;

}

/*!

\since 5.0

Returns the signature of this method (e.g.,

1769

\c{setValue(double)}).

1770

1771

\sa parameterTypes(), parameterNames()

1772

1773

QByteArray QMetaMethod::methodSignature() const

{

if (!mobj)

return QByteArray();

return QMetaMethodPrivate::get(this)->signature();

}

/*!

\since 5.0

Returns the name of this method.

1784

1785

\sa methodSignature(), parameterCount()

1786

1787

QByteArray QMetaMethod::name() const

{

if (!mobj)

return QByteArray();

return QMetaMethodPrivate::get(this)->name();

}

/*!

\since 5.0

Returns the return type of this method.

1798

1799

The return value is one of the types that are registered

1800

with QMetaType, or QMetaType::UnknownType if the type is not registered.

1801

1802

\sa parameterType(), QMetaType, typeName()

1803

1804

int QMetaMethod::returnType() const

1805

{

1806

if (!mobj)

1807

return QMetaType::UnknownType;

1808

return QMetaMethodPrivate::get(this)->returnType();

}

/*!

\since 5.0

Returns the number of parameters of this method.

1815

1816

\sa parameterType(), parameterNames()

1817

1818

int QMetaMethod::parameterCount() const

{

if (!mobj)

return 0;

return QMetaMethodPrivate::get(this)->parameterCount();

}

/*!

\since 5.0

Returns the type of the parameter at the given \a index.

1829

1830

The return value is one of the types that are registered

1831

with QMetaType, or QMetaType::UnknownType if the type is not registered.

1832

1833

\sa parameterCount(), returnType(), QMetaType

1834

1835

int QMetaMethod::parameterType(int index) const

1836

{

1837

if (!mobj || index < 0)

1838

return QMetaType::UnknownType;

1839

if (index >= QMetaMethodPrivate::get(this)->parameterCount())

1840

return QMetaType::UnknownType;

1841

1842

int type = QMetaMethodPrivate::get(this)->parameterType(index);

1843

if (type != QMetaType::UnknownType)

1844

return type;

1845

1846

void *argv[] = { &type, &index };

1847

mobj->static_metacall(QMetaObject::RegisterMethodArgumentMetaType, QMetaMethodPrivate::get(this)->ownMethodIndex(), argv);

1848

if (type != -1)

1849

return type;

1850

return QMetaType::UnknownType;

}

/*!

\since 5.0

\internal

Gets the parameter \a types of this method. The storage

1858

for \a types must be able to hold parameterCount() items.

1859

1860

\sa parameterCount(), returnType(), parameterType()

1861

1862

void QMetaMethod::getParameterTypes(int *types) const

{

if (!mobj)

return;

QMetaMethodPrivate::get(this)->getParameterTypes(types);

}

/*!

Returns a list of parameter types.

1871

1872

\sa parameterNames(), methodSignature()

1873

1874

QList<QByteArray> QMetaMethod::parameterTypes() const

1875

{

1876

if (!mobj)

1877

return QList<QByteArray>();

1878

return QMetaMethodPrivate::get(this)->parameterTypes();

}

/*!

Returns a list of parameter names.

1883

1884

\sa parameterTypes(), methodSignature()

1885

1886

QList<QByteArray> QMetaMethod::parameterNames() const

1887

{

1888

QList<QByteArray> list;

1889

if (!mobj)

1890

return list;

1891

return QMetaMethodPrivate::get(this)->parameterNames();

}

/*!

Returns the return type name of this method.

1897

1898

\sa returnType(), QMetaType::type()

1899

1900

const char *QMetaMethod::typeName() const

{

if (!mobj)

return 0;

return QMetaMethodPrivate::get(this)->rawReturnTypeName();

}

/*!

Returns the tag associated with this method.

1909

1910

Tags are special macros recognized by \c moc that make it

1911

possible to add extra information about a method.

1912

1913

Tag information can be added in the following

1914

way in the function declaration:

1915

1916

\code

1917

// In the class MainWindow declaration

1918

#ifndef Q_MOC_RUN

1919

// define the tag text as empty, so the compiler doesn't see it

1920

# define MY_CUSTOM_TAG

#endif

...

private slots:

MY_CUSTOM_TAG void testFunc();

1925

\endcode

1926

1927

and the information can be accessed by using:

\code

MainWindow win;

win.show();

int functionIndex = win.metaObject()->indexOfSlot("testFunc()");

1934

QMetaMethod mm = win.metaObject()->method(functionIndex);

1935

qDebug() << mm.tag(); // prints MY_CUSTOM_TAG

1936

\endcode

1937

1938

For the moment, \c moc will extract and record all tags, but it will not

1939

handle any of them specially. You can use the tags to annotate your methods

1940

differently, and treat them according to the specific needs of your

1941

application.

1942

1943

\note Since Qt 5.0, \c moc expands preprocessor macros, so it is necessary

1944

to surround the definition with \c #ifndef \c Q_MOC_RUN, as shown in the

1945

example above. This was not required in Qt 4. The code as shown above works

1946

with Qt 4 too.

1947

1948

const char *QMetaMethod::tag() const

{

if (!mobj)

return 0;

return QMetaMethodPrivate::get(this)->tag().constData();

}

/*!

\internal

int QMetaMethod::attributes() const

{

if (!mobj)

return false;

return ((mobj->d.data[handle + 4])>>4);

}

/*!

\since 4.6

Returns this method's index.

1970

1971

int QMetaMethod::methodIndex() const

{

if (!mobj)

return -1;

return QMetaMethodPrivate::get(this)->ownMethodIndex() + mobj->methodOffset();

1976

}

1977

1978

// This method has been around for a while, but the documentation was marked \internal until 5.1

1979

/*!

1980

\since 5.1

1981

Returns the method revision if one was

1982

specified by Q_REVISION, otherwise returns 0.

1983

1984

int QMetaMethod::revision() const

{

if (!mobj)

return 0;

if ((QMetaMethod::Access)(mobj->d.data[handle + 4] & MethodRevisioned)) {

1989

int offset = priv(mobj->d.data)->methodData

1990

+ priv(mobj->d.data)->methodCount * 5

1991

+ QMetaMethodPrivate::get(this)->ownMethodIndex();

1992

return mobj->d.data[offset];

}

return 0;

}

/*!

Returns the access specification of this method (private,

1999

protected, or public).

2000

2001

\note Signals are always public, but you should regard that as an

2002

implementation detail. It is almost always a bad idea to emit a signal from

outside its class.

\sa methodType()

QMetaMethod::Access QMetaMethod::access() const

{

if (!mobj)

return Private;

return (QMetaMethod::Access)(mobj->d.data[handle + 4] & AccessMask);

}

/*!

Returns the type of this method (signal, slot, or method).

\sa access()

QMetaMethod::MethodType QMetaMethod::methodType() const

2020

{

2021

if (!mobj)

2022

return QMetaMethod::Method;

2023

return (QMetaMethod::MethodType)((mobj->d.data[handle + 4] & MethodTypeMask)>>2);

}

/*!

\fn QMetaMethod QMetaMethod::fromSignal(PointerToMemberFunction signal)

2028

\since 5.0

2029

2030

Returns the meta-method that corresponds to the given \a signal, or an

2031

invalid QMetaMethod if \a signal is not a signal of the class.

Example:

\snippet code/src_corelib_kernel_qmetaobject.cpp 9

/*!

\internal

Implementation of the fromSignal() function.

2042

2043

\a metaObject is the class's meta-object

2044

\a signal is a pointer to a pointer to a member signal of the class

2045

2046

QMetaMethod QMetaMethod::fromSignalImpl(const QMetaObject *metaObject, void **signal)

2047

{

2048

int i = -1;

2049

void *args[] = { &i, signal };

2050

QMetaMethod result;

2051

for (const QMetaObject *m = metaObject; m; m = m->d.superdata) {

2052

m->static_metacall(QMetaObject::IndexOfMethod, 0, args);

2053

if (i >= 0) {

2054

result.mobj = m;

2055

result.handle = priv(m->d.data)->methodData + 5*i;

break;

}

}

return result;

}

/*!

Invokes this method on the object \a object. Returns \c true if the member could be invoked.

2064

Returns \c false if there is no such member or the parameters did not match.

2065

2066

The invocation can be either synchronous or asynchronous, depending on the

\a connectionType:

\list

\li If \a connectionType is Qt::DirectConnection, the member will be invoked immediately.

2071

2072

\li If \a connectionType is Qt::QueuedConnection,

2073

a QEvent will be posted and the member is invoked as soon as the application

2074

enters the main event loop.

2075

2076

\li If \a connectionType is Qt::AutoConnection, the member is invoked

2077

synchronously if \a object lives in the same thread as the

2078

caller; otherwise it will invoke the member asynchronously.

2079

\endlist

2080

2081

The return value of this method call is placed in \a

2082

returnValue. If the invocation is asynchronous, the return value cannot

2083

be evaluated. You can pass up to ten arguments (\a val0, \a val1,

2084

\a val2, \a val3, \a val4, \a val5, \a val6, \a val7, \a val8,

2085

and \a val9) to this method call.

2086

2087

QGenericArgument and QGenericReturnArgument are internal

2088

helper classes. Because signals and slots can be dynamically

2089

invoked, you must enclose the arguments using the Q_ARG() and

2090

Q_RETURN_ARG() macros. Q_ARG() takes a type name and a

2091

const reference of that type; Q_RETURN_ARG() takes a type name

2092

and a non-const reference.

2093

2094

To asynchronously invoke the

2095

\l{QPushButton::animateClick()}{animateClick()} slot on a

2096

QPushButton:

2097

2098

\snippet code/src_corelib_kernel_qmetaobject.cpp 6

2099

2100

With asynchronous method invocations, the parameters must be of

2101

types that are known to Qt's meta-object system, because Qt needs

2102

to copy the arguments to store them in an event behind the

2103

scenes. If you try to use a queued connection and get the error

2104

message

2105

2106

\snippet code/src_corelib_kernel_qmetaobject.cpp 7

2107

2108

call qRegisterMetaType() to register the data type before you

2109

call QMetaMethod::invoke().

2110

2111

To synchronously invoke the \c compute(QString, int, double) slot on

2112

some arbitrary object \c obj retrieve its return value:

2113

2114

\snippet code/src_corelib_kernel_qmetaobject.cpp 8

2115

2116

QMetaObject::normalizedSignature() is used here to ensure that the format

2117

of the signature is what invoke() expects. E.g. extra whitespace is

2118

removed.

2119

2120

If the "compute" slot does not take exactly one QString, one int

2121

and one double in the specified order, the call will fail.

2122

2123

\warning this method will not test the validity of the arguments: \a object

2124

must be an instance of the class of the QMetaObject of which this QMetaMethod

2125

has been constructed with. The arguments must have the same type as the ones

2126

expected by the method, else, the behaviour is undefined.

2127

2128

\sa Q_ARG(), Q_RETURN_ARG(), qRegisterMetaType(), QMetaObject::invokeMethod()

2129

2130

bool QMetaMethod::invoke(QObject *object,

2131

Qt::ConnectionType connectionType,

2132

QGenericReturnArgument returnValue,

2133

QGenericArgument val0,

2134

QGenericArgument val1,

2135

QGenericArgument val2,

2136

QGenericArgument val3,

2137

QGenericArgument val4,

2138

QGenericArgument val5,

2139

QGenericArgument val6,

2140

QGenericArgument val7,

2141

QGenericArgument val8,

2142

QGenericArgument val9) const

2143

{

2144

if (!object || !mobj)

2145

return false;

2146

2147

Q_ASSERT(mobj->cast(object));

2148

2149

// check return type

2150

if (returnValue.data()) {

2151

const char *retType = typeName();

2152

if (qstrcmp(returnValue.name(), retType) != 0) {

2153

// normalize the return value as well

2154

QByteArray normalized = QMetaObject::normalizedType(returnValue.name());

2155

if (qstrcmp(normalized.constData(), retType) != 0) {

2156

// String comparison failed, try compare the metatype.

2157

int t = returnType();

2158

if (t == QMetaType::UnknownType || t != QMetaType::type(normalized))

return false;

}

}

}

// check argument count (we don't allow invoking a method if given too few arguments)

2165

const char *typeNames[] = {

returnValue.name(),

val0.name(),

val1.name(),

val2.name(),

val3.name(),

val4.name(),

val5.name(),

val6.name(),

val7.name(),

val8.name(),

val9.name()

};

int paramCount;

for (paramCount = 1; paramCount < MaximumParamCount; ++paramCount) {

2180

if (qstrlen(typeNames[paramCount]) <= 0)

2181

break;

2182

}

2183

if (paramCount <= QMetaMethodPrivate::get(this)->parameterCount())

2184

return false;

2185

2186

// check connection type

2187

QThread *currentThread = QThread::currentThread();

2188

QThread *objectThread = object->thread();

2189

if (connectionType == Qt::AutoConnection) {

2190

connectionType = currentThread == objectThread

2191

? Qt::DirectConnection

2192

: Qt::QueuedConnection;

}

#ifdef QT_NO_THREAD

if (connectionType == Qt::BlockingQueuedConnection) {

2197

connectionType = Qt::DirectConnection;

}

#endif

// invoke!

void *param[] = {

returnValue.data(),

val0.data(),

val1.data(),

val2.data(),

val3.data(),

val4.data(),

val5.data(),

val6.data(),

val7.data(),

val8.data(),

val9.data()

};

int idx_relative = QMetaMethodPrivate::get(this)->ownMethodIndex();

2216

int idx_offset = mobj->methodOffset();

2217

Q_ASSERT(QMetaObjectPrivate::get(mobj)->revision >= 6);

2218

QObjectPrivate::StaticMetaCallFunction callFunction = mobj->d.static_metacall;

2219

2220

if (connectionType == Qt::DirectConnection) {

2221

if (callFunction) {

2222

callFunction(object, QMetaObject::InvokeMetaMethod, idx_relative, param);

2223

return true;

2224

} else {

2225

return QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, idx_relative + idx_offset, param) < 0;

2226

}

2227

} else if (connectionType == Qt::QueuedConnection) {

2228

if (returnValue.data()) {

2229

qWarning("QMetaMethod::invoke: Unable to invoke methods with return values in "

2230

"queued connections");

return false;

}

int nargs = 1; // include return type

2235

void **args = (void **) malloc(paramCount * sizeof(void *));

2236

Q_CHECK_PTR(args);

2237

int *types = (int *) malloc(paramCount * sizeof(int));

2238

Q_CHECK_PTR(types);

2239

types[0] = 0; // return type

2240

args[0] = 0;

2241

2242

for (int i = 1; i < paramCount; ++i) {

2243

types[i] = QMetaType::type(typeNames[i]);

2244

if (types[i] != QMetaType::UnknownType) {

2245

args[i] = QMetaType::create(types[i], param[i]);

2246

++nargs;

2247

} else if (param[i]) {

2248

// Try to register the type and try again before reporting an error.

2249

void *argv[] = { &types[i], &i };

2250

QMetaObject::metacall(object, QMetaObject::RegisterMethodArgumentMetaType,

2251

idx_relative + idx_offset, argv);

2252

if (types[i] == -1) {

2253

qWarning("QMetaMethod::invoke: Unable to handle unregistered datatype '%s'",

2254

typeNames[i]);

2255

for (int x = 1; x < i; ++x) {

2256

if (types[x] && args[x])

2257

QMetaType::destroy(types[x], args[x]);

}

free(types);

free(args);

return false;

}

}

}

QCoreApplication::postEvent(object, new QMetaCallEvent(idx_offset, idx_relative, callFunction,

2267

0, -1, nargs, types, args));

2268

} else { // blocking queued connection

2269

#ifndef QT_NO_THREAD

2270

if (currentThread == objectThread) {

2271

qWarning("QMetaMethod::invoke: Dead lock detected in "

2272

"BlockingQueuedConnection: Receiver is %s(%p)",

2273

mobj->className(), object);

2274

}

2275

2276

QSemaphore semaphore;

2277

QCoreApplication::postEvent(object, new QMetaCallEvent(idx_offset, idx_relative, callFunction,

2278

0, -1, 0, 0, param, &semaphore));

2279

semaphore.acquire();

2280

#endif // QT_NO_THREAD

}

return true;

}

/*! \fn bool QMetaMethod::invoke(QObject *object,

2286

QGenericReturnArgument returnValue,

2287

QGenericArgument val0 = QGenericArgument(0),

2288

QGenericArgument val1 = QGenericArgument(),

2289

QGenericArgument val2 = QGenericArgument(),

2290

QGenericArgument val3 = QGenericArgument(),

2291

QGenericArgument val4 = QGenericArgument(),

2292

QGenericArgument val5 = QGenericArgument(),

2293

QGenericArgument val6 = QGenericArgument(),

2294

QGenericArgument val7 = QGenericArgument(),

2295

QGenericArgument val8 = QGenericArgument(),

2296

QGenericArgument val9 = QGenericArgument()) const

2297

\overload invoke()

2298

2299

This overload always invokes this method using the connection type Qt::AutoConnection.

2300

2301

2302

/*! \fn bool QMetaMethod::invoke(QObject *object,

2303

Qt::ConnectionType connectionType,

2304

QGenericArgument val0 = QGenericArgument(0),

2305

QGenericArgument val1 = QGenericArgument(),

2306

QGenericArgument val2 = QGenericArgument(),

2307

QGenericArgument val3 = QGenericArgument(),

2308

QGenericArgument val4 = QGenericArgument(),

2309

QGenericArgument val5 = QGenericArgument(),

2310

QGenericArgument val6 = QGenericArgument(),

2311

QGenericArgument val7 = QGenericArgument(),

2312

QGenericArgument val8 = QGenericArgument(),

2313

QGenericArgument val9 = QGenericArgument()) const

\overload invoke()

This overload can be used if the return value of the member is of no interest.

/*!

\fn bool QMetaMethod::invoke(QObject *object,

2322

QGenericArgument val0 = QGenericArgument(0),

2323

QGenericArgument val1 = QGenericArgument(),

2324

QGenericArgument val2 = QGenericArgument(),

2325

QGenericArgument val3 = QGenericArgument(),

2326

QGenericArgument val4 = QGenericArgument(),

2327

QGenericArgument val5 = QGenericArgument(),

2328

QGenericArgument val6 = QGenericArgument(),

2329

QGenericArgument val7 = QGenericArgument(),

2330

QGenericArgument val8 = QGenericArgument(),

2331

QGenericArgument val9 = QGenericArgument()) const

\overload invoke()

This overload invokes this method using the

2336

connection type Qt::AutoConnection and ignores return values.

/*!

\since 5.5

Invokes this method on a Q_GADGET. Returns \c true if the member could be invoked.

2343

Returns \c false if there is no such member or the parameters did not match.

2344

2345

The pointer \a gadget must point to an instance of the gadget class.

2346

2347

The invocation is always synchronous.

2348

2349

The return value of this method call is placed in \a

2350

returnValue. You can pass up to ten arguments (\a val0, \a val1,

2351

\a val2, \a val3, \a val4, \a val5, \a val6, \a val7, \a val8,

2352

and \a val9) to this method call.

2353

2354

\warning this method will not test the validity of the arguments: \a gadget

2355

must be an instance of the class of the QMetaObject of which this QMetaMethod

2356

has been constructed with. The arguments must have the same type as the ones

2357

expected by the method, else, the behavior is undefined.

2358

2359

\sa Q_ARG(), Q_RETURN_ARG(), qRegisterMetaType(), QMetaObject::invokeMethod()

2360

2361

bool QMetaMethod::invokeOnGadget(void* gadget, QGenericReturnArgument returnValue, QGenericArgument val0, QGenericArgument val1, QGenericArgument val2, QGenericArgument val3, QGenericArgument val4, QGenericArgument val5, QGenericArgument val6, QGenericArgument val7, QGenericArgument val8, QGenericArgument val9) const

2362

{

2363

if (!gadget || !mobj)

return false;

// check return type

if (returnValue.data()) {

2368

const char *retType = typeName();

2369

if (qstrcmp(returnValue.name(), retType) != 0) {

2370

// normalize the return value as well

2371

QByteArray normalized = QMetaObject::normalizedType(returnValue.name());

2372

if (qstrcmp(normalized.constData(), retType) != 0) {

2373

// String comparison failed, try compare the metatype.

2374

int t = returnType();

2375

if (t == QMetaType::UnknownType || t != QMetaType::type(normalized))

return false;

}

}

}

// check argument count (we don't allow invoking a method if given too few arguments)

2382

const char *typeNames[] = {

returnValue.name(),

val0.name(),

val1.name(),

val2.name(),

val3.name(),

val4.name(),

val5.name(),

val6.name(),

val7.name(),

val8.name(),

val9.name()

};

int paramCount;

for (paramCount = 1; paramCount < MaximumParamCount; ++paramCount) {

2397

if (qstrlen(typeNames[paramCount]) <= 0)

2398

break;

2399

}

2400

if (paramCount <= QMetaMethodPrivate::get(this)->parameterCount())

return false;

// invoke!

void *param[] = {

returnValue.data(),

val0.data(),

val1.data(),

val2.data(),

val3.data(),

val4.data(),

val5.data(),

val6.data(),

val7.data(),

val8.data(),

val9.data()

};

int idx_relative = QMetaMethodPrivate::get(this)->ownMethodIndex();

2418

Q_ASSERT(QMetaObjectPrivate::get(mobj)->revision >= 6);

2419

QObjectPrivate::StaticMetaCallFunction callFunction = mobj->d.static_metacall;

2420

if (!callFunction)

2421

return false;

2422

callFunction(reinterpret_cast<QObject*>(gadget), QMetaObject::InvokeMetaMethod, idx_relative, param);

return true;

}

/*!

\fn bool QMetaMethod::invokeOnGadget(void *gadget,

2428

QGenericArgument val0 = QGenericArgument(0),

2429

QGenericArgument val1 = QGenericArgument(),

2430

QGenericArgument val2 = QGenericArgument(),

2431

QGenericArgument val3 = QGenericArgument(),

2432

QGenericArgument val4 = QGenericArgument(),

2433

QGenericArgument val5 = QGenericArgument(),

2434

QGenericArgument val6 = QGenericArgument(),

2435

QGenericArgument val7 = QGenericArgument(),

2436

QGenericArgument val8 = QGenericArgument(),

2437

QGenericArgument val9 = QGenericArgument()) const

\overload

\since 5.5

This overload invokes this method for a \a gadget and ignores return values.

/*!

\class QMetaEnum

\inmodule QtCore

\brief The QMetaEnum class provides meta-data about an enumerator.

\ingroup objectmodel

Use name() for the enumerator's name. The enumerator's keys (names

2453

of each enumerated item) are returned by key(); use keyCount() to find

2454

the number of keys. isFlag() returns whether the enumerator is

2455

meant to be used as a flag, meaning that its values can be combined

2456

using the OR operator.

2457

2458

The conversion functions keyToValue(), valueToKey(), keysToValue(),

2459

and valueToKeys() allow conversion between the integer

2460

representation of an enumeration or set value and its literal

2461

representation. The scope() function returns the class scope this

2462

enumerator was declared in.

2463

2464

\sa QMetaObject, QMetaMethod, QMetaProperty

/*!

\fn bool QMetaEnum::isValid() const

2469

2470

Returns \c true if this enum is valid (has a name); otherwise returns

false.

\sa name()

/*!

\fn const QMetaObject *QMetaEnum::enclosingMetaObject() const

\internal

/*!

\fn QMetaEnum::QMetaEnum()

\internal

/*!

Returns the name of the enumerator (without the scope).

2489

2490

For example, the Qt::AlignmentFlag enumeration has \c

2491

AlignmentFlag as the name and \l Qt as the scope.

2492

2493

\sa isValid(), scope()

2494

2495

const char *QMetaEnum::name() const

{

if (!mobj)

return 0;

return rawStringData(mobj, mobj->d.data[handle]);

}

/*!

Returns the number of keys.

\sa key()

int QMetaEnum::keyCount() const

{

if (!mobj)

return 0;

return mobj->d.data[handle + 2];

}

/*!

Returns the key with the given \a index, or 0 if no such key exists.

2517

2518

\sa keyCount(), value(), valueToKey()

2519

2520

const char *QMetaEnum::key(int index) const

{

if (!mobj)

return 0;

int count = mobj->d.data[handle + 2];

2525

int data = mobj->d.data[handle + 3];

2526

if (index >= 0 && index < count)

2527

return rawStringData(mobj, mobj->d.data[data + 2*index]);

return 0;

}

/*!

Returns the value with the given \a index; or returns -1 if there

2533

is no such value.

2534

2535

\sa keyCount(), key(), keyToValue()

2536

2537

int QMetaEnum::value(int index) const

{

if (!mobj)

return 0;

int count = mobj->d.data[handle + 2];

2542

int data = mobj->d.data[handle + 3];

2543

if (index >= 0 && index < count)

2544

return mobj->d.data[data + 2*index + 1];

return -1;

}

/*!

Returns \c true if this enumerator is used as a flag; otherwise returns

2551

false.

2552

2553

When used as flags, enumerators can be combined using the OR

2554

operator.

2555

2556

\sa keysToValue(), valueToKeys()

2557

2558

bool QMetaEnum::isFlag() const

2559

{

2560

return mobj && mobj->d.data[handle + 1];

}

/*!

Returns the scope this enumerator was declared in.

2566

2567

For example, the Qt::AlignmentFlag enumeration has \c Qt as

2568

the scope and \c AlignmentFlag as the name.

\sa name()

const char *QMetaEnum::scope() const

2573

{

2574

return mobj ? objectClassName(mobj) : 0;

}

/*!

Returns the integer value of the given enumeration \a key, or -1

2579

if \a key is not defined.

2580

2581

If \a key is not defined, *\a{ok} is set to false; otherwise

2582

*\a{ok} is set to true.

2583

2584

For flag types, use keysToValue().

2585

2586

\sa valueToKey(), isFlag(), keysToValue()

2587

2588

int QMetaEnum::keyToValue(const char *key, bool *ok) const

{

if (ok != 0)

*ok = false;

if (!mobj || !key)

return -1;

uint scope = 0;

const char *qualified_key = key;

2596

const char *s = key + qstrlen(key);

2597

while (s > key && *s != ':')

2598

--s;

2599

if (s > key && *(s-1)==':') {

scope = s - key - 1;

key += scope + 2;

}

int count = mobj->d.data[handle + 2];

2604

int data = mobj->d.data[handle + 3];

2605

for (int i = 0; i < count; ++i) {

2606

const QByteArray className = stringData(mobj, priv(mobj->d.data)->className);

2607

if ((!scope || (className.size() == int(scope) && strncmp(qualified_key, className.constData(), scope) == 0))

2608

&& strcmp(key, rawStringData(mobj, mobj->d.data[data + 2*i])) == 0) {

2609

if (ok != 0)

2610

*ok = true;

2611

return mobj->d.data[data + 2*i + 1];

}

}

return -1;

}

/*!

Returns the string that is used as the name of the given

2619

enumeration \a value, or 0 if \a value is not defined.

2620

2621

For flag types, use valueToKeys().

2622

2623

\sa isFlag(), valueToKeys()

2624

2625

const char* QMetaEnum::valueToKey(int value) const

{

if (!mobj)

return 0;

int count = mobj->d.data[handle + 2];

2630

int data = mobj->d.data[handle + 3];

2631

for (int i = 0; i < count; ++i)

2632

if (value == (int)mobj->d.data[data + 2*i + 1])

2633

return rawStringData(mobj, mobj->d.data[data + 2*i]);

return 0;

}

/*!

Returns the value derived from combining together the values of

2639

the \a keys using the OR operator, or -1 if \a keys is not

2640

defined. Note that the strings in \a keys must be '|'-separated.

2641

2642

If \a keys is not defined, *\a{ok} is set to false; otherwise

2643

*\a{ok} is set to true.

2644

2645

\sa isFlag(), valueToKey(), valueToKeys()

2646

2647

int QMetaEnum::keysToValue(const char *keys, bool *ok) const

{

if (ok != 0)

*ok = false;

if (!mobj || !keys)

return -1;

if (ok != 0)

*ok = true;

QStringList l = QString::fromLatin1(keys).split(QLatin1Char('|'));

2656

if (l.isEmpty())

2657

return 0;

2658

//#### TODO write proper code, do not use QStringList

2659

int value = 0;

2660

int count = mobj->d.data[handle + 2];

2661

int data = mobj->d.data[handle + 3];

2662

for (int li = 0; li < l.size(); ++li) {

2663

QString trimmed = l.at(li).trimmed();

2664

QByteArray qualified_key = trimmed.toLatin1();

2665

const char *key = qualified_key.constData();

2666

uint scope = 0;

2667

const char *s = key + qstrlen(key);

2668

while (s > key && *s != ':')

2669

--s;

2670

if (s > key && *(s-1)==':') {

scope = s - key - 1;

key += scope + 2;

}

int i;

for (i = count-1; i >= 0; --i) {

2676

const QByteArray className = stringData(mobj, priv(mobj->d.data)->className);

2677

if ((!scope || (className.size() == int(scope) && strncmp(qualified_key.constData(), className.constData(), scope) == 0))

2678

&& strcmp(key, rawStringData(mobj, mobj->d.data[data + 2*i])) == 0) {

2679

value |= mobj->d.data[data + 2*i + 1];

break;

}

}

if (i < 0) {

if (ok != 0)

*ok = false;

value |= -1;

}

}

return value;

}

/*!

Returns a byte array of '|'-separated keys that represents the

2694

given \a value.

2695

2696

\sa isFlag(), valueToKey(), keysToValue()

2697

2698

QByteArray QMetaEnum::valueToKeys(int value) const

{

QByteArray keys;

if (!mobj)

return keys;

int count = mobj->d.data[handle + 2];

2704

int data = mobj->d.data[handle + 3];

2705

int v = value;

2706

// reverse iterate to ensure values like Qt::Dialog=0x2|Qt::Window are processed first.

2707

for (int i = count - 1; i >= 0; --i) {

2708

int k = mobj->d.data[data + 2*i + 1];

2709

if ((k != 0 && (v & k) == k ) || (k == value)) {

v = v & ~k;

if (!keys.isEmpty())

keys.prepend('|');

keys.prepend(stringData(mobj, mobj->d.data[data + 2*i]));

}

}

return keys;

}

/*!

\fn QMetaEnum QMetaEnum::fromType()

2721

\since 5.5

2722

2723

Returns the QMetaEnum corresponding to the type in the template parameter.

2724

The enum needs to be declared with Q_ENUM.

2725

2726

2727

static QByteArray qualifiedName(const QMetaEnum &e)

2728

{

2729

return QByteArray(e.scope()) + "::" + e.name();

}

/*!

\class QMetaProperty

\inmodule QtCore

\brief The QMetaProperty class provides meta-data about a property.

\ingroup objectmodel

Property meta-data is obtained from an object's meta-object. See

2740

QMetaObject::property() and QMetaObject::propertyCount() for

2741

details.

2742

2743

\section1 Property Meta-Data

2744

2745

A property has a name() and a type(), as well as various

2746

attributes that specify its behavior: isReadable(), isWritable(),

2747

isDesignable(), isScriptable(), revision(), and isStored().

2748

2749

If the property is an enumeration, isEnumType() returns \c true; if the

2750

property is an enumeration that is also a flag (i.e. its values

2751

can be combined using the OR operator), isEnumType() and

2752

isFlagType() both return true. The enumerator for these types is

2753

available from enumerator().

2754

2755

The property's values are set and retrieved with read(), write(),

2756

and reset(); they can also be changed through QObject's set and get

2757

functions. See QObject::setProperty() and QObject::property() for

2758

details.

2759

2760

\section1 Copying and Assignment

2761

2762

QMetaProperty objects can be copied by value. However, each copy will

2763

refer to the same underlying property meta-data.

2764

2765

\sa QMetaObject, QMetaEnum, QMetaMethod, {Qt's Property System}

/*!

\fn bool QMetaProperty::isValid() const

2770

2771

Returns \c true if this property is valid (readable); otherwise

returns \c false.

\sa isReadable()

/*!

\fn const QMetaObject *QMetaProperty::enclosingMetaObject() const

\internal

/*!

\internal

QMetaProperty::QMetaProperty()

2786

: mobj(0), handle(0), idx(0)

{

}

/*!

Returns this property's name.

2793

2794

\sa type(), typeName()

2795

2796

const char *QMetaProperty::name() const

{

if (!mobj)

return 0;

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2801

return rawStringData(mobj, mobj->d.data[handle]);

}

/*!

Returns the name of this property's type.

\sa type(), name()

const char *QMetaProperty::typeName() const

{

if (!mobj)

return 0;

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2814

return rawTypeNameFromTypeInfo(mobj, mobj->d.data[handle + 1]);

}

/*!

Returns this property's type. The return value is one

2819

of the values of the QVariant::Type enumeration.

2820

2821

\sa userType(), typeName(), name()

2822

2823

QVariant::Type QMetaProperty::type() const

2824

{

2825

if (!mobj)

2826

return QVariant::Invalid;

2827

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2828

2829

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

2830

uint type = typeFromTypeInfo(mobj, mobj->d.data[handle + 1]);

2831

if (type >= QMetaType::User)

2832

return QVariant::UserType;

2833

if (type != QMetaType::UnknownType)

2834

return QVariant::Type(type);

2835

if (isEnumType()) {

2836

int enumMetaTypeId = QMetaType::type(qualifiedName(menum));

2837

if (enumMetaTypeId == QMetaType::UnknownType)

2838

return QVariant::Int;

2839

}

2840

#ifdef QT_COORD_TYPE

2841

// qreal metatype must be resolved at runtime.

2842

if (strcmp(typeName(), "qreal") == 0)

2843

return QVariant::Type(qMetaTypeId<qreal>());

2844

#endif

2845

2846

return QVariant::UserType;

}

/*!

\since 4.2

Returns this property's user type. The return value is one

2853

of the values that are registered with QMetaType, or QMetaType::UnknownType if

2854

the type is not registered.

2855

2856

\sa type(), QMetaType, typeName()

2857

2858

int QMetaProperty::userType() const

2859

{

2860

if (!mobj)

2861

return QMetaType::UnknownType;

2862

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

2863

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2864

int type = typeFromTypeInfo(mobj, mobj->d.data[handle + 1]);

2865

if (type != QMetaType::UnknownType)

2866

return type;

2867

if (isEnumType()) {

2868

type = QMetaType::type(qualifiedName(menum));

2869

if (type == QMetaType::UnknownType) {

2870

type = registerPropertyType();

2871

if (type == QMetaType::UnknownType)

2872

return QVariant::Int; // Match behavior of QMetaType::type()

}

return type;

}

type = QMetaType::type(typeName());

2877

if (type != QMetaType::UnknownType)

2878

return type;

2879

return registerPropertyType();

}

/*!

\since 4.6

Returns this property's index.

2886

2887

int QMetaProperty::propertyIndex() const

{

if (!mobj)

return -1;

return idx + mobj->propertyOffset();

}

/*!

Returns \c true if the property's type is an enumeration value that

2896

is used as a flag; otherwise returns \c false.

2897

2898

Flags can be combined using the OR operator. A flag type is

2899

implicitly also an enum type.

2900

2901

\sa isEnumType(), enumerator(), QMetaEnum::isFlag()

2902

2903

2904

bool QMetaProperty::isFlagType() const

2905

{

2906

return isEnumType() && menum.isFlag();

}

/*!

Returns \c true if the property's type is an enumeration value;

2911

otherwise returns \c false.

2912

2913

\sa enumerator(), isFlagType()

2914

2915

bool QMetaProperty::isEnumType() const

{

if (!mobj)

return false;

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2920

int flags = mobj->d.data[handle + 2];

2921

return (flags & EnumOrFlag) && menum.name();

}

/*!

\internal

Returns \c true if the property has a C++ setter function that

2928

follows Qt's standard "name" / "setName" pattern. Designer and uic

2929

query hasStdCppSet() in order to avoid expensive

2930

QObject::setProperty() calls. All properties in Qt [should] follow

2931

this pattern.

2932

2933

bool QMetaProperty::hasStdCppSet() const

{

if (!mobj)

return false;

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2938

int flags = mobj->d.data[handle + 2];

2939

return (flags & StdCppSet);

}

/*!

\internal

Executes metacall with QMetaObject::RegisterPropertyMetaType flag.

2945

Returns id of registered type or QMetaType::UnknownType if a type

2946

could not be registered for any reason.

2947

2948

int QMetaProperty::registerPropertyType() const

2949

{

2950

int registerResult = -1;

2951

void *argv[] = { &registerResult };

2952

mobj->static_metacall(QMetaObject::RegisterPropertyMetaType, idx, argv);

2953

return registerResult == -1 ? QMetaType::UnknownType : registerResult;

}

/*!

Returns the enumerator if this property's type is an enumerator

2958

type; otherwise the returned value is undefined.

2959

2960

\sa isEnumType(), isFlagType()

2961

2962

QMetaEnum QMetaProperty::enumerator() const

{

return menum;

}

/*!

Reads the property's value from the given \a object. Returns the value

2969

if it was able to read it; otherwise returns an invalid variant.

2970

2971

\sa write(), reset(), isReadable()

2972

2973

QVariant QMetaProperty::read(const QObject *object) const

2974

{

2975

if (!object || !mobj)

2976

return QVariant();

2977

2978

uint t = QVariant::Int;

2979

if (isEnumType()) {

2980

2981

try to create a QVariant that can be converted to this enum

2982

type (only works if the enum has already been registered

2983

with QMetaType)

2984

2985

int enumMetaTypeId = QMetaType::type(qualifiedName(menum));

2986

if (enumMetaTypeId != QMetaType::UnknownType)

2987

t = enumMetaTypeId;

2988

} else {

2989

int handle = priv(mobj->d.data)->propertyData + 3*idx;

2990

const char *typeName = 0;

2991

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

2992

uint typeInfo = mobj->d.data[handle + 1];

2993

if (!(typeInfo & IsUnresolvedType))

2994

t = typeInfo;

2995

else {

2996

typeName = rawStringData(mobj, typeInfo & TypeNameIndexMask);

2997

t = QMetaType::type(typeName);

2998

}

2999

if (t == QMetaType::UnknownType) {

3000

// Try to register the type and try again before reporting an error.

3001

t = registerPropertyType();

3002

if (t == QMetaType::UnknownType) {

3003

qWarning("QMetaProperty::read: Unable to handle unregistered datatype '%s' for property '%s::%s'", typeName, mobj->className(), name());

return QVariant();

}

}

}

// the status variable is changed by qt_metacall to indicate what it did

3010

// this feature is currently only used by Qt D-Bus and should not be depended

3011

// upon. Don't change it without looking into QDBusAbstractInterface first

3012

// -1 (unchanged): normal qt_metacall, result stored in argv[0]

3013

// changed: result stored directly in value

3014

int status = -1;

3015

QVariant value;

3016

void *argv[] = { 0, &value, &status };

3017

if (t == QMetaType::QVariant) {

3018

argv[0] = &value;

3019

} else {

3020

value = QVariant(t, (void*)0);

3021

argv[0] = value.data();

3022

}

3023

if (priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall) {

3024

mobj->d.static_metacall(const_cast<QObject*>(object), QMetaObject::ReadProperty, idx, argv);

3025

} else {

3026

QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::ReadProperty,

3027

idx + mobj->propertyOffset(), argv);

}

if (status != -1)

return value;

if (t != QMetaType::QVariant && argv[0] != value.data())

3033

// pointer or reference

3034

return QVariant((QVariant::Type)t, argv[0]);

return value;

}

/*!

Writes \a value as the property's value to the given \a object. Returns

3040

true if the write succeeded; otherwise returns \c false.

3041

3042

If \a value is not of the same type type as the property, a conversion

3043

is attempted. An empty QVariant() is equivalent to a call to reset()

3044

if this property is resetable, or setting a default-constructed object

3045

otherwise.

3046

3047

\sa read(), reset(), isWritable()

3048

3049

bool QMetaProperty::write(QObject *object, const QVariant &value) const

3050

{

3051

if (!object || !isWritable())

return false;

QVariant v = value;

uint t = QVariant::Invalid;

3056

if (isEnumType()) {

3057

if (v.type() == QVariant::String) {

3058

bool ok;

3059

if (isFlagType())

3060

v = QVariant(menum.keysToValue(value.toByteArray(), &ok));

3061

else

3062

v = QVariant(menum.keyToValue(value.toByteArray(), &ok));

3063

if (!ok)

3064

return false;

3065

} else if (v.type() != QVariant::Int && v.type() != QVariant::UInt) {

3066

int enumMetaTypeId = QMetaType::type(qualifiedName(menum));

3067

if ((enumMetaTypeId == QMetaType::UnknownType) || (v.userType() != enumMetaTypeId) || !v.constData())

3068

return false;

3069

v = QVariant(*reinterpret_cast<const int *>(v.constData()));

3070

}

3071

v.convert(QVariant::Int);

3072

} else {

3073

int handle = priv(mobj->d.data)->propertyData + 3*idx;

3074

const char *typeName = 0;

3075

Q_ASSERT(priv(mobj->d.data)->revision >= 7);

3076

uint typeInfo = mobj->d.data[handle + 1];

3077

if (!(typeInfo & IsUnresolvedType))

3078

t = typeInfo;

3079

else {

3080

typeName = rawStringData(mobj, typeInfo & TypeNameIndexMask);

3081

t = QMetaType::type(typeName);

3082

if (t == QMetaType::UnknownType)

3083

t = registerPropertyType();

3084

if (t == QMetaType::UnknownType)

3085

return false;

3086

}

3087

if (t != QMetaType::QVariant && int(t) != value.userType()) {

3088

if (!value.isValid()) {

3089

if (isResettable())

3090

return reset(object);

3091

v = QVariant(t, 0);

3092

} else if (!v.convert(t)) {

return false;

}

}

}

// the status variable is changed by qt_metacall to indicate what it did

3099

// this feature is currently only used by Qt D-Bus and should not be depended

3100

// upon. Don't change it without looking into QDBusAbstractInterface first

3101

// -1 (unchanged): normal qt_metacall, result stored in argv[0]

3102

// changed: result stored directly in value, return the value of status

3103

int status = -1;

3104

// the flags variable is used by the declarative module to implement

3105

// interception of property writes.

3106

int flags = 0;

3107

void *argv[] = { 0, &v, &status, &flags };

3108

if (t == QMetaType::QVariant)

argv[0] = &v;

else

argv[0] = v.data();

if (priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall)

3113

mobj->d.static_metacall(object, QMetaObject::WriteProperty, idx, argv);

3114

else

3115

QMetaObject::metacall(object, QMetaObject::WriteProperty, idx + mobj->propertyOffset(), argv);

return status;

}

/*!

Resets the property for the given \a object with a reset method.

3122

Returns \c true if the reset worked; otherwise returns \c false.

3123

3124

Reset methods are optional; only a few properties support them.

\sa read(), write()

bool QMetaProperty::reset(QObject *object) const

3129

{

3130

if (!object || !mobj || !isResettable())

3131

return false;

3132

void *argv[] = { 0 };

3133

if (priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall)

3134

mobj->d.static_metacall(object, QMetaObject::ResetProperty, idx, argv);

3135

else

3136

QMetaObject::metacall(object, QMetaObject::ResetProperty, idx + mobj->propertyOffset(), argv);

return true;

}

/*!

\since 5.5

Reads the property's value from the given \a gadget. Returns the value

3143

if it was able to read it; otherwise returns an invalid variant.

3144

3145

This function should only be used if this is a property of a Q_GADGET

3146

3147

QVariant QMetaProperty::readOnGadget(const void *gadget) const

3148

{

3149

Q_ASSERT(priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall);

3150

return read(reinterpret_cast<const QObject*>(gadget));

}

/*!

\since 5.5

Writes \a value as the property's value to the given \a gadget. Returns

3157

true if the write succeeded; otherwise returns \c false.

3158

3159

This function should only be used if this is a property of a Q_GADGET

3160

3161

bool QMetaProperty::writeOnGadget(void *gadget, const QVariant &value) const

3162

{

3163

Q_ASSERT(priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall);

3164

return write(reinterpret_cast<QObject*>(gadget), value);

}

/*!

\since 5.5

Resets the property for the given \a gadget with a reset method.

3171

Returns \c true if the reset worked; otherwise returns \c false.

3172

3173

Reset methods are optional; only a few properties support them.

3174

3175

This function should only be used if this is a property of a Q_GADGET

3176

3177

bool QMetaProperty::resetOnGadget(void *gadget) const

3178

{

3179

Q_ASSERT(priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall);

3180

return reset(reinterpret_cast<QObject*>(gadget));

}

/*!

Returns \c true if this property can be reset to a default value; otherwise

returns \c false.

\sa reset()

bool QMetaProperty::isResettable() const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3194

return flags & Resettable;

}

/*!

Returns \c true if this property is readable; otherwise returns \c false.

3199

3200

\sa isWritable(), read(), isValid()

3201

3202

bool QMetaProperty::isReadable() const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3207

return flags & Readable;

}

/*!

Returns \c true if this property has a corresponding change notify signal;

3212

otherwise returns \c false.

\sa notifySignal()

bool QMetaProperty::hasNotifySignal() const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3221

return flags & Notify;

}

/*!

\since 4.5

Returns the QMetaMethod instance of the property change notifying signal if

3228

one was specified, otherwise returns an invalid QMetaMethod.

3229

3230

\sa hasNotifySignal()

3231

3232

QMetaMethod QMetaProperty::notifySignal() const

3233

{

3234

int id = notifySignalIndex();

3235

if (id != -1)

3236

return mobj->method(id);

3237

else

3238

return QMetaMethod();

}

/*!

\since 4.6

Returns the index of the property change notifying signal if one was

3245

specified, otherwise returns -1.

3246

3247

\sa hasNotifySignal()

3248

3249

int QMetaProperty::notifySignalIndex() const

3250

{

3251

if (hasNotifySignal()) {

3252

int offset = priv(mobj->d.data)->propertyData +

3253

priv(mobj->d.data)->propertyCount * 3 + idx;

3254

return mobj->d.data[offset] + mobj->methodOffset();

} else {

return -1;

}

}

// This method has been around for a while, but the documentation was marked \internal until 5.1

/*!

\since 5.1

Returns the property revision if one was

3265

specified by REVISION, otherwise returns 0.

3266

3267

int QMetaProperty::revision() const

{

if (!mobj)

return 0;

int flags = mobj->d.data[handle + 2];

3272

if (flags & Revisioned) {

3273

int offset = priv(mobj->d.data)->propertyData +

3274

priv(mobj->d.data)->propertyCount * 3 + idx;

3275

// Revision data is placed after NOTIFY data, if present.

3276

// Iterate through properties to discover whether we have NOTIFY signals.

3277

for (int i = 0; i < priv(mobj->d.data)->propertyCount; ++i) {

3278

int handle = priv(mobj->d.data)->propertyData + 3*i;

3279

if (mobj->d.data[handle + 2] & Notify) {

3280

offset += priv(mobj->d.data)->propertyCount;

break;

}

}

return mobj->d.data[offset];

} else {

return 0;

}

}

/*!

Returns \c true if this property is writable; otherwise returns

3292

false.

3293

3294

\sa isReadable(), write()

3295

3296

bool QMetaProperty::isWritable() const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3301

return flags & Writable;

}

/*!

Returns \c true if this property is designable for the given \a object;

3307

otherwise returns \c false.

3308

3309

If no \a object is given, the function returns \c false if the

3310

\c{Q_PROPERTY()}'s \c DESIGNABLE attribute is false; otherwise

3311

returns \c true (if the attribute is true or is a function or expression).

3312

3313

\sa isScriptable(), isStored()

3314

3315

bool QMetaProperty::isDesignable(const QObject *object) const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3320

bool b = flags & Designable;

3321

if (object) {

3322

void *argv[] = { &b };

3323

QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::QueryPropertyDesignable,

3324

idx + mobj->propertyOffset(), argv);

}

return b;

}

/*!

Returns \c true if the property is scriptable for the given \a object;

3333

otherwise returns \c false.

3334

3335

If no \a object is given, the function returns \c false if the

3336

\c{Q_PROPERTY()}'s \c SCRIPTABLE attribute is false; otherwise returns

3337

true (if the attribute is true or is a function or expression).

3338

3339

\sa isDesignable(), isStored()

3340

3341

bool QMetaProperty::isScriptable(const QObject *object) const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3346

bool b = flags & Scriptable;

3347

if (object) {

3348

void *argv[] = { &b };

3349

QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::QueryPropertyScriptable,

3350

idx + mobj->propertyOffset(), argv);

}

return b;

}

/*!

Returns \c true if the property is stored for \a object; otherwise returns

3357

false.

3358

3359

If no \a object is given, the function returns \c false if the

3360

\c{Q_PROPERTY()}'s \c STORED attribute is false; otherwise returns

3361

true (if the attribute is true or is a function or expression).

3362

3363

\sa isDesignable(), isScriptable()

3364

3365

bool QMetaProperty::isStored(const QObject *object) const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3370

bool b = flags & Stored;

3371

if (object) {

3372

void *argv[] = { &b };

3373

QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::QueryPropertyStored,

3374

idx + mobj->propertyOffset(), argv);

}

return b;

}

/*!

Returns \c true if this property is designated as the \c USER

3381

property, i.e., the one that the user can edit for \a object or

3382

that is significant in some other way. Otherwise it returns

3383

false. e.g., the \c text property is the \c USER editable property

3384

of a QLineEdit.

3385

3386

If \a object is null, the function returns \c false if the \c

3387

{Q_PROPERTY()}'s \c USER attribute is false. Otherwise it returns

3388

true.

3389

3390

\sa QMetaObject::userProperty(), isDesignable(), isScriptable()

3391

3392

bool QMetaProperty::isUser(const QObject *object) const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3397

bool b = flags & User;

3398

if (object) {

3399

void *argv[] = { &b };

3400

QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::QueryPropertyUser,

3401

idx + mobj->propertyOffset(), argv);

}

return b;

}

/*!

\since 4.6

Returns \c true if the property is constant; otherwise returns \c false.

3409

3410

A property is constant if the \c{Q_PROPERTY()}'s \c CONSTANT attribute

3411

is set.

3412

3413

bool QMetaProperty::isConstant() const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3418

return flags & Constant;

}

/*!

\since 4.6

Returns \c true if the property is final; otherwise returns \c false.

3424

3425

A property is final if the \c{Q_PROPERTY()}'s \c FINAL attribute

3426

is set.

3427

3428

bool QMetaProperty::isFinal() const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3433

return flags & Final;

}

/*!

\obsolete

Returns \c true if the property is editable for the given \a object;

3440

otherwise returns \c false.

3441

3442

If no \a object is given, the function returns \c false if the

3443

\c{Q_PROPERTY()}'s \c EDITABLE attribute is false; otherwise returns

3444

true (if the attribute is true or is a function or expression).

3445

3446

\sa isDesignable(), isScriptable(), isStored()

3447

3448

bool QMetaProperty::isEditable(const QObject *object) const

{

if (!mobj)

return false;

int flags = mobj->d.data[handle + 2];

3453

bool b = flags & Editable;

3454

if (object) {

3455

void *argv[] = { &b };

3456

QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::QueryPropertyEditable,

3457

idx + mobj->propertyOffset(), argv);

}

return b;

}

/*!

\class QMetaClassInfo

3464

\inmodule QtCore

3465

3466

\brief The QMetaClassInfo class provides additional information

about a class.

\ingroup objectmodel

Class information items are simple \e{name}--\e{value} pairs that

3472

are specified using Q_CLASSINFO() in the source code. The

3473

information can be retrieved using name() and value(). For example:

3474

3475

\snippet code/src_corelib_kernel_qmetaobject.cpp 5

3476

3477

This mechanism is free for you to use in your Qt applications. Qt

3478

doesn't use it for any of its classes.

\sa QMetaObject

/*!

\fn QMetaClassInfo::QMetaClassInfo()

\internal

/*!

\fn const QMetaObject *QMetaClassInfo::enclosingMetaObject() const

\internal

/*!

Returns the name of this item.

\sa value()

const char *QMetaClassInfo::name() const

{

if (!mobj)

return 0;

return rawStringData(mobj, mobj->d.data[handle]);

}

/*!

Returns the value of this item.

\sa name()

const char* QMetaClassInfo::value() const

{

if (!mobj)

return 0;

return rawStringData(mobj, mobj->d.data[handle + 1]);

}

/*!

\macro QGenericArgument Q_ARG(Type, const Type &value)

3520

\relates QMetaObject

3521

3522

This macro takes a \a Type and a \a value of that type and

3523

returns a \l QGenericArgument object that can be passed to

3524

QMetaObject::invokeMethod().

\sa Q_RETURN_ARG()

/*!

\macro QGenericReturnArgument Q_RETURN_ARG(Type, Type &value)

3531

\relates QMetaObject

3532

3533

This macro takes a \a Type and a non-const reference to a \a

3534

value of that type and returns a QGenericReturnArgument object

3535

that can be passed to QMetaObject::invokeMethod().

\sa Q_ARG()

/*!

\class QGenericArgument

3542

\inmodule QtCore

3543

3544

\brief The QGenericArgument class is an internal helper class for

3545

marshalling arguments.

3546

3547

This class should never be used directly. Please use the \l Q_ARG()

3548

macro instead.

3549

3550

\sa Q_ARG(), QMetaObject::invokeMethod(), QGenericReturnArgument

/*!

\fn QGenericArgument::QGenericArgument(const char *name, const void *data)

3555

3556

Constructs a QGenericArgument object with the given \a name and \a data.

/*!

\fn QGenericArgument::data () const

3561

3562

Returns the data set in the constructor.

/*!

\fn QGenericArgument::name () const

3567

3568

Returns the name set in the constructor.

/*!

\class QGenericReturnArgument

3573

\inmodule QtCore

3574

3575

\brief The QGenericReturnArgument class is an internal helper class for

3576

marshalling arguments.

3577

3578

This class should never be used directly. Please use the

3579

Q_RETURN_ARG() macro instead.

3580

3581

\sa Q_RETURN_ARG(), QMetaObject::invokeMethod(), QGenericArgument

/*!

\fn QGenericReturnArgument::QGenericReturnArgument(const char *name, void *data)

3586

3587

Constructs a QGenericReturnArgument object with the given \a name

and \a data.

/*!

\internal

If the local_method_index is a cloned method, return the index of the original.

3594

3595

Example: if the index of "destroyed()" is passed, the index of "destroyed(QObject*)" is returned

3596

3597

int QMetaObjectPrivate::originalClone(const QMetaObject *mobj, int local_method_index)

3598

{

3599

Q_ASSERT(local_method_index < get(mobj)->methodCount);

3600

int handle = get(mobj)->methodData + 5 * local_method_index;

3601

while (mobj->d.data[handle + 4] & MethodCloned) {

3602

Q_ASSERT(local_method_index > 0);

3603

handle -= 5;

3604

local_method_index--;

3605

}

3606

return local_method_index;

}

/*!

\internal

Returns the parameter type names extracted from the given \a signature.

3613

3614

QList<QByteArray> QMetaObjectPrivate::parameterTypeNamesFromSignature(const char *signature)

3615

{

3616

QList<QByteArray> list;

3617

while (*signature && *signature != '(')

3618

++signature;

3619

while (*signature && *signature != ')' && *++signature != ')') {

3620

const char *begin = signature;

3621

int level = 0;

3622

while (*signature && (level > 0 || *signature != ',') && *signature != ')') {

3623

if (*signature == '<')

3624

++level;

3625

else if (*signature == '>')

--level;

++signature;

}

list += QByteArray(begin, signature - begin);

}

return list;

}

QT_END_NAMESPACE

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9