void Properties::DisplayProperties(QVariant p) {
// get current property
QString propertyName;
QTreeWidgetItem* item = ui->propertyView->currentItem();
if (item) {
propertyName = item->data(0, Qt::DisplayRole).toString();
}
ui->propertyView->clear();
// only support QVariantMap or QVariantHash at this level
switch (p.type()) {
case QMetaType::QVariantMap:
ParseIterable(NULL, p.toMap());
break;
case QMetaType::QVariantHash:
ParseIterable(NULL, p.toHash());
break;
case QMetaType::QVariantList:
ParseList(NULL, p.toList());
break;
default:
qWarning("Trying to display scalar value as a property");
break;
}
// expand at least the first level
ui->propertyView->expandToDepth(0);
if (propertyName.size() != 0) {
// try to restore the path
QList<QTreeWidgetItem*> items =
ui->propertyView->findItems(propertyName, Qt::MatchRecursive);
if (items.size())
items.front()->setSelected(true);
}
}
QVector<JsonKitsPage::ConditionalFeature> JsonKitsPage::parseFeatures(const QVariant &data,
QString *errorMessage)
{
QVector<ConditionalFeature> result;
if (errorMessage)
errorMessage->clear();
if (data.isNull())
return result;
if (data.type() != QVariant::List) {
if (errorMessage)
*errorMessage = tr("Feature list is set and not of type list.");
return result;
}
foreach (const QVariant &element, data.toList()) {
if (element.type() == QVariant::String) {
result.append({ element.toString(), QVariant(true) });
} else if (element.type() == QVariant::Map) {
const QVariantMap obj = element.toMap();
const QString feature = obj.value(QLatin1String(KEY_FEATURE)).toString();
if (feature.isEmpty()) {
*errorMessage = tr("No \"%1\" key found in feature list object.")
.arg(QLatin1String(KEY_FEATURE));
return QVector<ConditionalFeature>();
}
result.append({ feature, obj.value(QLatin1String(KEY_CONDITION), true) });
} else {
if (errorMessage)
*errorMessage = tr("Feature list element is not a string or object.");
return QVector<ConditionalFeature>();
}
}
return result;
}
void
TestPyOtherSide::testSetToList()
{
// Test if a Python set is converted to a list
PyObject *set = PySet_New(NULL);
QVERIFY(set != NULL);
PyObject *o = NULL;
o = PyLong_FromLong(123);
QVERIFY(o != NULL);
QVERIFY(PySet_Add(set, o) == 0);
o = PyLong_FromLong(321);
QVERIFY(o != NULL);
QVERIFY(PySet_Add(set, o) == 0);
o = PyLong_FromLong(444);
QVERIFY(o != NULL);
QVERIFY(PySet_Add(set, o) == 0);
// This will not be added (no duplicates in a set)
o = PyLong_FromLong(123);
QVERIFY(o != NULL);
QVERIFY(PySet_Add(set, o) == 0);
// At this point, we should have 3 items (123, 321 and 444)
QVERIFY(PySet_Size(set) == 3);
QVariant v = convertPyObjectToQVariant(set);
QVERIFY(v.canConvert(QMetaType::QVariantList));
QList<QVariant> l = v.toList();
QVERIFY(l.size() == 3);
QVERIFY(l.contains(123));
QVERIFY(l.contains(321));
QVERIFY(l.contains(444));
}
void Evaluate::addVariant(QVariant &object) {
if (object.isValid()) {
switch(object.type()) {
case QMetaType::QString:
{
QString string = object.toString();
addString(string);
}
break;
case QMetaType::QVariantList:
{
QVariantList list = object.toList();
addArray(list);
}
break;
case QMetaType::Double:
m_buffer.append(object.toString());
break;
case QMetaType::QVariantMap:
{
QVariantMap map = object.toMap();
addMap(map);
break;
}
case QMetaType::Bool:
{
m_buffer.append(object.toString());
break;
}
default:
m_buffer.append("null");
}
} else {
m_buffer.append("null");
}
}
// <name> or (rename <name> <altName>)
void writeName(QXmlStreamWriter &stream, const QVariant &v)
{
if (v.type() == QVariant::List)
{
QVariantList l = v.toList();
if (l[0].toString() != "rename")
{
qWarning("Wrong name description");
}
else
{
stream.writeAttribute("name", l[1].toString());
//stream.writeAttribute("altName", l[2].toString()); // TODO: strip quotes
}
}
else if (v.type() == QVariant::String)
{
stream.writeAttribute("name", v.toString());
}
else
{
qWarning("Wrong name description");
}
}
QStringList FindValueOperation::findValue(const QVariant &in, const QVariant &value,
const QString &prefix)
{
QStringList result;
if (in.type() == value.type() && in == value) {
result << prefix;
} else if (in.type() == QVariant::Map) {
const QVariantMap map = in.toMap();
for (QVariantMap::const_iterator i = map.begin(); i != map.end(); ++i) {
QString pfx = prefix;
if (!pfx.isEmpty())
pfx.append(QLatin1Char('/'));
pfx.append(i.key());
result.append(findValue(i.value(), value, pfx));
}
} else if (in.type() == QVariant::List) {
QVariantList list = in.toList();
for (int pos = 0; pos < list.count(); ++pos) {
QString pfx = prefix + QLatin1Char('[') + QString::number(pos) + QLatin1Char(']');
result.append(findValue(list.at(pos), value, pfx));
}
}
return result;
}
CommandDataModel::CommandDataModel()
{
// Load saveBeforeExecute option
QVariant s = mSettings.value(QLatin1String("saveBeforeExecute"), true);
mSaveBeforeExecute = s.toBool();
// Load command list
const QVariant variant = mSettings.value(QLatin1String("commandList"));
const QList<QVariant> commands = variant.toList();
foreach (const QVariant &commandVariant, commands)
mCommands.append(Command::fromQVariant(commandVariant));
// Add default commands the first time the app has booted up.
// This is useful on it's own and helps demonstrate how to use the commands.
const QString addPrefStr = QLatin1String("addedDefaultCommands");
const bool addedCommands = mSettings.value(addPrefStr, false).toBool();
if (!addedCommands) {
// Disable default commands by default so user gets an informative
// warning when clicking the command button for the first time
Command command(false);
#ifdef Q_WS_X11
command.command = QLatin1String("gedit %mapfile");
#elif defined(Q_WS_MAC)
command.command = QLatin1String("open -t %mapfile");
#endif
if (!command.command.isEmpty()) {
command.name = tr("Open in text editor");
mCommands.push_back(command);
}
commit();
mSettings.setValue(addPrefStr, true);
}
}
void AbstractInputTool::load(const QVariant& settings)
{
clear();
const QVariantList list = settings.toList();
for (int i = 0; i < list.size(); i++)
{
const QVariantMap map = list.at(i).toMap();
const QString id = map["instance"].toString();
const QVariantList vpath = map["path"].toList();
QList< int > path;
for (int j = 0; j < vpath.size(); j++)
{
path << vpath.at(j).toInt();
}
InterfaceDescriptor_ptr ref =
m_model->getReflective(id);
if (ref)
{
AbstractInputItem * item =
createAbstractInputItem(id, ref, path);
if (item)
{
item->load(map["config"]);
m_model->check(id, path);
}
}
}
}
bool Serializer::SerializerPrivate::serialize( const QVariant &v, QIODevice * io, int indentLevel, bool beginNoIndent )
{
if ( ! v.isValid() )
{
// invalid or null?
io->write("null");
}else if (( v.type() == QVariant::List ) || ( v.type() == QVariant::StringList ))
{
// an array or a stringlist?
bool isFirst = true;
io->write(getSeparator(indentMode, beginNoIndent ? 0 : indentLevel, BeginSeparator, SquareBracket));
const QVariantList list = v.toList();
Q_FOREACH( const QVariant& var, list )
{
if(!isFirst)
io->write(getSeparator(indentMode, indentLevel, JoinSeparator, SquareBracket));
isFirst = false;
if(!serialize( var, io, indentLevel+1))
return false;
}
io->write(getSeparator(indentMode, indentLevel, EndSeparator, SquareBracket));
} else if ( v.type() == QVariant::Map )
static LfpObject variantAsObject(const QVariant &v, const QString &name = QString())
{
if(v.type() == QVariant::List)
{
QVariantList list = v.toList();
LfpObject obj("sequence", name);
for(int n = 0; n < list.count(); ++n)
obj += variantAsObject(list[n]);
return obj;
}
else if(v.type() == QVariant::Map)
{
QVariantMap map = v.toMap();
LfpObject obj("map", name);
QMapIterator<QString, QVariant> it(map);
while(it.hasNext())
{
it.next();
obj += variantAsObject(it.value(), it.key());
}
return obj;
}
else
{
if(v.type() == QVariant::Bool)
return LfpObject("bool", name, v);
else if(v.type() == QVariant::Int || v.type() == QVariant::LongLong)
return LfpObject("int", name, v);
else if(v.type() == QVariant::String)
return LfpObject("string", name, v);
else if(v.type() == QVariant::ByteArray)
return LfpObject("bytearray", name, v);
else
return LfpObject(); // TODO: error?
}
}
QByteArray Serializer::SerializerPrivate::serialize( const QVariant &v, int reserved )
{
QByteArray str;
bool error = false;
QByteArray indent;
if ( ! v.isValid() ) { // invalid or null?
str = "null";
} else if (( v.type() == QVariant::List ) || ( v.type() == QVariant::StringList )){ // an array or a stringlist?
const QVariantList list = v.toList();
QList<QByteArray> values;
Q_FOREACH( const QVariant& var, list )
{
reserved++;
QByteArray serializedValue = serialize( var,reserved );
reserved--;
if ( serializedValue.isNull() ) {
error = true;
break;
}
values << serializedValue;
}
if (indentMode == QJson::IndentMinimum) {
QByteArray indent = buildIndent(reserved - 1);
str = "[\n" + join( values, ",\n" ) + "\n" + indent + "]";
}
else if (indentMode == QJson::IndentMedium || indentMode == QJson::IndentFull){
QByteArray indent = buildIndent(reserved);
str = "[\n" + join( values, ",\n" ) + "\n" + indent + "]";
}
else {
str = "[ " + join( values, ", " ) + " ]";
}
} else if ( v.type() == QVariant::Map ) { // variant is a map?
QJsonValue QMetaObjectPublisher::wrapResult(const QVariant &result)
{
if (QObject *object = result.value<QObject *>()) {
QJsonObject objectInfo;
objectInfo[KEY_QOBJECT] = true;
QString id = registeredObjectIds.value(object);
if (id.isEmpty()) {
// neither registered, nor wrapped, do so now
id = QUuid::createUuid().toString();
registeredObjectIds[object] = id;
registeredObjects[id] = object;
QJsonObject info = classInfoForObject(object);
wrappedObjects[object] = info;
objectInfo[KEY_DATA] = info;
if (propertyUpdatesInitialized) {
// if other objects are initialized already, do the same here
initializePropertyUpdates(object, info);
}
} else if (wrappedObjects.contains(object)) {
// if this object was wrapped, send the full class info
// this is required for proper multi-client support
objectInfo[KEY_DATA] = wrappedObjects.value(object);
}
objectInfo[KEY_ID] = id;
return objectInfo;
} else if (result.canConvert<QVariantList>()) {
// recurse and potentially wrap contents of the array
return wrapList(result.toList());
}
// no need to wrap this
return QJsonValue::fromVariant(result);
}
QByteArray Json::serialize(const QVariant &data, bool &success)
{
QByteArray str;
success = true;
if(!data.isValid()) // invalid or null?
{
str = "null";
}
else if((data.type() == QVariant::List) ||
(data.type() == QVariant::StringList)) // variant is a list?
{
QList<QByteArray> values;
const QVariantList list = data.toList();
Q_FOREACH(const QVariant& v, list)
{
QByteArray serializedValue = serialize(v);
if(serializedValue.isNull())
{
success = false;
break;
}
values << serializedValue;
}
void PlayerComponent::updateAudioDeviceList()
{
QVariantList settingList;
QVariant list = getAudioDeviceList();
QSet<QString> devices;
foreach (const QVariant& d, list.toList())
{
Q_ASSERT(d.type() == QVariant::Map);
QVariantMap dmap = d.toMap();
devices.insert(dmap["name"].toString());
QVariantMap entry;
entry["value"] = dmap["name"];
entry["title"] = dmap["description"];
settingList << entry;
}
SettingsComponent::Get().updatePossibleValues(SETTINGS_SECTION_AUDIO, "device", settingList);
checkCurrentAudioDevice(m_audioDevices, devices);
m_audioDevices = devices;
}
int JsonDbPartition::remove(const QJSValue &object, const QJSValue &options, const QJSValue &callback)
{
QJSValue actualOptions = options;
QJSValue actualCallback = callback;
if (options.isCallable()) {
if (!callback.isUndefined()) {
qWarning() << "Callback should be the last parameter.";
return -1;
}
actualCallback = actualOptions;
actualOptions = QJSValue(QJSValue::UndefinedValue);
}
QVariantMap opts = qjsvalue_to_qvariant(actualOptions).toMap();
QJsonDbWriteRequest::ConflictResolutionMode conflictMode =
static_cast<QJsonDbWriteRequest::ConflictResolutionMode>(opts.value(QStringLiteral("mode")).toInt());
QVariant obj = qjsvalue_to_qvariant(object);
QJsonDbWriteRequest *request(0);
if (obj.type() == QVariant::List) {
request = new QJsonDbRemoveRequest(qvariantlist_to_qjsonobject_list(obj.toList()));
} else {
request = new QJsonDbRemoveRequest(QJsonObject::fromVariantMap(obj.toMap()));
}
request->setPartition(_name);
request->setConflictResolutionMode(conflictMode);
connect(request, SIGNAL(finished()), this, SLOT(requestFinished()));
connect(request, SIGNAL(finished()), request, SLOT(deleteLater()));
connect(request, SIGNAL(error(QtJsonDb::QJsonDbRequest::ErrorCode,QString)),
this, SLOT(requestError(QtJsonDb::QJsonDbRequest::ErrorCode,QString)));
connect(request, SIGNAL(error(QtJsonDb::QJsonDbRequest::ErrorCode,QString)),
request, SLOT(deleteLater()));
JsonDatabase::sharedConnection().send(request);
writeCallbacks.insert(request, actualCallback);
return request->property("requestId").toInt();
}
void ParameterProperties::setValue(QVariant p)
{
setType(p.type());
switch (p.type())
{
case QVariant::Bool:
_bool->setCurrentIndex(p.toBool() ? 1 : 0);
break;
case QVariant::Int:
_int->setText(QString::number(p.toInt()));
break;
case QVariant::Double:
_double->setText(QString::number(p.toDouble()));
break;
case QVariant::String:
_string->setText(p.toString());
break;
case QVariant::List:
setList(p.toList());
break;
default:
_string->setText(p.toString());
}
}
bool QtVariantContext::isFalse(const QString& key) const
{
QVariant value = this->value(key);
switch (value.userType()) {
case QMetaType::QChar:
case QMetaType::Double:
case QMetaType::Float:
case QMetaType::Int:
case QMetaType::UInt:
case QMetaType::LongLong:
case QMetaType::ULongLong:
case QVariant::Bool:
return !value.toBool();
case QVariant::List:
case QVariant::StringList:
return value.toList().isEmpty();
case QVariant::Hash:
return value.toHash().isEmpty();
case QVariant::Map:
return value.toMap().isEmpty();
default:
return value.toString().isEmpty();
}
}
void AsyncSqlWorker::backup() {
LOG_DEBUG(TAG_ASYNCWORKER, "getFeedsList");
QString query = "SELECT * FROM FEED_TABLE";
LOG_DEBUG(TAG_ASYNCWORKER, "GET_FEEDS = %s", query.toStdString().c_str());
QVariant resultFromQuery = m_pSqlDataAccess->execute(query);
// serialize to shared files
QVariantList feedsList = resultFromQuery.toList();
if (!feedsList.isEmpty()) {
QFile file(QString("/accounts/1000/shared/documents/newsspotbackup"));
if (!file.open(QIODevice::WriteOnly)) {
qWarning() << "Cannot write to shared folder: " + file.fileName();
return;
}
QDataStream out(&file);
if (out.status() == QDataStream::Ok) {
out << feedsList;
} else {
qWarning() << "Error writing to data stream.";
}
file.close();
} else {
qDebug() << "No feeds to backup.";
}
}
void TrackerClient::httpRequestDone(bool error)
{
if (lastTrackerRequest) {
emit stopped();
return;
}
if (error) {
emit connectionError(http.error());
return;
}
QByteArray response = http.readAll();
http.abort();
BencodeParser parser;
if (!parser.parse(response)) {
qWarning("Error parsing bencode response from tracker: %s",
qPrintable(parser.errorString()));
http.abort();
return;
}
QMap<QByteArray, QVariant> dict = parser.dictionary();
if (dict.contains("failure reason")) {
// no other items are present
emit failure(QString::fromUtf8(dict.value("failure reason").toByteArray()));
return;
}
if (dict.contains("warning message")) {
// continue processing
emit warning(QString::fromUtf8(dict.value("warning message").toByteArray()));
}
if (dict.contains("tracker id")) {
// store it
trackerId = dict.value("tracker id").toByteArray();
}
if (dict.contains("interval")) {
// Mandatory item
if (requestIntervalTimer != -1)
killTimer(requestIntervalTimer);
requestIntervalTimer = startTimer(dict.value("interval").toInt() * 1000);
}
if (dict.contains("peers")) {
// store it
peers.clear();
QVariant peerEntry = dict.value("peers");
if (peerEntry.type() == QVariant::List) {
QList<QVariant> peerTmp = peerEntry.toList();
for (int i = 0; i < peerTmp.size(); ++i) {
TorrentPeer tmp;
QMap<QByteArray, QVariant> peer = qVariantValue<QMap<QByteArray, QVariant> >(peerTmp.at(i));
tmp.id = QString::fromUtf8(peer.value("peer id").toByteArray());
tmp.address.setAddress(QString::fromUtf8(peer.value("ip").toByteArray()));
tmp.port = peer.value("port").toInt();
peers << tmp;
}
} else {
QByteArray peerTmp = peerEntry.toByteArray();
for (int i = 0; i < peerTmp.size(); i += 6) {
TorrentPeer tmp;
uchar *data = (uchar *)peerTmp.constData() + i;
tmp.port = (int(data[4]) << 8) + data[5];
uint ipAddress = 0;
ipAddress += uint(data[0]) << 24;
ipAddress += uint(data[1]) << 16;
ipAddress += uint(data[2]) << 8;
ipAddress += uint(data[3]);
tmp.address.setAddress(ipAddress);
peers << tmp;
}
}
emit peerListUpdated(peers);
}
}
int lqtL_qvariant_value(lua_State *L) {
QVariant* self = static_cast<QVariant*>(lqtL_toudata(L, 1, "QVariant*"));
lqtL_selfcheck(L, self, "QVariant");
QVariant::Type type;
if (lua_isnoneornil(L, 2)) {
type = self->type();
} else {
type = (QVariant::Type)lqtL_toenum(L, 2, "QVariant.Type");
const char * currentType = self->typeName();
if (!self->canConvert(type) || !self->convert(type)) {
lua_pushnil(L);
lua_pushfstring(L, "cannot convert %s to %s", currentType, self->typeToName(type));
return 2;
}
}
switch (self->type()) {
case QVariant::Invalid: lua_pushnil(L); return 1;
/* basic types */
case QVariant::Bool: lua_pushboolean(L, self->toBool()); return 1;
case QVariant::Double: lua_pushnumber(L, self->toDouble()); return 1;
case QVariant::Int: lua_pushinteger(L, self->toInt()); return 1;
case QVariant::UInt: lua_pushinteger(L, self->toUInt()); return 1;
case QVariant::LongLong: lua_pushnumber(L, self->toLongLong()); return 1;
case QVariant::ULongLong: lua_pushnumber(L, self->toULongLong()); return 1;
case QVariant::ByteArray: {
const QByteArray &ba = self->toByteArray();
lua_pushlstring(L, ba.data(), ba.size());
return 1;
};
/* QtCore types */
case QVariant::BitArray: lqtL_passudata(L, new QBitArray(self->value<QBitArray>()), "QBitArray*"); return 1;
case QVariant::Char: lqtL_passudata(L, new QChar(self->value<QChar>()), "QChar*"); return 1;
case QVariant::Date: lqtL_passudata(L, new QDate(self->value<QDate>()), "QDate*"); return 1;
case QVariant::DateTime: lqtL_passudata(L, new QDateTime(self->value<QDateTime>()), "QDateTime*"); return 1;
case QVariant::KeySequence: lqtL_passudata(L, new QKeySequence(self->value<QKeySequence>()), "QKeySequence*"); return 1;
case QVariant::Line: lqtL_passudata(L, new QLine(self->value<QLine>()), "QLine*"); return 1;
case QVariant::LineF: lqtL_passudata(L, new QLineF(self->value<QLineF>()), "QLineF*"); return 1;
case QVariant::List: lqtL_passudata(L, new QList<QVariant>(self->toList()), "QList<QVariant>*"); return 1;
case QVariant::Locale: lqtL_passudata(L, new QLocale(self->value<QLocale>()), "QLocale*"); return 1;
case QVariant::Point: lqtL_passudata(L, new QPoint(self->value<QPoint>()), "QPoint*"); return 1;
case QVariant::PointF: lqtL_passudata(L, new QPointF(self->value<QPointF>()), "QPointF*"); return 1;
case QVariant::Rect: lqtL_passudata(L, new QRect(self->value<QRect>()), "QRect*"); return 1;
case QVariant::RectF: lqtL_passudata(L, new QRectF(self->value<QRectF>()), "QRectF*"); return 1;
case QVariant::RegExp: lqtL_passudata(L, new QRegExp(self->value<QRegExp>()), "QRegExp*"); return 1;
case QVariant::Size: lqtL_passudata(L, new QSize(self->value<QSize>()), "QSize*"); return 1;
case QVariant::SizeF: lqtL_passudata(L, new QSizeF(self->value<QSizeF>()), "QSizeF*"); return 1;
case QVariant::String: lqtL_passudata(L, new QString(self->value<QString>()), "QString*"); return 1;
case QVariant::StringList: lqtL_passudata(L, new QStringList(self->value<QStringList>()), "QStringList*"); return 1;
case QVariant::Time: lqtL_passudata(L, new QTime(self->value<QTime>()), "QTime*"); return 1;
case QVariant::Url: lqtL_passudata(L, new QUrl(self->value<QUrl>()), "QUrl*"); return 1;
#ifdef MODULE_qtgui
/* QtGui types */
case QVariant::Bitmap: lqtL_passudata(L, new QBitmap(self->value<QBitmap>()), "QBitmap*"); return 1;
case QVariant::Brush: lqtL_passudata(L, new QBrush(self->value<QBrush>()), "QBrush*"); return 1;
case QVariant::Color: lqtL_passudata(L, new QColor(self->value<QColor>()), "QColor*"); return 1;
case QVariant::Cursor: lqtL_passudata(L, new QCursor(self->value<QCursor>()), "QCursor*"); return 1;
case QVariant::Font: lqtL_passudata(L, new QFont(self->value<QFont>()), "QFont*"); return 1;
case QVariant::Icon: lqtL_passudata(L, new QIcon(self->value<QIcon>()), "QIcon*"); return 1;
case QVariant::Image: lqtL_passudata(L, new QImage(self->value<QImage>()), "QImage*"); return 1;
case QVariant::Matrix: lqtL_passudata(L, new QMatrix(self->value<QMatrix>()), "QMatrix*"); return 1;
case QVariant::Matrix4x4: lqtL_passudata(L, new QMatrix4x4(self->value<QMatrix4x4>()), "QMatrix4x4*"); return 1;
case QVariant::Palette: lqtL_passudata(L, new QPalette(self->value<QPalette>()), "QPalette*"); return 1;
case QVariant::Pen: lqtL_passudata(L, new QPen(self->value<QPen>()), "QPen*"); return 1;
case QVariant::Pixmap: lqtL_passudata(L, new QPixmap(self->value<QPixmap>()), "QPixmap*"); return 1;
case QVariant::Polygon: lqtL_passudata(L, new QPolygon(self->value<QPolygon>()), "QPolygon*"); return 1;
case QVariant::Quaternion: lqtL_passudata(L, new QQuaternion(self->value<QQuaternion>()), "QQuaternion*"); return 1;
case QVariant::Region: lqtL_passudata(L, new QRegion(self->value<QRegion>()), "QRegion*"); return 1;
case QVariant::SizePolicy: lqtL_passudata(L, new QSizePolicy(self->value<QSizePolicy>()), "QSizePolicy*"); return 1;
case QVariant::Transform: lqtL_passudata(L, new QTransform(self->value<QTransform>()), "QTransform*"); return 1;
case QVariant::TextFormat: lqtL_passudata(L, new QTextFormat(self->value<QTextFormat>()), "QTextFormat*"); return 1;
case QVariant::TextLength: lqtL_passudata(L, new QTextLength(self->value<QTextLength>()), "QTextLength*"); return 1;
case QVariant::Vector2D: lqtL_passudata(L, new QVector2D(self->value<QVector2D>()), "QVector2D*"); return 1;
case QVariant::Vector3D: lqtL_passudata(L, new QVector3D(self->value<QVector3D>()), "QVector3D*"); return 1;
case QVariant::Vector4D: lqtL_passudata(L, new QVector4D(self->value<QVector4D>()), "QVector4D*"); return 1;
#endif
}
return 0;
}
PublishFormat PublishFormat::fromVariant(Type type, const QVariant &in, bool *ok, QString *errorMessage)
{
QString pn;
if(type == HttpResponse)
pn = "'http-response'";
else if(type == HttpStream)
pn = "'http-stream'";
else // WebSocketMessage
pn = "'ws-message'";
if(!isKeyedObject(in))
{
setError(ok, errorMessage, QString("%1 is not an object").arg(pn));
return PublishFormat();
}
PublishFormat out(type);
bool ok_;
if(type == HttpResponse)
{
if(keyedObjectContains(in, "code"))
{
QVariant vcode = keyedObjectGetValue(in, "code");
if(!vcode.canConvert(QVariant::Int))
{
setError(ok, errorMessage, QString("%1 contains 'code' with wrong type").arg(pn));
return PublishFormat();
}
out.code = vcode.toInt();
if(out.code < 0 || out.code > 999)
{
setError(ok, errorMessage, QString("%1 contains 'code' with invalid value").arg(pn));
return PublishFormat();
}
}
else
out.code = 200;
QString reasonStr = getString(in, pn, "reason", false, &ok_, errorMessage);
if(!ok_)
{
if(ok)
*ok = false;
return PublishFormat();
}
if(!reasonStr.isEmpty())
out.reason = reasonStr.toUtf8();
else
out.reason = StatusReasons::getReason(out.code);
if(keyedObjectContains(in, "headers"))
{
QVariant vheaders = keyedObjectGetValue(in, "headers");
if(vheaders.type() == QVariant::List)
{
foreach(const QVariant &vheader, vheaders.toList())
{
if(vheader.type() != QVariant::List)
{
setError(ok, errorMessage, "headers contains element with wrong type");
return PublishFormat();
}
QVariantList lheader = vheader.toList();
if(lheader.count() != 2)
{
setError(ok, errorMessage, "headers contains list with wrong number of elements");
return PublishFormat();
}
QString name = getString(lheader[0], &ok_);
if(!ok_)
{
setError(ok, errorMessage, "header contains name element with wrong type");
return PublishFormat();
}
QString val = getString(lheader[1], &ok_);
if(!ok_)
{
setError(ok, errorMessage, "header contains value element with wrong type");
return PublishFormat();
}
out.headers += HttpHeader(name.toUtf8(), val.toUtf8());
}
}
else if(isKeyedObject(vheaders))
bool GmpProtocol::setFieldData(int index, const QVariant &value,
FieldAttrib attrib)
{
bool isOk = false;
if (attrib != FieldValue)
goto _exit;
switch (index)
{
case kType:
{
uint type = value.toUInt(&isOk);
if (isOk)
data.set_type(type);
break;
}
case kRsvdMrtCode:
{
uint val = value.toUInt(&isOk);
if (isOk)
data.set_rsvd_code(val);
break;
}
case kChecksum:
{
uint csum = value.toUInt(&isOk);
if (isOk)
data.set_checksum(csum);
break;
}
case kMldMrt:
{
uint mrt = value.toUInt(&isOk);
if (isOk)
data.set_max_response_time(mrt);
break;
}
case kGroupAddress:
// XXX: Handled by subclass
isOk = false;
break;
case kRsvd1:
isOk = false;
break;
case kSFlag:
{
bool flag = value.toBool();
data.set_s_flag(flag);
isOk = true;
break;
}
case kQrv:
{
uint qrv = value.toUInt(&isOk);
if (isOk)
data.set_qrv(qrv);
break;
}
case kQqic:
{
uint qqi = value.toUInt(&isOk);
if (isOk)
data.set_qqi(qqi);
break;
}
case kSourceCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_source_count(count);
break;
}
case kSources:
// XXX: Handled by subclass
isOk = false;
break;
case kRsvd2:
isOk = false;
break;
case kGroupRecordCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_group_record_count(count);
break;
}
case kGroupRecords:
{
QVariantList list = value.toList();
data.clear_group_records();
for (int i = 0; i < list.count(); i++)
{
QVariantMap grpRec = list.at(i).toMap();
OstProto::Gmp::GroupRecord *rec = data.add_group_records();
rec->set_type(OstProto::Gmp::GroupRecord::RecordType(
grpRec["groupRecordType"].toInt()));
// NOTE: rec->group_address => subclass responsibility
rec->set_is_override_source_count(
grpRec["overrideGroupRecordSourceCount"].toBool());
rec->set_source_count(grpRec["groupRecordSourceCount"].toUInt());
// NOTE: rec->sources => subclass responsibility
rec->set_is_override_aux_data_length(
grpRec["overrideAuxDataLength"].toBool());
rec->set_aux_data_length(grpRec["auxDataLength"].toUInt());
QByteArray ba = grpRec["auxData"].toByteArray();
// pad to word boundary
if (ba.size() % 4)
ba.append(QByteArray(4 - (ba.size() % 4), char(0)));
rec->set_aux_data(std::string(ba.constData(), ba.size()));
}
break;
}
// Meta Fields
case kIsOverrideChecksum:
{
bool ovr = value.toBool();
data.set_is_override_checksum(ovr);
isOk = true;
break;
}
case kGroupMode:
{
uint mode = value.toUInt(&isOk);
if (isOk && data.GroupMode_IsValid(mode))
data.set_group_mode((OstProto::Gmp::GroupMode)mode);
break;
}
case kGroupCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_group_count(count);
break;
}
case kGroupPrefix:
{
uint prefix = value.toUInt(&isOk);
if (isOk)
data.set_group_prefix(prefix);
break;
}
case kIsOverrideSourceCount:
{
bool ovr = value.toBool();
data.set_is_override_source_count(ovr);
isOk = true;
break;
}
case kIsOverrideGroupRecordCount:
{
bool ovr = value.toBool();
data.set_is_override_group_record_count(ovr);
isOk = true;
break;
}
default:
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
index);
break;
}
_exit:
return isOk;
}
void insertArgument(QDomDocument& doc, QDomElement& where, const QVariant& what)
{
switch(what.type())
{
case QMetaType::Bool:
insertValue(doc, where, "boolean", what.toBool() ? "1" : "0");
break;
case QMetaType::Int:
case QMetaType::UInt:
// case QMetaType::Long:
// case QMetaType::Short:
// case QMetaType::ULong:
// case QMetaType::UShort:
insertValue(doc, where, "i4", what.toString());
break;
case QMetaType::ULongLong:
case QMetaType::LongLong:
insertValue(doc, where, "ex:i8", what.toString());
break;
// case QMetaType::Float:
case QMetaType::Double:
insertValue(doc, where, "double", what.toString());
break;
case QMetaType::QString:
insertValue(doc, where, "string", what.toString());
break;
case QMetaType::QByteArray:
insertValue(doc, where, "base64", what.toByteArray().toBase64());
break;
case QMetaType::QDateTime:
insertValue(doc, where, "dateTime.iso8601", what.toDateTime().toString(Qt::ISODate));
break;
case QMetaType::QVariantList:
{
QDomElement array, data, value;
value = doc.createElement("value");
array = doc.createElement("array");
data = doc.createElement("data");
QList<QVariant> list = what.toList();
foreach(QVariant v, list)
insertArgument(doc, data, v);
array.appendChild(data);
value.appendChild(array);
where.appendChild(value);
}
break;
case QMetaType::QStringList:
{
QDomElement array, data, value;
value = doc.createElement("value");
array = doc.createElement("array");
data = doc.createElement("data");
QStringList list = what.toStringList();
foreach(QString v, list)
insertArgument(doc, data, v);
array.appendChild(data);
value.appendChild(array);
where.appendChild(value);
}
break;
case QMetaType::QVariantMap:
{
QDomElement _struct, value;
_struct = doc.createElement("struct");
value = doc.createElement("value");
QMap<QString, QVariant> map = what.toMap();
for(QMap<QString, QVariant>::iterator it = map.begin(); it != map.end(); it++)
{
QDomElement member = doc.createElement("member");
QDomElement name = doc.createElement("name");
QDomText ntext = doc.createTextNode(it.key());
name.appendChild(ntext);
member.appendChild(name);
insertArgument(doc, member, it.value());
_struct.appendChild(member);
}
value.appendChild(_struct);
where.appendChild(value);
}
break;
default:
qDebug() << "XmlRpc::insertArgument(): Unsupported QVariant type:" << what.type();
}
}
void RenderWindow::sEdit()
{
if(_table->currentSelection() == -1)
return;
bool do_update = false;
int r = _table->currentRow();
Q3CheckTableItem * ctItem = (Q3CheckTableItem*)_table->item(r, 0);
if(ctItem == 0)
return;
bool active = ctItem->isChecked();
QString name = _table->text(r, 1);
QVariant var = _params[name];
BoolEdit * be = 0;
IntEdit * ie = 0;
DoubleEdit * de = 0;
StringEdit * se = 0;
ListEdit * le = 0;
switch(var.type()) {
case QVariant::Bool:
be = new BoolEdit(this);
be->_name->setText(name);
be->_active->setChecked(active);
be->setValue(var.toBool());
if(be->exec() == QDialog::Accepted) {
var = QVariant(be->value(), 0);
active = be->_active->isChecked();
do_update = TRUE;
}
delete be;
be = 0;
break;
case QVariant::Int:
ie = new IntEdit(this);
ie->_name->setText(name);
ie->_active->setChecked(active);
ie->_value->setText(QString::number(var.toInt()));
if(ie->exec() == QDialog::Accepted) {
var = QVariant(ie->_value->text().toInt());
active = ie->_active->isChecked();
do_update = TRUE;
}
delete ie;
ie = 0;
break;
case QVariant::Double:
de = new DoubleEdit(this);
de->_name->setText(name);
de->_active->setChecked(active);
de->_value->setText(QString::number(var.toDouble()));
if(de->exec() == QDialog::Accepted) {
var = QVariant(de->_value->text().toDouble());
active = de->_active->isChecked();
do_update = TRUE;
}
delete de;
de = 0;
break;
case QVariant::String:
se = new StringEdit(this);
se->_name->setText(name);
se->_active->setChecked(active);
se->_value->setText(var.toString());
if(se->exec() == QDialog::Accepted) {
var = QVariant(se->_value->text());
active = se->_active->isChecked();
do_update = TRUE;
}
delete se;
se = 0;
break;
case QVariant::List:
le = new ListEdit(this);
le->_name->setText(name);
le->_active->setChecked(active);
le->setList(var.toList());
if(le->exec() == QDialog::Accepted) {
var = QVariant(le->list());
active = le->_active->isChecked();
do_update = TRUE;
}
delete le;
le = 0;
break;
default:
QMessageBox::warning(this, tr("Warning"), QString(tr("I do not know how to edit QVariant type %1.")).arg(var.typeName()));
};
if(do_update) {
_params[name] = var;
ctItem->setChecked(active);
_table->setText(r, 1, name);
_table->setText(r, 2, var.typeName());
_table->setText(r, 3, var.toString());
}
}
void toXmlRpcValue( const int spaces, const QVariant &child, QByteArray &b )
{
#ifdef DEBUG_XMLRPC
qDebug() << "toXmlRpcValue()";
#endif
switch ( child.type() )
{
case QVariant::LongLong:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><longlong>" + QString::number( child.toLongLong()) + "</longlong></value>" );
break;
case QVariant::ULongLong:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><ulonglong>" + QString::number( child.toULongLong()) + "</ulonglong></value>" );
break;
case QVariant::Int:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><int>" + QString::number( child.toInt()) + "</int></value>" );
break;
case QVariant::Bool:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( QString( "<value><boolean>") + (child.toBool() ? "1" : "0") + "</boolean></value>" );
break;
case QVariant::String:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><string>" + child.toString() + "</string></value>" );
break;
case QVariant::Double:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><double>" + QString::number( child.toDouble()) + "</double></value>" );
break;
case QVariant::Time:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><time.iso8601>" + child.toTime().toString( "HH:mm:ss") +
"</time.iso8601></value>" );
break;
case QVariant::Date:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><date.iso8601>" + child.toDate().toString( "yyyyMMdd") +
"</date.iso8601></value>" );
break;
case QVariant::DateTime:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><dateTime.iso8601>" + child.toDateTime().toString( "yyyyMMddTHH:mm:ss") +
"</dateTime.iso8601></value>" );
break;
case QVariant::ByteArray:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><base64>" + child.toByteArray().toBase64() + "</base64></value>" );
break;
case QVariant::List:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><array><data>" );
toXmlRpcArray( spaces + 2, child.toList(), b );
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "</data></array></value>" );
break;
case QVariant::Map:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><struct>" );
toXmlRpcStruct( spaces + 2, child.toMap(), b );
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "</struct></value>" );
break;
case QVariant::Invalid:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append("<value><invalid/></value>");
break;
default:
qCritical() << "toXmlRpcValue(): unknown return xmlrpc type" << child.typeName() << endl << child;
qFatal( "programming error" );
}
}
void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value)
{
if (writeHandle() == 0) {
setStatus(QSettings::AccessError);
return;
}
QString rKey = escapedKey(uKey);
HKEY handle = createOrOpenKey(writeHandle(), registryPermissions, keyPath(rKey));
if (handle == 0) {
setStatus(QSettings::AccessError);
return;
}
DWORD type;
QByteArray regValueBuff;
// Determine the type
switch (value.type()) {
case QVariant::List:
case QVariant::StringList: {
// If none of the elements contains '\0', we can use REG_MULTI_SZ, the
// native registry string list type. Otherwise we use REG_BINARY.
type = REG_MULTI_SZ;
QStringList l = variantListToStringList(value.toList());
QStringList::const_iterator it = l.constBegin();
for (; it != l.constEnd(); ++it) {
if ((*it).length() == 0 || stringContainsNullChar(*it)) {
type = REG_BINARY;
break;
}
}
if (type == REG_BINARY) {
QString s = variantToString(value);
regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2);
} else {
QStringList::const_iterator it = l.constBegin();
for (; it != l.constEnd(); ++it) {
const QString &s = *it;
regValueBuff += QByteArray((const char*)s.utf16(), (s.length() + 1) * 2);
}
regValueBuff.append((char)0);
regValueBuff.append((char)0);
}
break;
}
case QVariant::Int:
case QVariant::UInt: {
type = REG_DWORD;
qint32 i = value.toInt();
regValueBuff = QByteArray((const char*)&i, sizeof(qint32));
break;
}
case QVariant::LongLong:
case QVariant::ULongLong: {
type = REG_QWORD;
qint64 i = value.toLongLong();
regValueBuff = QByteArray((const char*)&i, sizeof(qint64));
break;
}
case QVariant::ByteArray:
// fallthrough intended
default: {
// If the string does not contain '\0', we can use REG_SZ, the native registry
// string type. Otherwise we use REG_BINARY.
QString s = variantToString(value);
type = stringContainsNullChar(s) ? REG_BINARY : REG_SZ;
if (type == REG_BINARY) {
regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2);
} else {
regValueBuff = QByteArray((const char*)s.utf16(), (s.length() + 1) * 2);
}
break;
}
}
// set the value
LONG res = RegSetValueEx(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()), 0, type,
reinterpret_cast<const unsigned char*>(regValueBuff.constData()),
regValueBuff.size());
if (res == ERROR_SUCCESS) {
deleteWriteHandleOnExit = false;
} else {
qWarning("QSettings: failed to set subkey \"%s\": %s",
rKey.toLatin1().data(), errorCodeToString(res).toLatin1().data());
setStatus(QSettings::AccessError);
}
RegCloseKey(handle);
}
void XmlPListSerializer::RenderValue(const QString &sName,
const QVariant &vValue,
bool needKey)
{
if ( vValue.canConvert<QObject*>())
{
const QObject *pObject = vValue.value<QObject*>();
SerializePListObjectProperties(sName, pObject, needKey);
return;
}
switch(vValue.type())
{
case QVariant::List:
{
RenderList(sName, vValue.toList());
break;
}
case QVariant::StringList:
{
RenderStringList(sName, vValue.toStringList());
break;
}
case QVariant::Map:
{
RenderMap(sName, vValue.toMap());
break;
}
case QVariant::DateTime:
{
if (vValue.toDateTime().isValid())
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("date", vValue.toDateTime()
.toUTC().toString("yyyy-MM-ddThh:mm:ssZ"));
}
break;
}
case QVariant::ByteArray:
{
if (!vValue.toByteArray().isNull())
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("data",
vValue.toByteArray().toBase64().data());
}
break;
}
case QVariant::Bool:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeEmptyElement(vValue.toBool() ?
"true" : "false");
break;
}
case QVariant::UInt:
case QVariant::ULongLong:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("integer",
QString::number(vValue.toULongLong()));
break;
}
case QVariant::Int:
case QVariant::LongLong:
case QVariant::Double:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("real",
QString("%1").arg(vValue.toDouble(), 0, 'f', 6));
break;
}
// anything else will be unrecognised, so wrap in a string
case QVariant::String:
default:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("string", vValue.toString());
break;
}
}
}
void comment::set(const ParameterList &pParams)
{
QVariant param;
bool valid;
param = pParams.value("comment_id", &valid);
if (valid)
{
_cmnttype->setType(XComboBox::AllCommentTypes);
_commentid = param.toInt();
populate();
}
param = pParams.value("commentIDList", &valid);
if (valid)
{
_commentIDList = param.toList();
_commentLocation = _commentIDList.indexOf(_commentid);
if((_commentLocation-1) >= 0)
_prev->setEnabled(true);
else
_prev->setEnabled(false);
if((_commentLocation+1) < _commentIDList.size())
_next->setEnabled(true);
else
_next->setEnabled(false);
}
param = pParams.value("mode", &valid);
if (valid)
{
if (param.toString() == "new")
{
_mode = cNew;
_cmnttype->setFocus();
_next->setVisible(false);
_prev->setVisible(false);
}
else if (param.toString() == "edit")
{
_mode = cEdit;
_next->setVisible(false);
_prev->setVisible(false);
_cmnttype->setEnabled(false);
}
else if (param.toString() == "view")
{
_mode = cView;
_next->setVisible(true);
_prev->setVisible(true);
_cmnttype->setEnabled(false);
_comment->setReadOnly(true);
_save->hide();
_close->setText(tr("&Close"));
_close->setShortcut(QKeySequence::Close);
_more->hide();
_close->setFocus();
}
}
param = pParams.value("sourceType", &valid);
if (valid)
{
_sourcetype = param.toString();
if(!(_mode == cEdit || _mode == cView))
{
// CommentMap *map = Comments::commentMap().value(_sourcetype);
// _cmnttype->setType(map ? (XComboBox::XComboBoxTypes)map->doctypeId : XComboBox::AllCommentTypes);
if (_sourcetype == "ADDR")
_cmnttype->setType(XComboBox::AddressCommentTypes);
else if (_sourcetype == "BBH")
_cmnttype->setType(XComboBox::BBOMHeadCommentTypes);
else if (_sourcetype == "BBI")
_cmnttype->setType(XComboBox::BBOMItemCommentTypes);
else if (_sourcetype == "BMH")
_cmnttype->setType(XComboBox::BOMHeadCommentTypes);
else if (_sourcetype == "BMI")
_cmnttype->setType(XComboBox::BOMItemCommentTypes);
else if (_sourcetype == "BOH")
_cmnttype->setType(XComboBox::BOOHeadCommentTypes);
else if (_sourcetype == "BOI")
_cmnttype->setType(XComboBox::BOOItemCommentTypes);
else if (_sourcetype == "CRMA")
_cmnttype->setType(XComboBox::CRMAccountCommentTypes);
else if (_sourcetype == "T")
_cmnttype->setType(XComboBox::ContactCommentTypes);
else if (_sourcetype == "C")
_cmnttype->setType(XComboBox::CustomerCommentTypes);
else if (_sourcetype == "EMP")
_cmnttype->setType(XComboBox::EmployeeCommentTypes);
else if (_sourcetype == "INCDT")
_cmnttype->setType(XComboBox::IncidentCommentTypes);
else if (_sourcetype == "I")
_cmnttype->setType(XComboBox::ItemCommentTypes);
else if (_sourcetype == "IS")
_cmnttype->setType(XComboBox::ItemSiteCommentTypes);
else if (_sourcetype == "IR")
_cmnttype->setType(XComboBox::ItemSourceCommentTypes);
else if (_sourcetype == "L")
_cmnttype->setType(XComboBox::LocationCommentTypes);
else if (_sourcetype == "LS")
_cmnttype->setType(XComboBox::LotSerialCommentTypes);
else if (_sourcetype == "OPP")
_cmnttype->setType(XComboBox::OpportunityCommentTypes);
else if (_sourcetype == "J")
_cmnttype->setType(XComboBox::ProjectCommentTypes);
else if (_sourcetype == "P")
_cmnttype->setType(XComboBox::PurchaseOrderCommentTypes);
else if (_sourcetype == "PI")
_cmnttype->setType(XComboBox::PurchaseOrderItemCommentTypes);
else if (_sourcetype == "RA")
_cmnttype->setType(XComboBox::ReturnAuthCommentTypes);
else if (_sourcetype == "RI")
_cmnttype->setType(XComboBox::ReturnAuthItemCommentTypes);
else if (_sourcetype == "Q")
_cmnttype->setType(XComboBox::QuoteCommentTypes);
else if (_sourcetype == "QI")
_cmnttype->setType(XComboBox::QuoteItemCommentTypes);
else if (_sourcetype == "S")
_cmnttype->setType(XComboBox::SalesOrderCommentTypes);
else if (_sourcetype == "SI")
_cmnttype->setType(XComboBox::SalesOrderItemCommentTypes);
else if (_sourcetype == "TA")
_cmnttype->setType(XComboBox::TaskCommentTypes);
else if (_sourcetype == "TIME")
_cmnttype->setType(XComboBox::TimeAttendanceCommentTypes);
else if (_sourcetype == "TD")
_cmnttype->setType(XComboBox::TodoItemCommentTypes);
else if (_sourcetype == "TO")
_cmnttype->setType(XComboBox::TransferOrderCommentTypes);
else if (_sourcetype == "TI")
_cmnttype->setType(XComboBox::TransferOrderItemCommentTypes);
else if (_sourcetype == "V")
_cmnttype->setType(XComboBox::VendorCommentTypes);
else if (_sourcetype == "WH")
_cmnttype->setType(XComboBox::WarehouseCommentTypes);
else if (_sourcetype == "W")
_cmnttype->setType(XComboBox::WorkOrderCommentTypes);
else
_cmnttype->setType(XComboBox::AllCommentTypes);
}
}
param = pParams.value("source_id", &valid);
if (valid)
{
_targetId = param.toInt();
}
_comments->setType(_sourcetype);
_comments->setId(_targetId);
}
void ChangeProperties::updateProperties()
{
bool hasControl = activex && !activex->isNull();
tabWidget->setEnabled(hasControl);
listProperties->clear();
listEditRequests->clear();
if (hasControl) {
const QMetaObject *mo = activex->metaObject();
const int numprops = mo->propertyCount();
for (int i = mo->propertyOffset(); i < numprops; ++i) {
const QMetaProperty property = mo->property(i);
QTreeWidgetItem *item = new QTreeWidgetItem(listProperties);
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);
item->setTextColor(2, Qt::gray);
}
QVariant var = activex->property(property.name());
switch (var.type()) {
case QVariant::Color:
{
QColor col = qvariant_cast<QColor>(var);
item->setText(2, col.name());
}
break;
case QVariant::Font:
{
QFont fnt = qvariant_cast<QFont>(var);
item->setText(2, fnt.toString());
}
break;
case QVariant::Bool:
{
item->setText(2, var.toBool() ? QLatin1String("true") : QLatin1String("false"));
}
break;
case QVariant::Pixmap:
{
QPixmap pm = qvariant_cast<QPixmap>(var);
item->setIcon(2, pm);
}
break;
case QVariant::List:
{
QList<QVariant> varList = var.toList();
QStringList strList;
for (int i = 0; i < varList.count(); ++i) {
QVariant var = varList.at(i);
strList << var.toString();
}
item->setText(2, strList.join(QLatin1String(", ")));
}
break;
case QVariant::Int:
if (property.isEnumType()) {
const QMetaEnum enumerator = mo->enumerator(mo->indexOfEnumerator(property.typeName()));
item->setText(2, QString::fromLatin1(enumerator.valueToKey(var.toInt())));
break;
}
//FALLTHROUGH
default:
item->setText(2, var.toString());
break;
}
bool requesting = false;
#if 0
{
void *argv[] = { &requesting };
activex->qt_metacall(QMetaObject::Call(0x10000000) /*RequestingEdit*/, i, argv);
}
#endif
if (requesting) {
QTreeWidgetItem *check = new QTreeWidgetItem(listEditRequests);
check->setText(0, QString::fromLatin1(property.name()));
check->setCheckState(0, activex->propertyWritable(property.name()) ? Qt::Checked : Qt::Unchecked);
}
}
listProperties->setCurrentItem(listProperties->topLevelItem(0));
} else {
editValue->clear();
}
}
void AddFixture::fillTree(const QString& selectManufacturer,
const QString& selectModel)
{
QTreeWidgetItem* parent = NULL;
QTreeWidgetItem* child;
QString manuf;
QString model;
QList<QVariant> expanded;
QSettings settings;
QVariant var = settings.value(SETTINGS_EXPANDED);
if (var.isValid() == true)
{
expanded = var.toList();
}
/* Clear the tree of any previous data */
m_tree->clear();
QString filter = m_searchEdit->text().toLower();
/* Add all known fixture definitions to the tree */
QStringListIterator it(m_doc->fixtureDefCache()->manufacturers());
while (it.hasNext() == true)
{
bool manufAdded = false;
manuf = it.next();
if (manuf == KXMLFixtureGeneric)
continue;
QStringListIterator modit(m_doc->fixtureDefCache()->models(manuf));
while (modit.hasNext() == true)
{
model = modit.next();
if (filter.isEmpty() == false &&
manuf.toLower().contains(filter) == false &&
model.toLower().contains(filter) == false)
continue;
if (manufAdded == false)
{
parent = new QTreeWidgetItem(m_tree);
parent->setText(KColumnName, manuf);
manufAdded = true;
}
child = new QTreeWidgetItem(parent);
child->setText(KColumnName, model);
if (manuf == selectManufacturer &&
model == selectModel)
{
parent->setExpanded(true);
m_tree->setCurrentItem(child);
}
else if(expanded.indexOf(manuf) != -1)
{
parent->setExpanded(true);
}
m_fxiCount++;
}
}
/* Sort the tree A-Z BEFORE appending a generic entries */
m_tree->sortItems(0, Qt::AscendingOrder);
/* Create a parent for the generic devices */
parent = new QTreeWidgetItem(m_tree);
parent->setText(KColumnName, KXMLFixtureGeneric);
QStringListIterator modit(m_doc->fixtureDefCache()->models(KXMLFixtureGeneric));
while (modit.hasNext() == true)
{
model = modit.next();
child = new QTreeWidgetItem(parent);
child->setText(KColumnName, model);
if (selectManufacturer == KXMLFixtureGeneric &&
model == selectModel)
{
parent->setExpanded(true);
m_tree->setCurrentItem(child);
}
else if(expanded.indexOf(manuf) != -1)
{
parent->setExpanded(true);
}
m_fxiCount++;
}
/* Create a child for generic dimmer device */
child = new QTreeWidgetItem(parent);
child->setText(KColumnName, KXMLFixtureGeneric);
parent->sortChildren(0, Qt::AscendingOrder);
/* Select generic dimmer by default */
if (selectManufacturer == KXMLFixtureGeneric &&
selectModel == KXMLFixtureGeneric)
{
parent->setExpanded(true);
m_tree->setCurrentItem(child);
}
}
