ParamEnum::ParamEnum( QObject *parent, const char* name, int value, const QString& e, int *ptr )
: AbstractParam(parent, name, QVariant::Int)
{
m_ptr = ptr;
QStringList L = e.split('|', QString::SkipEmptyParts);
if (!L.isEmpty()) {
for (int i = 0; i < L.size(); ++i) {
m_keys.append(L[i]);
m_values.append(i);
}
} else {
QObject *p = parent;
while (p) {
const QMetaObject *mo = p->metaObject();
int index = mo->indexOfEnumerator(e.toLatin1().data());
if (index >= 0) {
const QMetaEnum me = mo->enumerator(index);
for (int i = 0; i < me.keyCount(); ++i) {
m_keys.append(me.key(i));
m_values.append(me.value(i));
}
break;
}
p = p->parent();
}
}
m_value = m_defaultValue = value;
if (m_ptr) *m_ptr = m_value;
}
// private:
Phantom::Phantom(QObject *parent)
: REPLCompletable(parent)
, m_terminated(false)
, m_returnValue(0)
, m_filesystem(0)
, m_system(0)
{
// Skip the first argument, i.e. the application executable (phantomjs).
QStringList args = QApplication::arguments();
args.removeFirst();
// Prepare the configuration object based on the command line arguments.
// Because this object will be used by other classes, it needs to be ready ASAP.
m_config.init(&args);
// initialize key map
QMetaEnum keys = staticQtMetaObject.enumerator( staticQtMetaObject.indexOfEnumerator("Key") );
for(int i = 0; i < keys.keyCount(); ++i) {
QString name = keys.key(i);
if (name.startsWith("Key_")) {
name.remove(0, 4);
}
m_keyMap[name] = keys.value(i);
}
}
SignalData::SignalData()
{
qDebug() << "SignalData ctor" << this;
connect(&mSampler, SIGNAL(dataArrived()), SLOT(fetchSamples()));
connect(&mSampler, SIGNAL(started()), this, SIGNAL(started()));
connect(&mSampler, SIGNAL(finished()), this, SIGNAL(finished()));
connect(&mSampler, SIGNAL(terminated()), this, SIGNAL(finished()));
connect(&mSampler, SIGNAL(error(QString)), this, SIGNAL(error(QString)));
const QMetaObject metaObject = Sample::staticMetaObject;
const QMetaEnum metaEnum = metaObject.enumerator(metaObject.indexOfEnumerator("Marker"));
for (int i = 0; i < metaEnum.keyCount(); i++) {
mSamples.insert((Sample::Marker)metaEnum.value(i), QVector<Sample>());
mBoundingRects.insert((Sample::Marker)metaEnum.value(i), QRectF());
}
}
QDebug operator <<(QDebug debug, const Snore::SnorePlugin::PluginTypes &flags)
{
QMetaEnum e = SnorePlugin::staticMetaObject.enumerator(SnorePlugin::staticMetaObject.indexOfEnumerator("PluginType"));
debug.nospace() << "PluginTypes(";
bool needSeparator = false;
int key;
for (int i = 0; i < e.keyCount(); ++i)
{
key = e.value(i);
if (flags.testFlag((SnorePlugin::PluginType)key))
{
if (needSeparator)
{
debug.nospace() << '|';
}
else
{
needSeparator = true;
}
debug.nospace() << e.valueToKey(key);
}
}
debug << ')';
return debug.space();
}
void GPhotoExposureControl::stateChanged(QCamera::State state)
{
if (m_state != state) {
if (m_state == QCamera::UnloadedState && state == QCamera::LoadedState) {
m_state = state;
QMetaEnum parameter = metaObject()->enumerator(metaObject()->indexOfEnumerator("ExposureParameter"));
for (int i = 0; i < parameter.keyCount(); ++i) {
ExposureParameter p = ExposureParameter(parameter.value(i));
if (isParameterSupported(p)) {
// Set all parameters requested on start to session object
if (m_requestedValues.contains(p))
setValue(p, m_requestedValues.value(p));
// or just notify frontend that it's allowed to get the parameter values from backend
else
emit actualValueChanged(p);
}
}
} else {
m_state = state;
}
}
}
void MainWindow::genLineEnding()
{
resetPlot();
QMetaEnum endingStyleEnum = QCPLineEnding::staticMetaObject.enumerator(QCPLineEnding::staticMetaObject.indexOfEnumerator("EndingStyle"));
double offset = -0.2;
double step = 1.4/((double)endingStyleEnum.keyCount()-1);
for (int i=0; i<endingStyleEnum.keyCount(); ++i)
{
QCPLineEnding ending(static_cast<QCPLineEnding::EndingStyle>(endingStyleEnum.value(i)));
QString endingName(endingStyleEnum.key(i));
if (ending.style() == QCPLineEnding::esSkewedBar)
ending.setInverted(true);
QCPItemLine *line = new QCPItemLine(customPlot);
line->setPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::FlatCap));
customPlot->addItem(line);
line->start->setCoords(offset+i*step-0.1, -0.2);
line->end->setCoords(offset+i*step, 0.5);
line->setHead(ending);
QCPItemText *text = new QCPItemText(customPlot);
customPlot->addItem(text);
text->position->setParentAnchor(line->end);
text->position->setCoords(8, -15-(i%2)*15);
text->setFont(QFont(font().family(), 8));
text->setText(endingName);
}
customPlot->savePng(dir.filePath("QCPLineEnding.png"), 500, 100);
}
QString flagsToString(const QMetaEnum &aMetaEnum, const int &aValue)
{
QString res="[";
for (int i=0; i<aMetaEnum.keyCount(); ++i)
{
int aFlag=aMetaEnum.value(i);
if (((aValue & aFlag)==aFlag) && (aFlag!=0 || aValue==0))
{
bool good=true;
while (aFlag)
{
if (aFlag & 1)
{
good=(aFlag==1);
break;
}
aFlag>>=1;
}
if (good)
{
if (res.length()>1)
{
res.append(", ");
}
res.append(QString::fromLatin1(aMetaEnum.key(i)));
}
}
}
void copyEnumsToProperties(QObject* object) {
const QMetaObject* meta = object->metaObject();
for (int i = 0; i < meta->enumeratorCount(); ++i) {
QMetaEnum metaenum = meta->enumerator(i);
for (int j = 0; j < metaenum.keyCount(); ++j) {
object->setProperty(metaenum.key(j), metaenum.value(j));
}
}
}
QWidget *MoveTypeDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &/* option */, const QModelIndex &/* index */) const
{
QComboBox *editor = new QComboBox(parent);
QMetaEnum moveInput = KeyBind::staticMetaObject.enumerator( KeyBind::staticMetaObject.indexOfEnumerator("MoveInputs") );
for(int i=0; i<moveInput.keyCount(); ++i) {
editor->addItem(moveInput.key(i),moveInput.value(i));
}
return editor;
}
QString QObjectWriter::
toString(const QVariant& val, const QMetaProperty& mprop) const {
QString result;
QVariant::Type t = mprop.type();
if (t == QVariant::Time) {
QTime t = qVariantValue<QTime>(val);
if (t.hour() > 0) {
return t.toString("hh:mm:ss");
}
else {
return t.toString("m:ss");
}
}
if (mprop.isEnumType()) {
int value = val.toInt();
QMetaEnum menum = mprop.enumerator();
if (mprop.isFlagType()) {
QStringList selectedFlags;
int kc = menum.keyCount();
for (int j=0; j<kc; ++j) {
if (menum.value(j) == 0) continue;
if ((value & menum.value(j)) == menum.value(j)) {
selectedFlags << menum.key(j);
}
}
result = selectedFlags.join("|") + QString(" (%1)").arg(val.toInt());
}
else result = QString("%1 (%2)").arg(menum.valueToKey(value)).arg(val.toInt());
return result;
}
if (m_map.contains(t)) {
VariantWriter* vw = m_map[t];
result = vw->toString(val, mprop);
}
else if (m_vwriter != 0 && result == QString())
result = m_vwriter->toString(val, mprop);
if (result == QString())
result = Qt::escape(val.toString());
else
result = Qt::escape(result);
return result;
}
void Terrain3D::loadUserSettings()
{
const QMetaObject &mo = Settings::staticMetaObject;
const QMetaEnum me = mo.enumerator(mo.indexOfEnumerator("Key"));
//loop through every Settings::Key and tell ourself that a value has
//changed to effectively load the value
for (int i=0; i<me.keyCount(); i++)
{
Settings::Key key = static_cast<Settings::Key>(me.value(i));
settingsValueChanged(key, mMainSettings->value(key));
}
}
SimpleLoggerRoutingInfo::SimpleLoggerRoutingInfo(QObject *parent) :
QObject(parent), m_levels(nullptr), m_routing(nullptr), m_locationRegExp(nullptr), m_messageRegExp(nullptr),
m_locationRegExpPatternSyntax(QRegExp::RegExp2), m_messageRegExpPatternSyntax(QRegExp::RegExp2),
m_locRegExpCaseSensitivity(Qt::CaseInsensitive), m_messageRegExpCaseSensitivity(Qt::CaseInsensitive),
m_enabled(true)
{
const QMetaObject* metaObj = metaObject();
QMetaEnum metaEnum = metaObj->enumerator(metaObj->indexOfEnumerator("MessageCategory"));
m_levels = new QMap<MessageCategory, int>();
for (int i=0; i<metaEnum.keyCount(); ++i)
{
m_levels->insert(static_cast<MessageCategory>(metaEnum.value(i)), 0);
}
metaEnum = metaObj->enumerator(metaObj->indexOfEnumerator("MessageRouting"));
m_routing = new QMap<MessageRouting, bool>();
for (int i=0; i<metaEnum.keyCount(); ++i)
{
m_routing->insert(static_cast<MessageRouting>(metaEnum.value(i)), false);
}
}
void GCF::Components::EnumEditorCreator::initialize(QWidget* editor, QMetaEnum enumStruct)
{
QComboBox* combo = qobject_cast<QComboBox*>(editor);
if(!combo)
return;
for(int i=enumStruct.keyCount()-1; i>=0; i--)
{
QString key = QString("%1").arg(enumStruct.key(i));
int value = enumStruct.value(i);
combo->insertItem(0, key);
combo->setItemData(0, value);
}
}
void SimpleLoggerRoutingInfo::setRouting(MessageRoutings messageRoutings, bool state)
{
const QMetaObject* metaObj = metaObject();
QMetaEnum metaEnum = metaObj->enumerator(metaObj->indexOfEnumerator("MessageRouting"));
for (int i=0; i<metaEnum.keyCount(); ++i)
{
MessageRouting messageRouting = static_cast<MessageRouting>(metaEnum.value(i));
if ((messageRoutings & messageRouting) == messageRouting)
{
m_routing->insert(messageRouting, state);
}
}
}
int ObjectControllerPrivate::enumToInt(const QMetaEnum &metaEnum, int enumValue) const
{
QMap<int, int> valueMap; // dont show multiple enum values which have the same values
int pos = 0;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value)) {
if (value == enumValue)
return pos;
valueMap[value] = pos++;
}
}
return -1;
}
int ObjectControllerPrivate::intToEnum(const QMetaEnum &metaEnum, int intValue) const
{
QMap<int, bool> valueMap; // dont show multiple enum values which have the same values
QList<int> values;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value)) {
valueMap[value] = true;
values.append(value);
}
}
if (intValue >= values.count())
return -1;
return values.at(intValue);
}
QString enumToString(const QMetaEnum &aMetaEnum, const int &aValue)
{
QString res=qApp->translate("Property", "[No enumeration value]");
for (int i=0; i<aMetaEnum.keyCount(); ++i)
{
if (aMetaEnum.value(i)==aValue)
{
res=QString::fromLatin1(aMetaEnum.key(i));
break;
}
}
return res;
}
void QtScriptEngine::copyEnumsToScriptObject(
QScriptEngine *engine, const QMetaObject *metaObject, QScriptValue *object)
{
for (int enumIndex = 0; enumIndex < metaObject->enumeratorCount(); enumIndex++)
{
QMetaEnum metaEnum = metaObject->enumerator(enumIndex);
QScriptValue enumClass = engine->newObject();
for (int keyIndex = 0; keyIndex < metaEnum.keyCount(); keyIndex++)
{
enumClass.setProperty(metaEnum.key(keyIndex), metaEnum.value(keyIndex));
}
object->setProperty(metaEnum.name(), enumClass);
}
}
int ObjectControllerPrivate::flagToInt(const QMetaEnum &metaEnum, int flagValue) const
{
if (!flagValue)
return 0;
int intValue = 0;
QMap<int, int> valueMap; // dont show multiple enum values which have the same values
int pos = 0;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value) && isPowerOf2(value)) {
if (isSubValue(flagValue, value))
intValue |= (1 << pos);
valueMap[value] = pos++;
}
}
return intValue;
}
void QQmlTypePrivate::insertEnums(const QMetaObject *metaObject) const
{
// Add any enum values defined by 'related' classes
if (metaObject->d.relatedMetaObjects) {
const QMetaObject **related = metaObject->d.relatedMetaObjects;
if (related) {
while (*related)
insertEnums(*related++);
}
}
// Add any enum values defined by this class, overwriting any inherited values
for (int ii = 0; ii < metaObject->enumeratorCount(); ++ii) {
QMetaEnum e = metaObject->enumerator(ii);
for (int jj = 0; jj < e.keyCount(); ++jj)
m_enums.insert(QString::fromUtf8(e.key(jj)), e.value(jj));
}
}
QWidget *EnumPropItem::createProperyEditor(QWidget *parent) const
{
ComboBoxEditor *editor = new ComboBoxEditor(parent,false);
connect(editor,SIGNAL(currentIndexChanged(QString)),this,SLOT(slotEnumChanged(QString)));
QStringList enumValues;
QMetaEnum propEnum = object()->metaObject()->property(object()->metaObject()->indexOfProperty(propertyName().toLatin1())).enumerator();
for (int i=0;i<propEnum.keyCount();i++){
if (m_acceptableValues.isEmpty()) enumValues.append(propEnum.key(i));
else {
if (m_acceptableValues.contains(propEnum.value(i))){
enumValues.append(propEnum.key(i));
}
}
}
editor->addItems(enumValues);
return editor;
}
QVariant ObjectEnumModel::data(const QModelIndex &index, int role) const
{
if (!index.parent().isValid()) {
return SuperClass::data(index, role);
}
if (role == Qt::DisplayRole) {
const QMetaEnum e = m_metaObject->enumerator(index.parent().row());
if (index.column() == 0) {
return e.key(index.row());
}
if (index.column() == 1) {
return e.value(index.row());
}
}
return QVariant();
}
CollectionAssetsModel::CollectionAssetsModel(QObject *parent)
: QAbstractItemModel(parent),
d(new Private(this))
{
// set the role names based on the values of the DisplayRoles enum for
// the sake of QML
QHash<int, QByteArray> roles;
QMetaEnum e = metaObject()->enumerator(metaObject()->indexOfEnumerator("DisplayRoles"));
for (int i = 0; i < e.keyCount(); ++i) {
roles.insert(e.value(i), e.key(i));
}
setRoleNames(roles);
connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(modelReset()),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(collectionIdChanged()),
this, SLOT(fetchAssets()));
}
int ObjectControllerPrivate::intToFlag(const QMetaEnum &metaEnum, int intValue) const
{
QMap<int, bool> valueMap; // dont show multiple enum values which have the same values
QList<int> values;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value) && isPowerOf2(value)) {
valueMap[value] = true;
values.append(value);
}
}
int flagValue = 0;
int temp = intValue;
int i = 0;
while (temp) {
if (i >= values.count())
return -1;
if (temp & 1)
flagValue |= values.at(i);
i++;
temp = temp >> 1;
}
return flagValue;
}
void PropertiesEditorDialog::canvasSelectionChanged()
{
// Clear the existing properties.
QMap<QtProperty *, QString>::ConstIterator itProp =
m_property_to_id.constBegin();
while (itProp != m_property_to_id.constEnd())
{
delete itProp.key();
itProp++;
}
m_property_to_id.clear();
m_id_to_property.clear();
if (!m_canvas)
{
return;
}
QList<QGraphicsSvgItem *> list = m_canvas->selectedGeneralItems();
QObject *item = m_canvas;
int firstProperty = Canvas::staticMetaObject.propertyOffset();
bool canvasItemProperties = false;
if (list.count() > 0)
{
item = list.front();
canvasItemProperties = true;
firstProperty = QGraphicsSvgItem::staticMetaObject.propertyOffset();
}
QtVariantProperty *property = NULL;
const QMetaObject* metaObject = item->metaObject();
QStringList properties;
for(int i = firstProperty; i < metaObject->propertyCount(); ++i)
{
//qDebug("== %s", metaObject->property(i).name());
// Justin: Get rid of the first 2 special properties for QGraphicsSvgItems; it's meaningless to display them.
if (QString(metaObject->property(i).name()).compare(QString("elementId")) == 0 || QString(metaObject->property(i).name()).compare(QString("maximumCacheSize")) == 0) continue;
const QMetaProperty& prop = metaObject->property(i);
int type = prop.userType();
if (type == QVariant::UInt)
{
type = QVariant::Int;
}
//qDebug("## %s, %d, %s", prop.name(), prop.userType(), item->property(prop.name()).typeName());
if (prop.isEnumType())
{
property = m_variant_manager->addProperty(QtVariantPropertyManager::enumTypeId(), QLatin1String(prop.name()));
QMetaEnum metaEnum = prop.enumerator();
QMap<int, bool> valueMap; // dont show multiple enum values which have the same values
QStringList enumNames;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value)) {
valueMap[value] = true;
enumNames.append(QLatin1String(metaEnum.key(i)));
}
}
property->setAttribute(QLatin1String("enumNames"), enumNames);
//qDebug() << prop.name() << "= " << item->property(prop.name()).value<dunnart::Connector::RoutingType>();
int enumValueIndex = *reinterpret_cast<const int *>
(item->property(prop.name()).constData());
property->setValue(metaEnum.value(enumValueIndex));
}
else if (m_variant_manager->isPropertyTypeSupported(type))
{
if (!prop.isWritable())
{
property = m_read_only_manager->addProperty(type, QLatin1String(prop.name()) + QLatin1String(" (read-only)"));
}
else
{
property = m_variant_manager->addProperty(type, QLatin1String(prop.name()));
}
property->setValue(item->property(prop.name()));
}
else
{
property = m_read_only_manager->addProperty(QVariant::String, QLatin1String(prop.name()));
property->setValue(QLatin1String("< Unknown Type >"));
property->setEnabled(false);
}
Q_ASSERT(property);
//property->setAttribute(QLatin1String("minimum"), 0);
//property->setAttribute(QLatin1String("maximum"), 100);
addProperty(property, prop.name());
}
QList<QByteArray> propertyList = item->dynamicPropertyNames();
for (int i = 0; i < propertyList.size(); ++i)
{
//qDebug("-- %s", propertyList.at(i).constData());
const char *propName = propertyList.at(i).constData();
const QVariant& propVariant = item->property(propName);
property = m_variant_manager->addProperty(propVariant.userType(), QString(propName));
//property->setAttribute(QLatin1String("minimum"), 0);
//property->setAttribute(QLatin1String("maximum"), 100);
property->setValue(propVariant);
Q_ASSERT(property);
addProperty(property, propName);
}
}
QJsonObject QMetaObjectPublisher::classInfoForObject(const QObject *object)
{
QJsonObject data;
if (!object) {
qWarning("null object given to MetaObjectPublisher - bad API usage?");
return data;
}
QJsonArray qtSignals;
QJsonArray qtMethods;
QJsonArray qtProperties;
QJsonObject qtEnums;
const QMetaObject *metaObject = object->metaObject();
QSet<int> notifySignals;
QSet<QString> identifiers;
for (int i = 0; i < metaObject->propertyCount(); ++i) {
const QMetaProperty &prop = metaObject->property(i);
QJsonArray propertyInfo;
const QString &propertyName = QString::fromLatin1(prop.name());
propertyInfo.append(i);
propertyInfo.append(propertyName);
identifiers << propertyName;
QJsonArray signalInfo;
if (prop.hasNotifySignal()) {
notifySignals << prop.notifySignalIndex();
const int numParams = prop.notifySignal().parameterCount();
if (numParams > 1) {
qWarning("Notify signal for property '%s' has %d parameters, expected zero or one.",
prop.name(), numParams);
}
// optimize: compress the common propertyChanged notification names, just send a 1
const QByteArray ¬ifySignal = prop.notifySignal().name();
static const QByteArray changedSuffix = QByteArrayLiteral("Changed");
if (notifySignal.length() == changedSuffix.length() + propertyName.length() &&
notifySignal.endsWith(changedSuffix) && notifySignal.startsWith(prop.name()))
{
signalInfo.append(1);
} else {
signalInfo.append(QString::fromLatin1(notifySignal));
}
signalInfo.append(prop.notifySignalIndex());
} else if (!prop.isConstant()) {
qWarning("Property '%s'' of object '%s' has no notify signal and is not constant, "
"value updates in HTML will be broken!",
prop.name(), object->metaObject()->className());
}
propertyInfo.append(signalInfo);
propertyInfo.append(wrapResult(prop.read(object)));
qtProperties.append(propertyInfo);
}
for (int i = 0; i < metaObject->methodCount(); ++i) {
if (notifySignals.contains(i)) {
continue;
}
const QMetaMethod &method = metaObject->method(i);
//NOTE: this must be a string, otherwise it will be converted to '{}' in QML
const QString &name = QString::fromLatin1(method.name());
// optimize: skip overloaded methods/signals or property getters, on the JS side we can only
// call one of them anyways
// TODO: basic support for overloaded signals, methods
if (identifiers.contains(name)) {
continue;
}
identifiers << name;
// send data as array to client with format: [name, index]
QJsonArray data;
data.append(name);
data.append(i);
if (method.methodType() == QMetaMethod::Signal) {
qtSignals.append(data);
} else if (method.access() == QMetaMethod::Public) {
qtMethods.append(data);
}
}
for (int i = 0; i < metaObject->enumeratorCount(); ++i) {
QMetaEnum enumerator = metaObject->enumerator(i);
QJsonObject values;
for (int k = 0; k < enumerator.keyCount(); ++k) {
values[QString::fromLatin1(enumerator.key(k))] = enumerator.value(k);
}
qtEnums[QString::fromLatin1(enumerator.name())] = values;
}
data[KEY_SIGNALS] = qtSignals;
data[KEY_METHODS] = qtMethods;
data[KEY_PROPERTIES] = qtProperties;
if (!qtEnums.isEmpty()) {
data[KEY_ENUMS] = qtEnums;
}
return data;
}
Parser::Parser(Can *onCan, QObject *parent) :
QObject(parent),
consoleKey1(),
consoleKey2(),
ipdState(),
mcoLimits(),
mcoMode(),
mcoState(),
mmCoord(),
mmAltLong(),
mpState(),
mvdDd(),
sysDiagnostics(),
sysKey(),
tskbmState(),
uktolDd1(),
vdsState()
{
QMetaEnum auxDescriptors = AuxResource::staticMetaObject.enumerator (
AuxResource::staticMetaObject.indexOfEnumerator ("Descriptor"));
for (int i = 0; i < auxDescriptors.keyCount(); i ++)
{
AuxResource::Descriptor descriptor = AuxResource::Descriptor(auxDescriptors.value(i));
auxResources[descriptor] = new AuxResourceVersion (descriptor, this);
auxResources[descriptor]->connect (onCan, SIGNAL(messageReceived(CanFrame)), SLOT(processCanMessage(CanFrame)));
this->connect (auxResources[descriptor], SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
}
consoleKey1.connect (onCan, SIGNAL(messageReceived(CanFrame)), SLOT(processCanMessage(CanFrame)));
consoleKey2.connect (onCan, SIGNAL(messageReceived(CanFrame)), SLOT(processCanMessage(CanFrame)));
ipdState.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
mcoLimits.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
mcoMode.connect (onCan, SIGNAL(messageReceived(CanFrame)), SLOT(processCanMessage(CanFrame)));
mcoState.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
mmAltLong.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
mmCoord.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
mpState.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
mvdDd.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
sysDiagnostics.connect (onCan, SIGNAL(messageReceived(CanFrame)), SLOT(processCanMessage(CanFrame)));
sysKey.connect (onCan, SIGNAL(messageReceived(CanFrame)), SLOT(processCanMessage(CanFrame)));
tskbmState.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
uktolDd1.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
vdsState.connect (onCan, SIGNAL(messageReceived(CanFrame)),SLOT(processCanMessage(CanFrame)));
this->connect (&consoleKey1, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&consoleKey1, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&ipdState, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mcoLimits, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mcoMode, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mcoState, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mmAltLong, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mmCoord, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mpState, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&mvdDd, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&sysDiagnostics, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&sysKey, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&tskbmState, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&uktolDd1, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
this->connect (&vdsState, SIGNAL(whateverChanged()), SLOT(getChildChagnedSignal()));
}
bool Xsd::GetEnumXSD( HTTPRequest *pRequest, QString sEnumName )
{
if (sEnumName.isEmpty())
return false;
// ----------------------------------------------------------------------
// sEnumName needs to be in class.enum format
// ----------------------------------------------------------------------
if (sEnumName.count('.') != 1 )
return false;
QStringList lstTypeParts = sEnumName.split( '.' );
// ----------------------------------------------------------------------
// Create Parent object so we can get to its metaObject
// ----------------------------------------------------------------------
QString sParentFQN = "DTC::" + lstTypeParts[0];
int nParentId = QMetaType::type( sParentFQN.toUtf8() );
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
QObject *pParentClass = (QObject *)QMetaType::construct( nParentId );
#else
QObject *pParentClass = (QObject *)QMetaType::create( nParentId );
#endif
const QMetaObject *pMetaObject = pParentClass->metaObject();
QMetaType::destroy( nParentId, pParentClass );
// ----------------------------------------------------------------------
// Now look up enum
// ----------------------------------------------------------------------
int nEnumIdx = pMetaObject->indexOfEnumerator( lstTypeParts[1].toUtf8() );
if (nEnumIdx < 0 )
return false;
QMetaEnum metaEnum = pMetaObject->enumerator( nEnumIdx );
// ----------------------------------------------------------------------
// render xsd for this enum
//
// <xs:simpleType name="RecordingInfo.RecordingDupMethodEnum">
// <xs:restriction base="xs:string">
// <xs:enumeration value="kDupCheckNone">
// <xs:annotation>
// <xs:appinfo>
// <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">1</EnumerationValue>
// </xs:appinfo>
// </xs:annotation>
// </xs:enumeration>
// <xs:enumeration value="kDupCheckSub">
// <xs:annotation>
// <xs:appinfo>
// <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">2</EnumerationValue>
// </xs:appinfo>
// </xs:annotation>
// </xs:enumeration>
// </xs:restriction>
// </xs:simpleType>
//
// <xs:element name="RecordingInfo.RecordingDupMethodEnum" type="tns:RecordingInfo.RecordingDupMethodEnum" nillable="true"/>
// ----------------------------------------------------------------------
if (!pRequest->m_mapParams.contains( "raw" ))
{
appendChild( createProcessingInstruction( "xml-stylesheet",
"type=\"text/xsl\" href=\"/xslt/enum.xslt\"" ));
}
// ----------------------------------------------------------------------
// Create xs:simpleType structure
// ----------------------------------------------------------------------
QDomElement oTypeNode = createElement( "xs:simpleType" );
QDomElement oRestrictNode = createElement( "xs:restriction" );
oTypeNode .setAttribute( "name", sEnumName );
oRestrictNode.setAttribute( "base", "xs:string" );
oTypeNode.appendChild( oRestrictNode );
for( int nIdx = 0; nIdx < metaEnum.keyCount(); nIdx++)
{
QDomElement oEnum = createElement( "xs:enumeration" );
oEnum.setAttribute( "value", metaEnum.key( nIdx ));
// ------------------------------------------------------------------
// Add appInfo to store numerical value & translated text
// ------------------------------------------------------------------
QDomElement oAnn = createElement( "xs:annotation" );
QDomElement oApp = createElement( "xs:appinfo" );
QDomElement oEnumVal = createElement( "EnumerationValue" );
QDomElement oEnumDesc = createElement( "EnumerationDesc" );
oEnum.appendChild( oAnn );
oAnn .appendChild( oApp );
oApp .appendChild( oEnumVal );
oApp .appendChild( oEnumDesc );
oEnumVal .appendChild( createTextNode( QString::number( metaEnum.value( nIdx ))));
oEnumDesc.appendChild( createTextNode( QObject::tr( metaEnum.key( nIdx ), "Enums" )));
oRestrictNode.appendChild( oEnum );
}
// ----------------------------------------------------------------------
QDomElement oElementNode = createElement( "xs:element" );
oElementNode.setAttribute( "name" , sEnumName );
oElementNode.setAttribute( "type" , "tns:" + sEnumName );
oElementNode.setAttribute( "nillable", "true" );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
QDomElement oRoot = CreateSchemaRoot();
oRoot.appendChild( oTypeNode );
oRoot.appendChild( oElementNode );
appendChild( oRoot );
// ----------------------------------------------------------------------
// Return xsd doc to caller
// ----------------------------------------------------------------------
QTextStream os( &(pRequest->m_response) );
pRequest->m_eResponseType = ResponseTypeXML;
save( os, 0 );
return true;
}
void ObjectControllerPrivate::addClassProperties(const QMetaObject *metaObject)
{
if (!metaObject)
return;
addClassProperties(metaObject->superClass());
QtProperty *classProperty = m_classToProperty.value(metaObject);
if (!classProperty) {
QString className = QLatin1String(metaObject->className());
classProperty = m_manager->addProperty(QtVariantPropertyManager::groupTypeId(), className);
m_classToProperty[metaObject] = classProperty;
m_propertyToClass[classProperty] = metaObject;
for (int idx = metaObject->propertyOffset(); idx < metaObject->propertyCount(); idx++) {
QMetaProperty metaProperty = metaObject->property(idx);
int type = metaProperty.userType();
QtVariantProperty *subProperty = 0;
if (!metaProperty.isReadable()) {
subProperty = m_readOnlyManager->addProperty(QVariant::String, QLatin1String(metaProperty.name()));
subProperty->setValue(QLatin1String("< Non Readable >"));
} else if (metaProperty.isEnumType()) {
if (metaProperty.isFlagType()) {
subProperty = m_manager->addProperty(QtVariantPropertyManager::flagTypeId(), QLatin1String(metaProperty.name()));
QMetaEnum metaEnum = metaProperty.enumerator();
QMap<int, bool> valueMap;
QStringList flagNames;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value) && isPowerOf2(value)) {
valueMap[value] = true;
flagNames.append(QLatin1String(metaEnum.key(i)));
}
subProperty->setAttribute(QLatin1String("flagNames"), flagNames);
subProperty->setValue(flagToInt(metaEnum, metaProperty.read(m_object).toInt()));
}
} else {
subProperty = m_manager->addProperty(QtVariantPropertyManager::enumTypeId(), QLatin1String(metaProperty.name()));
QMetaEnum metaEnum = metaProperty.enumerator();
QMap<int, bool> valueMap; // dont show multiple enum values which have the same values
QStringList enumNames;
for (int i = 0; i < metaEnum.keyCount(); i++) {
int value = metaEnum.value(i);
if (!valueMap.contains(value)) {
valueMap[value] = true;
enumNames.append(QLatin1String(metaEnum.key(i)));
}
}
subProperty->setAttribute(QLatin1String("enumNames"), enumNames);
subProperty->setValue(enumToInt(metaEnum, metaProperty.read(m_object).toInt()));
}
} else if (m_manager->isPropertyTypeSupported(type)) {
if (!metaProperty.isWritable())
subProperty = m_readOnlyManager->addProperty(type, QLatin1String(metaProperty.name()) + QLatin1String(" (Non Writable)"));
if (!metaProperty.isDesignable())
subProperty = m_readOnlyManager->addProperty(type, QLatin1String(metaProperty.name()) + QLatin1String(" (Non Designable)"));
else
subProperty = m_manager->addProperty(type, QLatin1String(metaProperty.name()));
subProperty->setValue(metaProperty.read(m_object));
} else {
subProperty = m_readOnlyManager->addProperty(QVariant::String, QLatin1String(metaProperty.name()));
subProperty->setValue(QLatin1String("< Unknown Type >"));
subProperty->setEnabled(false);
}
classProperty->addSubProperty(subProperty);
m_propertyToIndex[subProperty] = idx;
m_classToIndexToProperty[metaObject][idx] = subProperty;
}
} else {
updateClassProperties(metaObject, false);
}
m_topLevelProperties.append(classProperty);
m_browser->addProperty(classProperty);
}
QString qax_generateDocumentation(QAxBase *that)
{
that->metaObject();
if (that->isNull())
return QString();
ITypeInfo *typeInfo = 0;
IDispatch *dispatch = 0;
that->queryInterface(IID_IDispatch, (void**)&dispatch);
if (dispatch)
dispatch->GetTypeInfo(0, LOCALE_SYSTEM_DEFAULT, &typeInfo);
QString docu;
QTextStream stream(&docu, QIODevice::WriteOnly);
const QMetaObject *mo = that->metaObject();
QString coClass = QLatin1String(mo->classInfo(mo->indexOfClassInfo("CoClass")).value());
stream << "<h1 align=center>" << coClass << " Reference</h1>" << endl;
stream << "<p>The " << coClass << " COM object is a " << that->qObject()->metaObject()->className();
stream << " with the CLSID " << that->control() << ".</p>" << endl;
stream << "<h3>Interfaces</h3>" << endl;
stream << "<ul>" << endl;
const char *inter = 0;
int interCount = 1;
while ((inter = mo->classInfo(mo->indexOfClassInfo("Interface " + QByteArray::number(interCount))).value())) {
stream << "<li>" << inter << endl;
interCount++;
}
stream << "</ul>" << endl;
stream << "<h3>Event Interfaces</h3>" << endl;
stream << "<ul>" << endl;
interCount = 1;
while ((inter = mo->classInfo(mo->indexOfClassInfo("Event Interface " + QByteArray::number(interCount))).value())) {
stream << "<li>" << inter << endl;
interCount++;
}
stream << "</ul>" << endl;
QList<QString> methodDetails, propDetails;
const int slotCount = mo->methodCount();
if (slotCount) {
stream << "<h2>Public Slots:</h2>" << endl;
stream << "<ul>" << endl;
int defArgCount = 0;
for (int islot = mo->methodOffset(); islot < slotCount; ++islot) {
const QMetaMethod slot = mo->method(islot);
if (slot.methodType() != QMetaMethod::Slot)
continue;
if (slot.attributes() & QMetaMethod::Cloned) {
++defArgCount;
continue;
}
QByteArray returntype(slot.typeName());
if (returntype.isEmpty())
returntype = "void";
QByteArray prototype = namedPrototype(slot.parameterTypes(), slot.parameterNames(), defArgCount);
QByteArray signature = slot.methodSignature();
QByteArray name = signature.left(signature.indexOf('('));
stream << "<li>" << returntype << " <a href=\"#" << name << "\"><b>" << name << "</b></a>" << prototype << ";</li>" << endl;
prototype = namedPrototype(slot.parameterTypes(), slot.parameterNames());
QString detail = QString::fromLatin1("<h3><a name=") + QString::fromLatin1(name.constData()) + QLatin1String("></a>") +
QLatin1String(returntype.constData()) + QLatin1Char(' ') +
QLatin1String(name.constData()) + QLatin1Char(' ') +
QString::fromLatin1(prototype.constData()) + QLatin1String("<tt> [slot]</tt></h3>\n");
prototype = namedPrototype(slot.parameterTypes(), QList<QByteArray>());
detail += docuFromName(typeInfo, QString::fromLatin1(name.constData()));
detail += QLatin1String("<p>Connect a signal to this slot:<pre>\n");
detail += QString::fromLatin1("\tQObject::connect(sender, SIGNAL(someSignal") + QString::fromLatin1(prototype.constData()) +
QLatin1String("), object, SLOT(") + QString::fromLatin1(name.constData()) +
QString::fromLatin1(prototype.constData()) + QLatin1String("));");
detail += QLatin1String("</pre>\n");
if (1) {
detail += QLatin1String("<p>Or call the function directly:<pre>\n");
bool hasParams = slot.parameterTypes().count() != 0;
if (hasParams)
detail += QLatin1String("\tQVariantList params = ...\n");
detail += QLatin1String("\t");
QByteArray functionToCall = "dynamicCall";
if (returntype == "IDispatch*" || returntype == "IUnknown*") {
functionToCall = "querySubObject";
returntype = "QAxObject *";
}
if (returntype != "void")
detail += QLatin1String(returntype.constData()) + QLatin1String(" result = ");
detail += QLatin1String("object->") + QLatin1String(functionToCall.constData()) +
QLatin1String("(\"" + name + prototype + '\"');
if (hasParams)
detail += QLatin1String(", params");
detail += QLatin1Char(')');
if (returntype != "void" && returntype != "QAxObject *" && returntype != "QVariant")
detail += QLatin1Char('.') + QLatin1String(toType(returntype));
detail += QLatin1String(";</pre>\n");
} else {
detail += QLatin1String("<p>This function has parameters of unsupported types and cannot be called directly.");
}
methodDetails << detail;
defArgCount = 0;
}
stream << "</ul>" << endl;
}
int signalCount = mo->methodCount();
if (signalCount) {
ITypeLib *typeLib = 0;
if (typeInfo) {
UINT index = 0;
typeInfo->GetContainingTypeLib(&typeLib, &index);
typeInfo->Release();
}
typeInfo = 0;
stream << "<h2>Signals:</h2>" << endl;
stream << "<ul>" << endl;
for (int isignal = mo->methodOffset(); isignal < signalCount; ++isignal) {
const QMetaMethod signal(mo->method(isignal));
if (signal.methodType() != QMetaMethod::Signal)
continue;
QByteArray prototype = namedPrototype(signal.parameterTypes(), signal.parameterNames());
QByteArray signature = signal.methodSignature();
QByteArray name = signature.left(signature.indexOf('('));
stream << "<li>void <a href=\"#" << name << "\"><b>" << name << "</b></a>" << prototype << ";</li>" << endl;
QString detail = QLatin1String("<h3><a name=") + QLatin1String(name.constData()) + QLatin1String("></a>void ") +
QLatin1String(name.constData()) + QLatin1Char(' ') +
QLatin1String(prototype.constData()) + QLatin1String("<tt> [signal]</tt></h3>\n");
if (typeLib) {
interCount = 0;
do {
if (typeInfo)
typeInfo->Release();
typeInfo = 0;
typeLib->GetTypeInfo(++interCount, &typeInfo);
QString typeLibDocu = docuFromName(typeInfo, QString::fromLatin1(name.constData()));
if (!typeLibDocu.isEmpty()) {
detail += typeLibDocu;
break;
}
} while (typeInfo);
}
prototype = namedPrototype(signal.parameterTypes(), QList<QByteArray>());
detail += QLatin1String("<p>Connect a slot to this signal:<pre>\n");
detail += QLatin1String("\tQObject::connect(object, SIGNAL(") + QString::fromLatin1(name.constData()) +
QString::fromLatin1(prototype.constData()) +
QLatin1String("), receiver, SLOT(someSlot") + QString::fromLatin1(prototype.constData()) + QLatin1String("));");
detail += QLatin1String("</pre>\n");
methodDetails << detail;
if (typeInfo)
typeInfo->Release();
typeInfo = 0;
}
stream << "</ul>" << endl;
if (typeLib)
typeLib->Release();
}
const int propCount = mo->propertyCount();
if (propCount) {
if (dispatch)
dispatch->GetTypeInfo(0, LOCALE_SYSTEM_DEFAULT, &typeInfo);
stream << "<h2>Properties:</h2>" << endl;
stream << "<ul>" << endl;
for (int iprop = 0; iprop < propCount; ++iprop) {
const QMetaProperty prop = mo->property(iprop);
QByteArray name(prop.name());
QByteArray type(prop.typeName());
stream << "<li>" << type << " <a href=\"#" << name << "\"><b>" << name << "</b></a>;</li>" << endl;
QString detail = QLatin1String("<h3><a name=") + QString::fromLatin1(name.constData()) + QLatin1String("></a>") +
QLatin1String(type.constData()) +
QLatin1Char(' ') + QLatin1String(name.constData()) + QLatin1String("</h3>\n");
detail += docuFromName(typeInfo, QString::fromLatin1(name));
QVariant::Type vartype = QVariant::nameToType(type);
if (!prop.isReadable())
continue;
if (prop.isEnumType())
vartype = QVariant::Int;
if (vartype != QVariant::Invalid) {
detail += QLatin1String("<p>Read this property's value using QObject::property:<pre>\n");
if (prop.isEnumType())
detail += QLatin1String("\tint val = ");
else
detail += QLatin1Char('\t') + QLatin1String(type.constData()) + QLatin1String(" val = ");
detail += QLatin1String("object->property(\"") + QLatin1String(name.constData()) +
QLatin1String("\").") + QLatin1String(toType(type).constData()) + QLatin1String(";\n");
detail += QLatin1String("</pre>\n");
} else if (type == "IDispatch*" || type == "IUnknown*") {
detail += QLatin1String("<p>Get the subobject using querySubObject:<pre>\n");
detail += QLatin1String("\tQAxObject *") + QLatin1String(name.constData()) +
QLatin1String(" = object->querySubObject(\"") + QLatin1String(name.constData()) + QLatin1String("\");\n");
detail += QLatin1String("</pre>\n");
} else {
detail += QLatin1String("<p>This property is of an unsupported type.\n");
}
if (prop.isWritable()) {
detail += QLatin1String("Set this property' value using QObject::setProperty:<pre>\n");
if (prop.isEnumType()) {
detail += QLatin1String("\tint newValue = ... // string representation of values also supported\n");
} else {
detail += QLatin1String("\t") + QString::fromLatin1(type.constData()) + QLatin1String(" newValue = ...\n");
}
detail += QLatin1String("\tobject->setProperty(\"") + QString::fromLatin1(name) + QLatin1String("\", newValue);\n");
detail += QLatin1String("</pre>\n");
detail += QLatin1String("Or using the ");
QByteArray setterSlot;
if (isupper(name.at(0))) {
setterSlot = "Set" + name;
} else {
QByteArray nameUp = name;
nameUp[0] = toupper(nameUp.at(0));
setterSlot = "set" + nameUp;
}
detail += QLatin1String("<a href=\"#") + QString::fromLatin1(setterSlot) + QLatin1String("\">") +
QString::fromLatin1(setterSlot.constData()) + QLatin1String("</a> slot.\n");
}
if (prop.isEnumType()) {
detail += QLatin1String("<p>See also <a href=\"#") + QString::fromLatin1(type) +
QLatin1String("\">") + QString::fromLatin1(type) + QLatin1String("</a>.\n");
}
propDetails << detail;
}
stream << "</ul>" << endl;
}
const int enumCount = mo->enumeratorCount();
if (enumCount) {
stream << "<hr><h2>Member Type Documentation</h2>" << endl;
for (int i = 0; i < enumCount; ++i) {
const QMetaEnum enumdata = mo->enumerator(i);
stream << "<h3><a name=" << enumdata.name() << "></a>" << enumdata.name() << "</h3>" << endl;
stream << "<ul>" << endl;
for (int e = 0; e < enumdata.keyCount(); ++e) {
stream << "<li>" << enumdata.key(e) << "\t=" << enumdata.value(e) << "</li>" << endl;
}
stream << "</ul>" << endl;
}
}
if (methodDetails.count()) {
stream << "<hr><h2>Member Function Documentation</h2>" << endl;
for (int i = 0; i < methodDetails.count(); ++i)
stream << methodDetails.at(i) << endl;
}
if (propDetails.count()) {
stream << "<hr><h2>Property Documentation</h2>" << endl;
for (int i = 0; i < propDetails.count(); ++i)
stream << propDetails.at(i) << endl;
}
if (typeInfo)
typeInfo->Release();
if (dispatch)
dispatch->Release();
return docu;
}
