QVariant BluetoothDevicesModel::data(const QModelIndex &index, int role) const
{
qDebug()<<"requested role: "<<roleNames()[role];
if(!index.isValid() || index.row() < 0)
{
qDebug()<<"index is not valid: "<<index.row()<<","<<index.column();
return QVariant(); ///this is retarded but it has to be done.
}
if(roleNames()[role] == "bluetoothDevice")
{
return QVariant::fromValue<QObject*>((QObject*)m_devices[index.row()]);
}
QString roleName = roleNames()[role];
QMetaObject object = BluetoothDevice::staticMetaObject;
for(int i=0; i<object.propertyCount(); i++)
{
if(object.property(i).name() == roleName)
{
return object.property(i).read(m_devices[index.row()]);
}
}
return QVariant();
}
void ImportQMetaObject::import(const QMetaObject& t)
{
Analitza::BuiltinMethods* b=m_a->builtinMethods();
QByteArray classname(t.className());
classname.replace("::", "_");
for(int p=0; p<t.propertyCount(); p++) {
QMetaProperty prop=t.property(p);
QByteArray name(prop.name());
if(prop.isReadable()) {
QObjectGet* getter=new QObjectGet(name);
b->insertFunction(QString(classname+'_'+name), getter->type(classname, prop), getter);
}
if(prop.isWritable()) {
QObjectSet* setter=new QObjectSet(name);
b->insertFunction(QString(classname+"_set_"+name), setter->type(classname, prop), setter);
}
}
if(t.superClass()) {
QObjectCastToParent *cast = new QObjectCastToParent(t.className(), t.superClass()->className());
b->insertFunction(classname+QStringLiteral("_toParent"), cast->type(), cast);
}
}
BluetoothDevicesModel::BluetoothDevicesModel(QObject *parent) :
QAbstractListModel(parent), m_connected(false), adapter(NULL)
{
manager = new OrgBluezManagerInterface(
"org.bluez",
"/", QDBusConnection::systemBus(), this);
connect(manager,SIGNAL(DefaultAdapterChanged(QDBusObjectPath)),
this,SLOT(defaultAdapterChanged(QDBusObjectPath)));
connect(manager,SIGNAL(AdapterRemoved(QDBusObjectPath)),this,SLOT(adapterRemoved(QDBusObjectPath)));
defaultAdapterChanged(manager->DefaultAdapter());
QMetaObject properties = BluetoothDevice::staticMetaObject;
for(int i=0; i<properties.propertyCount();i++)
{
m_roleNames[i]=properties.property(i).name();
}
m_roleNames[m_roleNames.keys().count()+1] = "bluetoothDevice";
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
setRoleNames(m_roleNames);
#endif
}
QStringList Utils::propertyNames(const QMetaObject& meta)
{
QStringList names;
for (int i = meta.propertyOffset(); i < meta.propertyCount(); ++i)
{
names << meta.property(i).name();
}
return names;
}
QStringList QtMetaUtilities::getNames(const QMetaObject &metaObject)
{
QStringList retour;
QString className = QLatin1String(metaObject.className());
if (className == "QObject")
return retour;
for (int idx = metaObject.propertyOffset(); idx < metaObject.propertyCount(); idx++)
retour <<metaObject.property(idx).name();
return retour;
}
QList<QVariant> QtMetaUtilities::getValues(const QMetaObject &metaObject, const QObject *object)
{
QList<QVariant> retour;
QString className = QLatin1String(metaObject.className());
if (className == "QObject")
return retour;
for (int idx = metaObject.propertyOffset(); idx < metaObject.propertyCount(); idx++)
retour << metaObject.property(idx).read(object);
return retour;
}
QList<QPair<QString, QVariant::Type> >QtMetaUtilities::getNamesNTypes(const QMetaObject &metaObject)
{
QList<QPair<QString, QVariant::Type> >retour;
QString className = QLatin1String(metaObject.className());
if (className == "QObject")
return retour;
for (int idx = metaObject.propertyOffset(); idx < metaObject.propertyCount(); idx++) {
QMetaProperty prop = metaObject.property(idx);
retour.append(QPair<QString, QVariant::Type>(prop.name(), prop.type()));
}
return retour;
}
QString QtMetaUtilities::toString(const QMetaObject &metaObject, const QObject *object)
{
QString retour;
QString className = QLatin1String(metaObject.className());
if (className == "QObject")
return retour;
for (int idx = metaObject.propertyOffset(); idx < metaObject.propertyCount(); idx++)
{
retour += QString("[ %1 = %2 ]")
.arg(metaObject.property(idx).name())
.arg(metaObject.property(idx).read(object).toString());
}
return retour;
}
QString AsemanQtTools::exportItem(const QString &module, int major, int minor, const QString &component, bool store)
{
QString result;
aseman_qt_tools_indexCache << component;
QMetaObject meta = T::staticMetaObject;
QString inherits = fixType(meta.superClass()? meta.superClass()->className() : "");
bool isModel = component.toLower().contains("model");
result += QString("# %1\n\n").arg(component);
QString headers;
headers += QString(" * [Component details](#component-details)\n");
QString details = QString("\n### Component details:\n\n");
details += QString("|Detail|Value|\n"
"|------|-----|\n");
details += QString("|%1|%2 %3.%4|\n").arg("Import").arg(module).arg(major).arg(minor);
details += QString("|%1|<font color='#074885'>%2</font>|\n").arg("Component").arg(component);
details += QString("|%1|<font color='#074885'>%2</font>|\n").arg("C++ class").arg(meta.className());
details += QString("|%1|<font color='#074885'>%2</font>|\n").arg("Inherits").arg(inherits);
details += QString("|%1|<font color='#074885'>%2</font>|\n").arg("Model").arg(isModel?"Yes":"No");
QString resultProperties;
QStringList propertiesSignals;
for(int i=0; i<meta.propertyCount(); i++)
{
QMetaProperty property = meta.property(i);
const QString &propertyName = property.name();
const QString &propertyType = fixType(property.typeName());
propertiesSignals << property.notifySignal().name();
QString text = QString("* <font color='#074885'><b>%1</b></font>: %2").arg(propertyName).arg(propertyType);
if(!property.isWritable())
text += " (readOnly)";
text += "\n";
if(meta.propertyOffset()<=i)
resultProperties += text;
}
QString enumResults;
for(int i=meta.enumeratorOffset(); i<meta.enumeratorCount(); i++)
{
QMetaEnum enumerator = meta.enumerator(i);
const QString &enumName = enumerator.name();
enumResults += QString("\n##### %1\n\n").arg(enumName);
enumResults += QString("|Key|Value|\n"
"|---|-----|\n");
for(int j=0; j<enumerator.keyCount(); j++)
enumResults += QString("|%1|%2|\n").arg(enumerator.key(j)).arg(enumerator.value(j));
}
QString resultSlots;
QString resultSignals;
for(int i=meta.methodOffset(); i<meta.methodCount(); i++)
{
QMetaMethod method = meta.method(i);
if(method.access() != QMetaMethod::Public)
continue;
const QString &methodName = method.name();
if(propertiesSignals.contains(methodName))
continue;
const QString &methodType = fixType(method.typeName());
QString args;
const QList<QByteArray> ¶mNames = method.parameterNames();
const QList<QByteArray> ¶mTypes = method.parameterTypes();
for(int j=0; j<paramNames.count(); j++)
{
if(j != 0)
args += ", ";
args += fixType(paramTypes[j]) + " " + paramNames[j];
}
QString text = QString(" * %1 <font color='#074885'><b>%2</b></font>(%3)\n").arg(methodType).arg(methodName).arg(args);
switch(static_cast<int>(method.methodType()))
{
case QMetaMethod::Slot:
resultSlots += text;
break;
case QMetaMethod::Signal:
resultSignals += text;
break;
}
}
if(!resultProperties.isEmpty())
{
headers += QString(" * [Normal Properties](#normal-properties)\n");
resultProperties = QString("\n### Normal Properties\n\n") + resultProperties;
}
if(!enumResults.isEmpty())
{
headers += QString(" * [Enumerator](#enumerator)\n");
enumResults = QString("\n### Enumerator\n\n") + enumResults;
}
if(!resultSlots.isEmpty())
{
headers += QString(" * [Methods](#methods)\n");
resultSlots = QString("\n### Methods\n\n") + resultSlots;
}
if(!resultSignals.isEmpty())
{
headers += QString(" * [Signals](#signals)\n");
resultSignals = QString("\n### Signals\n\n") + resultSignals;
}
if(isModel)
headers += QString(" * [Roles](#roles)\n");
result += headers + "\n";
result += details + "\n";
result += resultProperties + "\n";
result += resultSlots + "\n";
result += resultSignals + "\n";
result += enumResults + "\n";
if(!store)
return result;
QString path = aseman_qt_tools_destination + "/" + component.toLower() + ".md";
QFile file(path);
if(!file.open(QFile::WriteOnly))
return result;
file.write(result.toUtf8());
file.close();
return result;
}
void CDiagramItem::toXml(QDomElement &n)
{
QMetaObject *meta = NULL;
QMetaProperty prop;
QDomDocument doc;
QDomElement ext, childNode;
QList<QByteArray> props;
QStringList filtersOut, filtersIn;
CDiagramSerializable *inst = NULL;
filtersIn = filterProperties();
filtersOut << "width"
<< "height"
<< "x"
<< "y"
<< "z"
<< "pos"
<< "size"
<< "parent"
<< "effect"
<< "children"
<< "layout"
<< "palette";
doc = n.ownerDocument();
ext = doc.createElement( QString("ext") );
childNode = doc.createElement( QString("children") );
n.setAttribute( QString("type"), interType());
n.setAttribute( QString("category"), category() );
n.setAttribute( QString("name"), name() );
n.setAttribute( QString("libCategory"), libraryCategory() );
n.setAttribute( QString("libName"), libraryName() );
n.setAttribute( QString("id"), QString::number(id()) );
meta = const_cast<QMetaObject*>(metaObject());
for (int i = 0; i < meta->propertyCount(); ++i)
{
QString propName;
QByteArray b;
QDataStream s(&b, QIODevice::WriteOnly);
prop = meta->property(i);
propName = QString(prop.name());
if (filtersIn.isEmpty())
{
if (filtersOut.contains(propName, Qt::CaseInsensitive) || prop.userType() == 0)
{
continue;
}
}
else
{
if (!filtersIn.contains(propName, Qt::CaseInsensitive))
{
continue;
}
}
if (prop.isValid() && prop.isReadable())
{
s << prop.read(this);
QDomElement e = doc.createElement(QString("property"));
e.setAttribute( QString("name"), QString(prop.name()) );
e.setAttribute( QString("type"), QString(prop.typeName()) );
e.appendChild( doc.createTextNode( QString(b.toBase64() ) ) );
n.appendChild(e);
// qDebug() << "save->name:" << prop.name() << " value:" << prop.read(this);
}
}
props = dynamicPropertyNames();
for (int i = 0; i < props.length(); ++i)
{
inst = RS_PROPERTY(props.at(i).constData());
// inst = property(props.at(i).constData()).value<CDiagramSerializable*>();
if (inst)
{
QDomElement c = doc.createElement(QString("child"));
c.setAttribute( QString("dynamicProperty"), QString(props.at(i).constData()) );
inst->toXml(c);
childNode.appendChild(c);
}
}
n.appendChild(childNode);
extToXml( ext );
n.appendChild( ext );
}
