void QGeoTiledMappingManagerEngine::updateTileRequests(QGeoTiledMapData *map,
const QSet<QGeoTileSpec> &tilesAdded,
const QSet<QGeoTileSpec> &tilesRemoved)
{
Q_D(QGeoTiledMappingManagerEngine);
typedef QSet<QGeoTileSpec>::const_iterator tile_iter;
// add and remove tiles from tileset for this map
QSet<QGeoTileSpec> oldTiles = d->mapHash_.value(map);
tile_iter rem = tilesRemoved.constBegin();
tile_iter remEnd = tilesRemoved.constEnd();
for (; rem != remEnd; ++rem) {
oldTiles.remove(*rem);
}
tile_iter add = tilesAdded.constBegin();
tile_iter addEnd = tilesAdded.constEnd();
for (; add != addEnd; ++add) {
oldTiles.insert(*add);
}
d->mapHash_.insert(map, oldTiles);
// add and remove map from mapset for the tiles
QSet<QGeoTileSpec> reqTiles;
QSet<QGeoTileSpec> cancelTiles;
rem = tilesRemoved.constBegin();
for (; rem != remEnd; ++rem) {
QSet<QGeoTiledMapData *> mapSet = d->tileHash_.value(*rem);
mapSet.remove(map);
if (mapSet.isEmpty()) {
cancelTiles.insert(*rem);
d->tileHash_.remove(*rem);
} else {
d->tileHash_.insert(*rem, mapSet);
}
}
add = tilesAdded.constBegin();
for (; add != addEnd; ++add) {
QSet<QGeoTiledMapData *> mapSet = d->tileHash_.value(*add);
if (mapSet.isEmpty()) {
reqTiles.insert(*add);
}
mapSet.insert(map);
d->tileHash_.insert(*add, mapSet);
}
cancelTiles -= reqTiles;
QMetaObject::invokeMethod(d->fetcher_, "updateTileRequests",
Qt::QueuedConnection,
Q_ARG(QSet<QGeoTileSpec>, reqTiles),
Q_ARG(QSet<QGeoTileSpec>, cancelTiles));
}
void ItemsListModel::RemoveItems (QSet<IDType_t> ids)
{
if (ids.isEmpty ())
return;
const bool shouldReset = ids.size () > 10;
for (auto i = CurrentItems_.begin ();
i != CurrentItems_.end () && !ids.isEmpty (); )
{
if (!ids.contains (i->ItemID_))
{
++i;
continue;
}
ids.remove (i->ItemID_);
if (!shouldReset)
{
const size_t dist = std::distance (CurrentItems_.begin (), i);
beginRemoveRows (QModelIndex (), dist, dist);
}
i = CurrentItems_.erase (i);
if (!shouldReset)
{
endRemoveRows ();
qApp->processEvents (QEventLoop::ExcludeUserInputEvents);
}
}
if (shouldReset)
reset ();
}
QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManagerPrivate::requestTiles(const QSet<QGeoTileSpec> &tiles)
{
QSet<QGeoTileSpec> cancelTiles = requested_ - tiles;
QSet<QGeoTileSpec> requestTiles = tiles - requested_;
QSet<QGeoTileSpec> cached;
// int tileSize = tiles.size();
// int newTiles = requestTiles.size();
typedef QSet<QGeoTileSpec>::const_iterator iter;
QList<QSharedPointer<QGeoTileTexture> > cachedTex;
QGeoTiledMappingManagerEngine *engine = map_ ?
static_cast<QGeoTiledMappingManagerEngine *>(map_->engine()) : 0;
// remove tiles in cache from request tiles
if (engine) {
iter i = requestTiles.constBegin();
iter end = requestTiles.constEnd();
for (; i != end; ++i) {
QGeoTileSpec tile = *i;
QSharedPointer<QGeoTileTexture> tex = engine->getTileTexture(tile);
if (tex) {
cachedTex << tex;
cached.insert(tile);
}
}
}
requestTiles -= cached;
requested_ -= cancelTiles;
requested_ += requestTiles;
// qDebug() << "required # tiles: " << tileSize << ", new tiles: " << newTiles << ", total server requests: " << requested_.size();
if (!requestTiles.isEmpty() || !cancelTiles.isEmpty()) {
if (engine) {
// qDebug() << "new server requests: " << requestTiles.size() << ", server cancels: " << cancelTiles.size();
engine->updateTileRequests(map_, requestTiles, cancelTiles);
// Remove any cancelled tiles from the error retry hash to avoid
// re-using the numbers for a totally different request cycle.
iter i = cancelTiles.constBegin();
iter end = cancelTiles.constEnd();
for (; i != end; ++i) {
retries_.remove(*i);
futures_.remove(*i);
}
}
}
return cachedTex;
}
void QGeoTiledMappingManagerEngine::engineTileFinished(const QGeoTileSpec &spec, const QByteArray &bytes, const QString &format)
{
Q_D(QGeoTiledMappingManagerEngine);
QSet<QGeoTiledMapData *> maps = d->tileHash_.value(spec);
typedef QSet<QGeoTiledMapData *>::const_iterator map_iter;
map_iter map = maps.constBegin();
map_iter mapEnd = maps.constEnd();
for (; map != mapEnd; ++map) {
QSet<QGeoTileSpec> tileSet = d->mapHash_.value(*map);
tileSet.remove(spec);
if (tileSet.isEmpty())
d->mapHash_.remove(*map);
else
d->mapHash_.insert(*map, tileSet);
}
d->tileHash_.remove(spec);
tileCache()->insert(spec, bytes, format, d->cacheHint_);
map = maps.constBegin();
mapEnd = maps.constEnd();
for (; map != mapEnd; ++map) {
(*map)->getRequestManager()->tileFetched(spec);
}
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
// Activate the Select From Favorites popup
void tSiriusController::SelectFavoriteChannels()
{
bool hasList = RefreshFavoriteChannels(tAudioSettings::Instance()->Favorites()); //if returns false that means we have no subscriptions yet, we're still powering up
if (hasList == true)
{
Assert( m_pFavoriteChannels != 0 );
QSet<int> favoriteSet = QSet<int>::fromList(*m_pFavoriteChannels);
if (favoriteSet.isEmpty())
{
tMessageBox::Error( 0, tr( "Favorites"), tr("No favorites defined"), tMessageBox::CLOSE );
return;
}
const QList<tChannelRecord *>& chanList = GetSubscribedSubsetList(favoriteSet);
SelectFromChannels(chanList, tr("Channels") + QString(" - ") + tr("Favorites"), false); //no favorites column needed for the favorites list (all we'd be able to do is unfavorite them, not sure that is entirely useful?)
}
else
{
tMessageBox::Error( 0, tr( "Favorites"), tr("Still powering up, please try again."), tMessageBox::CLOSE );
}
}
bool TestConfigParser::isKnownSymbol(const QString &symbol)
{
if (knownSymbols.isEmpty()) {
knownSymbols
// If you add a symbol here, add a case for it in
// isDefined() as well.
<< "Q_OS_LINUX"
<< "Q_OS_SOLARIS"
<< "Q_OS_WINCE"
<< "Q_OS_SYMBIAN"
<< "Q_OS_MAC"
<< "Q_OS_WIN"
<< "Q_CC_MSVC"
<< "Q_CC_MSVC32"
<< "Q_CC_MSVC64"
<< "Q_CC_MINGW"
<< "Q_CC_MINGW32"
<< "Q_CC_MINGW64"
<< "Q_CC_INTEL"
<< "Q_CC_INTEL32"
<< "Q_CC_INTEL64"
;
}
return knownSymbols.contains(symbol);
}
int CFrmUserList::ItemUpdateGroup(QSharedPointer<CUserInfo> info)
{
QSet<QString> groups = info->GetGroups();
if(groups.isEmpty())
{
QString szDefaulGroup(tr("My friends"));
groups.insert(szDefaulGroup);
}
for(QSet<QString>::iterator itGroup = groups.begin(); itGroup != groups.end(); itGroup++)
{
QString szGroup = *itGroup;
QStandardItem* lstGroup = NULL;
QMap<QString, QStandardItem*>::iterator it;
it = m_Groups.find(szGroup);
if(m_Groups.end() == it)
{
//新建立组条目
lstGroup = ItemInsertGroup(szGroup);
}
else
lstGroup = it.value();
QList<QStandardItem *> lstItems = NewItemRoster(info);
if(lstItems.isEmpty())
continue;
lstGroup->appendRow(lstItems);
}
return 0;
}
void PlayersListModel::saveSet(const QSet<QString> & set, const QString & suffix)
{
qDebug("saving set");
QString fileName = QString("%1/%2_%3.txt").arg(cfgdir->absolutePath(), m_nickname.toLower(), suffix);
QFile txt(fileName);
// list empty? => rather have no file for the list than an empty one
if (set.isEmpty())
{
if (txt.exists())
{
// try to remove file, if successful we're done here.
if (txt.remove())
return;
}
else
// there is no file
return;
}
if(!txt.open(QIODevice::WriteOnly | QIODevice::Truncate))
return;
QTextStream stream(&txt);
stream.setCodec("UTF-8");
stream << "; this list is used by Hedgewars - do not edit it unless you know what you're doing!" << endl;
foreach(const QString & nick, set.values())
stream << nick << endl;
txt.close();
}
QList<ctkServiceReference> ctkServices::get(const QString& clazz, const QString& filter,
ctkPluginPrivate* plugin) const
{
Q_UNUSED(plugin)
QMutexLocker lock(&mutex);
QListIterator<ctkServiceRegistration>* s = 0;
QList<ctkServiceRegistration> v;
ctkLDAPExpr ldap;
if (clazz.isEmpty())
{
if (!filter.isEmpty())
{
ldap = ctkLDAPExpr(filter);
QSet<QString> matched = ldap.getMatchedObjectClasses();
if (!matched.isEmpty())
{
v.clear();
foreach (QString className, matched)
{
const QList<ctkServiceRegistration>& cl = classServices[className];
v += cl;
}
if (!v.isEmpty())
{
s = new QListIterator<ctkServiceRegistration>(v);
}
else
{
return QList<ctkServiceReference>();
}
}
else
{
FormGenAcceptResult FormGenRecordComposition::acceptsValueImpl(const QVariant &val) const
{
if( variantType(val) != QMetaType::QVariantHash )
return FormGenAcceptResult::reject({}, val);
QVariantHash hash = val.toHash();
QStringList valueStringList;
QSet<QString> processedTags;
for( const auto &elm : mElements ) {
auto elementAccepts = elm.element->acceptsValue(hash.value(elm.tag));
if( ! elementAccepts.acceptable ) {
QString path = elm.tag;
if( ! elementAccepts.path.isEmpty() )
path += QString("/%1").arg(elementAccepts.path);
return FormGenAcceptResult::reject(path, elementAccepts.value);
}
valueStringList.append(FormGenElement::keyStringValuePair(elm.tag, elementAccepts.valueString));
processedTags.insert(elm.tag);
}
QSet<QString> remainingTags = hash.keys().toSet() - processedTags;
if( ! remainingTags.isEmpty() )
return FormGenAcceptResult::reject(*remainingTags.cbegin(),
hash.value(*remainingTags.cbegin()));
return FormGenAcceptResult::accept(val, FormGenElement::objectString(valueStringList));
}
void CntFavoritesView::handleMemberSelection( QSet<QContactLocalId> aIds )
{
if ( aIds.isEmpty() )
{
showPreviousView();
}
else
{
QList<QContactRelationship> memberships;
foreach (QContactLocalId id, aIds) {
QContactId contactId;
contactId.setLocalId(id);
QContactRelationship membership;
membership.setRelationshipType(QContactRelationship::HasMember);
membership.setFirst(mContact->id());
membership.setSecond(contactId);
memberships.append(membership);
}
if (!memberships.isEmpty()) {
getContactManager()->saveRelationships(&memberships, NULL);
}
CntViewParameters viewParameters;
viewParameters.insert(EViewId, favoritesMemberView);
QVariant var;
var.setValue(*mContact);
viewParameters.insert(ESelectedGroupContact, var);
mViewManager->changeView(viewParameters);
}
bool QXmppServerPrivate::routeData(const QString &to, const QByteArray &data)
{
// refuse to route packets to empty destination, own domain or sub-domains
const QString toDomain = QXmppUtils::jidToDomain(to);
if (to.isEmpty() || to == domain || toDomain.endsWith("." + domain))
return false;
if (toDomain == domain) {
// look for a client connection
QList<QXmppIncomingClient*> found;
if (QXmppUtils::jidToResource(to).isEmpty()) {
foreach (QXmppIncomingClient *conn, incomingClientsByBareJid.value(to))
found << conn;
} else {
QXmppIncomingClient *conn = incomingClientsByJid.value(to);
if (conn)
found << conn;
}
// send data
foreach (QXmppStream *conn, found)
QMetaObject::invokeMethod(conn, "sendData", Q_ARG(QByteArray, data));
return !found.isEmpty();
} else if (!serversForServers.isEmpty()) {
bool check;
Q_UNUSED(check);
// look for an outgoing S2S connection
foreach (QXmppOutgoingServer *conn, outgoingServers) {
if (conn->remoteDomain() == toDomain) {
// send or queue data
QMetaObject::invokeMethod(conn, "queueData", Q_ARG(QByteArray, data));
return true;
}
}
// if we did not find an outgoing server,
// we need to establish the S2S connection
QXmppOutgoingServer *conn = new QXmppOutgoingServer(domain, 0);
conn->setLocalStreamKey(QXmppUtils::generateStanzaHash().toLatin1());
conn->moveToThread(q->thread());
conn->setParent(q);
check = QObject::connect(conn, SIGNAL(disconnected()),
q, SLOT(_q_outgoingServerDisconnected()));
Q_UNUSED(check);
// add stream
outgoingServers.insert(conn);
q->setGauge("outgoing-server.count", outgoingServers.size());
// queue data and connect to remote server
QMetaObject::invokeMethod(conn, "queueData", Q_ARG(QByteArray, data));
QMetaObject::invokeMethod(conn, "connectToHost", Q_ARG(QString, toDomain));
return true;
} else {
bool TestConfigParser::isDefined(const QString &symbol)
{
if (definedSymbols.isEmpty()) {
definedSymbols
#ifdef Q_OS_LINUX
<< "Q_OS_LINUX"
#endif
#ifdef Q_OS_SOLARIS
<< "Q_OS_SOLARIS"
#endif
#ifdef Q_OS_WINCE
<< "Q_OS_WINCE"
#endif
#ifdef Q_OS_SYMBIAN
<< "Q_OS_SYMBIAN"
#endif
#ifdef Q_OS_MAC
<< "Q_OS_MAC"
#endif
#ifdef Q_OS_WIN
<< "Q_OS_WIN"
#endif
#ifdef Q_CC_MSVC
<< "Q_CC_MSVC"
#endif
#ifdef Q_CC_MINGW
<< "Q_CC_MINGW"
#endif
#ifdef Q_CC_INTEL
<< "Q_CC_INTEL"
#endif
;
}
return definedSymbols.contains(symbol);
}
void QrsMetamodelLoader::resolveInheritance(QSet<ElementType *> &elements
, const QHash<QPair<ElementType *, ElementType *>, QString> &overridingProperties)
{
// Here we should copy properties, labels and so on from parent subtypes to child subtypes.
// So we should traverse multigraph from starting from parent types, then child ones and so on.
// The situation is a bit more complex because we may have multiple inheritance, then the child node may be
// visited only when all parent properties are already visited.
while (!elements.isEmpty()) {
for (ElementType *child : elements) {
// Checking that all parents are already visited.
bool allParentsAreVisited = true;
for (const qrgraph::Edge *edge : child->outgoingEdges(ElementType::generalizationLinkType)) {
ElementType *parent = static_cast<ElementType *>(edge->end());
if (elements.contains(parent)) {
allParentsAreVisited = false;
break;
}
}
if (allParentsAreVisited) {
elements.remove(child);
for (const qrgraph::Edge *edge : child->outgoingEdges(ElementType::generalizationLinkType)) {
ElementType *parent = static_cast<ElementType *>(edge->end());
inherit(*child, *parent, overridingProperties[qMakePair(child, parent)]);
}
break;
}
}
}
}
int CFrmUserList::UpdateGroup(CRoster* pRoster, QSet<QString> groups)
{
if(groups.isEmpty())
{
QString szDefaulGroup(tr("My friends"));
groups.insert(szDefaulGroup);
}
for(QSet<QString>::iterator itGroup = groups.begin(); itGroup != groups.end(); itGroup++)
{
QString szGroup = *itGroup;
QStandardItem* lstGroup = NULL;
QMap<QString, QStandardItem*>::iterator it;
it = m_Groups.find(szGroup);
if(m_Groups.end() == it)
{
//新建立组条目
/*lstGroup = new QStandardItem(szGroup);
lstGroup->setEditable(false); //禁止双击编辑
m_pModel->appendRow(lstGroup);
m_Groups.insert(szGroup, lstGroup);//*/
lstGroup = InsertGroup(szGroup);
}
else
lstGroup = it.value();
lstGroup->appendRow(pRoster->GetItem());
LOG_MODEL_DEBUG("Roster", "CFrmUserList::UpdateGroup:%s,(%s)",
qPrintable(pRoster->BareJid()),
qPrintable(szGroup));
}
return 0;
}
void FlatToFoldersProxyModel::HandleChanged (const QModelIndex& idx)
{
QSet<QString> newTags = QSet<QString>::fromList (idx.data (RoleTags).toStringList ());
if (newTags.isEmpty ())
newTags << QString ();
QPersistentModelIndex pidx (idx);
QList<FlatTreeItem_ptr> items = Items_.values (pidx);
QSet<QString> oldTags;
Q_FOREACH (FlatTreeItem_ptr item, items)
oldTags << item->Tag_;
QSet<QString> added = QSet<QString> (newTags).subtract (oldTags);
QSet<QString> removed = QSet<QString> (oldTags).subtract (newTags);
QSet<QString> changed = QSet<QString> (newTags).intersect (oldTags);
Q_FOREACH (QString ch, changed)
{
FlatTreeItem_ptr folder = GetFolder (ch);
QList<FlatTreeItem_ptr>& c = folder->C_;
int findex = Root_->C_.indexOf (folder);
QModelIndex fmi = index (findex, 0);
for (int i = 0, size = c.size ();
i < size; ++i)
{
if (c.at (i)->Index_ != pidx)
continue;
emit dataChanged (index (i, 0, fmi),
index (i, columnCount () - 1, fmi));
break;
}
}
QMimeData* EntryModel::mimeData(const QModelIndexList& indexes) const
{
if (indexes.isEmpty()) {
return nullptr;
}
QMimeData* data = new QMimeData();
QByteArray encoded;
QDataStream stream(&encoded, QIODevice::WriteOnly);
QSet<Entry*> seenEntries;
for (const QModelIndex& index : indexes) {
if (!index.isValid()) {
continue;
}
Entry* entry = entryFromIndex(index);
if (!seenEntries.contains(entry)) {
// make sure we don't add entries multiple times when we get indexes
// with the same row but different columns
stream << entry->group()->database()->uuid() << entry->uuid();
seenEntries.insert(entry);
}
}
if (seenEntries.isEmpty()) {
delete data;
return nullptr;
}
else {
data->setData(mimeTypes().at(0), encoded);
return data;
}
}
//-----------------------------------------------------------------------------
//! Called when the channels sub menu is selected, so we can refresh lists
//-----------------------------------------------------------------------------
void tSiriusController::ChannelsSubmenuSelected()
{
//first clear out the subscribed channels
m_SubscribedChannels.clear();
m_SubscribedChannels << m_rSiriusConnector.SubscribedChannelList();
//now fixup the favorites
RefreshFavoriteChannels(tAudioSettings::Instance()->Favorites());
if (m_pFavoriteChannels)
{
QSet<int> favoriteSet = QSet<int>::fromList(*m_pFavoriteChannels);
if (favoriteSet.isEmpty())
{
m_pSelectFromFavoritesAction->setEnabled(false);
}
else
{
m_pSelectFromFavoritesAction->setEnabled(true);
}
}
else
{
m_pSelectFromFavoritesAction->setEnabled(true);
}
}
bool PluginManager::setData (const QModelIndex& index,
const QVariant& data, int role)
{
if (index.column () != 0 ||
role != Qt::CheckStateRole)
return false;
QPluginLoader_ptr loader = AvailablePlugins_.at (index.row ());
if (!data.toBool () &&
PluginContainers_.contains (loader))
{
PluginTreeBuilder builder;
builder.AddObjects (Plugins_);
builder.Calculate ();
QSet<QObject*> oldSet = QSet<QObject*>::fromList (builder.GetResult ());
builder.RemoveObject (loader->instance ());
builder.Calculate ();
const QSet<QObject*>& newSet = QSet<QObject*>::fromList (builder.GetResult ());
oldSet.subtract (newSet);
oldSet.remove (loader->instance ());
if (!oldSet.isEmpty ())
{
QStringList pluginNames;
Q_FOREACH (QObject *obj, oldSet)
{
IInfo *ii = qobject_cast<IInfo*> (obj);
pluginNames << (ii->GetName () + " (" + ii->GetInfo () + ")");
}
void QGeoTiledMappingManagerEngine::engineTileError(const QGeoTileSpec &spec, const QString &errorString)
{
Q_D(QGeoTiledMappingManagerEngine);
QSet<QGeoTiledMapData *> maps = d->tileHash_.value(spec);
typedef QSet<QGeoTiledMapData *>::const_iterator map_iter;
map_iter map = maps.constBegin();
map_iter mapEnd = maps.constEnd();
for (; map != mapEnd; ++map) {
QSet<QGeoTileSpec> tileSet = d->mapHash_.value(*map);
tileSet.remove(spec);
if (tileSet.isEmpty())
d->mapHash_.remove(*map);
else
d->mapHash_.insert(*map, tileSet);
}
d->tileHash_.remove(spec);
for (map = maps.constBegin(); map != mapEnd; ++map) {
(*map)->getRequestManager()->tileError(spec, errorString);
}
emit tileError(spec, errorString);
}
void KStandardItemListWidget::dataChanged(const QHash<QByteArray, QVariant>& current,
const QSet<QByteArray>& roles)
{
Q_UNUSED(current);
m_dirtyContent = true;
QSet<QByteArray> dirtyRoles;
if (roles.isEmpty()) {
dirtyRoles = visibleRoles().toSet();
} else {
dirtyRoles = roles;
}
// The icon-state might depend from other roles and hence is
// marked as dirty whenever a role has been changed
dirtyRoles.insert("iconPixmap");
dirtyRoles.insert("iconName");
QSetIterator<QByteArray> it(dirtyRoles);
while (it.hasNext()) {
const QByteArray& role = it.next();
m_dirtyContentRoles.insert(role);
}
}
void ActionTree::add(ActionGroup* actiongroup)
{
actions_cache.append(actiongroup);
// key
itKey itK = actions.find(actiongroup->key);
if (itK == actions.end()) itK = actions.insert(actiongroup->key, ModeChannelMap());
// mode
QString mode = actiongroup->mode;
if (mode.isEmpty()) mode = QLatin1String(" ");
itMode itM = itK->find(mode);
if (itM == itK->end()) itM = itK->insert(mode, ChannelMap());
// channel
QSet<int> channels;
foreach(unsigned int chan, actiongroup->channels)
channels.insert((int)chan);
if (channels.isEmpty()) channels.insert(-1);
foreach(int channel, channels)
{
itChannel itC = itM->find(channel);
if (itC == itM->end())
{
qDebug() << "ActionTree insert (Mode/Key/Channels):" << actiongroup->mode << actiongroup->key << actiongroup->channels;
itC = itM->insert(channel, actiongroup);
}
else
{
qWarning() << "ActionTree same triggers (Mode/Key/Channels):" << actiongroup->mode << actiongroup->key << actiongroup->channels;
}
}
void QgsConfigParser::appendCRSElementsToLayer( QDomElement& layerElement, QDomDocument& doc, const QStringList &crsList ) const
{
if ( layerElement.isNull() )
{
return;
}
//insert the CRS elements after the title element to be in accordance with the WMS 1.3 specification
QDomElement titleElement = layerElement.firstChildElement( "Title" );
//In case the number of advertised CRS is constrained
QSet<QString> crsSet = supportedOutputCrsSet();
QStringList::const_iterator crsIt = crsList.constBegin();
for ( ; crsIt != crsList.constEnd(); ++crsIt )
{
if ( !crsSet.isEmpty() && !crsSet.contains( *crsIt ) ) //consider epsg output constraint
{
continue;
}
QDomElement crsElement = doc.createElement( "CRS" );
QDomText crsText = doc.createTextNode( *crsIt );
crsElement.appendChild( crsText );
layerElement.insertAfter( crsElement, titleElement );
}
}
QMultimedia::SupportEstimate QGstUtils::hasSupport(const QString &mimeType,
const QStringList &codecs,
const QSet<QString> &supportedMimeTypeSet)
{
if (supportedMimeTypeSet.isEmpty())
return QMultimedia::NotSupported;
QString mimeTypeLowcase = mimeType.toLower();
bool containsMimeType = supportedMimeTypeSet.contains(mimeTypeLowcase);
if (!containsMimeType) {
const char* mimeTypeAlias = getMimeTypeAlias(mimeTypeLowcase);
containsMimeType = supportedMimeTypeSet.contains(mimeTypeAlias);
if (!containsMimeType) {
containsMimeType = supportedMimeTypeSet.contains("video/" + mimeTypeLowcase)
|| supportedMimeTypeSet.contains("video/x-" + mimeTypeLowcase)
|| supportedMimeTypeSet.contains("audio/" + mimeTypeLowcase)
|| supportedMimeTypeSet.contains("audio/x-" + mimeTypeLowcase);
}
}
int supportedCodecCount = 0;
foreach (const QString &codec, codecs) {
QString codecLowcase = codec.toLower();
const char* codecAlias = getCodecAlias(codecLowcase);
if (codecAlias) {
if (supportedMimeTypeSet.contains(codecAlias))
supportedCodecCount++;
} else if (supportedMimeTypeSet.contains("video/" + codecLowcase)
|| supportedMimeTypeSet.contains("video/x-" + codecLowcase)
|| supportedMimeTypeSet.contains("audio/" + codecLowcase)
|| supportedMimeTypeSet.contains("audio/x-" + codecLowcase)) {
supportedCodecCount++;
}
}
void Generator::cloneScreens(KScreen::OutputList &connectedOutputs)
{
ASSERT_OUTPUTS(connectedOutputs);
if (connectedOutputs.isEmpty()) {
return;
}
QSet<QSize> commonSizes;
const QSize maxScreenSize = m_currentConfig->screen()->maxSize();
QList<QSet<QSize>> modes;
Q_FOREACH(const KScreen::OutputPtr &output, connectedOutputs) {
QSet<QSize> modeSizes;
Q_FOREACH(const KScreen::ModePtr &mode, output->modes()) {
const QSize size = mode->size();
if (size.width() > maxScreenSize.width() || size.height() > maxScreenSize.height()) {
continue;
}
modeSizes.insert(mode->size());
}
//If we have nothing to compare against
if (commonSizes.isEmpty()) {
commonSizes = modeSizes;
continue;
}
commonSizes.intersect(modeSizes);
}
void QSGDistanceFieldGlyphCache::populate(const QVector<glyph_t> &glyphs)
{
QSet<glyph_t> referencedGlyphs;
QSet<glyph_t> newGlyphs;
int count = glyphs.count();
for (int i = 0; i < count; ++i) {
glyph_t glyphIndex = glyphs.at(i);
if ((int) glyphIndex >= glyphCount()) {
qWarning("Warning: distance-field glyph is not available with index %d", glyphIndex);
continue;
}
GlyphData &gd = glyphData(glyphIndex);
++gd.ref;
referencedGlyphs.insert(glyphIndex);
if (gd.texCoord.isValid() || m_populatingGlyphs.contains(glyphIndex))
continue;
m_populatingGlyphs.insert(glyphIndex);
if (gd.boundingRect.isEmpty()) {
gd.texCoord.width = 0;
gd.texCoord.height = 0;
} else {
newGlyphs.insert(glyphIndex);
}
}
referenceGlyphs(referencedGlyphs);
if (!newGlyphs.isEmpty())
requestGlyphs(newGlyphs);
}
void WidgetDownloads::removeSelectedEntries()
{
QSet<quint64> downloadIDs;
QModelIndexList selectedRows = this->ui->tblDownloads->selectionModel()->selectedRows();
bool allComplete = true;
for (QListIterator<QModelIndex> i(selectedRows); i.hasNext();)
{
const QModelIndex& index = i.next();
downloadIDs += this->currentDownloadsModel->getDownloadIDs(index).toSet();
if (!this->currentDownloadsModel->isFileComplete(index))
allComplete = false;
}
if (!downloadIDs.isEmpty())
{
if (!allComplete)
{
QMessageBox msgBox(this);
msgBox.setWindowIcon(QIcon(":/icons/ressources/delete.png"));
msgBox.setWindowTitle(tr("Remove selected downloads"));
msgBox.setText(tr("Are you sure to remove the selected downloads? There is one or more unfinished download."));
msgBox.setIcon(QMessageBox::Question);
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Ok);
if (msgBox.exec() == QMessageBox::Ok)
this->coreConnection->cancelDownloads(downloadIDs.toList());
}
else
this->coreConnection->cancelDownloads(downloadIDs.toList());
}
}
void MythCCExtractorPlayer::IngestTeletext(void)
{
TeletextInfo::iterator ttxit = m_ttx_info.begin();
for (; ttxit != m_ttx_info.end(); ++ttxit)
{
typedef QPair<int, int> qpii;
QSet<qpii> updatedPages = (*ttxit).reader->GetUpdatedPages();
if (updatedPages.isEmpty())
continue;
QSet<qpii>::const_iterator it = updatedPages.constBegin();
for (; it != updatedPages.constEnd(); ++it)
{
(*ttxit).reader->SetPage((*it).first, (*it).second);
TeletextSubPage *subpage = (*ttxit).reader->FindSubPage();
if (subpage && subpage->subtitle)
{
IngestSubtitle((*ttxit).subs[(*it).first],
to_string_list(*subpage));
}
}
(*ttxit).reader->ClearUpdatedPages();
}
}
/*!
\internal
*/
void QDirIteratorPrivate::checkAndPushDirectory(const QFileInfo &fileInfo)
{
// If we're doing flat iteration, we're done.
if (!(iteratorFlags & QDirIterator::Subdirectories))
return;
// Never follow non-directory entries
if (!fileInfo.isDir())
return;
// Follow symlinks only when asked
if (!(iteratorFlags & QDirIterator::FollowSymlinks) && fileInfo.isSymLink())
return;
// Never follow . and ..
QString fileName = fileInfo.fileName();
if (QLatin1String(".") == fileName || QLatin1String("..") == fileName)
return;
// No hidden directories unless requested
if (!(filters & QDir::AllDirs) && !(filters & QDir::Hidden) && fileInfo.isHidden())
return;
// Stop link loops
if (!visitedLinks.isEmpty() &&
visitedLinks.contains(fileInfo.canonicalFilePath()))
return;
pushDirectory(fileInfo);
}
/*! Returns an exception rule which has been explicitly set for the event.
Note: if more than one exception rule exists, the order of the rules is undefined, so any one could be returned.*/
QOrganizerRecurrenceRule QOrganizerEvent::exceptionRule() const
{
QSet<QOrganizerRecurrenceRule> exrules = exceptionRules();
if (!exrules.isEmpty())
return *exrules.begin();
return QOrganizerRecurrenceRule();
}
