qObjectnode::
qObjectnode(QObject *data, QGraphicsItem *parent, bool autodelete) : GraphicsNode(parent),m_autodelete(autodelete)
{
m_data=data;
if(m_data==0)
qWarning("NULL Data Object!");
else {
QWidget* tst = dynamic_cast<QWidget*>(data);
if(tst!=0)
setCentralWidget(tst);
const QMetaObject* m = m_data->metaObject();
int property_count = m->propertyCount()-1;
for(;property_count>=0;property_count--) {
QMetaProperty prop = m->property(property_count);
if(prop.isConstant() || !prop.isUser())
continue;
if(prop.isReadable() && prop.hasNotifySignal())
{
add_source(QString(prop.name()) + "[" +QString(prop.typeName()) +"]",m_data,property_count);
}
if(prop.isWritable())
add_sink(QString(prop.name()) + "[" +QString(prop.typeName()) +"]",m_data,property_count);
}
}
}
QVariant ObjectStaticPropertyModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || !m_obj || index.row() < 0 ||
index.row() >= m_obj.data()->metaObject()->propertyCount()) {
return QVariant();
}
const QMetaProperty prop = m_obj.data()->metaObject()->property(index.row());
if (role == Qt::DisplayRole) {
if (index.column() == 0) {
return prop.name();
} else if (index.column() == 1) {
// QMetaProperty::read sets QVariant::typeName to int for enums,
// so we need to handle that separately here
const QVariant value = prop.read(m_obj.data());
const QString enumStr = Util::enumToString(value, prop.typeName(), m_obj.data());
if (!enumStr.isEmpty()) {
return enumStr;
}
return VariantHandler::displayString(value);
} else if (index.column() == 2) {
return prop.typeName();
} else if (index.column() == 3) {
const QMetaObject *mo = m_obj.data()->metaObject();
while (mo->propertyOffset() > index.row()) {
mo = mo->superClass();
}
return mo->className();
}
} else if (role == Qt::DecorationRole) {
if (index.column() == 1) {
return VariantHandler::decoration(prop.read(m_obj.data()));
}
} else if (role == Qt::EditRole) {
if (index.column() == 1) {
return prop.read(m_obj.data());
}
} else if (role == Qt::ToolTipRole) {
const QString toolTip =
tr("Constant: %1\nDesignable: %2\nFinal: %3\nResetable: %4\n"
"Has notification: %5\nScriptable: %6\nStored: %7\nUser: %8\nWritable: %9").
arg(translateBool(prop.isConstant())).
arg(translateBool(prop.isDesignable(m_obj.data()))).
arg(translateBool(prop.isFinal())).
arg(translateBool(prop.isResettable())).
arg(translateBool(prop.hasNotifySignal())).
arg(translateBool(prop.isScriptable(m_obj.data()))).
arg(translateBool(prop.isStored(m_obj.data()))).
arg(translateBool(prop.isUser(m_obj.data()))).
arg(translateBool(prop.isWritable()));
return toolTip;
}
return QVariant();
}
static int writeProperty(QObject *obj, const QByteArray &property_name, QVariant value,
int propFlags = QDBusConnection::ExportAllProperties)
{
const QMetaObject *mo = obj->metaObject();
int pidx = mo->indexOfProperty(property_name);
if (pidx == -1) {
// this object has no property by that name
return PropertyNotFound;
}
QMetaProperty mp = mo->property(pidx);
// check if this property is writable
if (!mp.isWritable())
return PropertyReadOnly;
// check if this property is exported
bool isScriptable = mp.isScriptable();
if (!(propFlags & QDBusConnection::ExportScriptableProperties) && isScriptable)
return PropertyNotFound;
if (!(propFlags & QDBusConnection::ExportNonScriptableProperties) && !isScriptable)
return PropertyNotFound;
// we found our property
// do we have the right type?
int id = mp.userType();
if (!id){
// type not registered or invalid / void?
qWarning("QDBusConnection: Unable to handle unregistered datatype '%s' for property '%s::%s'",
mp.typeName(), mo->className(), property_name.constData());
return PropertyWriteFailed;
}
if (id != QMetaType::QVariant && value.userType() == QDBusMetaTypeId::argument()) {
// we have to demarshall before writing
void *null = 0;
QVariant other(id, null);
if (!QDBusMetaType::demarshall(qvariant_cast<QDBusArgument>(value), id, other.data())) {
qWarning("QDBusConnection: type `%s' (%d) is not registered with QtDBus. "
"Use qDBusRegisterMetaType to register it",
mp.typeName(), id);
return PropertyWriteFailed;
}
value = other;
}
if (mp.userType() == qMetaTypeId<QDBusVariant>())
value = QVariant::fromValue(QDBusVariant(value));
// the property type here should match
return mp.write(obj, value) ? PropertyWriteSuccess : PropertyWriteFailed;
}
QSObject QSAEditor::queryQSObject( const QMetaObject *meta, const QString &property, bool /*includeSuperClass*/ ) const
{
int propertyIndex = -1;
const QMetaObject *m = meta;
propertyIndex = m->indexOfProperty(property.toLatin1().constData());
if (propertyIndex >= 0) {
QMetaProperty mp = m->property(propertyIndex);
QSObject o = vTypeToQSType( QString::fromLatin1(mp.typeName()) );
if ( !o.isNull() && !o.isUndefined() )
return o;
}
m = meta;
for (int i=0; i<m->methodCount(); ++i) {
QMetaMethod mm = m->method(i);
if (mm.methodType() == QMetaMethod::Slot) {
QString n = QLatin1String(mm.methodSignature());
n = n.left(n.indexOf('('));
if ( property != n )
continue;
return vTypeToQSType(mm.typeName());
}
}
return env()->createUndefined();
}
QWidget* Enums::createEditor(QWidget * parent, const QModelIndex & index)
{
Q_UNUSED(index);
const QMetaObject * metaObject = object()->metaObject();
QMetaProperty metaProperty = metaObject->property(objectProperty());
const char *typeName = metaProperty.typeName();
int enumIdx = metaObject->indexOfEnumerator(typeName);
QStringList excludeList;
if (int index = metaObject->indexOfProperty(QString("_%1_exclude").arg(metaProperty.name()).toLatin1())) {
excludeList = metaObject->property(index).read(object()).toStringList();
}
cb = new QComboBox(parent);
for (int en = 0; en < metaObject->enumerator(enumIdx).keyCount(); ++en) {
QString itemName = metaObject->enumerator(enumIdx).key(en);
int itemData = metaObject->enumerator(enumIdx).value(en);
if (!excludeList.contains(itemName))
cb->insertItem(en, itemName, itemData);
}
connect(cb, SIGNAL(currentIndexChanged(int)), this, SLOT(setValue(int)));
return cb;
}
static QVariantMap readAllProperties(QObject *object, int flags)
{
QVariantMap result;
const QMetaObject *mo = object->metaObject();
// QObject has properties, so don't start from 0
for (int i = QObject::staticMetaObject.propertyCount(); i < mo->propertyCount(); ++i) {
QMetaProperty mp = mo->property(i);
// is it readable?
if (!mp.isReadable())
continue;
// is it a registered property?
int typeId = qDBusNameToTypeId(mp.typeName());
if (!typeId)
continue;
const char *signature = QDBusMetaType::typeToSignature(typeId);
if (!signature)
continue;
// is this property visible from the outside?
if ((mp.isScriptable() && flags & QDBusConnection::ExportScriptableProperties) ||
(!mp.isScriptable() && flags & QDBusConnection::ExportNonScriptableProperties)) {
// yes, it's visible
QVariant value = mp.read(object);
if (value.isValid())
result.insert(QString::fromLatin1(mp.name()), value);
}
}
return result;
}
// Creates a string, describing an object, using meta-object introspection
QString objToString(const QObject *obj) {
QStringList result;
const QMetaObject *meta = obj->metaObject();
result += QString("class %1 : public %2 {").arg(meta->className())
.arg(meta->superClass()->className());
for (auto i=0; i < meta->propertyCount(); ++i) {
const QMetaProperty property = meta->property(i);
QVariant value = obj->property(property.name());
if (value.canConvert(QVariant::String))
result += QString(" %1 %2 = %3;")
.arg(property.typeName())
.arg(property.name())
.arg(value.toString());
}
QString signalPrefix("");
for (auto i=0; i < meta->methodCount(); ++i) {
const QMetaMethod method = meta->method(i);
const QMetaMethod::MethodType methodType = method.methodType();
if (methodType == QMetaMethod::Signal)
signalPrefix = QStringLiteral("Q_SIGNAL");
else if (methodType == QMetaMethod::Slot)
signalPrefix = QStringLiteral("Q_SLOT");
result += QString(" %1 %2 %3;")
.arg(signalPrefix)
.arg(QVariant::typeToName(method.returnType()))
.arg(QString(method.methodSignature()));
}
result += "};";
return result.join("\n");
}
void QDBusViewer::setProperty(const BusSignature &sig)
{
QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
QMetaProperty prop = iface.metaObject()->property(iface.metaObject()->indexOfProperty(sig.mName.toLatin1()));
bool ok;
QString input = QInputDialog::getText(this, tr("Arguments"),
tr("Please enter the value of the property %1 (type %2)").arg(
sig.mName, QString::fromLatin1(prop.typeName())),
QLineEdit::Normal, QString(), &ok);
if (!ok)
return;
QVariant value = input;
if (!value.convert(prop.type())) {
QMessageBox::warning(this, tr("Unable to marshall"),
tr("Value conversion failed, unable to set property"));
return;
}
QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Set"));
QList<QVariant> arguments;
arguments << sig.mInterface << sig.mName << qVariantFromValue(QDBusVariant(value));
message.setArguments(arguments);
c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
}
extern "C" SEXP qt_qproperties(SEXP x) {
const QMetaObject *meta = unwrapSmoke(x, QMetaObject);
int n = meta->propertyCount();
SEXP ans, ans_type, ans_name, ans_readable, ans_writable;
PROTECT(ans = allocVector(VECSXP, 4));
ans_name = allocVector(STRSXP, n);
SET_VECTOR_ELT(ans, 0, ans_name);
ans_type = allocVector(STRSXP, n);
SET_VECTOR_ELT(ans, 1, ans_type);
ans_readable = allocVector(LGLSXP, n);
SET_VECTOR_ELT(ans, 2, ans_readable);
ans_writable = allocVector(LGLSXP, n);
SET_VECTOR_ELT(ans, 3, ans_writable);
for (int i = 0; i < n; i++) {
QMetaProperty metaProperty = meta->property(i);
SET_STRING_ELT(ans_type, i, mkChar(metaProperty.typeName()));
SET_STRING_ELT(ans_name, i, mkChar(metaProperty.name()));
LOGICAL(ans_readable)[i] = metaProperty.isReadable();
LOGICAL(ans_writable)[i] = metaProperty.isWritable();
}
UNPROTECT(1);
return ans;
}
ExpressionType type(const QByteArray& name, const QMetaProperty& prop) const
{
ExpressionType typeGet(ExpressionType::Lambda);
typeGet.addParameter(ExpressionType(name))
.addParameter(toExpressionType(prop.type(), prop.typeName()));
return typeGet;
}
bool QObject::setProperty(const char *name, const QVariant &value)
{
const QMetaObject* metaObj = metaObject();
if (! name || ! metaObj) {
return false;
}
int index = metaObj->indexOfProperty(name);
if (index < 0) {
const int k = m_extra_propertyNames.indexOf(name);
if (value.isValid()) {
// add or update dynamic property
if (k == -1) {
m_extra_propertyNames.append(name);
m_extra_propertyValues.append(value);
} else {
m_extra_propertyValues[k] = value;
}
} else {
// remove dynamic property
if (k == -1) {
return false;
}
m_extra_propertyNames.removeAt(k);
m_extra_propertyValues.removeAt(k);
}
QDynamicPropertyChangeEvent event(name);
QCoreApplication::sendEvent(this, &event);
return false;
}
QMetaProperty p = metaObj->property(index);
if (! p.isWritable()) {
qWarning("%s::setProperty() Property \"%s\" is invalid, read only, or does not exist", metaObj->className(), name);
}
//
bool retval = p.write(this, value);
if (! retval) {
qWarning("%s::setProperty() Set property \"%s\" failed. Passed value is of type %s, property is of type %s",
metaObj->className(), name, value.typeName(), p.typeName() );
}
return retval;
}
void QJnextMainLoop::set(QObject *object, QVariantList& args,
QByteArray* retval) {
QByteArray property = args.takeFirst().toByteArray();
const QMetaObject * meta = object->metaObject();
int propertyIndex = meta->indexOfProperty(property);
if (propertyIndex < 0) {
retval->append("No such property " + property);
return;
}
QMetaProperty metaprop = meta->property(propertyIndex);
if (!metaprop.isWritable()) {
retval->append("Property " + property + " is not writable");
return;
}
QVariant vValue = args.takeFirst();
/* handle enum inputs as text */
if (metaprop.isEnumType()) {
int id;
const QMetaEnum &enumerator = metaprop.enumerator();
QByteArray keys;
for (int i = 0; i < enumerator.keyCount(); ++i)
keys += enumerator.key(i) + QByteArray(" ");
#ifdef DEBUG_QJnextMainLoop
qDebug() << "[QJnextMainLoop]\tEnumerator" << enumerator.isFlag() << enumerator.scope() << enumerator.name() <<
keys;
#endif
if (enumerator.isFlag())
id = enumerator.keyToValue(vValue.toByteArray().constData());
else
id = enumerator.keysToValue(vValue.toByteArray().constData());
if (id != -1)
vValue = QVariant(id);
}
#ifdef DEBUG_QJnextMainLoop
qDebug() << "[QJnextMainLoop]\tSET" << meta->className() << property << vValue
<< vValue.canConvert(metaprop.type());
#endif
if (!vValue.convert(metaprop.type())) {
retval->append(
"Unable to convert \"" + vValue.toByteArray() + "\" to "
+ metaprop.typeName());
return;
}
if (!metaprop.write(object, vValue))
retval->append(
QByteArray("Unable to set property ") + meta->className() + "."
+ property + " to " + vValue.toByteArray());
else
*retval = QByteArray();
}
QVariant QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp) const
{
if (!connection.isConnected()) // not connected
return QVariant();
// try to read this property
QDBusMessage msg = QDBusMessage::createMethodCall(service, path,
QLatin1String(DBUS_INTERFACE_PROPERTIES),
QLatin1String("Get"));
msg << interface << QString::fromUtf8(mp.name());
QDBusMessage reply = connection.call(msg, QDBus::Block);
if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 1 &&
reply.signature() == QLatin1String("v")) {
QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant();
// make sure the type is right
if (qstrcmp(mp.typeName(), value.typeName()) == 0) {
if (mp.type() == QVariant::LastType)
// QVariant is special in this context
return qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant();
return value;
}
}
// there was an error...
if (reply.type() == QDBusMessage::ErrorMessage)
lastError = reply;
else if (reply.signature() != QLatin1String("v")) {
QString errmsg = QLatin1String("Invalid signature `%1' in return from call to "
DBUS_INTERFACE_PROPERTIES);
lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(reply.signature()));
} else {
QString errmsg = QLatin1String("Unexpected type `%1' when retrieving property "
"`%2 %3.%4'");
lastError = QDBusError(QDBusError::InvalidSignature,
errmsg.arg(QLatin1String(reply.arguments().at(0).typeName()),
QLatin1String(mp.typeName()),
interface, QString::fromUtf8(mp.name())));
}
return QVariant();
}
QVariant Properties::data( const QModelIndex & index, int role ) const
{
if ( getTarget() == nullptr )
return QVariant();
QList< QByteArray > dynamicProperties = getTarget()->dynamicPropertyNames( );
int staticPropertyCount = getTarget()->metaObject( )->propertyCount( )
- _hiddenStaticPropertiesCount;
int propertyCount = getTarget()->metaObject( )->propertyCount( ) + dynamicProperties.size( );
QString propertyName( "" );
QString propertyType( "" );
bool propertyIsEnum( false );
if ( index.row( ) >= 0 && index.row( ) < staticPropertyCount ) { // Dealing with static properties
QMetaProperty staticProperty = getTarget()->metaObject( )->property( _hiddenStaticPropertiesCount + index.row( ) );
propertyName = ( staticProperty.name( ) != nullptr ? QString( staticProperty.name( ) ) : "" );
propertyType = ( staticProperty.typeName( ) != nullptr ? QString( staticProperty.typeName( ) ) : "" );
}
else if ( index.row( ) >= staticPropertyCount && // Dealing with dynamic properties
index.row( ) < propertyCount ) {
int dynamicPropertyIndex = index.row( ) - staticPropertyCount;
propertyName = dynamicProperties.at( dynamicPropertyIndex );
propertyType = getTarget()->property( propertyName.toLatin1( ) ).typeName( );
qDebug() << "propertyType=" << propertyType;
propertyIsEnum = isEnum( propertyName );
}
if ( !propertyName.isEmpty( ) && !propertyType.isEmpty( ) )
{
if ( role == PropertyNameRole )
return propertyName;
else if ( role == PropertyTypeRole )
return propertyType;
else if ( role == PropertyIsEnumRole )
return propertyIsEnum;
else if ( role == PropertyDataRole )
return property( propertyName.toLatin1( ) );
else if ( role == PropertyOptionsRole )
return QVariant::fromValue< qps::Options* >( const_cast< qps::Properties* >( this )->getPropertyOptions( propertyName ) ); // Return the corresponding options object for the requested property
}
return data( index, role );
}
void listInterface(const QString &service, const QString &path, const QString &interface)
{
QDBusInterfacePtr iface(*connection, service, path, interface);
if (!iface->isValid()) {
QDBusError err(iface->lastError());
fprintf(stderr, "Interface '%s' not available in object %s at %s:\n%s (%s)\n",
qPrintable(interface), qPrintable(path), qPrintable(service),
qPrintable(err.name()), qPrintable(err.message()));
exit(1);
}
const QMetaObject *mo = iface->metaObject();
// properties
for (int i = mo->propertyOffset(); i < mo->propertyCount(); ++i) {
QMetaProperty mp = mo->property(i);
printf("property ");
if (mp.isReadable() && mp.isWritable())
printf("readwrite");
else if (mp.isReadable())
printf("read");
else
printf("write");
printf(" %s %s.%s\n", mp.typeName(), qPrintable(interface), mp.name());
}
// methods (signals and slots)
for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
QMetaMethod mm = mo->method(i);
QByteArray signature = mm.signature();
signature.truncate(signature.indexOf('('));
printf("%s %s%s%s %s.%s(",
mm.methodType() == QMetaMethod::Signal ? "signal" : "method",
mm.tag(), *mm.tag() ? " " : "",
*mm.typeName() ? mm.typeName() : "void",
qPrintable(interface), signature.constData());
QList<QByteArray> types = mm.parameterTypes();
QList<QByteArray> names = mm.parameterNames();
bool first = true;
for (int i = 0; i < types.count(); ++i) {
printf("%s%s",
first ? "" : ", ",
types.at(i).constData());
if (!names.at(i).isEmpty())
printf(" %s", names.at(i).constData());
first = false;
}
printf(")\n");
}
}
PropertyWidget* GooeyEngine::CreatePropertyWidget(Block* block, kint propertyIndex)
{
QMetaProperty property = block->metaObject()->property(propertyIndex);
QString type = QString::fromAscii(property.typeName());
const QMetaObject* mo = Instance()->_inputWidgets.value(type, K_NULL);
if(mo == K_NULL)
{
qWarning("GooeyEngine / Could not find property widget for type %s !", property.typeName());
return K_NULL;
}
// Create an instance
PropertyWidget* widget = static_cast<PropertyWidget*>(mo->newInstance());
// Setup the data
widget->setData(block, propertyIndex);
// Build the UI
widget->update();
return widget;
}
const char* getpropertytype(QObject* obj, const char* propname, bool includesuper)
{
const QMetaObject* objmeta = obj->metaObject();
int i = objmeta->indexOfProperty(propname);
if (i == -1)
return NULL;
QMetaProperty propmeta = objmeta->property(i);
if (!propmeta.isValid())
return NULL;
const char* type = propmeta.typeName();
return type;
}
void MetaInfoPrivate::parseProperties(NodeMetaInfo &nodeMetaInfo, const QMetaObject *qMetaObject) const
{
Q_ASSERT_X(qMetaObject, Q_FUNC_INFO, "invalid QMetaObject");
Q_ASSERT_X(nodeMetaInfo.isValid(), Q_FUNC_INFO, "invalid NodeMetaInfo");
for (int i = qMetaObject->propertyOffset(); i < qMetaObject->propertyCount(); ++i) {
QMetaProperty qProperty = qMetaObject->property(i);
PropertyMetaInfo propertyInfo;
propertyInfo.setName(QLatin1String(qProperty.name()));
QString typeName(qProperty.typeName());
QString noStar = typeName;
bool star = false;
while (noStar.contains('*')) {//strip star
noStar.chop(1);
star = true;
}
if (m_QtTypesToQmlTypes.contains(noStar)) {
typeName = star ? m_QtTypesToQmlTypes.value(noStar) + '*' : m_QtTypesToQmlTypes.value(noStar);
//### versions
}
propertyInfo.setType(typeName);
propertyInfo.setValid(true);
propertyInfo.setReadable(qProperty.isReadable());
propertyInfo.setWritable(qProperty.isWritable());
propertyInfo.setResettable(qProperty.isResettable());
propertyInfo.setEnumType(qProperty.isEnumType());
propertyInfo.setFlagType(qProperty.isFlagType());
if (propertyInfo.isEnumType()) {
EnumeratorMetaInfo enumerator;
QMetaEnum qEnumerator = qProperty.enumerator();
enumerator.setValid(qEnumerator.isValid());
enumerator.setIsFlagType(qEnumerator.isFlag());
enumerator.setScope(qEnumerator.scope());
enumerator.setName(qEnumerator.name());
for (int i = 0 ;i < qEnumerator.keyCount(); i++)
{
enumerator.addElement(qEnumerator.valueToKey(i), i);
}
propertyInfo.setEnumerator(enumerator);
}
nodeMetaInfo.addProperty(propertyInfo);
}
}
QString objToString(const QObject* obj) {
QStringList result;
const QMetaObject* meta = obj->metaObject();
result += QString("class %1 : public %2 {")
.arg(meta->className()).arg(meta->superClass()->className());
for (int i=0; i < meta->propertyCount(); ++i) {
const QMetaProperty qmp = meta->property(i);
QVariant value = obj->property(qmp.name());
result += QString(" %1 %2 = %3;")
.arg(qmp.typeName()).arg(qmp.name())
.arg(value.toString()); }
result += "};";
return result.join("\n");
}
QMap<QString,QPair<QString,QVariant> > Modifier::serializeProperties() {
QMap<QString,QPair<QString,QVariant> > result;
for (int i = 0; i < metaObject()->propertyCount(); ++i) {
QMetaProperty metaproperty = metaObject()->property(i);
const char *name = metaproperty.name();
QVariant value = property(name);
QString type(metaproperty.typeName());
if (metaproperty.isEnumType())
type = "int";
result.insert(name, QPair<QString,QVariant>(type, value));
}
return result;
}
void SaxsviewProperty::setValue(QObject *obj) {
if (!mProperty) {
//
// Find the meta-property information; the passed object must
// provide the Q_PROPERTY name passed to the constructor.
//
int indexOfProperty = obj->metaObject()->indexOfProperty(qPrintable(mPropertyName));
QMetaProperty metaProperty = obj->metaObject()->property(indexOfProperty);
if (metaProperty.isValid()) {
//
// Create an editor factory if and only if the property is writeable.
//
if (metaProperty.isWritable()) {
mBrowser->setFactoryForManager(mManager, new QtVariantEditorFactory(this));
connect(mManager, SIGNAL(valueChanged(QtProperty*, const QVariant&)),
this, SLOT(valueChanged(QtProperty*, const QVariant&)));
}
if (!mManager->isPropertyTypeSupported(metaProperty.type()))
qFatal("internal error: property '%s', property type not supported: '%s'",
metaProperty.name(), metaProperty.typeName());
//
// Check if this is an enum and handle it specially if yes.
//
if (metaProperty.isEnumType()) {
QStringList enumNames;
QMetaEnum metaEnum = metaProperty.enumerator();
//
// WARNING: This only builds a list of names in the order
// as defined. The combobox to display these names
// provides the selected index, not the actual enum
// value.
//
for (int i = 0; i < metaEnum.keyCount(); ++i)
enumNames << metaEnum.key(i);
setEnumNames(enumNames);
}
if (mAttributes.contains("enumNames"))
mProperty = mManager->addProperty(mManager->enumTypeId(), mPropertyLabel);
else
mProperty = mManager->addProperty(metaProperty.type(), mPropertyLabel);
} else if (obj->dynamicPropertyNames().contains(qPrintable(mPropertyName))) {
QVariant ObjectStaticPropertyModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || !m_obj || index.row() < 0 ||
index.row() >= m_obj.data()->metaObject()->propertyCount()) {
return QVariant();
}
const QMetaProperty prop = m_obj.data()->metaObject()->property(index.row());
if (role == Qt::DisplayRole) {
if (index.column() == 0) {
return prop.name();
} else if (index.column() == 1) {
return Util::variantToString(prop.read(m_obj.data()));
} else if (index.column() == 2) {
return prop.typeName();
} else if (index.column() == 3) {
const QMetaObject *mo = m_obj.data()->metaObject();
while (mo->propertyOffset() > index.row()) {
mo = mo->superClass();
}
return mo->className();
}
} else if (role == Qt::EditRole) {
if (index.column() == 1) {
return prop.read(m_obj.data());
}
} else if (role == Qt::ToolTipRole) {
const QString toolTip =
tr("Constant: %1\nDesignable: %2\nFinal: %3\nResetable: %4\n"
"Has notification: %5\nScriptable: %6\nStored: %7\nUser: %8\nWritable: %9").
arg(translateBool(prop.isConstant())).
arg(translateBool(prop.isDesignable(m_obj.data()))).
arg(translateBool(prop.isFinal())).
arg(translateBool(prop.isResettable())).
arg(translateBool(prop.hasNotifySignal())).
arg(translateBool(prop.isScriptable(m_obj.data()))).
arg(translateBool(prop.isStored(m_obj.data()))).
arg(translateBool(prop.isUser(m_obj.data()))).
arg(translateBool(prop.isWritable()));
return toolTip;
}
return QVariant();
}
QVariant Enums::data(const QModelIndex & index)
{
const QMetaObject * metaObject = object()->metaObject();
QMetaProperty metaProperty = metaObject->property(objectProperty());
const char *typeName = metaProperty.typeName();
int enumIdx = metaObject->indexOfEnumerator(typeName);
if (!index.isValid() || !object() || -1 == objectProperty())
return QVariant();
switch (index.column())
{
case 0:
return metaProperty.name();
case 1: {
return metaObject->enumerator(enumIdx).valueToKey(*reinterpret_cast<int*>(value().data()));
}
}
return QVariant();
}
void QDeclarativePropertyCache::Data::lazyLoad(const QMetaProperty &p, QDeclarativeEngine *engine)
{
Q_UNUSED(engine);
coreIndex = p.propertyIndex();
notifyIndex = p.notifySignalIndex();
revision = p.revision();
flags = fastFlagsForProperty(p);
int type = p.type();
if (type == QMetaType::QObjectStar || type == QMetaType::QWidgetStar) {
propType = type;
flags |= QDeclarativePropertyCache::Data::IsQObjectDerived;
} else if (type == QVariant::UserType || type == -1) {
propTypeName = p.typeName();
flags |= QDeclarativePropertyCache::Data::NotFullyResolved;
} else {
propType = type;
}
}
void GCF::Components::ScriptableObjectExplorer::on_itemDoubleClicked(QTreeWidgetItem* item)
{
if(!item)
return;
int type = item->type();
QTreeWidgetItem* objItem = item;
QObject* object = 0;
QString objectName;
while(objItem && objItem->type() != OBJECT_ITEM)
objItem = objItem->parent();
if(!objItem)
return;
object = objItem->data(0, Qt::UserRole).value<QObject*>();
objectName = objItem->text(1);
switch(type)
{
case OBJECT_ITEM:
emit objectDoubleClicked(object, objectName);
break;
case METHOD_ITEM: {
QMetaMethod m = item->data(0, Qt::UserRole).value<QMetaMethod>();
emit methodDoubleClicked(object, objectName, item->text(0), QString(m.signature()) );
} break;
case EVENT_ITEM: {
QMetaMethod m = item->data(0, Qt::UserRole).value<QMetaMethod>();
emit signalDoubleClicked(object, objectName, item->text(0), QString(m.signature()) );
} break;
case PROPERTY_ITEM:{
QMetaProperty prop = item->data(0, Qt::UserRole).value<QMetaProperty>();
emit propertyDoubleClicked(object, objectName, item->text(0), QString(prop.typeName()));
} break;
}
}
void QObjectHelper::qvariant2qobject(const QVariantMap& variant, QObject* object)
{
const QMetaObject *metaobject = object->metaObject();
QVariantMap::const_iterator iter;
for (iter = variant.constBegin(); iter != variant.constEnd(); ++iter) {
int pIdx = metaobject->indexOfProperty( iter.key().toUtf8() );
if ( pIdx < 0 ) {
continue;
}
QMetaProperty metaproperty = metaobject->property( pIdx );
QVariant::Type type = metaproperty.type();
QVariant v( iter.value() );
if ( v.canConvert( type ) ) {
v.convert( type );
metaproperty.write( object, v );
} else if (QString(QLatin1String("QVariant")).compare(QLatin1String(metaproperty.typeName())) == 0) {
metaproperty.write( object, v );
}
}
}
bool parseObject(const QVariant &source, QObject *target)
{
if (!source.isValid() || !source.canConvert(QVariant::Map)) {
qDebug() << "[ObjectParser] Error: Invalid object... " << source.toByteArray();
return false;
}
const QVariantMap &map = source.toMap();
const QMetaObject *metaobject = target->metaObject();
QVariantMap::const_iterator it;
QVariantMap::const_iterator end = map.constEnd();
for (it = map.constBegin(); it != end; ++it) {
const int index = metaobject->indexOfProperty(it.key().toLatin1());
if (index < 0) {
continue;
}
const QMetaProperty metaproperty = metaobject->property(index);
const QVariant::Type type = metaproperty.type();
QVariant v = it.value();
if (v.canConvert(type)) {
v.convert(type);
metaproperty.write(target, v);
} else if (QString(QLatin1String("QVariant"))
.compare(QLatin1String(metaproperty.typeName())) == 0) {
metaproperty.write(target, v);
} else {
qDebug() << "[ObjectParser] Warning: unable to map variable" << it.key() << "of type"
<< v.type() << "to type" << metaproperty.type() << "!";
metaproperty.write(target, QVariant());
}
}
return true;
}
void ControlInfo::setControl(QWidget *activex)
{
listInfo->clear();
const QMetaObject *mo = activex->metaObject();
QTreeWidgetItem *group = new QTreeWidgetItem(listInfo);
group->setText(0, tr("Class Info"));
group->setText(1, QString::number(mo->classInfoCount()));
QTreeWidgetItem *item = 0;
int i;
int count;
for (i = mo->classInfoOffset(); i < mo->classInfoCount(); ++i) {
const QMetaClassInfo info = mo->classInfo(i);
item = new QTreeWidgetItem(group);
item->setText(0, QString::fromLatin1(info.name()));
item->setText(1, QString::fromLatin1(info.value()));
}
group = new QTreeWidgetItem(listInfo);
group->setText(0, tr("Signals"));
count = 0;
for (i = mo->methodOffset(); i < mo->methodCount(); ++i) {
const QMetaMethod method = mo->method(i);
if (method.methodType() == QMetaMethod::Signal) {
++count;
item = new QTreeWidgetItem(group);
item->setText(0, QString::fromLatin1(method.signature()));
}
}
group->setText(1, QString::number(count));
group = new QTreeWidgetItem(listInfo);
group->setText(0, tr("Slots"));
count = 0;
for (i = mo->methodOffset(); i < mo->methodCount(); ++i) {
const QMetaMethod method = mo->method(i);
if (method.methodType() == QMetaMethod::Slot) {
++count;
item = new QTreeWidgetItem(group);
item->setText(0, QString::fromLatin1(method.signature()));
}
}
group->setText(1, QString::number(count));
group = new QTreeWidgetItem(listInfo);
group->setText(0, tr("Properties"));
count = 0;
for (i = mo->propertyOffset(); i < mo->propertyCount(); ++i) {
++count;
const QMetaProperty property = mo->property(i);
item = new QTreeWidgetItem(group);
item->setText(0, QString::fromLatin1(property.name()));
item->setText(1, QString::fromLatin1(property.typeName()));
if (!property.isDesignable()) {
item->setTextColor(0, Qt::gray);
item->setTextColor(1, Qt::gray);
}
}
group->setText(1, QString::number(count));
}
int Dialog::showDialog(const QString& view, QObject* viewModel, int type)
{
QDialog* dialog = NULL;
QMainWindow* mainWindow = NULL;
QWidget* windowWidget = NULL;
QWidget* layoutWidget = NULL;
switch (type)
{
case Dialog::MainWindow:
mainWindow = new QMainWindow();
windowWidget = mainWindow;
layoutWidget = new QWidget(windowWidget);
mainWindow->setCentralWidget(layoutWidget);
break;
case Dialog::ModalDialog:
dialog = new QDialog(QApplication::activeWindow());
windowWidget = dialog;
layoutWidget = dialog;
break;
default:
dialog = new QDialog();
windowWidget = dialog;
layoutWidget = dialog;
break;
}
QGridLayout* layout = new QGridLayout(layoutWidget);
// Create view
QDeclarativeView* v = new QDeclarativeView(layoutWidget);
if (viewModel)
{
int count = viewModel->metaObject()->propertyCount();
for (int i = 0; i < count; ++i)
{
QMetaProperty p = viewModel->metaObject()->property(i);
if (p.isReadable() && p.typeName() == QString("QDeclarativeImageProvider*"))
{
QString name = p.name();
QDeclarativeImageProvider* value = p.read(viewModel).value<QDeclarativeImageProvider*>();
v->engine()->addImageProvider(name.toLatin1(), new ProxyImageProvider(value));
}
}
v->rootContext()->setContextProperty("dataContext", viewModel);
}
QString path;
foreach (path, importPaths)
v->engine()->addImportPath(path);
foreach (path, pluginPaths)
v->engine()->addPluginPath(path);
v->setSource(QUrl(view));
v->setResizeMode(QDeclarativeView::SizeRootObjectToView);
// Initialize dialog
QGraphicsObject* root = v->rootObject();
QVariant property = root->property("dialogTitle");
if (property.isValid())
windowWidget->setWindowTitle(property.toString());
property = root->property("dialogMinWidth");
if (property.isValid())
layoutWidget->setMinimumWidth(property.toInt());
property = root->property("dialogMinHeight");
if (property.isValid())
layoutWidget->setMinimumHeight(property.toInt());
property = root->property("dialogMaxWidth");
if (property.isValid())
layoutWidget->setMaximumWidth(property.toInt());
property = root->property("dialogMaxHeight");
if (property.isValid())
layoutWidget->setMaximumHeight(property.toInt());
property = root->property("dialogResizable");
if (property.isValid() && !property.toBool())
layout->setSizeConstraint(QLayout::SetFixedSize);
Qt::WindowStates states = windowWidget->windowState();
Qt::WindowFlags flags = windowWidget->windowFlags();
property = root->property("dialogMinimizeButton");
if (property.isValid())
flags = property.toBool() ? flags | Qt::WindowMinimizeButtonHint : flags & ~Qt::WindowMinimizeButtonHint;
property = root->property("dialogMaximizeButton");
if (property.isValid())
flags = property.toBool() ? flags | Qt::WindowMaximizeButtonHint : flags & ~Qt::WindowMaximizeButtonHint;
property = root->property("dialogCloseButton");
if (property.isValid())
flags = property.toBool() ? flags | Qt::WindowCloseButtonHint : flags & ~Qt::WindowCloseButtonHint;
property = root->property("dialogFullScreen");
if (property.isValid())
states = property.toBool() ? states | Qt::WindowFullScreen : states & ~Qt::WindowFullScreen;
flags = flags & ~Qt::WindowContextHelpButtonHint;
windowWidget->setWindowFlags(flags);
windowWidget->setWindowState(states);
property = root->property("dialogToolBar");
if (type == Dialog::MainWindow && property.isValid() && property.typeName() == QString("QDeclarativeListProperty<QDeclarativeItem>"))
{
QToolBar* toolbar = new QToolBar(mainWindow);
toolbar->setMovable(false);
toolbar->setFloatable(false);
toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
toolbar->setAllowedAreas(Qt::TopToolBarArea);
QDeclarativeListProperty<QDeclarativeItem> btnList = property.value< QDeclarativeListProperty<QDeclarativeItem> >();
int btnCount = btnList.count(&btnList);
for (int i = 0; i < btnCount; ++i)
{
QDeclarativeItem* item = btnList.at(&btnList, i);
if (!item->property("text").isValid())
continue;
QString itemText = item->property("text").toString();
QString itemTooltip = item->property("tooltip").isValid() ? item->property("tooltip").toString() : "";
QString itemIconSource = item->property("iconSource").isValid() ? item->property("iconSource").toString() : "";
int itemIconSize = item->property("iconSize").isValid() ? item->property("iconSize").toInt() : -1;
if (itemText == "|")
{
toolbar->addSeparator();
}
else if (itemText == "-")
{
QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
toolbar->addWidget(spacer);
}
else
{
QAction* action = new QAction(mainWindow);
action->setText(itemText);
action->setToolTip(itemTooltip);
action->setIcon(QIcon(itemIconSource));
QObject::connect(action, SIGNAL(triggered()), item, SLOT(trigger()));
if (item->property("enabled").isValid())
new PropertyBinding(action, "enabled", item, "enabled", PropertyBinding::OneWay, NULL, this);
if (item->property("visible").isValid())
new PropertyBinding(action, "visible", item, "visible", PropertyBinding::OneWay, NULL, this);
toolbar->addAction(action);
}
if (itemIconSize != -1)
toolbar->setIconSize(QSize(itemIconSize, itemIconSize));
}
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
mainWindow->addToolBar(toolbar);
}
property = root->property("dialogMenu");
if (type == Dialog::MainWindow && property.isValid() && property.typeName() == QString("QDeclarativeListProperty<QDeclarativeItem>"))
{
QDeclarativeListProperty<QDeclarativeItem> list = property.value< QDeclarativeListProperty<QDeclarativeItem> >();
int count = list.count(&list);
for (int i = 0; i < count; ++i)
{
QDeclarativeItem* item = list.at(&list, i);
if (!item->property("text").isValid())
continue;
QString itemText = item->property("text").toString();
QMenu * menuItem = mainWindow->menuBar()->addMenu(itemText);
if (!item->property("submenu").isValid() || item->property("submenu").typeName() != QString("QDeclarativeListProperty<QDeclarativeItem>"))
continue;
QDeclarativeListProperty<QDeclarativeItem> innerList = item->property("submenu").value< QDeclarativeListProperty<QDeclarativeItem> >();
int innerCount = innerList.count(&innerList);
for (int j = 0; j < innerCount; ++j)
{
QDeclarativeItem* innerItem = innerList.at(&innerList, j);
if (!innerItem->property("text").isValid())
continue;
QString innerItemText = innerItem->property("text").toString();
QString innerItemShortcut = innerItem->property("shortcut").isValid() ? innerItem->property("shortcut").toString() : "";
QString innerItemIconSource = innerItem->property("iconSource").isValid() ? innerItem->property("iconSource").toString() : "";
if (innerItemText == "-")
{
menuItem->addSeparator();
}
else
{
QAction * action = menuItem->addAction(QIcon(innerItemIconSource), innerItemText);
action->setShortcut(QKeySequence(innerItemShortcut));
QObject::connect(action, SIGNAL(triggered()), innerItem, SLOT(trigger()));
if (innerItem->property("enabled").isValid())
new PropertyBinding(action, "enabled", innerItem, "enabled", PropertyBinding::OneWay, NULL, this);
if (innerItem->property("visible").isValid())
new PropertyBinding(action, "visible", innerItem, "visible", PropertyBinding::OneWay, NULL, this);
}
}
}
}
new DialogCallbacks(windowWidget, v, root);
// Initialize layout
layout->setMargin(0);
layout->addWidget(v, 0, 0);
// Execute
switch (type)
{
case Dialog::ModalDialog:
dialog->exec();
break;
case Dialog::MainWindow:
{
if (mainWindowGeometry.isEmpty())
{
mainWindow->adjustSize();
mainWindow->move(QApplication::desktop()->screen()->rect().center() - mainWindow->rect().center());
}
else
mainWindow->restoreGeometry(mainWindowGeometry);
}
default:
windowWidget->setAttribute(Qt::WA_DeleteOnClose);
windowWidget->show();
break;
}
int result = 0;
property = root->property("dialogResult");
if (property.isValid())
result = property.toInt();
if (type == Dialog::ModalDialog)
delete dialog;
return result;
}
void QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, QVariant &where) const
{
if (!isValid || !canMakeCalls()) { // can't make calls
where.clear();
return;
}
// is this metatype registered?
const char *expectedSignature = "";
if (mp.type() != 0xff) {
expectedSignature = QDBusMetaType::typeToSignature(where.userType());
if (expectedSignature == 0) {
qWarning("QDBusAbstractInterface: type %s must be registered with QtDBus before it can be "
"used to read property %s.%s",
mp.typeName(), qPrintable(interface), mp.name());
lastError = QDBusError(QDBusError::Failed,
QString::fromLatin1("Unregistered type %1 cannot be handled")
.arg(QLatin1String(mp.typeName())));
where.clear();
return;
}
}
// try to read this property
QDBusMessage msg = QDBusMessage::createMethodCall(service, path,
QLatin1String(DBUS_INTERFACE_PROPERTIES),
QLatin1String("Get"));
QDBusMessagePrivate::setParametersValidated(msg, true);
msg << interface << QString::fromUtf8(mp.name());
QDBusMessage reply = connection.call(msg, QDBus::Block);
if (reply.type() != QDBusMessage::ReplyMessage) {
lastError = reply;
where.clear();
return;
}
if (reply.signature() != QLatin1String("v")) {
QString errmsg = QLatin1String("Invalid signature `%1' in return from call to "
DBUS_INTERFACE_PROPERTIES);
lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(reply.signature()));
where.clear();
return;
}
QByteArray foundSignature;
const char *foundType = 0;
QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant();
if (value.userType() == where.userType() || mp.type() == 0xff
|| (expectedSignature[0] == 'v' && expectedSignature[1] == '\0')) {
// simple match
where = value;
return;
}
if (value.userType() == qMetaTypeId<QDBusArgument>()) {
QDBusArgument arg = qvariant_cast<QDBusArgument>(value);
foundType = "user type";
foundSignature = arg.currentSignature().toLatin1();
if (foundSignature == expectedSignature) {
// signatures match, we can demarshall
QDBusMetaType::demarshall(arg, where.userType(), where.data());
return;
}
} else {
foundType = value.typeName();
foundSignature = QDBusMetaType::typeToSignature(value.userType());
}
// there was an error...
QString errmsg = QLatin1String("Unexpected `%1' (%2) when retrieving property `%3.%4' "
"(expected type `%5' (%6))");
lastError = QDBusError(QDBusError::InvalidSignature,
errmsg.arg(QString::fromLatin1(foundType),
QString::fromLatin1(foundSignature),
interface,
QString::fromUtf8(mp.name()),
QString::fromLatin1(mp.typeName()),
QString::fromLatin1(expectedSignature)));
where.clear();
return;
}