bool QgsCategorizedSymbolRendererModel::setData( const QModelIndex &index, const QVariant &value, int role )
{
if ( !index.isValid() )
return false;
if ( index.column() == 0 && role == Qt::CheckStateRole )
{
mRenderer->updateCategoryRenderState( index.row(), value == Qt::Checked );
emit dataChanged( index, index );
return true;
}
if ( role != Qt::EditRole )
return false;
switch ( index.column() )
{
case 1: // value
{
// try to preserve variant type for this value
QVariant val;
switch ( mRenderer->categories().value( index.row() ).value().type() )
{
case QVariant::Int:
val = value.toInt();
break;
case QVariant::Double:
val = value.toDouble();
break;
case QVariant::List:
{
const QStringList parts = value.toString().split( ';' );
QVariantList list;
list.reserve( parts.count() );
for ( const QString &p : parts )
list << p;
if ( list.count() == 1 )
val = list.at( 0 );
else
val = list;
break;
}
default:
val = value.toString();
break;
}
mRenderer->updateCategoryValue( index.row(), val );
break;
}
case 2: // label
mRenderer->updateCategoryLabel( index.row(), value.toString() );
break;
default:
return false;
}
emit dataChanged( index, index );
return true;
}
void ChatView::startTasks()
{
# if defined(DEBUG_PERFORMANCE)
QTime t;
if (!m_messagesQueue.isEmpty())
qDebug() << "ChatView::startTasks()" << SimpleID::encode(m_id);
# endif
if (!m_messagesQueue.isEmpty()) {
DEBUG_TIME_START
if (m_messagesQueue.size() > MAX_MESSAGES_AT_ONCE) {
QVariantList query;
# if QT_VERSION >= 0x040700
query.reserve(MAX_MESSAGES_AT_ONCE);
# endif
for (int i = 0; i < MAX_MESSAGES_AT_ONCE; ++i)
query.append(m_messagesQueue.takeFirst());
emit messages(query);
DEBUG_TIME_ELAPSED_MQ
QTimer::singleShot(0, this, SLOT(startTasks()));
}
else {
emit messages(m_messagesQueue);
DEBUG_TIME_ELAPSED_MQ
m_messagesQueue.clear();
}
}
void ItemTagsScriptable::tag()
{
const auto args = currentArguments();
auto tagName = args.value(0).toString();
if ( tagName.isEmpty() ) {
tagName = askTagName( addTagText(), m_userTags );
if ( tagName.isEmpty() )
return;
}
if ( args.size() <= 1 ) {
const auto dataValueList = call("selectedItemsData").toList();
QVariantList dataList;
dataList.reserve( dataValueList.size() );
for (const auto &itemDataValue : dataValueList) {
auto itemData = itemDataValue.toMap();
auto itemTags = ::tags(itemData);
if ( addTag(tagName, &itemTags) )
itemData.insert( mimeTags, itemTags.join(",") );
dataList.append(itemData);
}
call( "setSelectedItemsData", QVariantList() << QVariant(dataList) );
} else {
for ( int row : rows(args, 1) ) {
auto itemTags = tags(row);
if ( addTag(tagName, &itemTags) )
setTags(row, itemTags);
}
}
}
QVariant SourcesModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
return QVariant();
if (index.row() >= m_size)
return QVariant();
Plasma::QueryMatch m = fetchMatch(index.row());
Q_ASSERT(m.runner());
switch(role) {
case Qt::DisplayRole:
return m.text();
case Qt::DecorationRole:
if (!m.iconName().isEmpty()) {
return m.iconName();
}
return m.icon();
case TypeRole:
return m.matchCategory();
case SubtextRole:
return m.subtext();
case ActionsRole: {
const auto &actions = m_manager->actionsForMatch(m);
if (actions.isEmpty()) {
return QVariantList();
}
QVariantList actionsList;
actionsList.reserve(actions.size());
for (QAction *action : actions) {
actionsList.append(QVariant::fromValue(action));
}
return actionsList;
}
case DuplicateRole:
return m_duplicates.value(m.text());
/*
case PreviewTypeRole:
return m.previewType();
case PreviewUrlRole:
return m.previewUrl();
case PreviewLabelRole:
return m.previewLabel();
*/
}
return QVariant();
}
QVariantList convertToVariant(const QList<QString> &val)
{
QVariantList ret;
ret.reserve(val.count());
for(const QString &s : val)
ret.push_back(s);
return ret;
}
int QDBusInterfacePrivate::metacall(QMetaObject::Call c, int id, void **argv)
{
Q_Q(QDBusInterface);
if (c == QMetaObject::InvokeMetaMethod) {
int offset = metaObject->methodOffset();
QMetaMethod mm = metaObject->method(id + offset);
if (mm.methodType() == QMetaMethod::Signal) {
// signal relay from D-Bus world to Qt world
QMetaObject::activate(q, metaObject, id, argv);
} else if (mm.methodType() == QMetaMethod::Slot || mm.methodType() == QMetaMethod::Method) {
// method call relay from Qt world to D-Bus world
// get D-Bus equivalent signature
QString methodName = QString::fromLatin1(mm.name());
const int *inputTypes = metaObject->inputTypesForMethod(id);
int inputTypesCount = *inputTypes;
// we will assume that the input arguments were passed correctly
QVariantList args;
args.reserve(inputTypesCount);
int i = 1;
for ( ; i <= inputTypesCount; ++i)
args << QVariant(inputTypes[i], argv[i]);
// make the call
QDBusMessage reply = q->callWithArgumentList(QDBus::Block, methodName, args);
if (reply.type() == QDBusMessage::ReplyMessage) {
// attempt to demarshall the return values
args = reply.arguments();
QVariantList::ConstIterator it = args.constBegin();
const int *outputTypes = metaObject->outputTypesForMethod(id);
int outputTypesCount = *outputTypes++;
if (mm.returnType() != QMetaType::UnknownType && mm.returnType() != QMetaType::Void) {
// this method has a return type
if (argv[0] && it != args.constEnd())
copyArgument(argv[0], *outputTypes++, *it);
// skip this argument even if we didn't copy it
--outputTypesCount;
++it;
}
for (int j = 0; j < outputTypesCount && it != args.constEnd(); ++i, ++j, ++it) {
copyArgument(argv[i], outputTypes[j], *it);
}
}
// done
lastError = QDBusError(reply);
return -1;
}
}
return id;
}
void deserializeInitDynamicPacket(QDataStream &in, QMetaObjectBuilder &builder, QVariantList &values)
{
quint32 numSignals = 0;
quint32 numMethods = 0;
quint32 numProperties = 0;
in >> numSignals;
in >> numMethods;
int curIndex = 0;
for (quint32 i = 0; i < numSignals; ++i) {
QByteArray signature;
in >> signature;
++curIndex;
builder.addSignal(signature);
}
for (quint32 i = 0; i < numMethods; ++i) {
QByteArray signature, returnType;
in >> signature;
in >> returnType;
++curIndex;
const bool isVoid = returnType.isEmpty() || returnType == QByteArrayLiteral("void");
if (isVoid)
builder.addMethod(signature);
else
builder.addMethod(signature, QByteArrayLiteral("QRemoteObjectPendingCall"));
}
in >> numProperties;
const quint32 initialListSize = values.size();
if (static_cast<quint32>(values.size()) < numProperties)
values.reserve(numProperties);
else if (static_cast<quint32>(values.size()) > numProperties)
for (quint32 i = numProperties; i < initialListSize; ++i)
values.removeLast();
for (quint32 i = 0; i < numProperties; ++i) {
QByteArray name;
QByteArray typeName;
QByteArray signalName;
in >> name;
in >> typeName;
in >> signalName;
if (signalName.isEmpty())
builder.addProperty(name, typeName);
else
builder.addProperty(name, typeName, builder.indexOfSignal(signalName));
QVariant value;
in >> value;
if (i < initialListSize)
values[i] = value;
else
values.append(value);
}
}
void dos_qvariant_setArray(::DosQVariant *vptr, int size, ::DosQVariant **array)
{
auto variant = static_cast<QVariant *>(vptr);
QVariantList data;
data.reserve(size);
for (int i = 0; i < size; ++i)
data << *(static_cast<QVariant *>(array[i]));
variant->setValue(data);
}
/*!
*/
QVariant SceneDocument::toVariant(const QJsonArray& array) noexcept
{
QVariantList node;
node.reserve(array.size());
for (const auto& element : array) {
const auto value = toVariant(element);
node.append(value);
}
return QVariant::fromValue(node);
}
bool DataStore::appendItemsFlags(const PimItem::List &items, const QVector<Flag> &flags,
bool *flagsChanged, bool checkIfExists,
const Collection &col, bool silent)
{
QSet<QByteArray> added;
QVariantList itemsIds;
itemsIds.reserve(items.count());
Q_FOREACH (const PimItem &item, items) {
itemsIds.append(item.id());
}
QVariantList_ *newVariantList(DataValue *list, int len)
{
QVariantList *vlist = new QVariantList();
vlist->reserve(len);
for (int i = 0; i < len; i++) {
QVariant var;
unpackDataValue(&list[i], &var);
vlist->append(var);
}
return vlist;
}
void KMReaderWin::displayAboutPage()
{
QVariantHash data;
data[QStringLiteral("version")] = QStringLiteral(KDEPIM_VERSION);
data[QStringLiteral("firstStart")] = kmkernel->firstStart();
QVariantList features;
features.reserve(numKMailNewFeatures);
for (int i = 0; i < numKMailNewFeatures; ++i) {
features.push_back(i18n(kmailNewFeatures[i]));
}
data[QStringLiteral("newFeatures")] = features;
QVariantList changes;
changes.reserve(numKMailChanges);
for (int i = 0; i < numKMailChanges; ++i) {
features.push_back(i18n(kmailChanges[i]));
}
data[QStringLiteral("importantChanges")] = changes;
displaySplashPage(QStringLiteral("introduction_kmail.html"), data);
}
void QRemoteObjectRegistry::initialize()
{
qRegisterMetaType<QRemoteObjectSourceLocation>();
qRegisterMetaTypeStreamOperators<QRemoteObjectSourceLocation>();
qRegisterMetaType<QRemoteObjectSourceLocations>();
qRegisterMetaTypeStreamOperators<QRemoteObjectSourceLocations>();
QVariantList properties;
properties.reserve(3);
properties << QVariant::fromValue(QRemoteObjectSourceLocations());
properties << QVariant::fromValue(QRemoteObjectSourceLocation());
properties << QVariant::fromValue(QRemoteObjectSourceLocation());
setProperties(properties);
}
void ItemTagsScriptable::untag()
{
const auto args = currentArguments();
auto tagName = args.value(0).toString();
if ( args.size() <= 1 ) {
const auto dataValueList = call("selectedItemsData").toList();
if ( tagName.isEmpty() ) {
QStringList allTags;
for (const auto &itemDataValue : dataValueList) {
const auto itemData = itemDataValue.toMap();
allTags.append( ::tags(itemData) );
}
tagName = askRemoveTagName(allTags);
if ( allTags.isEmpty() )
return;
}
QVariantList dataList;
dataList.reserve( dataValueList.size() );
for (const auto &itemDataValue : dataValueList) {
auto itemData = itemDataValue.toMap();
auto itemTags = ::tags(itemData);
if ( removeTag(tagName, &itemTags) )
itemData.insert( mimeTags, itemTags.join(",") );
dataList.append(itemData);
}
call( "setSelectedItemsData", QVariantList() << QVariant(dataList) );
} else {
const auto rows = this->rows(args, 1);
if ( tagName.isEmpty() ) {
QStringList allTags;
for (int row : rows)
allTags.append( this->tags(row) );
tagName = askRemoveTagName(allTags);
if ( allTags.isEmpty() )
return;
}
for (int row : rows) {
auto itemTags = tags(row);
if ( removeTag(tagName, &itemTags) )
setTags(row, itemTags);
}
}
}
QVariantList EventQuery::createDecorationData(const QStringList & item) const
{
Q_UNUSED(item);
QVariantList decorationList;
decorationList.reserve(Max_columns-1);
for(int i = 0; i < Max_columns; i++) {
//TODO: find out if event is also available in akonadi
decorationList.append(QVariant());
}
return decorationList;
}
void
ImporterSqlConnection::slotQuery( const QString &query, const QVariantMap &bindValues,
bool* const ok )
{
Q_ASSERT( this->thread() == ThreadWeaver::Thread::currentThread() );
if( ok != 0 )
*ok = false;
QSqlDatabase db = connection();
if( !db.isOpen() )
return;
QSqlQuery q( db );
q.setForwardOnly( true );
q.prepare( query );
for( QVariantMap::ConstIterator bindValue = bindValues.constBegin();
bindValue != bindValues.constEnd(); ++bindValue )
q.bindValue( bindValue.key(), bindValue.value() );
if( q.exec() )
{
if( ok != 0 )
*ok = true;
m_result.reserve( q.size() );
while( q.next() )
{
const int fields = q.record().count();
QVariantList row;
row.reserve( fields );
for( int field = 0; field < fields; ++field )
row.append( q.value( field ) );
m_result.append( row );
}
}
else
warning() << __PRETTY_FUNCTION__ << q.lastError().text();
// This is a stupid QSqlDatabase connection manager; we don't want to leave connection
// open unless we're inside a transaction.
if( !isTransaction() )
db.close();
}
QByteArray DefaultReminderAttribute::serialized() const
{
QVariantList list;
list.reserve(m_reminders.count());
Q_FOREACH (const ReminderPtr &rem, m_reminders) {
QVariantMap reminder;
if (rem->type() == KCalCore::Alarm::Display) {
reminder[QStringLiteral("type")] = QLatin1String("display");
} else if (rem->type() == KCalCore::Alarm::Email) {
reminder[QStringLiteral("type")] = QLatin1String("email");
}
reminder[QStringLiteral("time")] = rem->startOffset().asSeconds();
list << reminder;
}
void QSListModel::move(int from, int to, int count)
{
if (from > to) {
int f = from;
int t = to;
int c = count;
count = f - t;
from = t;
to = t + c;
}
if (count <= 0 ||
from == to ||
from + count > m_storage.count() ||
to + count > m_storage.count() ||
from < 0 ||
to < 0) {
return;
}
beginMoveRows(QModelIndex(), from, from + count - 1,
QModelIndex(), to > from ? to + count : to);
QVariantList tmp;
tmp.reserve(to - from + count);
// Move "to" block
for (int i=0 ; i < (to - from) ; i++) {
tmp.append(m_storage[from + count + i]);
}
// Move "from" block
for (int i = 0 ; i < count ; i++) {
tmp.append(m_storage[from + i]);
}
// Replace
for (int i=0 ; i < tmp.count() ; ++i) {
m_storage[from + i] = tmp[i];
}
endMoveRows();
}
QVariantList EventQuery::createDisplayData(const QStringList & item) const
{
QVariantList displayList;
displayList.reserve(Max_columns-1);
for(int i = 0; i < Max_columns; i++) {
QVariant newEntry;
switch(i) {
case Column_Date: {
QDateTime date = QDateTime::fromString( item.at(Column_Date), Qt::ISODate);
if(date.isValid()) {
newEntry = date.toString("dd.MM.yyyy");
}
break;
}
case Column_Publication:
{
QString publicationsContent = QLatin1String("<font size=\"85%\">");
publicationsContent.append( item.at(i) );
publicationsContent.chop(5); //last </br>
publicationsContent.append(QLatin1String("</font>"));
newEntry = publicationsContent;
break;
}
case Column_StarRate:
case Column_Title:
newEntry = item.at(i);
break;
default:
newEntry = QVariant();
}
displayList.append(newEntry);
}
return displayList;
}
QVariant DeferredSignal::result()
{
if(!m_argv) {
return QVariant();
}
//legacy from QObjectComWrapper
const QMetaObject *mo = m_method.enclosingMetaObject();
QList<QByteArray> ptypes = m_method.parameterTypes();
int pcount = ptypes.count();
QVariantList result;
result.reserve(pcount);
//prepare arguments
for (int p = 0; p < pcount; ++p) {
bool out;
QByteArray ptype = paramType(ptypes.at(p), &out);
QVariant variant;
if (mo->indexOfEnumerator(ptype) != -1) {
// convert enum values to int
variant = QVariant(*reinterpret_cast<int *>(m_argv[p+1]));
} else {
QVariant::Type vt = QVariant::nameToType(ptype);
if (vt == QVariant::UserType) {
if (ptype.endsWith('*')) {
variant = QVariant(QMetaType::type(ptype), (void**)m_argv[p+1]);
} else {
variant = QVariant(QMetaType::type(ptype), m_argv[p+1]);
}
} else {
variant = QVariant(vt, m_argv[p + 1]);
}
}
result.push_back(variant);
}
return result;
}
QVariantMap QgsRemoveDuplicatesByAttributeAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
std::unique_ptr< QgsProcessingFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
const QStringList fieldNames = parameterAsFields( parameters, QStringLiteral( "FIELDS" ), context );
QgsAttributeList attributes;
for ( const QString &field : fieldNames )
{
const int index = source->fields().lookupField( field );
if ( index < 0 )
feedback->reportError( QObject::tr( "Field %1 not found in INPUT layer, skipping" ).arg( field ) );
else
attributes.append( index );
}
if ( attributes.isEmpty() )
throw QgsProcessingException( QObject::tr( "No input fields found" ) );
QString noDupeSinkId;
std::unique_ptr< QgsFeatureSink > noDupeSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, noDupeSinkId, source->fields(),
source->wkbType(), source->sourceCrs() ) );
if ( !noDupeSink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
QString dupeSinkId;
std::unique_ptr< QgsFeatureSink > dupesSink( parameterAsSink( parameters, QStringLiteral( "DUPLICATES" ), context, dupeSinkId, source->fields(),
source->wkbType(), source->sourceCrs() ) );
const long count = source->featureCount();
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
long long keptCount = 0;
long long discardedCount = 0;
QSet< QVariantList > matched;
QgsFeatureIterator it = source->getFeatures( QgsFeatureRequest(), QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks );
QgsFeature f;
QVariantList dupeKey;
dupeKey.reserve( attributes.size() );
for ( int i : attributes )
{
( void )i;
dupeKey.append( QVariant() );
}
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
int i = 0;
for ( int attr : attributes )
dupeKey[i++] = f.attribute( attr );
if ( matched.contains( dupeKey ) )
{
// duplicate
discardedCount++;
if ( dupesSink )
dupesSink->addFeature( f, QgsFeatureSink::FastInsert );
}
else
{
// not duplicate
keptCount++;
matched.insert( dupeKey );
noDupeSink->addFeature( f, QgsFeatureSink::FastInsert );
}
feedback->setProgress( current * step );
current++;
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "RETAINED_COUNT" ), keptCount );
outputs.insert( QStringLiteral( "DUPLICATE_COUNT" ), discardedCount );
outputs.insert( QStringLiteral( "OUTPUT" ), noDupeSinkId );
if ( dupesSink )
outputs.insert( QStringLiteral( "DUPLICATES" ), dupeSinkId );
return outputs;
}
