void evaluation() { QFETCH( QString, string ); QFETCH( bool, evalError ); QFETCH( QVariant, result ); QgsExpression exp( string ); QCOMPARE( exp.hasParserError(), false ); if ( exp.hasParserError() ) qDebug() << exp.parserErrorString(); QVariant res = exp.evaluate(); if ( exp.hasEvalError() ) qDebug() << exp.evalErrorString(); if ( res.type() != result.type() ) { qDebug() << "got " << res.typeName() << " instead of " << result.typeName(); } //qDebug() << res.type() << " " << result.type(); //qDebug() << "type " << res.typeName(); QCOMPARE( exp.hasEvalError(), evalError ); QCOMPARE( res.type(), result.type() ); switch ( res.type() ) { case QVariant::Invalid: break; // nothing more to check case QVariant::Int: QCOMPARE( res.toInt(), result.toInt() ); break; case QVariant::Double: QCOMPARE( res.toDouble(), result.toDouble() ); break; case QVariant::String: QCOMPARE( res.toString(), result.toString() ); break; case QVariant::Date: QCOMPARE( res.toDate(), result.toDate() ); break; case QVariant::DateTime: QCOMPARE( res.toDateTime(), result.toDateTime() ); break; case QVariant::Time: QCOMPARE( res.toTime(), result.toTime() ); break; case QVariant::UserType: { if ( res.userType() == qMetaTypeId<QgsExpression::Interval>() ) { QgsExpression::Interval inter = res.value<QgsExpression::Interval>(); QgsExpression::Interval gotinter = result.value<QgsExpression::Interval>(); QCOMPARE( inter.seconds(), gotinter.seconds() ); } else { QFAIL( "unexpected user type" ); } break; } default: Q_ASSERT( false ); // should never happen } }
void ParameterEdit::editItem() { if(_table->currentSelection() != -1) { 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 GroupDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { QRect r = option.rect; QFont font = painter->font(); QPen pen = painter->pen(); if (!index.parent().isValid()) { painter->setBrush(Qt::red); font.setPixelSize(14); font.setUnderline(false); painter->setFont(font); pen.setColor(grayFont); //painter->setBackground(Qt::gray); painter->fillRect(option.rect, grayBackground); if (index.column()==0) { //if (option.state & QStyle::State_Editing) QPixmap icon = tree->isExpanded(index) ? QPixmap(":/Images/Visitors/icon_minus.png") : QPixmap(":/Images/Visitors/icon_plus.png"); painter->drawPixmap(r.x() + 8, r.y() + 6, 16, 16, icon); } painter->setPen(pen); painter->setFont(font); painter->drawText(QPoint(r.x() + 32, r.y() + 18), index.data().toString()); } else { if (option.state & QStyle::State_MouseOver) { painter->fillRect(option.rect, grayBackground); } QVariant value = index.data(Qt::DecorationRole); int adjust = index.column()==0 ? 24 : 0; if (value.isValid() && value.type() == QVariant::Icon) { QIcon icon = value.value<QIcon>(); if (icon.availableSizes().count()>0) { int width = icon.availableSizes().at(0).width(); icon.paint(painter, r.x()+8 + adjust, r.y(), width, 28); adjust += width + 8; } } font.setPixelSize(12); if (index.column() == 0 || index.column() == 10) { font.setUnderline(true); pen.setColor(hyperlink); } else { font.setUnderline(false); pen.setColor(grayFont); } painter->setPen(pen); painter->setFont(font); QTextOption textOptions(Qt::AlignLeft); textOptions.setWrapMode(QTextOption::NoWrap); painter->drawText(r.adjusted(8 + adjust,6,0,0), index.data().toString(), textOptions); //painter->drawText(QPoint(r.x() + 32, r.y() + r.height()/2 + font.pixelSize()/2 - 1), index.data().toString(), o); } }
void SettingsDialog::outputSettings() { QSettings settings; QListIterator<QString> itr(settings.allKeys()); QString output; output += "QOwnNotes Debug Information\n"; output += "===========================\n"; QDateTime dateTime = QDateTime::currentDateTime(); // add information about QOwnNotes output += "\n## General Info\n\n"; output += prepareDebugInformationLine("Current Date", dateTime.toString()); output += prepareDebugInformationLine("Version", QString(VERSION)); output += prepareDebugInformationLine("Build date", QString(__DATE__)); output += prepareDebugInformationLine("Build number", QString::number(BUILD)); output += prepareDebugInformationLine("Platform", QString(PLATFORM)); #if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)) output += prepareDebugInformationLine("Operating System", QSysInfo::prettyProductName()); output += prepareDebugInformationLine("Build architecture", QSysInfo::buildCpuArchitecture()); output += prepareDebugInformationLine("Current architecture", QSysInfo::currentCpuArchitecture()); #endif output += prepareDebugInformationLine("Release", QString(RELEASE)); output += prepareDebugInformationLine("Qt Version", QT_VERSION_STR); // add information about the server output += "\n## Server Info\n\n"; output += prepareDebugInformationLine("serverUrl", ui->serverUrlEdit->text()); output += prepareDebugInformationLine("appIsValid", QString(appIsValid ? "yes" : "no")); if (appIsValid) { output += prepareDebugInformationLine("serverVersion", serverVersion); output += prepareDebugInformationLine("appVersion", appVersion); } else { output += prepareDebugInformationLine("connectionErrorMessage", connectionErrorMessage); } // add information about the settings output += "\n## Settings\n\n"; // hide values of these keys QStringList keyHiddenList = (QStringList() << "cryptoKey" << "ownCloud/password"); while (itr.hasNext()) { QString key = itr.next(); QVariant value = settings.value(key); // hide values of certain keys if (keyHiddenList.contains(key)) { output += prepareDebugInformationLine(key, "<hidden>"); } else { switch (value.type()) { case QVariant::StringList: output += prepareDebugInformationLine( key, value.toStringList().join(", ")); break; case QVariant::ByteArray: output += prepareDebugInformationLine(key, "<binary data>"); break; default: output += prepareDebugInformationLine(key, value.toString()); } } } ui->debugInfoTextEdit->setPlainText(output); }
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 ExpandingWidgetModel::rowSelected(const QModelIndex& idx_) { QModelIndex idx( firstColumn(idx_) ); if( !m_partiallyExpanded.contains( idx ) ) { QModelIndex oldIndex = partiallyExpandedRow(); //Unexpand the previous partially expanded row if( !m_partiallyExpanded.isEmpty() ) { ///@todo allow multiple partially expanded rows while( !m_partiallyExpanded.isEmpty() ) m_partiallyExpanded.erase(m_partiallyExpanded.begin()); //partiallyUnExpand( m_partiallyExpanded.begin().key() ); } //Notify the underlying models that the item was selected, and eventually get back the text for the expanding widget. if( !idx.isValid() ) { //All items have been unselected if( oldIndex.isValid() ) emit dataChanged(oldIndex, oldIndex); } else { QVariant variant = data(idx, CodeCompletionModel::ItemSelected); if( !isExpanded(idx) && variant.type() == QVariant::String) { //Either expand upwards or downwards, choose in a way that //the visible fields of the new selected entry are not moved. if( oldIndex.isValid() && (oldIndex < idx || (!(oldIndex < idx) && oldIndex.parent() < idx.parent()) ) ) m_partiallyExpanded.insert(idx, ExpandUpwards); else m_partiallyExpanded.insert(idx, ExpandDownwards); //Say that one row above until one row below has changed, so no items will need to be moved(the space that is taken from one item is given to the other) if( oldIndex.isValid() && oldIndex < idx ) { emit dataChanged(oldIndex, idx); if( treeView()->verticalScrollMode() == QAbstractItemView::ScrollPerItem ) { //Qt fails to correctly scroll in ScrollPerItem mode, so the selected index is completely visible, //so we do the scrolling by hand. QRect selectedRect = treeView()->visualRect(idx); QRect frameRect = treeView()->frameRect(); if( selectedRect.bottom() > frameRect.bottom() ) { int diff = selectedRect.bottom() - frameRect.bottom(); //We need to scroll down QModelIndex newTopIndex = idx; QModelIndex nextTopIndex = idx; QRect nextRect = treeView()->visualRect(nextTopIndex); while( nextTopIndex.isValid() && nextRect.isValid() && nextRect.top() >= diff ) { newTopIndex = nextTopIndex; nextTopIndex = treeView()->indexAbove(nextTopIndex); if( nextTopIndex.isValid() ) nextRect = treeView()->visualRect(nextTopIndex); } treeView()->scrollTo( newTopIndex, QAbstractItemView::PositionAtTop ); } } //This is needed to keep the item we are expanding completely visible. Qt does not scroll the view to keep the item visible. //But we must make sure that it isn't too expensive. //We need to make sure that scrolling is efficient, and the whole content is not repainted. //Since we are scrolling anyway, we can keep the next line visible, which might be a cool feature. //Since this also doesn't work smoothly, leave it for now //treeView()->scrollTo( nextLine, QAbstractItemView::EnsureVisible ); } else if( oldIndex.isValid() && idx < oldIndex ) { emit dataChanged(idx, oldIndex); //For consistency with the down-scrolling, we keep one additional line visible above the current visible. //Since this also doesn't work smoothly, leave it for now /* QModelIndex prevLine = idx.sibling(idx.row()-1, idx.column()); if( prevLine.isValid() ) treeView()->scrollTo( prevLine );*/ } else emit dataChanged(idx, idx); } else if( oldIndex.isValid() ) { //We are not partially expanding a new row, but we previously had a partially expanded row. So signalize that it has been unexpanded. emit dataChanged(oldIndex, oldIndex); } } }else{ qCDebug( PLUGIN_QUICKOPEN ) << "ExpandingWidgetModel::rowSelected: Row is already partially expanded"; } }
void ChangeProperties::on_buttonSet_clicked() { QTreeWidgetItem *item = listProperties->currentItem(); if (!item) return; QString prop = item->text(0); QVariant value = activex->property(prop.toLatin1()); QVariant::Type type = value.type(); if (!value.isValid()) { const QMetaObject *mo = activex->metaObject(); const QMetaProperty property = mo->property(mo->indexOfProperty(prop.toLatin1())); type = QVariant::nameToType(property.typeName()); } switch (type) { case QVariant::Color: { QColor col; col.setNamedColor(editValue->text()); if (col.isValid()) { value = qVariantFromValue(col); } else { QMessageBox::warning(this, tr("Can't parse input"), tr("Failed to create a color from %1\n" "The string has to be a valid color name (e.g. 'red')\n" "or a RGB triple of format '#rrggbb'." ).arg(editValue->text())); } } break; case QVariant::Font: { QFont fnt; if (fnt.fromString(editValue->text())) { value = qVariantFromValue(fnt); } else { QMessageBox::warning(this, tr("Can't parse input"), tr("Failed to create a font from %1\n" "The string has to have a format family,<point size> or\n" "family,pointsize,stylehint,weight,italic,underline,strikeout,fixedpitch,rawmode." ).arg(editValue->text())); } } break; case QVariant::Pixmap: { QString fileName = editValue->text(); if (fileName.isEmpty()) fileName = QFileDialog::getOpenFileName(this); QPixmap pm(fileName); if (pm.isNull()) return; value = qVariantFromValue(pm); } break; case QVariant::Bool: { QString txt = editValue->text().toLower(); value = QVariant(txt != QLatin1String("0") && txt != QLatin1String("false")); } break; case QVariant::List: { QStringList txtList = editValue->text().split(QRegExp(QLatin1String("[,;]"))); QList<QVariant> varList; for (int i = 0; i < txtList.count(); ++i) { QVariant svar(txtList.at(i)); QString str = svar.toString(); str = str.trimmed(); bool ok; int n = str.toInt(&ok); if (ok) { varList << n; continue; } double d = str.toDouble(&ok); if (ok) { varList << d; continue; } varList << str; } value = varList; } break; default: value = editValue->text(); break; } Q_ASSERT(activex->setProperty(prop.toLatin1(), value)); updateProperties(); listProperties->setCurrentItem(listProperties->findItems(prop, Qt::MatchExactly).at(0)); }
QWidget* MultiDelegate::createEditor( QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const { const QAbstractItemModel* model = index.model(); QVariant value = model->data( index, Qt::EditRole); switch (value.type()) { case QMetaType::QTime: { QTimeEdit* editor = new QTimeEdit( parent); editor->setMaximumWidth( editor->sizeHint().width()); //// Get value snapshot into editor editor->setTime( value.toTime()); return editor; } case QMetaType::QDate: { QDateEdit* editor = new QDateEdit( parent); setupCalenderWidget( editor); editor->setMaximumWidth( editor->sizeHint().width()); //// Get value snapshot into editor editor->setDate( value.toDate()); return editor; } case QMetaType::QDateTime: { QDateTimeEdit* editor = new QDateTimeEdit( parent); setupCalenderWidget( editor); editor->setMaximumWidth( editor->sizeHint().width()); editor->setDateTime( value.toDateTime()); return editor; } case QMetaType::QImage: // Fall throu case QMetaType::QPixmap: // Fall throu case QMetaType::QIcon: { PixmapViewer* editor = new PixmapViewer( parent); connect( editor, SIGNAL(finished(int)), this, SLOT(closeEmittingEditor())); return editor; } case QMetaType::QStringList: { QVariant varList = index.model()->data( index, ItemDataRole::EnumList); if (varList.isNull()) break; // Not a enum-list, fall to std QListWidget* editor = new QListWidget( parent); foreach (const QString& bitItemText, varList.toStringList()) { QListWidgetItem* bitItem = new QListWidgetItem( bitItemText, editor); bitItem->setFlags(bitItem->flags() | Qt::ItemIsUserCheckable); bitItem->setCheckState(Qt::Unchecked); } int width = editor->sizeHintForColumn(0) + 25; int height = editor->sizeHintForRow(0) * editor->count() + 10; editor->setMinimumWidth( width); editor->setMaximumWidth( width); editor->setMinimumHeight( height); editor->setMaximumHeight( height); //// Get value snapshot into editor QStringList valList = value.toStringList(); int itemCount = editor->count(); for (int i = 0; i < itemCount; ++i) { QListWidgetItem* bitItem = editor->item(i); bool isActive = valList.contains( bitItem->text()); bitItem->setCheckState( isActive ? Qt::Checked : Qt::Unchecked); } return editor; } case QMetaType::QString: { QVariant varList = index.model()->data( index, ItemDataRole::EnumList); if (varList.isNull()) break; // Not a enum-list, fall to std QComboBox* editor = new QComboBox( parent); editor->setSizeAdjustPolicy(QComboBox::AdjustToContents); editor->addItems( varList.toStringList()); editor->setMaximumWidth( editor->minimumSizeHint().width()); //// Get value snapshot into editor editor->setCurrentIndex( editor->findText( value.toString())); return editor; } default:; } if (index.column() == 0) { emit itemEditTrigged( index); return 0; // No inline editor } QWidget* editor = QItemDelegate::createEditor( parent, option, index); //// Get value snapshot into editor QItemDelegate::setEditorData( editor, index); return editor; }
/* Converts \a var to \a arg, and tries to coerce \a arg to \a type. Used by QAxServerBase: - QAxServerBase::qt_metacall - IDispatch::Invoke(PROPERTYGET, METHOD) - IPersistPropertyBag::Save QAxBase: - IDispatch::Invoke (QAxEventSink) - QAxBase::internalProperty(WriteProperty) - QAxBase::internalInvoke() - QAxBase::dynamicCallHelper() - IPropertyBag::Read (QtPropertyBag) Also called recoursively for lists. */ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName, bool out) { QVariant qvar = var; // "type" is the expected type, so coerce if necessary QVariant::Type proptype = typeName.isEmpty() ? QVariant::Invalid : QVariant::nameToType(typeName); if (proptype == QVariant::UserType && !typeName.isEmpty()) { if (typeName == "short" || typeName == "char") proptype = QVariant::Int; else if (typeName == "float") proptype = QVariant::Double; } if (proptype != QVariant::Invalid && proptype != QVariant::UserType && proptype != qvar.type()) { if (qvar.canConvert(proptype)) qvar.convert(proptype); else qvar = QVariant(proptype); } if (out && arg.vt == (VT_VARIANT|VT_BYREF) && arg.pvarVal) { return QVariantToVARIANT(var, *arg.pvarVal, typeName, false); } if (out && proptype == QVariant::Invalid && typeName == "QVariant") { VARIANT *pVariant = new VARIANT; QVariantToVARIANT(var, *pVariant, QByteArray(), false); arg.vt = VT_VARIANT|VT_BYREF; arg.pvarVal = pVariant; return true; } switch ((int)qvar.type()) { case QVariant::String: if (out && arg.vt == (VT_BSTR|VT_BYREF)) { if (*arg.pbstrVal) SysFreeString(*arg.pbstrVal); *arg.pbstrVal = QStringToBSTR(qvar.toString()); arg.vt = VT_BSTR|VT_BYREF; } else { arg.vt = VT_BSTR; arg.bstrVal = QStringToBSTR(qvar.toString()); if (out) { arg.pbstrVal = new BSTR(arg.bstrVal); arg.vt |= VT_BYREF; } } break; case QVariant::Int: if (out && arg.vt == (VT_I4|VT_BYREF)) { *arg.plVal = qvar.toInt(); } else { arg.vt = VT_I4; arg.lVal = qvar.toInt(); if (out) { if (typeName == "short") { arg.vt = VT_I2; arg.piVal = new short(arg.lVal); } else if (typeName == "char") { arg.vt = VT_I1; arg.pcVal= new char(arg.lVal); } else { arg.plVal = new long(arg.lVal); } arg.vt |= VT_BYREF; } } break; case QVariant::UInt: if (out && (arg.vt == (VT_UINT|VT_BYREF) || arg.vt == (VT_I4|VT_BYREF))) { *arg.puintVal = qvar.toUInt(); } else { arg.vt = VT_UINT; arg.uintVal = qvar.toUInt(); if (out) { arg.puintVal = new uint(arg.uintVal); arg.vt |= VT_BYREF; } } break; case QVariant::LongLong: if (out && arg.vt == (VT_CY|VT_BYREF)) { arg.pcyVal->int64 = qvar.toLongLong(); #if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400 } else if (out && arg.vt == (VT_I8|VT_BYREF)) { *arg.pllVal = qvar.toLongLong(); } else { arg.vt = VT_I8; arg.llVal = qvar.toLongLong(); if (out) { arg.pllVal = new LONGLONG(arg.llVal); arg.vt |= VT_BYREF; } } #else } else {
/*! Renders the delegate using the given \a painter and style \a option for the item specified by \a index. When reimplementing this function in a subclass, you should update the area held by the option's \l{QStyleOption::rect}{rect} variable, using the option's \l{QStyleOption::state}{state} variable to determine the state of the item to be displayed, and adjust the way it is painted accordingly. For example, a selected item may need to be displayed differently to unselected items, as shown in the following code: \snippet itemviews/pixelator/pixeldelegate.cpp 2 \dots After painting, you should ensure that the painter is returned to its the state it was supplied in when this function was called. For example, it may be useful to call QPainter::save() before painting and QPainter::restore() afterwards. \sa QStyle::State */ void QItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const { Q_D(const QItemDelegate); Q_ASSERT(index.isValid()); QStyleOptionViewItem opt = setOptions(index, option); // prepare painter->save(); if (d->clipPainting) painter->setClipRect(opt.rect); // get the data and the rectangles QVariant value; QPixmap pixmap; QRect decorationRect; value = index.data(Qt::DecorationRole); if (value.isValid()) { // ### we need the pixmap to call the virtual function pixmap = decoration(opt, value); if (value.type() == QVariant::Icon) { d->tmp.icon = qvariant_cast<QIcon>(value); d->tmp.mode = d->iconMode(option.state); d->tmp.state = d->iconState(option.state); const QSize size = d->tmp.icon.actualSize(option.decorationSize, d->tmp.mode, d->tmp.state); decorationRect = QRect(QPoint(0, 0), size); } else { d->tmp.icon = QIcon(); decorationRect = QRect(QPoint(0, 0), pixmap.size()); } } else { d->tmp.icon = QIcon(); decorationRect = QRect(); } QString text; QRect displayRect; value = index.data(Qt::DisplayRole); if (value.isValid() && !value.isNull()) { text = QItemDelegatePrivate::valueToText(value, opt); displayRect = textRectangle(painter, d->textLayoutBounds(opt), opt.font, text); } QRect checkRect; Qt::CheckState checkState = Qt::Unchecked; value = index.data(Qt::CheckStateRole); if (value.isValid()) { checkState = static_cast<Qt::CheckState>(value.toInt()); checkRect = doCheck(opt, opt.rect, value); } // do the layout doLayout(opt, &checkRect, &decorationRect, &displayRect, false); // draw the item drawBackground(painter, opt, index); drawCheck(painter, opt, checkRect, checkState); drawDecoration(painter, opt, decorationRect, pixmap); drawDisplay(painter, opt, displayRect, text); drawFocus(painter, opt, displayRect); // done painter->restore(); }
QString QGalleryTrackerStringListColumn::toString(const QVariant &variant) const { return variant.type() == QVariant::StringList ? variant.toStringList().join(m_separatorString) : variant.toString(); }
void TestObject::setVariant(const QVariant &value) { qDebug() << value.type(); }
static void streamDebug(QDebug dbg, const QVariant &v) { switch(v.type()) { case QVariant::Cursor: #ifndef QT_NO_CURSOR // dbg.nospace() << qvariant_cast<QCursor>(v); //FIXME #endif break; case QVariant::Bitmap: // dbg.nospace() << qvariant_cast<QBitmap>(v); //FIXME break; case QVariant::Polygon: dbg.nospace() << qvariant_cast<QPolygon>(v); break; case QVariant::Region: dbg.nospace() << qvariant_cast<QRegion>(v); break; case QVariant::Font: // dbg.nospace() << qvariant_cast<QFont>(v); //FIXME break; case QVariant::Matrix: dbg.nospace() << qvariant_cast<QMatrix>(v); break; case QVariant::Transform: dbg.nospace() << qvariant_cast<QTransform>(v); break; case QVariant::Pixmap: // dbg.nospace() << qvariant_cast<QPixmap>(v); //FIXME break; case QVariant::Image: // dbg.nospace() << qvariant_cast<QImage>(v); //FIXME break; case QVariant::Brush: dbg.nospace() << qvariant_cast<QBrush>(v); break; case QVariant::Color: dbg.nospace() << qvariant_cast<QColor>(v); break; case QVariant::Palette: // dbg.nospace() << qvariant_cast<QPalette>(v); //FIXME break; #ifndef QT_NO_ICON case QVariant::Icon: // dbg.nospace() << qvariant_cast<QIcon>(v); // FIXME break; #endif case QVariant::SizePolicy: // dbg.nospace() << qvariant_cast<QSizePolicy>(v); //FIXME break; #ifndef QT_NO_SHORTCUT case QVariant::KeySequence: dbg.nospace() << qvariant_cast<QKeySequence>(v); break; #endif case QVariant::Pen: dbg.nospace() << qvariant_cast<QPen>(v); break; #ifndef QT_NO_MATRIX4X4 case QVariant::Matrix4x4: dbg.nospace() << qvariant_cast<QMatrix4x4>(v); break; #endif #ifndef QT_NO_VECTOR2D case QVariant::Vector2D: dbg.nospace() << qvariant_cast<QVector2D>(v); break; #endif #ifndef QT_NO_VECTOR3D case QVariant::Vector3D: dbg.nospace() << qvariant_cast<QVector3D>(v); break; #endif #ifndef QT_NO_VECTOR4D case QVariant::Vector4D: dbg.nospace() << qvariant_cast<QVector4D>(v); break; #endif #ifndef QT_NO_QUATERNION case QVariant::Quaternion: dbg.nospace() << qvariant_cast<QQuaternion>(v); break; #endif default: qcoreVariantHandler()->debugStream(dbg, v); break; } }
SEXP to_sexp(QVariant variant) { SEXP ans = NULL; switch(variant.type()) { case QMetaType::Void: ans = R_NilValue; break; case QMetaType::UChar: ans = ScalarRaw(variant.value<unsigned char>()); break; case QMetaType::Bool: ans = ScalarLogical(variant.value<bool>()); break; case QMetaType::Int: case QMetaType::UInt: case QMetaType::Long: case QMetaType::Short: case QMetaType::UShort: ans = ScalarInteger(variant.value<int>()); break; case QMetaType::Double: case QMetaType::LongLong: case QMetaType::ULong: case QMetaType::ULongLong: case QMetaType::Float: ans = ScalarReal(variant.value<double>()); break; case QMetaType::QChar: case QMetaType::Char: case QMetaType::QString: ans = qstring2sexp(variant.value<QString>()); break; case QMetaType::QByteArray: ans = to_sexp(variant.value<QByteArray>()); break; case QMetaType::VoidStar: ans = wrapPointer(variant.value<void *>()); break; case QMetaType::QObjectStar: ans = ptr_to_sexp(variant.value<QObject *>(), SmokeType(qt_Smoke, "QObject")); break; case QMetaType::QWidgetStar: ans = ptr_to_sexp(variant.value<QWidget *>(), SmokeType(qt_Smoke, "QWidget")); break; case QMetaType::QCursor: ans = QVARIANT_TO_SEXP(variant, QCursor); break; case QMetaType::QDate: ans = QVARIANT_TO_SEXP(variant, QDate); break; case QMetaType::QSize: ans = QVARIANT_TO_SEXP(variant, QSize); case QMetaType::QSizeF: ans = QVARIANT_TO_SEXP(variant, QSizeF); break; case QMetaType::QTime: ans = QVARIANT_TO_SEXP(variant, QTime); break; case QMetaType::QVariantList: ans = to_sexp(variant.value<QVariantList>(), SmokeType(qt_Smoke, "QList<QVariant>")); break; case QMetaType::QPolygon: ans = QVARIANT_TO_SEXP(variant, QPolygon); break; case QMetaType::QColor: ans = QVARIANT_TO_SEXP(variant, QColor); break; case QMetaType::QRectF: ans = QVARIANT_TO_SEXP(variant, QRectF); break; case QMetaType::QRect: ans = QVARIANT_TO_SEXP(variant, QRect); break; case QMetaType::QLine: ans = QVARIANT_TO_SEXP(variant, QLine); break; case QMetaType::QTextLength: ans = QVARIANT_TO_SEXP(variant, QTextLength); break; case QMetaType::QStringList: ans = to_sexp(variant.value<QStringList>(), SmokeType(qt_Smoke, "QStringList")); break; case QMetaType::QVariantMap: ans = to_sexp(variant.value<QVariantMap>(), SmokeType(qt_Smoke, "QMap<QString,QVariant>")); break; case QMetaType::QVariantHash: ans = to_sexp(variant.value<QVariantHash>(), SmokeType(qt_Smoke, "QHash<QString,QVariant>")); break; case QMetaType::QIcon: ans = QVARIANT_TO_SEXP(variant, QIcon); break; case QMetaType::QPen: ans = QVARIANT_TO_SEXP(variant, QPen); break; case QMetaType::QLineF: ans = QVARIANT_TO_SEXP(variant, QLineF); break; case QMetaType::QTextFormat: ans = QVARIANT_TO_SEXP(variant, QTextFormat); break; case QMetaType::QPoint: ans = QVARIANT_TO_SEXP(variant, QPoint); break; case QMetaType::QPointF: ans = QVARIANT_TO_SEXP(variant, QPointF); break; case QMetaType::QUrl: ans = QVARIANT_TO_SEXP(variant, QUrl); break; case QMetaType::QRegExp: ans = QVARIANT_TO_SEXP(variant, QRegExp); break; case QMetaType::QDateTime: ans = QVARIANT_TO_SEXP(variant, QDateTime); break; case QMetaType::QPalette: ans = QVARIANT_TO_SEXP(variant, QPalette); break; case QMetaType::QFont: ans = QVARIANT_TO_SEXP(variant, QFont); break; case QMetaType::QBrush: ans = QVARIANT_TO_SEXP(variant, QBrush); break; case QMetaType::QRegion: ans = QVARIANT_TO_SEXP(variant, QRegion); break; case QMetaType::QBitArray: ans = QVARIANT_TO_SEXP(variant, QBitArray); break; case QMetaType::QImage: ans = QVARIANT_TO_SEXP(variant, QImage); break; case QMetaType::QKeySequence: ans = QVARIANT_TO_SEXP(variant, QKeySequence); break; case QMetaType::QSizePolicy: ans = QVARIANT_TO_SEXP(variant, QSizePolicy); break; case QMetaType::QPixmap: ans = QVARIANT_TO_SEXP(variant, QPixmap); break; case QMetaType::QLocale: ans = QVARIANT_TO_SEXP(variant, QLocale); break; case QMetaType::QBitmap: ans = QVARIANT_TO_SEXP(variant, QBitmap); break; case QMetaType::QMatrix: /* obsolete */ ans = QVARIANT_TO_SEXP(variant, QMatrix); break; #if QT_VERSION >= 0x40300 case QMetaType::QTransform: ans = QVARIANT_TO_SEXP(variant, QTransform); break; #endif #if QT_VERSION >= 0x40600 case QMetaType::QMatrix4x4: ans = QVARIANT_TO_SEXP(variant, QMatrix4x4); break; case QMetaType::QVector2D: ans = QVARIANT_TO_SEXP(variant, QVector2D); break; case QMetaType::QVector3D: ans = QVARIANT_TO_SEXP(variant, QVector3D); break; case QMetaType::QVector4D: ans = QVARIANT_TO_SEXP(variant, QVector4D); break; case QMetaType::QQuaternion: ans = QVARIANT_TO_SEXP(variant, QQuaternion); break; #endif case QMetaType::User: break; default: error("Converting from QVariant: unhandled Qt type"); } if (!ans) error("Converting from QVariant: Qt type not yet implemented"); return ans; }
PyObject* scribus_getproperty(PyObject* /*self*/, PyObject* args, PyObject* kw) { PyObject* objArg = NULL; char* propertyName = NULL; char* kwargs[] = {const_cast<char*>("object"), const_cast<char*>("property"), NULL}; if (!PyArg_ParseTupleAndKeywords(args, kw, "Oes", kwargs, &objArg, "ascii", &propertyName)) return NULL; // Get the QObject* the object argument refers to QObject* obj = getQObjectFromPyArg(objArg); if (!obj) return NULL; objArg = NULL; // no need to decref, it's borrowed // Get the QMetaProperty for the property, so we can check // if it's a set/enum and do name/value translation. const QMetaObject* objmeta = obj->metaObject(); int i = objmeta->indexOfProperty(propertyName); if (i == -1) { PyErr_SetString(PyExc_ValueError, QObject::tr("Property not found").toLocal8Bit().data()); return NULL; } QMetaProperty propmeta = objmeta->property(i); if (!propmeta.isValid()) { PyErr_SetString(PyExc_ValueError, QObject::tr("Invalid property").toLocal8Bit().data()); return NULL; } // Get the property value as a variant type QVariant prop = obj->property(propertyName); // Convert the property to an instance of the closest matching Python type. PyObject* resultobj = NULL; // NUMERIC TYPES if (prop.type() == QVariant::Int) resultobj = PyLong_FromLong(prop.toInt()); else if (prop.type() == QVariant::Double) resultobj = PyFloat_FromDouble(prop.toDouble()); // BOOLEAN else if (prop.type() == QVariant::Bool) resultobj = PyBool_FromLong(prop.toBool()); // STRING TYPES else if (prop.type() == QVariant::ByteArray) resultobj = PyString_FromString(prop.toByteArray().data()); else if (prop.type() == QVariant::String) resultobj = PyString_FromString(prop.toString().toUtf8().data()); // HIGHER ORDER TYPES else if (prop.type() == QVariant::Point) { // Return a QPoint as an (x,y) tuple. QPoint pt = prop.toPoint(); return Py_BuildValue("(ii)", pt.x(), pt.y()); } else if (prop.type() == QVariant::Rect) { // Return a QRect as an (x,y,width,height) tuple. // FIXME: We should really construct and return an object that // matches the API of QRect and has properties to keep // left/top/right/bottom and x/y/width/height in sync. QRect r = prop.toRect(); return Py_BuildValue("(iiii)", r.x(), r.y(), r.width(), r.height()); } else if (prop.type() == QVariant::StringList) { QStringList tmp = prop.toStringList(); return convert_QStringList_to_PyListObject(tmp); } // UNHANDLED TYPE else { PyErr_SetString(PyExc_TypeError, QObject::tr("Couldn't convert result type '%1'.").arg(prop.typeName()).toLocal8Bit().constData() ); return resultobj; } // Return the resulting Python object if (resultobj == NULL) { // An exception was set while assigning to resultobj assert(PyErr_Occurred()); return NULL; } else return resultobj; }
void EffectWidgetPrivate::autogenerateUi() { Q_Q(EffectWidget); QVBoxLayout *mainLayout = new QVBoxLayout(q); mainLayout->setMargin(0); foreach (const EffectParameter ¶, effect->parameters()) { QVariant value = effect->parameterValue(para); QHBoxLayout *pLayout = new QHBoxLayout; mainLayout->addLayout(pLayout); QLabel *label = new QLabel(q); pLayout->addWidget(label); label->setText(para.name()); #ifndef QT_NO_TOOLTIP label->setToolTip(para.description()); #endif QWidget *control = 0; switch (para.type()) { case QVariant::String: { QComboBox *cb = new QComboBox(q); control = cb; if (value.type() == QVariant::Int) { //value just defines the item index foreach (const QVariant &item, para.possibleValues()) { cb->addItem(item.toString()); } cb->setCurrentIndex(value.toInt()); QObject::connect(cb, SIGNAL(currentIndexChanged(int)), q, SLOT(_k_setIntParameter(int))); } else { foreach (const QVariant &item, para.possibleValues()) { cb->addItem(item.toString()); if (item == value) { cb->setCurrentIndex(cb->count() - 1); } } QObject::connect(cb, SIGNAL(currentIndexChanged(QString)), q, SLOT(_k_setStringParameter(QString))); } } break; case QVariant::Bool: { QCheckBox *cb = new QCheckBox(q); control = cb; cb->setChecked(value.toBool()); QObject::connect(cb, SIGNAL(toggled(bool)), q, SLOT(_k_setToggleParameter(bool))); } break; case QVariant::Int: { QSpinBox *sb = new QSpinBox(q); control = sb; bool minValueOk = false; bool maxValueOk = false; const int minValue = para.minimumValue().toInt(&minValueOk); const int maxValue = para.minimumValue().toInt(&maxValueOk); sb->setRange(minValueOk ? minValue : DEFAULT_MIN_INT, maxValueOk ? maxValue : DEFAULT_MAX_INT); sb->setValue(value.toInt()); QObject::connect(sb, SIGNAL(valueChanged(int)), q, SLOT(_k_setIntParameter(int))); } break; case QVariant::Double: { const double minValue = (para.minimumValue().type() == QVariant::Double ? para.minimumValue().toDouble() : DEFAULT_MIN); const double maxValue = (para.maximumValue().type() == QVariant::Double ? para.maximumValue().toDouble() : DEFAULT_MAX); if (minValue == -1. && maxValue == 1.) { //Special case values between -1 and 1.0 to use a slider for improved usability QSlider *slider = new QSlider(Qt::Horizontal, q); slider->setRange(-SLIDER_RANGE, +SLIDER_RANGE); slider->setValue(int(SLIDER_RANGE * value.toDouble())); slider->setTickPosition(QSlider::TicksBelow); slider->setTickInterval(TICKINTERVAL); QObject::connect(slider, SIGNAL(valueChanged(int)), q, SLOT(_k_setSliderParameter(int))); } else { double step = 0.1; if (qAbs(maxValue - minValue) > 50) step = 1.0; QDoubleSpinBox *sb = new QDoubleSpinBox(q); control = sb; sb->setRange(minValue, maxValue); sb->setValue(value.toDouble()); sb->setSingleStep(step); QObject::connect(sb, SIGNAL(valueChanged(double)), q, SLOT(_k_setDoubleParameter(double))); } } break; default: break; }
QString ActionInstance::evaluateTextString(bool &ok, const QString &toEvaluate, int &position) { ok = true; int startIndex = position; QString result; while(position < toEvaluate.length()) { if(toEvaluate[position] == QLatin1Char('$')) { //find a variable name if(VariableRegExp.indexIn(toEvaluate, position) != -1) { QString foundVariableName = VariableRegExp.cap(1); QScriptValue foundVariable = d->scriptEngine->globalObject().property(foundVariableName); position += foundVariableName.length(); if(!foundVariable.isValid()) { ok = false; emit executionException(ActionException::InvalidParameterException, tr("Undefined variable \"%1\"").arg(foundVariableName)); return QString(); } QString stringEvaluationResult; if(foundVariable.isNull()) stringEvaluationResult = QStringLiteral("[Null]"); else if(foundVariable.isUndefined()) stringEvaluationResult = QStringLiteral("[Undefined]"); else if(foundVariable.isArray()) { while((position + 1 < toEvaluate.length()) && toEvaluate[position + 1] == QLatin1Char('[')) { position += 2; QString indexArray = evaluateTextString(ok, toEvaluate, position); if((position < toEvaluate.length()) && toEvaluate[position] == QLatin1Char(']')) { QScriptString internalIndexArray = d->scriptEngine->toStringHandle(indexArray); bool flag = true; int numIndex = internalIndexArray.toArrayIndex(&flag); if(flag) //numIndex is valid foundVariable = foundVariable.property(numIndex); else //use internalIndexArray foundVariable = foundVariable.property(internalIndexArray); } else { //syntax error ok = false; emit executionException(ActionException::InvalidParameterException, tr("Invalid parameter. Unable to evaluate string")); return QString(); } //COMPATIBILITY: we break the while loop if foundVariable is no more of Array type if(!foundVariable.isArray()) break; } //end of while, no more '[' if(foundVariable.isArray()) stringEvaluationResult = evaluateVariableArray(ok, foundVariable); else stringEvaluationResult = foundVariable.toString(); } else if(foundVariable.isVariant()) { QVariant variantEvaluationResult = foundVariable.toVariant(); switch(variantEvaluationResult.type()) { case QVariant::StringList: stringEvaluationResult = variantEvaluationResult.toStringList().join(QStringLiteral("\n")); break; case QVariant::ByteArray: stringEvaluationResult = QStringLiteral("[Raw data]"); break; default: stringEvaluationResult = foundVariable.toString(); break; } } else stringEvaluationResult = foundVariable.toString(); result.append(stringEvaluationResult); } } else if (toEvaluate[position] == QLatin1Char(']')) { if(startIndex == 0) //in top level evaluation isolated character ']' is accepted (for compatibility reason), now prefer "\]" //i.e without matching '[' result.append(toEvaluate[position]); else //on other levels, the parsing is stopped at this point return result; } else if(toEvaluate[position] == QLatin1Char('\\')) { if(startIndex == 0) { //for ascendant compatibility reason //in top level evaluation '\' is not only an escape character, //but can also be a standard character in some cases if((position + 1) < toEvaluate.length()) { position++; if(toEvaluate[position] == QLatin1Char('$') || toEvaluate[position] == QLatin1Char('[') || toEvaluate[position] == QLatin1Char(']') || toEvaluate[position] == QLatin1Char('\\')) result.append(toEvaluate[position]); else { position--; result.append(toEvaluate[position]); } } else result.append(toEvaluate[position]); } else { position++; if( position < toEvaluate.length() ) result.append(toEvaluate[position]); } } else result.append(toEvaluate[position]); position++; } return result; }
void KNConfigure::setData(const QString &key, const QVariant &value) { //Check whether the value is null. if(value.isNull()) { //Remove the key from the configure data. m_dataObject.remove(key); //Complete. return; } //Because the QJsonObject can only insert QJsonValue, and the construct //function of QJsonValue only have the following types: // bool, QString, array, double, object. //So we have to translate some complex type variant to object. switch(value.type()) { //For the basic types(double, float, int, bool, QString), we will save them //directly. case QVariant::LongLong: m_dataObject.insert(key, value.toLongLong()); break; case QVariant::Double: m_dataObject.insert(key, value.toDouble()); break; case QVariant::String: m_dataObject.insert(key, value.toString()); break; case QVariant::Int: m_dataObject.insert(key, value.toInt()); break; case QVariant::Bool: m_dataObject.insert(key, value.toBool()); break; //For advanced types(like Font), we have to translate them to a object. case QVariant::Font: { //Generate the font object. QFont font=value.value<QFont>(); QJsonObject fontObject; fontObject.insert("Type", QString("Font")); fontObject.insert("Family", font.family()); fontObject.insert("Size", font.pixelSize()); fontObject.insert("Bold", font.bold()); fontObject.insert("Italic", font.italic()); fontObject.insert("Underline", font.underline()); fontObject.insert("Strikeout", font.strikeOut()); fontObject.insert("Kerning", font.kerning()); //Insert the font object. m_dataObject.insert(key, fontObject); break; } case QVariant::KeySequence: { //Generate a key sequence object. QKeySequence keySequence=value.value<QKeySequence>(); //A shortcut object. QJsonObject shortcutObject; shortcutObject.insert("Type", QString("Shortcut")); shortcutObject.insert("Key", keySequence.toString( QKeySequence::PortableText)); //Insert the key sequence object. m_dataObject.insert(key, shortcutObject); break; } //For the JSON object, it is quite wired that QVariant doesn't enumerate the //JSON type here, but it will use the meta type json object here. case QMetaType::QJsonObject: { //Check with the value contains the custom type. QJsonObject customObject=value.toJsonObject(); //Check the custom object type is matched. if("CustomObject"==customObject.value("Type").toString()) { //Simply insert the json object to the data. m_dataObject.insert(key, customObject); } break; } //For the JSON array, directly save the original data. case QMetaType::QJsonArray: { //Simply insert the json array to the data. m_dataObject.insert(key, value.toJsonArray()); break; } default: return; } //Emit the signal. emit valueChanged(); }
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 multimediaProject::upgrade() { projectVersion version = documentElement().attribute( "creatorversion" ). replace( "svn", "" ); if( version < "0.2.1-20070501" ) { QDomNodeList list = elementsByTagName( "arpandchords" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); if( el.hasAttribute( "arpdir" ) ) { int arpdir = el.attribute( "arpdir" ).toInt(); if( arpdir > 0 ) { el.setAttribute( "arpdir", arpdir - 1 ); } else { el.setAttribute( "arpdisabled", "1" ); } } } list = elementsByTagName( "sampletrack" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); if( el.attribute( "vol" ) != "" ) { el.setAttribute( "vol", el.attribute( "vol" ).toFloat() * 100.0f ); } else { QDomNode node = el.namedItem( "automation-pattern" ); if( !node.isElement() || !node.namedItem( "vol" ).isElement() ) { el.setAttribute( "vol", 100.0f ); } } } list = elementsByTagName( "ladspacontrols" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); QDomNode anode = el.namedItem( "automation-pattern" ); QDomNode node = anode.firstChild(); while( !node.isNull() ) { if( node.isElement() ) { QString name = node.nodeName(); if( name.endsWith( "link" ) ) { el.setAttribute( name, node.namedItem( "time" ) .toElement() .attribute( "value" ) ); QDomNode oldNode = node; node = node.nextSibling(); anode.removeChild( oldNode ); continue; } } node = node.nextSibling(); } } QDomNode node = m_head.firstChild(); while( !node.isNull() ) { if( node.isElement() ) { if( node.nodeName() == "bpm" ) { int value = node.toElement().attribute( "value" ).toInt(); if( value > 0 ) { m_head.setAttribute( "bpm", value ); QDomNode oldNode = node; node = node.nextSibling(); m_head.removeChild( oldNode ); continue; } } else if( node.nodeName() == "mastervol" ) { int value = node.toElement().attribute( "value" ).toInt(); if( value > 0 ) { m_head.setAttribute( "mastervol", value ); QDomNode oldNode = node; node = node.nextSibling(); m_head.removeChild( oldNode ); continue; } } else if( node.nodeName() == "masterpitch" ) { m_head.setAttribute( "masterpitch", -node.toElement().attribute( "value" ).toInt() ); QDomNode oldNode = node; node = node.nextSibling(); m_head.removeChild( oldNode ); continue; } } node = node.nextSibling(); } } if( version < "0.2.1-20070508" ) { QDomNodeList list = elementsByTagName( "arpandchords" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); if( el.hasAttribute( "chorddisabled" ) ) { el.setAttribute( "chord-enabled", !el.attribute( "chorddisabled" ) .toInt() ); el.setAttribute( "arp-enabled", !el.attribute( "arpdisabled" ) .toInt() ); } else if( !el.hasAttribute( "chord-enabled" ) ) { el.setAttribute( "chord-enabled", true ); el.setAttribute( "arp-enabled", el.attribute( "arpdir" ).toInt() != 0 ); } } while( !( list = elementsByTagName( "channeltrack" ) ).isEmpty() ) { QDomElement el = list.item( 0 ).toElement(); el.setTagName( "instrumenttrack" ); } list = elementsByTagName( "instrumenttrack" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); if( el.hasAttribute( "vol" ) ) { float value = el.attribute( "vol" ).toFloat(); value = roundf( value * 0.585786438f ); el.setAttribute( "vol", value ); } else { QDomNodeList vol_list = el.namedItem( "automation-pattern" ) .namedItem( "vol" ).toElement() .elementsByTagName( "time" ); for( int j = 0; !vol_list.item( j ).isNull(); ++j ) { QDomElement timeEl = list.item( j ) .toElement(); int value = timeEl.attribute( "value" ) .toInt(); value = (int)roundf( value * 0.585786438f ); timeEl.setAttribute( "value", value ); } } } } if( version < "0.3.0-rc2" ) { QDomNodeList list = elementsByTagName( "arpandchords" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); if( el.attribute( "arpdir" ).toInt() > 0 ) { el.setAttribute( "arpdir", el.attribute( "arpdir" ).toInt() - 1 ); } } } if( version < "0.3.0" ) { QDomNodeList list; while( !( list = elementsByTagName( "pluckedstringsynth" ) ).isEmpty() ) { QDomElement el = list.item( 0 ).toElement(); el.setTagName( "vibedstrings" ); el.setAttribute( "active0", 1 ); } while( !( list = elementsByTagName( "lb303" ) ).isEmpty() ) { QDomElement el = list.item( 0 ).toElement(); el.setTagName( "lb302" ); } while( !( list = elementsByTagName( "channelsettings" ) ). isEmpty() ) { QDomElement el = list.item( 0 ).toElement(); el.setTagName( "instrumenttracksettings" ); } } if( version < "0.4.0-20080104" ) { QDomNodeList list = elementsByTagName( "fx" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); if( el.hasAttribute( "fxdisabled" ) && el.attribute( "fxdisabled" ).toInt() == 0 ) { el.setAttribute( "enabled", 1 ); } } } if( version < "0.4.0-20080118" ) { QDomNodeList list; while( !( list = elementsByTagName( "fx" ) ).isEmpty() ) { QDomElement fxchain = list.item( 0 ).toElement(); fxchain.setTagName( "fxchain" ); QDomNode rack = list.item( 0 ).firstChild(); QDomNodeList effects = rack.childNodes(); // move items one level up while( effects.count() ) { fxchain.appendChild( effects.at( 0 ) ); } fxchain.setAttribute( "numofeffects", rack.toElement().attribute( "numofeffects" ) ); fxchain.removeChild( rack ); } } if( version < "0.4.0-20080129" ) { QDomNodeList list; while( !( list = elementsByTagName( "arpandchords" ) ).isEmpty() ) { QDomElement aac = list.item( 0 ).toElement(); aac.setTagName( "arpeggiator" ); QDomNode cloned = aac.cloneNode(); cloned.toElement().setTagName( "chordcreator" ); aac.parentNode().appendChild( cloned ); } } if( version < "0.4.0-20080409" ) { QStringList s; s << "note" << "pattern" << "bbtco" << "sampletco" << "time"; for( QStringList::iterator it = s.begin(); it < s.end(); ++it ) { QDomNodeList list = elementsByTagName( *it ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); el.setAttribute( "pos", el.attribute( "pos" ).toInt()*3 ); el.setAttribute( "len", el.attribute( "len" ).toInt()*3 ); } } QDomNodeList list = elementsByTagName( "timeline" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); el.setAttribute( "lp0pos", el.attribute( "lp0pos" ).toInt()*3 ); el.setAttribute( "lp1pos", el.attribute( "lp1pos" ).toInt()*3 ); } } if( version < "0.4.0-20080607" ) { QDomNodeList list; while( !( list = elementsByTagName( "midi" ) ).isEmpty() ) { QDomElement el = list.item( 0 ).toElement(); el.setTagName( "midiport" ); } } if( version < "0.4.0-20080622" ) { QDomNodeList list; while( !( list = elementsByTagName( "automation-pattern" ) ).isEmpty() ) { QDomElement el = list.item( 0 ).toElement(); el.setTagName( "automationpattern" ); } list = elementsByTagName( "bbtrack" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); QString s = el.attribute( "name" ); s.replace( QRegExp( "^Beat/Baseline " ), "Beat/Bassline " ); el.setAttribute( "name", s ); } } if( version < "0.4.0-beta1" ) { // convert binary effect-key-blobs to XML QDomNodeList list; list = elementsByTagName( "effect" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); QString k = el.attribute( "key" ); if( !k.isEmpty() ) { const QList<QVariant> l = base64::decode( k, QVariant::List ).toList(); if( !l.isEmpty() ) { QString name = l[0].toString(); QVariant u = l[1]; EffectKey::AttributeMap m; // VST-effect? if( u.type() == QVariant::String ) { m["file"] = u.toString(); } // LADSPA-effect? else if( u.type() == QVariant::StringList ) { const QStringList sl = u.toStringList(); m["plugin"] = sl.value( 0 ); m["file"] = sl.value( 1 ); } EffectKey key( NULL, name, m ); el.appendChild( key.saveXML( *this ) ); } } } } if( version < "0.4.0-rc2" ) { QDomNodeList list = elementsByTagName( "audiofileprocessor" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); QString s = el.attribute( "src" ); s.replace( "drumsynth/misc ", "drumsynth/misc_" ); s.replace( "drumsynth/r&b", "drumsynth/r_n_b" ); s.replace( "drumsynth/r_b", "drumsynth/r_n_b" ); el.setAttribute( "src", s ); } list = elementsByTagName( "lb302" ); for( int i = 0; !list.item( i ).isNull(); ++i ) { QDomElement el = list.item( i ).toElement(); int s = el.attribute( "shape" ).toInt(); if( s >= 1 ) { s--; } el.setAttribute( "shape", QString("%1").arg(s) ); } } // Time-signature if ( !m_head.hasAttribute( "timesig_numerator" ) ) { m_head.setAttribute( "timesig_numerator", 4 ); m_head.setAttribute( "timesig_denominator", 4 ); } if( !m_head.hasAttribute( "mastervol" ) ) { m_head.setAttribute( "mastervol", 100 ); } //printf("%s\n", toString( 2 ).toUtf8().constData()); }
bool HStateVariableInfoPrivate::checkValue( const QVariant& value, QVariant* acceptableValue, QString* errDescr) const { QVariant tmp(value); if (m_dataType == HUpnpDataTypes::Undefined) { if (errDescr) { *errDescr = QString( "Data type of the state variable [%1] is not defined.").arg( m_name); } return false; } if (value.type() != m_variantDataType) { if (m_variantDataType == QVariant::Url) { // for some reason, QVariant does not provide automatic conversion between // QUrl and other types (this includes QString, unfortunately) and until it does, // this has to be handled as a special case. QUrl valueAsUrl(value.toString()); if (!valueAsUrl.isValid()) { if (errDescr) { *errDescr = QString( "Invalid value for a URL type: [%1]").arg( value.toString()); } return false; } tmp = valueAsUrl; } else if (!tmp.convert(m_variantDataType)) { if (errDescr) { *errDescr = "Data type mismatch."; } return false; } } if (m_dataType == HUpnpDataTypes::string && m_allowedValueList.size()) { if (m_allowedValueList.indexOf(value.toString()) < 0) { if (errDescr) { *errDescr = QString( "Value [%1] is not included in the allowed values list.").arg( value.toString()); } return false; } } else if (HUpnpDataTypes::isRational(m_dataType) && !m_allowedValueRange.isNull()) { qreal tmp = value.toDouble(); if (tmp < m_allowedValueRange.minimum().toDouble() || tmp > m_allowedValueRange.maximum().toDouble()) { if (errDescr) { *errDescr = QString( "Value [%1] is not within the specified allowed values range.").arg( value.toString()); } return false; } } else if (HUpnpDataTypes::isNumeric(m_dataType) && !m_allowedValueRange.isNull()) { qlonglong tmp = value.toLongLong(); if (tmp < m_allowedValueRange.minimum().toLongLong() || tmp > m_allowedValueRange.maximum().toLongLong()) { if (errDescr) { *errDescr = QString( "Value [%1] is not within the specified allowed values range.").arg( value.toString()); } return false; } } *acceptableValue = tmp; return true; }
void AccessManager::AccessManagerPrivate::setMetaDataForRequest(QNetworkRequest request, KIO::MetaData& metaData) { // Add any meta data specified within request... QVariant userMetaData = request.attribute (static_cast<QNetworkRequest::Attribute>(MetaData)); if (userMetaData.isValid() && userMetaData.type() == QVariant::Map) metaData += userMetaData.toMap(); metaData.insert(QL1S("PropagateHttpHeader"), QL1S("true")); if (request.hasRawHeader("User-Agent")) { metaData.insert(QL1S("UserAgent"), request.rawHeader("User-Agent")); request.setRawHeader("User-Agent", QByteArray()); } if (request.hasRawHeader("Accept")) { metaData.insert(QL1S("accept"), request.rawHeader("Accept")); request.setRawHeader("Accept", QByteArray()); } if (request.hasRawHeader("Accept-Charset")) { metaData.insert(QL1S("Charsets"), request.rawHeader("Accept-Charset")); request.setRawHeader("Accept-Charset", QByteArray()); } if (request.hasRawHeader("Accept-Language")) { metaData.insert(QL1S("Languages"), request.rawHeader("Accept-Language")); request.setRawHeader("Accept-Language", QByteArray()); } if (request.hasRawHeader("Referer")) { metaData.insert(QL1S("referrer"), request.rawHeader("Referer")); request.setRawHeader("Referer", QByteArray()); } if (request.hasRawHeader("Content-Type")) { metaData.insert(QL1S("content-type"), request.rawHeader("Content-Type")); request.setRawHeader("Content-Type", QByteArray()); } if (request.attribute(QNetworkRequest::AuthenticationReuseAttribute) == QNetworkRequest::Manual) { metaData.insert(QL1S("no-preemptive-auth-reuse"), QL1S("true")); } request.setRawHeader("Content-Length", QByteArray()); request.setRawHeader("Connection", QByteArray()); request.setRawHeader("If-None-Match", QByteArray()); request.setRawHeader("If-Modified-Since", QByteArray()); request.setRawHeader("x-kdewebkit-ignore-disposition", QByteArray()); QStringList customHeaders; Q_FOREACH(const QByteArray &key, request.rawHeaderList()) { const QByteArray value = request.rawHeader(key); if (value.length()) customHeaders << (key + QL1S(": ") + value); } if (!customHeaders.isEmpty()) { metaData.insert(QL1S("customHTTPHeader"), customHeaders.join("\r\n")); } // Append per request meta data, if any... if (!requestMetaData.isEmpty()) { metaData += requestMetaData; // Clear per request meta data... requestMetaData.clear(); } // Append per session meta data, if any... if (!sessionMetaData.isEmpty()) { metaData += sessionMetaData; } }
std::string fromIniCompatible(const QVariant& Var) { if (Var.type() == QVariant::StringList) return Var.toStringList().join(", ").toStdString(); else return Var.toString().toStdString(); }
void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, const QVariant &data, bool *ok) { QString errorFunction; pps_encoder_error_t error = PPS_ENCODER_OK; switch (data.type()) { case QVariant::Bool: error = pps_encoder_add_bool(encoder, name, data.toBool()); errorFunction = QStringLiteral("pps_encoder_add_bool"); break; // We want to support encoding uint even though libpps doesn't support it directly. // We can't encode uint as an int since that will lose precision (e.g. 2^31+1 can't be // encoded that way). However, we can convert uint to double without losing precision. // QVariant.toDouble() conveniently takes care of the conversion for us. case QVariant::UInt: case QVariant::Double: error = pps_encoder_add_double(encoder, name, data.toDouble()); errorFunction = QStringLiteral("pps_encoder_add_double"); break; case QVariant::Int: error = pps_encoder_add_int(encoder, name, data.toInt()); errorFunction = QStringLiteral("pps_encoder_add_int"); break; case QVariant::LongLong: error = pps_encoder_add_int64(encoder, name, data.toLongLong()); errorFunction = QStringLiteral("pps_encoder_add_int64"); break; case QVariant::String: error = pps_encoder_add_string(encoder, name, data.toString().toUtf8().constData()); errorFunction = QStringLiteral("pps_encoder_add_string"); break; case QVariant::List: error = pps_encoder_start_array(encoder, name); errorFunction = QStringLiteral("pps_encoder_start_array"); if (error == PPS_ENCODER_OK) { encodeArray(encoder, data.toList(), ok); error = pps_encoder_end_array(encoder); errorFunction = QStringLiteral("pps_encoder_end_array"); } break; case QVariant::Map: error = pps_encoder_start_object(encoder, name); errorFunction = QStringLiteral("pps_encoder_start_object"); if (error == PPS_ENCODER_OK) { encodeObject(encoder, data.toMap(), ok); error = pps_encoder_end_object(encoder); errorFunction = QStringLiteral("pps_encoder_end_object"); } break; case QVariant::Invalid: error = pps_encoder_add_null(encoder, name); errorFunction = QStringLiteral("pps_encoder_add_null"); break; default: qWarning() << "QPpsObjectPrivate::encodeData: the type of the parameter data is invalid"; *ok = false; return; } if (error != PPS_ENCODER_OK) { qWarning() << "QPpsObjectPrivate::encodeData: " << errorFunction << " failed"; *ok = false; } else { *ok = true; } }
bool QSQLiteResult::exec() { const QVector<QVariant> values = boundValues(); d->skippedStatus = false; d->skipRow = false; d->rInf.clear(); clearValues(); setLastError(QSqlError()); int res = sqlite3_reset(d->stmt); if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to reset statement"), QSqlError::StatementError, res)); d->finalize(); return false; } int paramCount = sqlite3_bind_parameter_count(d->stmt); if (paramCount == values.count()) { for (int i = 0; i < paramCount; ++i) { res = SQLITE_OK; const QVariant value = values.at(i); if (value.isNull()) { res = sqlite3_bind_null(d->stmt, i + 1); } else { switch (value.type()) { case QVariant::ByteArray: { const QByteArray *ba = static_cast<const QByteArray*>(value.constData()); res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(), ba->size(), SQLITE_STATIC); break; } case QVariant::Int: res = sqlite3_bind_int(d->stmt, i + 1, value.toInt()); break; case QVariant::Double: res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble()); break; case QVariant::UInt: case QVariant::LongLong: res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong()); break; case QVariant::String: { // lifetime of string == lifetime of its qvariant const QString *str = static_cast<const QString*>(value.constData()); res = sqlite3_bind_text16(d->stmt, i + 1, str->utf16(), (str->size()) * sizeof(QChar), SQLITE_STATIC); break; } default: { QString str = value.toString(); // SQLITE_TRANSIENT makes sure that sqlite buffers the data res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(), (str.size()) * sizeof(QChar), SQLITE_TRANSIENT); break; } } } if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to bind parameters"), QSqlError::StatementError, res)); d->finalize(); return false; } } } else { setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Parameter count mismatch"), QString(), QSqlError::StatementError)); return false; } d->skippedStatus = d->fetchNext(d->firstRow, 0, true); if (lastError().isValid()) { setSelect(false); setActive(false); return false; } setSelect(!d->rInf.isEmpty()); setActive(true); return true; }
void AVDecoder::setOptions(const QVariantHash &dict) { DPTR_D(AVDecoder); d.options = dict; if (d.dict) { av_dict_free(&d.dict); d.dict = 0; //aready 0 in av_free } if (dict.isEmpty()) return; // TODO: use QVariantMap only QVariant opt; if (dict.contains("avcodec")) opt = dict.value("avcodec"); if (opt.type() == QVariant::Hash) { QVariantHash avcodec_dict = opt.toHash(); // workaround for VideoDecoderFFmpeg. now it does not call av_opt_set_xxx, so set here in dict // TODO: wrong if opt is empty //if (dict.contains("FFmpeg")) // avcodec_dict.unite(dict.value("FFmpeg").toHash()); QHashIterator<QString, QVariant> i(avcodec_dict); while (i.hasNext()) { i.next(); const QByteArray key(i.key().toLower().toUtf8()); switch (i.value().type()) { case QVariant::Hash: // for example "vaapi": {...} continue; case QVariant::Bool: case QVariant::Int: { // QVariant.toByteArray(): "true" or "false", can not recognized by avcodec av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toInt()).constData(), 0); if (d.codec_ctx) av_opt_set_int(d.codec_ctx, key.constData(), i.value().toInt(), 0); } break; case QVariant::ULongLong: case QVariant::LongLong: { av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toLongLong()).constData(), 0); if (d.codec_ctx) av_opt_set_int(d.codec_ctx, key.constData(), i.value().toLongLong(), 0); } break; default: // avcodec key and value are in lower case av_dict_set(&d.dict, i.key().toLower().toUtf8().constData(), i.value().toByteArray().toLower().constData(), 0); break; } qDebug("avcodec option: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } else if (opt.type() == QVariant::Map) { QVariantMap avcodec_dict = opt.toMap(); // workaround for VideoDecoderFFmpeg. now it does not call av_opt_set_xxx, so set here in dict //if (dict.contains("FFmpeg")) // avcodec_dict.unite(dict.value("FFmpeg").toMap()); QMapIterator<QString, QVariant> i(avcodec_dict); while (i.hasNext()) { i.next(); const QByteArray key(i.key().toLower().toUtf8()); switch (i.value().type()) { case QVariant::Map: // for example "vaapi": {...} continue; case QVariant::Bool: case QVariant::UInt: case QVariant::Int: { // QVariant.toByteArray(): "true" or "false", can not recognized by avcodec av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toInt()), 0); if (d.codec_ctx) av_opt_set_int(d.codec_ctx, key.constData(), i.value().toInt(), 0); } break; case QVariant::ULongLong: case QVariant::LongLong: { av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toLongLong()).constData(), 0); if (d.codec_ctx) av_opt_set_int(d.codec_ctx, key.constData(), i.value().toLongLong(), 0); } break; default: // avcodec key and value are in lower case av_dict_set(&d.dict, i.key().toLower().toUtf8().constData(), i.value().toByteArray().toLower().constData(), 0); break; } qDebug("avcodec option: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } if (name() == "avcodec") return; if (dict.contains(name())) opt = dict.value(name()); else if (dict.contains(name().toLower())) opt = dict.value(name().toLower()); else return; if (opt.type() == QVariant::Hash) { QVariantHash property_dict(opt.toHash()); if (property_dict.isEmpty()) return; QHashIterator<QString, QVariant> i(property_dict); while (i.hasNext()) { i.next(); if (i.value().type() == QVariant::Hash) // for example "vaapi": {...} continue; setProperty(i.key().toUtf8().constData(), i.value()); qDebug("decoder property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } else if (opt.type() == QVariant::Map) { QVariantMap property_dict(opt.toMap()); if (property_dict.isEmpty()) return; QMapIterator<QString, QVariant> i(property_dict); while (i.hasNext()) { i.next(); if (i.value().type() == QVariant::Map) // for example "vaapi": {...} continue; setProperty(i.key().toUtf8().constData(), i.value()); qDebug("decoder property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } }
/*! Sets the \a newValue for \a option and returns \c true on success; \c false otherwise. \note If the option's associated type is \c quint8 or \c quint16 and the type of \a newValue is larger, the data will be truncated or conversation will fail. \table \header \li Key \li Description \row \li \l QModbusServer::DiagnosticRegister \li Sets the diagnostic register of the server in a device specific encoding to \a newValue. The default value preset is \c 0x0000. The bit values of the register need device specific documentation. \row \li \l QModbusServer::ExceptionStatusOffset \li Sets the exception status byte offset of the server to \a newValue which is the absolute offset address in the coils (0x register). Modbus register table starting with \c 0x0000h. The default value preset is \c 0x0000, using the exception status coils similar to Modicon 984 CPUs (coils 1-8). The function returns \c true if the coils register contains the 8 bits required for storing and retrieving the status coils, otherwise \c false. \row \li \l QModbusServer::DeviceBusy \li Sets a flag that signals that the server is engaged in processing a long-duration program command. Valid values are \c 0x0000 (not busy) and \c 0xffff (busy). The default value preset is \c 0x0000. \row \li \l QModbusServer::AsciiInputDelimiter \li The \a newValue becomes the end of message delimiter for future Modbus ASCII messages. The default value preset is \c {\n}. \row \li \l QModbusServer::ListenOnlyMode \li Ss the server's listen only state to \a newValue. If listen only mode is set to \c true, messages are monitored but no response will be sent. The default value preset is \c false. \row \li \l QModbusServer::ServerIdentifier \li Sets the server's manufacturer identifier to \a newValue. Possible values are in the range of \c 0x00 to 0xff. The default value preset is \c 0x0a. \row \li \l QModbusServer::RunIndicatorStatus \li Sets the servers' run indicator status to \a newValue. This data is used as addendum by the \l QModbusPdu::ReportServerId function code. Valid values are \c 0x00 (OFF) and \c 0xff (ON). The default value preset is \c 0xff (ON). \row \li \l QModbusServer::AdditionalData \li Sets the server's additional data to \a newValue. This data is used as addendum by the \l QModbusPdu::ReportServerId function code. The maximum data size cannot exceed 249 bytes to match response message size restrictions. The default value preset is \c {Qt Modbus Server}. \row \li \l QModbusServer::UserOption \li Sets the value of a user option to \a newValue. \note For user options, it is up to the developer to decide which types to use and ensure that components use the correct types when accessing and setting values. \endtable */ bool QModbusServer::setValue(int option, const QVariant &newValue) { #define CHECK_INT_OR_UINT(val) \ do { \ if ((val.type() != QVariant::Int) && (val.type() != QVariant::UInt)) \ return false; \ } while (0) Q_D(QModbusServer); switch (option) { case DiagnosticRegister: CHECK_INT_OR_UINT(newValue); d->m_serverOptions.insert(option, newValue); return true; case ExceptionStatusOffset: { CHECK_INT_OR_UINT(newValue); const quint16 tmp = newValue.value<quint16>(); QModbusDataUnit coils(QModbusDataUnit::Coils, tmp, 8); if (!data(&coils)) return false; d->m_serverOptions.insert(option, tmp); return true; } case DeviceBusy: { CHECK_INT_OR_UINT(newValue); const quint16 tmp = newValue.value<quint16>(); if ((tmp != 0x0000) && (tmp != 0xffff)) return false; d->m_serverOptions.insert(option, tmp); return true; } case AsciiInputDelimiter: { CHECK_INT_OR_UINT(newValue); bool ok = false; if (newValue.toUInt(&ok) > 0xff || !ok) return false; d->m_serverOptions.insert(option, newValue); return true; } case ListenOnlyMode: { if (newValue.type() != QVariant::Bool) return false; d->m_serverOptions.insert(option, newValue); return true; } case ServerIdentifier: CHECK_INT_OR_UINT(newValue); d->m_serverOptions.insert(option, newValue); return true; case RunIndicatorStatus: { CHECK_INT_OR_UINT(newValue); const quint8 tmp = newValue.value<quint8>(); if ((tmp != 0x00) && (tmp != 0xff)) return false; d->m_serverOptions.insert(option, tmp); return true; } case AdditionalData: { if (newValue.type() != QVariant::ByteArray) return false; const QByteArray additionalData = newValue.toByteArray(); if (additionalData.size() > 249) return false; d->m_serverOptions.insert(option, additionalData); return true; } default: break; }; if (option < UserOption) return false; d->m_serverOptions.insert(option, newValue); return true; #undef CHECK_INT_OR_UINT }
QVariant QSystemLocale::query(QueryType type, QVariant in) const { QSystemLocaleData *d = qSystemLocaleData(); #if defined(Q_OS_QNX) QBBLocaleData *bbd = qbbLocaleData(); #endif const QLocale &lc_numeric = d->lc_numeric; const QLocale &lc_time = d->lc_time; const QLocale &lc_monetary = d->lc_monetary; const QLocale &lc_messages = d->lc_messages; switch (type) { case DecimalPoint: return lc_numeric.decimalPoint(); case GroupSeparator: return lc_numeric.groupSeparator(); case ZeroDigit: return lc_numeric.zeroDigit(); case NegativeSign: return lc_numeric.negativeSign(); case DateFormatLong: return lc_time.dateFormat(QLocale::LongFormat); case DateFormatShort: return lc_time.dateFormat(QLocale::ShortFormat); case TimeFormatLong: return lc_time.timeFormat(QLocale::LongFormat); case TimeFormatShort: return lc_time.timeFormat(QLocale::ShortFormat); case DayNameLong: return lc_time.dayName(in.toInt(), QLocale::LongFormat); case DayNameShort: return lc_time.dayName(in.toInt(), QLocale::ShortFormat); case MonthNameLong: return lc_time.monthName(in.toInt(), QLocale::LongFormat); case MonthNameShort: return lc_time.monthName(in.toInt(), QLocale::ShortFormat); case DateToStringLong: return lc_time.toString(in.toDate(), QLocale::LongFormat); case DateToStringShort: return lc_time.toString(in.toDate(), QLocale::ShortFormat); case TimeToStringLong: return lc_time.toString(in.toTime(), QLocale::LongFormat); case TimeToStringShort: return lc_time.toString(in.toTime(), QLocale::ShortFormat); case DateTimeFormatLong: return lc_time.dateTimeFormat(QLocale::LongFormat); case DateTimeFormatShort: return lc_time.dateTimeFormat(QLocale::ShortFormat); case DateTimeToStringLong: return lc_time.toString(in.toDateTime(), QLocale::LongFormat); case DateTimeToStringShort: return lc_time.toString(in.toDateTime(), QLocale::ShortFormat); case PositiveSign: return lc_numeric.positiveSign(); case AMText: return lc_time.amText(); case PMText: return lc_time.pmText(); case FirstDayOfWeek: return lc_time.firstDayOfWeek(); case CurrencySymbol: return lc_monetary.currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt())); case CurrencyToString: { switch (in.type()) { case QVariant::Int: return lc_monetary.toCurrencyString(in.toInt()); case QVariant::UInt: return lc_monetary.toCurrencyString(in.toUInt()); case QVariant::Double: return lc_monetary.toCurrencyString(in.toDouble()); case QVariant::LongLong: return lc_monetary.toCurrencyString(in.toLongLong()); case QVariant::ULongLong: return lc_monetary.toCurrencyString(in.toULongLong()); default: break; } return QString(); } case MeasurementSystem: { const QString meas_locale = QString::fromLatin1(d->lc_measurement_var.constData(), d->lc_measurement_var.size()); if (meas_locale.compare(QLatin1String("Metric"), Qt::CaseInsensitive) == 0) return QLocale::MetricSystem; if (meas_locale.compare(QLatin1String("Other"), Qt::CaseInsensitive) == 0) return QLocale::MetricSystem; #if defined(Q_OS_QNX) return bbd->ppsMeasurement; #endif return QVariant((int)QLocale(meas_locale).measurementSystem()); } case UILanguages: { static QString languages = QString::fromLatin1(qgetenv("LANGUAGE")); if (!languages.isEmpty()) { QStringList lst = languages.split(QLatin1Char(':')); for (int i = 0; i < lst.size();) { const QString &name = lst.at(i); QString lang, script, cntry; if (name.isEmpty() || !qt_splitLocaleName(name, lang, script, cntry)) lst.removeAt(i); else ++i; } return lst; } if (!d->lc_messages_var.isEmpty()) { QString lang, script, cntry; if (qt_splitLocaleName(QString::fromLatin1(d->lc_messages_var.constData(), d->lc_messages_var.size()), lang, script, cntry)) { if (!cntry.length() && lang.length()) return QStringList(lang); return QStringList(lang % QLatin1Char('-') % cntry); } } return QVariant(); } case StringToStandardQuotation: return lc_messages.quoteString(in.value<QStringRef>()); case StringToAlternateQuotation: return lc_messages.quoteString(in.value<QStringRef>(), QLocale::AlternateQuotation); case ListToSeparatedString: return lc_messages.createSeparatedList(in.value<QStringList>()); case LocaleChanged: d->updateLocale(); break; default: break; } return QVariant(); }
bool qgsVariantLessThan( const QVariant& lhs, const QVariant& rhs ) { // invalid < NULL < any value if ( !lhs.isValid() ) return rhs.isValid(); else if ( lhs.isNull() ) return rhs.isValid() && !rhs.isNull(); else if ( !rhs.isValid() || rhs.isNull() ) return false; switch ( lhs.type() ) { case QVariant::Int: return lhs.toInt() < rhs.toInt(); case QVariant::UInt: return lhs.toUInt() < rhs.toUInt(); case QVariant::LongLong: return lhs.toLongLong() < rhs.toLongLong(); case QVariant::ULongLong: return lhs.toULongLong() < rhs.toULongLong(); case QVariant::Double: return lhs.toDouble() < rhs.toDouble(); case QVariant::Char: return lhs.toChar() < rhs.toChar(); case QVariant::Date: return lhs.toDate() < rhs.toDate(); case QVariant::Time: return lhs.toTime() < rhs.toTime(); case QVariant::DateTime: return lhs.toDateTime() < rhs.toDateTime(); case QVariant::Bool: return lhs.toBool() < rhs.toBool(); case QVariant::List: { const QList<QVariant> &lhsl = lhs.toList(); const QList<QVariant> &rhsl = rhs.toList(); int i, n = qMin( lhsl.size(), rhsl.size() ); for ( i = 0; i < n && lhsl[i].type() == rhsl[i].type() && lhsl[i].isNull() == rhsl[i].isNull() && lhsl[i] == rhsl[i]; i++ ) ; if ( i == n ) return lhsl.size() < rhsl.size(); else return qgsVariantLessThan( lhsl[i], rhsl[i] ); } case QVariant::StringList: { const QStringList &lhsl = lhs.toStringList(); const QStringList &rhsl = rhs.toStringList(); int i, n = qMin( lhsl.size(), rhsl.size() ); for ( i = 0; i < n && lhsl[i] == rhsl[i]; i++ ) ; if ( i == n ) return lhsl.size() < rhsl.size(); else return lhsl[i] < rhsl[i]; } default: return QString::localeAwareCompare( lhs.toString(), rhs.toString() ) < 0; } }
void TestQgsField::convertCompatible() { //test string field QgsField stringField( QStringLiteral( "string" ), QVariant::String, QStringLiteral( "string" ) ); QVariant stringVar( "test string" ); QVERIFY( stringField.convertCompatible( stringVar ) ); QCOMPARE( stringVar.toString(), QString( "test string" ) ); QVariant nullString = QVariant( QVariant::String ); QVERIFY( stringField.convertCompatible( nullString ) ); QCOMPARE( nullString.type(), QVariant::String ); QVERIFY( nullString.isNull() ); QVariant intVar( 5 ); QVERIFY( stringField.convertCompatible( intVar ) ); QCOMPARE( intVar.type(), QVariant::String ); QCOMPARE( intVar, QVariant( "5" ) ); QVariant nullInt = QVariant( QVariant::Int ); QVERIFY( stringField.convertCompatible( nullInt ) ); QCOMPARE( nullInt.type(), QVariant::String ); QVERIFY( nullInt.isNull() ); QVariant doubleVar( 1.25 ); QVERIFY( stringField.convertCompatible( doubleVar ) ); QCOMPARE( doubleVar.type(), QVariant::String ); QCOMPARE( doubleVar, QVariant( "1.25" ) ); QVariant nullDouble = QVariant( QVariant::Double ); QVERIFY( stringField.convertCompatible( nullDouble ) ); QCOMPARE( nullDouble.type(), QVariant::String ); QVERIFY( nullDouble.isNull() ); //test double QgsField doubleField( QStringLiteral( "double" ), QVariant::Double, QStringLiteral( "double" ) ); stringVar = QVariant( "test string" ); QVERIFY( !doubleField.convertCompatible( stringVar ) ); QCOMPARE( stringVar.type(), QVariant::Double ); QVERIFY( stringVar.isNull() ); nullString = QVariant( QVariant::String ); QVERIFY( doubleField.convertCompatible( nullString ) ); QCOMPARE( nullString.type(), QVariant::Double ); QVERIFY( nullString.isNull() ); intVar = QVariant( 5 ); QVERIFY( doubleField.convertCompatible( intVar ) ); QCOMPARE( intVar.type(), QVariant::Double ); QCOMPARE( intVar, QVariant( 5.0 ) ); nullInt = QVariant( QVariant::Int ); QVERIFY( doubleField.convertCompatible( nullInt ) ); QCOMPARE( nullInt.type(), QVariant::Double ); QVERIFY( nullInt.isNull() ); doubleVar = QVariant( 1.25 ); QVERIFY( doubleField.convertCompatible( doubleVar ) ); QCOMPARE( doubleVar.type(), QVariant::Double ); QCOMPARE( doubleVar, QVariant( 1.25 ) ); nullDouble = QVariant( QVariant::Double ); QVERIFY( doubleField.convertCompatible( nullDouble ) ); QCOMPARE( nullDouble.type(), QVariant::Double ); QVERIFY( nullDouble.isNull() ); //test special rules //conversion of double to int QgsField intField( QStringLiteral( "int" ), QVariant::Int, QStringLiteral( "int" ) ); //small double, should be rounded QVariant smallDouble( 45.7 ); QVERIFY( intField.convertCompatible( smallDouble ) ); QCOMPARE( smallDouble.type(), QVariant::Int ); QCOMPARE( smallDouble, QVariant( 46 ) ); QVariant negativeSmallDouble( -9345.754534525235235 ); QVERIFY( intField.convertCompatible( negativeSmallDouble ) ); QCOMPARE( negativeSmallDouble.type(), QVariant::Int ); QCOMPARE( negativeSmallDouble, QVariant( -9346 ) ); //large double, cannot be converted QVariant largeDouble( 9999999999.99 ); QVERIFY( !intField.convertCompatible( largeDouble ) ); QCOMPARE( largeDouble.type(), QVariant::Int ); QVERIFY( largeDouble.isNull() ); //conversion of string double value to int QVariant notNumberString( "notanumber" ); QVERIFY( !intField.convertCompatible( notNumberString ) ); QCOMPARE( notNumberString.type(), QVariant::Int ); QVERIFY( notNumberString.isNull() ); //small double, should be rounded QVariant smallDoubleString( "45.7" ); QVERIFY( intField.convertCompatible( smallDoubleString ) ); QCOMPARE( smallDoubleString.type(), QVariant::Int ); QCOMPARE( smallDoubleString, QVariant( 46 ) ); QVariant negativeSmallDoubleString( "-9345.754534525235235" ); QVERIFY( intField.convertCompatible( negativeSmallDoubleString ) ); QCOMPARE( negativeSmallDoubleString.type(), QVariant::Int ); QCOMPARE( negativeSmallDoubleString, QVariant( -9346 ) ); //large double, cannot be converted QVariant largeDoubleString( "9999999999.99" ); QVERIFY( !intField.convertCompatible( largeDoubleString ) ); QCOMPARE( largeDoubleString.type(), QVariant::Int ); QVERIFY( largeDoubleString.isNull() ); //conversion of longlong to int QVariant longlong( 99999999999999999LL ); QVERIFY( !intField.convertCompatible( longlong ) ); QCOMPARE( longlong.type(), QVariant::Int ); QVERIFY( longlong.isNull() ); QVariant smallLonglong( 99LL ); QVERIFY( intField.convertCompatible( smallLonglong ) ); QCOMPARE( smallLonglong.type(), QVariant::Int ); QCOMPARE( smallLonglong, QVariant( 99 ) ); //conversion of longlong to longlong field QgsField longlongField( QStringLiteral( "long" ), QVariant::LongLong, QStringLiteral( "longlong" ) ); longlong = QVariant( 99999999999999999LL ); QVERIFY( longlongField.convertCompatible( longlong ) ); QCOMPARE( longlong.type(), QVariant::LongLong ); QCOMPARE( longlong, QVariant( 99999999999999999LL ) ); //string representation of an int QVariant stringInt( "123456" ); QVERIFY( intField.convertCompatible( stringInt ) ); QCOMPARE( stringInt.type(), QVariant::Int ); QCOMPARE( stringInt, QVariant( 123456 ) ); // now with group separator for english locale stringInt = QVariant( "123,456" ); QVERIFY( intField.convertCompatible( stringInt ) ); QCOMPARE( stringInt.type(), QVariant::Int ); QCOMPARE( stringInt, QVariant( "123456" ) ); //string representation of a longlong QVariant stringLong( "99999999999999999" ); QVERIFY( longlongField.convertCompatible( stringLong ) ); QCOMPARE( stringLong.type(), QVariant::LongLong ); QCOMPARE( stringLong, QVariant( 99999999999999999LL ) ); // now with group separator for english locale stringLong = QVariant( "99,999,999,999,999,999" ); QVERIFY( longlongField.convertCompatible( stringLong ) ); QCOMPARE( stringLong.type(), QVariant::LongLong ); QCOMPARE( stringLong, QVariant( 99999999999999999LL ) ); //string representation of a double QVariant stringDouble( "123456.012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 123456.012345 ) ); // now with group separator for english locale stringDouble = QVariant( "1,223,456.012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 1223456.012345 ) ); // This should not convert stringDouble = QVariant( "1.223.456,012345" ); QVERIFY( ! doubleField.convertCompatible( stringDouble ) ); //double with precision QgsField doubleWithPrecField( QStringLiteral( "double" ), QVariant::Double, QStringLiteral( "double" ), 10, 3 ); doubleVar = QVariant( 10.12345678 ); //note - this returns true! QVERIFY( doubleWithPrecField.convertCompatible( doubleVar ) ); QCOMPARE( doubleVar.type(), QVariant::Double ); QCOMPARE( doubleVar.toDouble(), 10.123 ); //truncating string length QgsField stringWithLen( QStringLiteral( "string" ), QVariant::String, QStringLiteral( "string" ), 3 ); stringVar = QVariant( "longstring" ); QVERIFY( !stringWithLen.convertCompatible( stringVar ) ); QCOMPARE( stringVar.type(), QVariant::String ); QCOMPARE( stringVar.toString(), QString( "lon" ) ); ///////////////////////////////////////////////////////// // German locale tests //double with ',' as decimal separator for German locale QLocale::setDefault( QLocale::German ); QVariant doubleCommaVar( "1,2345" ); QVERIFY( doubleField.convertCompatible( doubleCommaVar ) ); QCOMPARE( doubleCommaVar.type(), QVariant::Double ); QCOMPARE( doubleCommaVar.toString(), QString( "1.2345" ) ); //string representation of an int stringInt = QVariant( "123456" ); QVERIFY( intField.convertCompatible( stringInt ) ); QCOMPARE( stringInt.type(), QVariant::Int ); QCOMPARE( stringInt, QVariant( 123456 ) ); // now with group separator for german locale stringInt = QVariant( "123.456" ); QVERIFY( intField.convertCompatible( stringInt ) ); QCOMPARE( stringInt.type(), QVariant::Int ); QCOMPARE( stringInt, QVariant( "123456" ) ); //string representation of a longlong stringLong = QVariant( "99999999999999999" ); QVERIFY( longlongField.convertCompatible( stringLong ) ); QCOMPARE( stringLong.type(), QVariant::LongLong ); QCOMPARE( stringLong, QVariant( 99999999999999999LL ) ); // now with group separator for german locale stringLong = QVariant( "99.999.999.999.999.999" ); QVERIFY( longlongField.convertCompatible( stringLong ) ); QCOMPARE( stringLong.type(), QVariant::LongLong ); QCOMPARE( stringLong, QVariant( 99999999999999999LL ) ); //string representation of a double stringDouble = QVariant( "123456,012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 123456.012345 ) ); // For doubles we also want to accept dot as a decimal point stringDouble = QVariant( "123456.012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 123456.012345 ) ); // now with group separator for german locale stringDouble = QVariant( "1.223.456,012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 1223456.012345 ) ); // Be are good citizens and we also accept english locale stringDouble = QVariant( "1,223,456.012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 1223456.012345 ) ); // Test that wrongly formatted decimal separator are also accepted QLocale::setDefault( QLocale::German ); stringDouble = QVariant( "12.23.456,012345" ); QVERIFY( doubleField.convertCompatible( stringDouble ) ); QCOMPARE( stringDouble.type(), QVariant::Double ); QCOMPARE( stringDouble, QVariant( 1223456.012345 ) ); }