void BanPair::loadBanPairs() {
AllBanSet.clear();
SecondBanSet.clear();
BanPairSet.clear();
// special cases
QStringList banlist = Config.value("Banlist/Pairs", "").toStringList();
foreach (QString line, banlist) {
QStringList names = line.split("+");
if (names.isEmpty())
continue;
QString first = names.at(0).trimmed();
if (names.length() == 2) {
QString second = names.at(1).trimmed();
if (first.isEmpty())
SecondBanSet.insert(second);
else {
BanPair pair(first, second);
BanPairSet.insert(pair);
}
}
else if (names.length()==1) {
AllBanSet.insert(first);
}
}
void Fixture_Test::channels()
{
Fixture fxi(this);
QLCFixtureDef* fixtureDef = m_doc->fixtureDefCache()->fixtureDef("i-Pix", "BB4");
QVERIFY(fixtureDef != NULL);
QLCFixtureMode* fixtureMode = fixtureDef->modes().last();
QVERIFY(fixtureMode != NULL);
fxi.setFixtureDefinition(fixtureDef, fixtureMode);
QCOMPARE(fxi.channel("red", Qt::CaseInsensitive), quint32(3));
QCOMPARE(fxi.channel("red", Qt::CaseInsensitive, QLCChannel::Intensity), quint32(3));
QCOMPARE(fxi.channel("brown", Qt::CaseInsensitive), QLCChannel::invalid());
QSet <quint32> chs;
chs << 3 << 4 << 21 << 22 << 12 << 13 << 30 << 31;
QCOMPARE(chs, fxi.channels("red", Qt::CaseInsensitive));
QCOMPARE(chs, fxi.channels("red", Qt::CaseInsensitive, QLCChannel::Intensity));
chs.clear();
chs << 5 << 6 << 23 << 24 << 14 << 15 << 32 << 33;
QCOMPARE(chs, fxi.channels("green", Qt::CaseInsensitive));
chs.clear();
QCOMPARE(chs, fxi.channels("green"));
chs.clear();
chs << 7 << 8 << 16 << 17 << 25 << 26 << 34 << 35;
QCOMPARE(chs, fxi.channels("blue", Qt::CaseInsensitive));
chs.clear();
QCOMPARE(chs, fxi.channels("green", Qt::CaseInsensitive, QLCChannel::Colour));
chs.clear();
QCOMPARE(fxi.channels("brown", Qt::CaseInsensitive, QLCChannel::Intensity), chs);
}
void EditPolygonTool::mouseReleased(QGraphicsSceneMouseEvent *event)
{
if (event->button() != Qt::LeftButton)
return;
switch (mMode) {
case NoMode:
if (mClickedHandle) {
QSet<PointHandle*> selection = mSelectedHandles;
const Qt::KeyboardModifiers modifiers = event->modifiers();
if (modifiers & (Qt::ShiftModifier | Qt::ControlModifier)) {
if (selection.contains(mClickedHandle))
selection.remove(mClickedHandle);
else
selection.insert(mClickedHandle);
} else {
selection.clear();
selection.insert(mClickedHandle);
}
setSelectedHandles(selection);
} else if (mClickedObjectItem) {
QSet<MapObjectItem*> selection = mapScene()->selectedObjectItems();
const Qt::KeyboardModifiers modifiers = event->modifiers();
if (modifiers & (Qt::ShiftModifier | Qt::ControlModifier)) {
if (selection.contains(mClickedObjectItem))
selection.remove(mClickedObjectItem);
else
selection.insert(mClickedObjectItem);
} else {
selection.clear();
selection.insert(mClickedObjectItem);
}
mapScene()->setSelectedObjectItems(selection);
updateHandles();
} else if (!mSelectedHandles.isEmpty()) {
// First clear the handle selection
setSelectedHandles(QSet<PointHandle*>());
} else {
// If there is no handle selection, clear the object selection
mapScene()->setSelectedObjectItems(QSet<MapObjectItem*>());
updateHandles();
}
break;
case Selecting:
updateSelection(event);
mapScene()->removeItem(mSelectionRectangle);
mMode = NoMode;
break;
case Moving:
finishMoving(event->scenePos());
break;
}
mMousePressed = false;
mClickedHandle = nullptr;
}
Cell* Grid::getSafestCell() const
{
QSet<Cell*> remainingCells;
// find the most constrained cells (fewest options in domain)
int minimumDomainSize = 100;
for( auto cellIter=cells.begin(); cellIter!=cells.end(); ++cellIter )
{
Cell* cell = *cellIter;
if( cell->value() != Cell::UNKNOWN )
continue;
if( cell->domain().size() < minimumDomainSize ){
minimumDomainSize = cell->domain().size();
remainingCells.clear();
}
if( cell->domain().size() == minimumDomainSize ){
remainingCells.insert(cell);
}
}
// if there are no cells return null, otherwise return a minimum cell
if( remainingCells.size() == 0 )
return nullptr;
else
return remainingCells.values()[0];
}
void tst_QFutureWatcher::progressValueChanged()
{
#ifdef PRINT
qDebug() << "main thread" << QThread::currentThread();
#endif
progressValues.clear();
const int listSize = 20;
QList<int> list = createList(listSize);
QFutureWatcher<void> futureWatcher;
ProgressObject progressObject;
QObject::connect(&futureWatcher, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
#ifdef PRINT
QObject::connect(&futureWatcher, SIGNAL(progressValueChanged(int)), &progressObject, SLOT(printProgress(int)), Qt::DirectConnection );
#endif
QObject::connect(&futureWatcher, SIGNAL(progressValueChanged(int)), &progressObject, SLOT(registerProgress(int)));
futureWatcher.setFuture(QtConcurrent::map(list, mapSleeper));
QTestEventLoop::instance().enterLoop(5);
QVERIFY(!QTestEventLoop::instance().timeout());
futureWatcher.disconnect();
QVERIFY(progressValues.contains(0));
QVERIFY(progressValues.contains(listSize));
}
void HalfEdgeWidget::paintEvent(QPaintEvent *event)
{
if(m_edge != nullptr)
{
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
QSet<Face*>* mySet = new QSet<Face*>;
drawMesh(mySet, m_edge, painter);
mySet->clear();
delete mySet;
}
}
void Fixture_Test::channels()
{
Fixture fxi(this);
QLCFixtureDef* fixtureDef = m_doc->fixtureDefCache()->fixtureDef("i-Pix", "BB4");
QVERIFY(fixtureDef != NULL);
QLCFixtureMode* fixtureMode = fixtureDef->modes().last();
QVERIFY(fixtureMode != NULL);
fxi.setFixtureDefinition(fixtureDef, fixtureMode);
QCOMPARE(fxi.channel(QLCChannel::Intensity, QLCChannel::Red), quint32(3));
QSet <quint32> chs;
chs << 3 << 4 << 21 << 22 << 12 << 13 << 30 << 31;
QCOMPARE(chs, fxi.channels(QLCChannel::Intensity, QLCChannel::Red));
chs.clear();
chs << 5 << 6 << 23 << 24 << 14 << 15 << 32 << 33;
QCOMPARE(chs, fxi.channels(QLCChannel::Intensity, QLCChannel::Green));
chs.clear();
chs << 7 << 8 << 16 << 17 << 25 << 26 << 34 << 35;
QCOMPARE(chs, fxi.channels(QLCChannel::Intensity, QLCChannel::Blue));
chs.clear();
QCOMPARE(chs, fxi.channels(QLCChannel::Colour, QLCChannel::Blue));
}
void tst_iteratekernel::throttling()
{
const int totalIterations = 400;
iterations = 0;
threads.clear();
ThrottleFor f(0, totalIterations);
f.startBlocking();
QCOMPARE((int)iterations, totalIterations);
QCOMPARE(threads.count(), 1);
}
void tst_QtConcurrentIterateKernel::throttling()
{
const int totalIterations = 400;
iterations.store(0);
threads.clear();
ThrottleFor f(0, totalIterations);
f.startBlocking();
QCOMPARE(iterations.load(), totalIterations);
QCOMPARE(threads.count(), 1);
}
bool QgsConfigParser::crsSetForLayer( const QDomElement& layerElement, QSet<QString> &crsSet ) const
{
if ( layerElement.isNull() )
{
return false;
}
crsSet.clear();
QDomNodeList crsNodeList = layerElement.elementsByTagName( "CRS" );
for ( int i = 0; i < crsNodeList.size(); ++i )
{
crsSet.insert( crsNodeList.at( i ).toElement().text() );
}
return true;
}
void ObjectSelectionTool::mouseReleased(QGraphicsSceneMouseEvent *event)
{
if (event->button() != Qt::LeftButton)
return;
switch (mMode) {
case NoMode:
if (mClickedObjectItem) {
QSet<MapObjectItem*> selection = mapScene()->selectedObjectItems();
const Qt::KeyboardModifiers modifiers = event->modifiers();
if (modifiers & (Qt::ShiftModifier | Qt::ControlModifier)) {
if (selection.contains(mClickedObjectItem))
selection.remove(mClickedObjectItem);
else
selection.insert(mClickedObjectItem);
} else {
selection.clear();
selection.insert(mClickedObjectItem);
}
mapScene()->setSelectedObjectItems(selection);
} else {
mapScene()->setSelectedObjectItems(QSet<MapObjectItem*>());
}
break;
case Selecting:
updateSelection(event->scenePos(), event->modifiers());
mapScene()->removeItem(mSelectionRectangle);
mMode = NoMode;
break;
case Moving:
finishMoving(event->scenePos());
break;
case Rotating:
finishRotating(event->scenePos());
break;
}
mMousePressed = false;
mClickedObjectItem = 0;
mClickedCornerHandle = 0;
}
void WrapHexGridTest::neighborhoodTest()
{
// generated by tools/scripts/hexgridder.py
// 00 01 02 03 04 05
// 06 07 08 09 10 11
// 12 13 14 15 16 17
// 18 19 20 21 22 23
// 24 25 26 27 28 29
// 30 31 32 33 34 35
WrapHexGrid<int> grid( QVector<int>() << 6 );
QVector< QPair<int, int> > neighborhood;
QSet<int> testNeighborhoodIndices;
QSet<int> trueNeighborhoodIndices;
QTextStream cout( stdout );
testNeighborhoodIndices.clear();
neighborhood = grid.neighborhood( 2, 0 );
for( int i=0; i<neighborhood.size(); i++ )
testNeighborhoodIndices.insert( neighborhood[i].first );
trueNeighborhoodIndices
<< 24 << 25 << 26
<< 35 << 30 << 31 << 32
<< 4 << 5 << 0 << 1 << 2
<< 10 << 11 << 06 << 07
<< 16 << 17 << 12;
cout << "testNeighborhood: ";
foreach( int index, testNeighborhoodIndices )
cout << index << " ";
cout << endl;
cout << "trueNeighborhood: ";
foreach( int index, trueNeighborhoodIndices )
cout << index << " ";
cout << endl;
QVERIFY2(testNeighborhoodIndices == trueNeighborhoodIndices, "Failure");
}
void tst_QSet::reserve()
{
QSet<int> set;
int n = set.capacity();
QVERIFY(n == 0);
set.reserve(1000);
QVERIFY(set.capacity() >= 1000);
for (int i = 0; i < 500; ++i)
set.insert(i);
QVERIFY(set.capacity() >= 1000);
for (int j = 0; j < 500; ++j)
set.remove(j);
QVERIFY(set.capacity() >= 1000);
set.clear();
QVERIFY(set.capacity() == 0);
}
bool QgsConfigParser::crsSetForLayer( const QDomElement& layerElement, QSet<int>& crsSet ) const
{
if ( layerElement.isNull() )
{
return false;
}
crsSet.clear();
bool intConversionOk;
QDomNodeList crsNodeList = layerElement.elementsByTagName( "CRS" );
for ( int i = 0; i < crsNodeList.size(); ++i )
{
int epsg = crsNodeList.at( i ).toElement().text().remove( 0, 5 ).toInt( &intConversionOk );
if ( intConversionOk )
{
crsSet.insert( epsg );
}
}
return true;
}
QSet<QString> ctkLDAPExpr::getMatchedObjectClasses() const
{
QSet<QString> objClasses;
if (d->m_operator == EQ)
{
if (d->m_attrName.compare(PluginConstants::OBJECTCLASS, Qt::CaseInsensitive) &&
d->m_attrValue.indexOf(WILDCARD) < 0)
{
objClasses.insert( d->m_attrValue );
}
}
else if (d->m_operator == AND)
{
for (int i = 0; i < d->m_args.size( ); i++) {
QSet<QString> r = d->m_args[i].getMatchedObjectClasses();
if ( !r.empty() ) {
if (objClasses.empty()) {
objClasses = r;
} else {
// if AND op and classes in several operands,
// then only the intersection is possible.
objClasses = r;
}
}
}
} else if (d->m_operator == OR) {
for (int i = 0; i < d->m_args.length( ); i++) {
QSet<QString> r = d->m_args[i].getMatchedObjectClasses();
if ( !r.empty() ) {
objClasses += r;
} else {
objClasses.clear();
break;
}
}
}
return objClasses;
}
void initLanguagesSet()
{
//This is one of the two places to insert a new language in the sources (the other one is in fetmainform.cpp).
languagesSet.clear();
languagesSet.insert("en_US");
languagesSet.insert("ar");
languagesSet.insert("bg");
languagesSet.insert("ca");
languagesSet.insert("de");
languagesSet.insert("el");
languagesSet.insert("es");
languagesSet.insert("fr");
languagesSet.insert("hu");
languagesSet.insert("id");
languagesSet.insert("it");
languagesSet.insert("lt");
languagesSet.insert("mk");
languagesSet.insert("ms");
languagesSet.insert("nl");
languagesSet.insert("pl");
languagesSet.insert("ro");
languagesSet.insert("tr");
languagesSet.insert("ru");
languagesSet.insert("fa");
languagesSet.insert("uk");
languagesSet.insert("pt_BR");
languagesSet.insert("da");
languagesSet.insert("si");
languagesSet.insert("sk");
languagesSet.insert("he");
languagesSet.insert("sr");
languagesSet.insert("gl");
languagesSet.insert("vi");
languagesSet.insert("uz");
languagesSet.insert("sq");
languagesSet.insert("zh_CN");
}
void PlayersListModel::loadSet(QSet<QString> & set, const QString & suffix)
{
set.clear();
QString fileName = QString("%1/%2_%3.txt").arg(cfgdir->absolutePath(), m_nickname.toLower(), suffix);
QFile txt(fileName);
if(!txt.open(QIODevice::ReadOnly))
return;
QTextStream stream(&txt);
stream.setCodec("UTF-8");
while(!stream.atEnd())
{
QString str = stream.readLine();
if(str.startsWith(";") || str.isEmpty())
continue;
set.insert(str.trimmed());
}
txt.close();
}
void SceneTreeItemEntity::DoSync(QStandardItem *rootItem, DAVA::Entity *entity)
{
if(NULL != rootItem && NULL != entity)
{
DAVA::int32 i;
QSet<DAVA::Entity *> entitiesSet;
QSet<DAVA::ParticleLayer *> layersSet;
DAVA::ParticleEmitter *emitter = DAVA::GetEmitter(entity);
DAVA::Vector<DAVA::ParticleLayer*> *emitterLayers = NULL;
// remember all entity childs
for(i = 0; i < entity->GetChildrenCount(); ++i)
{
entitiesSet.insert(entity->GetChild(i));
}
// remember all particle layers
if(NULL != emitter)
{
emitterLayers = &emitter->GetLayers();
for(size_t i = 0; i < emitterLayers->size(); ++i)
{
layersSet.insert(emitterLayers->operator[](i));
}
}
// remove items that are not in set
for(int i = 0; i < rootItem->rowCount(); ++i)
{
bool doRemove = true;
SceneTreeItem *childItem = (SceneTreeItem *) rootItem->child(i);
if(childItem->ItemType() == SceneTreeItem::EIT_Entity)
{
SceneTreeItemEntity *entityItem = (SceneTreeItemEntity *) childItem;
if(entitiesSet.contains(entityItem->entity))
{
doRemove = false;
}
}
else if(childItem->ItemType() == SceneTreeItem::EIT_Layer)
{
SceneTreeItemParticleLayer *layerItem = (SceneTreeItemParticleLayer *) childItem;
if(layersSet.contains(layerItem->layer))
{
doRemove = false;
}
}
if(doRemove)
{
rootItem->removeRow(i);
i--;
}
}
entitiesSet.clear();
layersSet.clear();
// add entities
int row = 0;
for(int i = 0; i < entity->GetChildrenCount(); ++i)
{
bool repeatStep;
DAVA::Entity *childEntity = entity->GetChild(i);
do
{
SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row);
DAVA::Entity *itemEntity = SceneTreeItemEntity::GetEntity(item);
repeatStep = false;
// remove items that we already add
while(entitiesSet.contains(itemEntity))
{
rootItem->removeRow(row);
item = (SceneTreeItem *) rootItem->child(row);
itemEntity = SceneTreeItemEntity::GetEntity(item);
}
// append entity that isn't in child items list
if(NULL == item)
{
rootItem->appendRow(new SceneTreeItemEntity(childEntity));
}
else if(childEntity != itemEntity)
{
// now we should decide what to do: remove item or insert it
// calc len until itemEntity will be found in real entity childs
int lenUntilRealEntity = 0;
for(int j = i; j < entity->GetChildrenCount(); ++j)
{
if(entity->GetChild(j) == itemEntity)
{
lenUntilRealEntity = j - i;
break;
}
}
// calc len until current real entity child will be found in current item childs
int lenUntilItem = 0;
for(int j = i; j < rootItem->rowCount(); ++j)
{
SceneTreeItem *itm = (SceneTreeItem *) rootItem->child(j);
DAVA::Entity *itmEn = SceneTreeItemEntity::GetEntity(itm);
if(childEntity == itmEn)
{
lenUntilItem = j - i;
break;
}
}
if(lenUntilRealEntity >= lenUntilItem)
{
rootItem->removeRow(row);
repeatStep = true;
}
else
{
rootItem->insertRow(row, new SceneTreeItemEntity(childEntity));
}
}
else
{
DoSync(item, itemEntity);
}
}
while(repeatStep);
// remember that we add that entity
entitiesSet.insert(childEntity);
row++;
}
// add layers
if(NULL != emitterLayers)
{
for(size_t i = 0; i < emitterLayers->size(); ++i)
{
bool repeatStep;
DAVA::ParticleLayer* childLayer = emitterLayers->operator[](i);
do
{
SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row);
DAVA::ParticleLayer *itemLayer = SceneTreeItemParticleLayer::GetLayer(item);
repeatStep = false;
// remove items that we already add
while(layersSet.contains(itemLayer))
{
rootItem->removeRow(row);
SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row);
DAVA::ParticleLayer *itemLayer = SceneTreeItemParticleLayer::GetLayer(item);
}
if(NULL == item)
{
rootItem->appendRow(new SceneTreeItemParticleLayer(emitter, childLayer));
}
else if(childLayer != itemLayer)
{
// now we should decide what to do: remove layer or insert it
// calc len until itemEntity will be found in real
int lenUntilRealLayer = 0;
for(int j = i; j < (int) emitterLayers->size(); ++j)
{
if(emitterLayers->operator[](j) == itemLayer)
{
lenUntilRealLayer = j - i;
break;
}
}
// calc len until current real entity child will be found in current item childs
int lenUntilItem = 0;
for(int j = i; j < rootItem->rowCount(); ++j)
{
SceneTreeItem *itm = (SceneTreeItem *) rootItem->child(j);
DAVA::ParticleLayer *itmLay = SceneTreeItemParticleLayer::GetLayer(itm);
if(childLayer == itmLay)
{
lenUntilItem = j - i;
break;
}
}
if(lenUntilRealLayer >= lenUntilItem)
{
rootItem->removeRow(row);
repeatStep = true;
}
else
{
rootItem->insertRow(row, new SceneTreeItemParticleLayer(emitter, childLayer));
}
}
else
{
SceneTreeItemParticleLayer::DoSync(item, itemLayer);
}
} while (repeatStep);
row++;
layersSet.insert(childLayer);
}
}
// remove all other rows
if(row < rootItem->rowCount())
{
rootItem->removeRows(row, rootItem->rowCount() - row);
}
}
}
void EasyCliqueNetwork::iterate(int nbIt, int minScore, bool guided)
{
QMap<int, int> scores;
auto toCluster = [&] (int x) {
return x/nbfanals;
};
if (debug) {
debugStates.clear();
QVector<int> fanals;
foreach (const QSet<int>& set, activatedFanals) {
if (!set.isEmpty()) {
fanals.push_back(*set.begin());
}
}
debugStates.push_back(fanals);
//qDebug() << debugStates;
}
for (int it = 0; it < nbIt; it++) {
scores.clear();
//add scores each iteration
foreach (const QSet<int>& set, activatedFanals) {
foreach(int x, set) {
for (int j = 0; j < interConnections[x].size(); j++) {
if (interConnections[x][j]) {
scores[j] += 1;
int destCluster = toCluster(j);
if (!guided || guide.contains(destCluster)) {
activatedFanals[destCluster].insert(j);
}
}
}
}
}
//pick best scores amongs each set
for(int i = 0; i < activatedFanals.size(); i++) {
const QSet<int> & set = activatedFanals[i];
int maxScore = minScore;
QSet<int> newSet;
foreach(int j, set) {
if (scores[j] > maxScore) {
maxScore = scores[j];
newSet.clear();
newSet.insert(j);
} else if (scores[j] == maxScore) {
newSet.insert(j);
}
}
activatedFanals[i] = newSet;
}
if (debug) {
QVector<int> fanals;
foreach (const QSet<int>& set, activatedFanals) {
if (!set.isEmpty()) {
fanals.push_back(*set.begin());
}
}
debugStates.push_back(fanals);
//qDebug() << fanals;
}
}
ThreadCountUser(bool finishImmediately = false)
{
threads.clear();
finishing = finishImmediately;
}
void WrapHexGridTest::neighborTest()
{
// generated by tools/scripts/hexgridder.py
// 00 01 02 03 04 05
// 06 07 08 09 10 11
// 12 13 14 15 16 17
// 18 19 20 21 22 23
// 24 25 26 27 28 29
// 30 31 32 33 34 35
QVector<int> size;
size << 6;
WrapHexGrid<int> grid( size );
QVector<int> neighbors;
QSet<int> testNeighborIndices;
QSet<int> trueNeighborIndices;
QTextStream cout( stdout );
testNeighborIndices.clear();
trueNeighborIndices.clear();
neighbors = grid.neighbors( 7 );
for( int i=0; i<neighbors.size(); i++ )
testNeighborIndices.insert( neighbors[i] );
trueNeighborIndices << 1 << 2 << 6 << 8 << 12 << 13;
cout << "testNeighbors: ";
foreach( int index, testNeighborIndices )
cout << index << " ";
cout << endl;
cout << "trueNeighbors: ";
foreach( int index, trueNeighborIndices )
cout << index << " ";
cout << endl;
QVERIFY2(testNeighborIndices == trueNeighborIndices, "Failure");
testNeighborIndices.clear();
trueNeighborIndices.clear();
neighbors = grid.neighbors( 0 );
for( int i=0; i<neighbors.size(); i++ )
testNeighborIndices.insert( neighbors[i] );
trueNeighborIndices << 1 << 6 << 5 << 11 << 30 << 31;
cout << "testNeighbors: ";
foreach( int index, testNeighborIndices )
cout << index << " ";
cout << endl;
cout << "trueNeighbors: ";
foreach( int index, trueNeighborIndices )
cout << index << " ";
cout << endl;
QVERIFY2(testNeighborIndices == trueNeighborIndices, "Failure");
testNeighborIndices.clear();
trueNeighborIndices.clear();
neighbors = grid.neighbors( 35 );
for( int i=0; i<neighbors.size(); i++ )
testNeighborIndices.insert( neighbors[i] );
trueNeighborIndices << 29 << 34 << 24 << 4 << 5 << 30;
cout << "testNeighbors: ";
foreach( int index, testNeighborIndices )
cout << index << " ";
cout << endl;
cout << "trueNeighbors: ";
foreach( int index, trueNeighborIndices )
cout << index << " ";
cout << endl;
QVERIFY2(testNeighborIndices == trueNeighborIndices, "Failure");
}
void runMultipleRulesTest()
{
ImplicitTagRulesSqliteReader reader;
reader.setAddTopTagOnly(false);
reader.setAllowWordsInvolvedInMultipleRules(false);
reader.open("test-files/io/ImplicitTagRulesSqliteReaderTest/rules.sqlite");
QSet<QString> words;
QSet<QString> ruleWordsInvolved;
bool wordsInvolvedInMultipleRules = false;
Tags tags;
words.insert("Mosque");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("MOSQUE");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("mosque");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("Mustashfa");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("MUSTASHFA");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("mustashfa");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("mosque");
words.insert("Mustashfa");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(2, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(tags.isEmpty());
words.clear();
words.insert("mosque2");
words.insert("Mustashfa");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("mosque 3");
words.insert("Mustashfa");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("alwhdt");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("Mustashfa");
words.insert("alwhdt");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(2, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(tags.isEmpty());
words.clear();
words.insert("Mustashfa alwhdt");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa alwhdt"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(!tags.isEmpty());
words.clear();
words.insert("Mustashfa alwhdt");
words.insert("Mustashfa");
words.insert("alwhdt");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(3, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa alwhdt"));
CPPUNIT_ASSERT(wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(tags.isEmpty());
words.clear();
words.insert("MUSTASHFA ALWHDT");
words.insert("MUSTASHFA");
words.insert("ALWHDT");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(3, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa alwhdt"));
CPPUNIT_ASSERT(wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(tags.isEmpty());
words.clear();
words.insert("mustashfa alwhdt");
words.insert("mustashfa");
words.insert("alwhdt");
tags = reader.getImplicitTags(words, ruleWordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(3, ruleWordsInvolved.size());
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(ruleWordsInvolved.contains("Mustashfa alwhdt"));
CPPUNIT_ASSERT(wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT(tags.isEmpty());
words.clear();
reader.close();
}
void runTagsTest()
{
ImplicitTagRulesSqliteReader reader;
reader.setAddTopTagOnly(false);
reader.setAllowWordsInvolvedInMultipleRules(false);
reader.open("test-files/io/ImplicitTagRulesSqliteReaderTest/rules.sqlite");
QSet<QString> words;
QSet<QString> wordsInvolved;
bool wordsInvolvedInMultipleRules = false;
Tags tags;
words.insert("Mosque");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(2, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "place_of_worship");
CPPUNIT_ASSERT(tags["leisure"] == "park");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("MOSQUE");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(2, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "place_of_worship");
CPPUNIT_ASSERT(tags["leisure"] == "park");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("mosque");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(2, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "place_of_worship");
CPPUNIT_ASSERT(tags["leisure"] == "park");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Mosque"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("mosque2");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(0, tags.size());
CPPUNIT_ASSERT_EQUAL(0, wordsInvolved.size());
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("mosque 3");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(0, tags.size());
CPPUNIT_ASSERT_EQUAL(0, wordsInvolved.size());
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("Eid Prayer Ground");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "place_of_worship");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Eid Prayer Ground"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("Mustashfa");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "hospital");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("alwhdt");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "clinic");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
words.insert("Mustashfa alwhdt");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(1, tags.size());
CPPUNIT_ASSERT(tags["amenity"] == "hospital");
CPPUNIT_ASSERT_EQUAL(1, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Mustashfa alwhdt"));
CPPUNIT_ASSERT(!wordsInvolvedInMultipleRules);
words.clear();
//the AddImplicitlyDerivedTagsPoiVisitor won't pass a word phrase and its constituent
//tokens in the same tags request, but if it did, then it should identify the words as
//belonging to multiple rules
words.insert("Mustashfa");
words.insert("alwhdt");
words.insert("Mustashfa alwhdt");
tags = reader.getImplicitTags(words, wordsInvolved, wordsInvolvedInMultipleRules);
CPPUNIT_ASSERT_EQUAL(0, tags.size());
CPPUNIT_ASSERT_EQUAL(3, wordsInvolved.size());
CPPUNIT_ASSERT(wordsInvolved.contains("Mustashfa"));
CPPUNIT_ASSERT(wordsInvolved.contains("alwhdt"));
CPPUNIT_ASSERT(wordsInvolved.contains("Mustashfa alwhdt"));
CPPUNIT_ASSERT(wordsInvolvedInMultipleRules);
words.clear();
reader.close();
}
void QgsOverlayUtils::resolveOverlaps( const QgsFeatureSource &source, QgsFeatureSink &sink, QgsProcessingFeedback *feedback )
{
int count = 0;
int totalCount = source.featureCount();
if ( totalCount == 0 )
return; // nothing to do here
QgsFeatureId newFid = -1;
QgsWkbTypes::GeometryType geometryType = QgsWkbTypes::geometryType( QgsWkbTypes::multiType( source.wkbType() ) );
QgsFeatureRequest requestOnlyGeoms;
requestOnlyGeoms.setSubsetOfAttributes( QgsAttributeList() );
QgsFeatureRequest requestOnlyAttrs;
requestOnlyAttrs.setFlags( QgsFeatureRequest::NoGeometry );
QgsFeatureRequest requestOnlyIds;
requestOnlyIds.setFlags( QgsFeatureRequest::NoGeometry );
requestOnlyIds.setSubsetOfAttributes( QgsAttributeList() );
// make a set of used feature IDs so that we do not try to reuse them for newly added features
QgsFeature f;
QSet<QgsFeatureId> fids;
QgsFeatureIterator it = source.getFeatures( requestOnlyIds );
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
return;
fids.insert( f.id() );
}
QHash<QgsFeatureId, QgsGeometry> geometries;
QgsSpatialIndex index;
QHash<QgsFeatureId, QList<QgsFeatureId> > intersectingIds; // which features overlap a particular area
// resolve intersections
it = source.getFeatures( requestOnlyGeoms );
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
return;
QgsFeatureId fid1 = f.id();
QgsGeometry g1 = f.geometry();
std::unique_ptr< QgsGeometryEngine > g1engine;
geometries.insert( fid1, g1 );
index.insertFeature( f );
QgsRectangle bbox( f.geometry().boundingBox() );
const QList<QgsFeatureId> ids = index.intersects( bbox );
for ( QgsFeatureId fid2 : ids )
{
if ( fid1 == fid2 )
continue;
if ( !g1engine )
{
// use prepared geometries for faster intersection tests
g1engine.reset( QgsGeometry::createGeometryEngine( g1.constGet() ) );
g1engine->prepareGeometry();
}
QgsGeometry g2 = geometries.value( fid2 );
if ( !g1engine->intersects( g2.constGet() ) )
continue;
QgsGeometry geomIntersection = g1.intersection( g2 );
if ( !sanitizeIntersectionResult( geomIntersection, geometryType ) )
continue;
//
// add intersection geometry
//
// figure out new fid
while ( fids.contains( newFid ) )
--newFid;
fids.insert( newFid );
geometries.insert( newFid, geomIntersection );
QgsFeature fx( newFid );
fx.setGeometry( geomIntersection );
index.insertFeature( fx );
// figure out which feature IDs belong to this intersection. Some of the IDs can be of the newly
// created geometries - in such case we need to retrieve original IDs
QList<QgsFeatureId> lst;
if ( intersectingIds.contains( fid1 ) )
lst << intersectingIds.value( fid1 );
else
lst << fid1;
if ( intersectingIds.contains( fid2 ) )
lst << intersectingIds.value( fid2 );
else
lst << fid2;
intersectingIds.insert( newFid, lst );
//
// update f1
//
QgsGeometry g12 = g1.difference( g2 );
index.deleteFeature( f );
geometries.remove( fid1 );
if ( sanitizeDifferenceResult( g12 ) )
{
geometries.insert( fid1, g12 );
QgsFeature f1x( fid1 );
f1x.setGeometry( g12 );
index.insertFeature( f1x );
}
//
// update f2
//
QgsGeometry g21 = g2.difference( g1 );
QgsFeature f2old( fid2 );
f2old.setGeometry( g2 );
index.deleteFeature( f2old );
geometries.remove( fid2 );
if ( sanitizeDifferenceResult( g21 ) )
{
geometries.insert( fid2, g21 );
QgsFeature f2x( fid2 );
f2x.setGeometry( g21 );
index.insertFeature( f2x );
}
// update our temporary copy of the geometry to what is left from it
g1 = g12;
g1engine.reset();
}
++count;
feedback->setProgress( count / ( double ) totalCount * 100. );
}
// release some memory of structures we don't need anymore
fids.clear();
index = QgsSpatialIndex();
// load attributes
QHash<QgsFeatureId, QgsAttributes> attributesHash;
it = source.getFeatures( requestOnlyAttrs );
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
return;
attributesHash.insert( f.id(), f.attributes() );
}
// store stuff in the sink
for ( auto i = geometries.constBegin(); i != geometries.constEnd(); ++i )
{
if ( feedback->isCanceled() )
return;
QgsFeature outFeature( i.key() );
outFeature.setGeometry( i.value() );
if ( intersectingIds.contains( i.key() ) )
{
const QList<QgsFeatureId> ids = intersectingIds.value( i.key() );
for ( QgsFeatureId id : ids )
{
outFeature.setAttributes( attributesHash.value( id ) );
sink.addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
else
{
outFeature.setAttributes( attributesHash.value( i.key() ) );
sink.addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
}
/**
* Shows the context menu for map objects. The menu allows you to duplicate and
* remove the map objects, or to edit their properties.
*/
void AbstractObjectTool::showContextMenu(MapObjectItem *clickedObjectItem,
QPoint screenPos)
{
QSet<MapObjectItem *> selection = mMapScene->selectedObjectItems();
if (clickedObjectItem && !selection.contains(clickedObjectItem)) {
selection.clear();
selection.insert(clickedObjectItem);
mMapScene->setSelectedObjectItems(selection);
}
if (selection.isEmpty())
return;
const QList<MapObject*> &selectedObjects = mapDocument()->selectedObjects();
const QList<ObjectGroup*> objectGroups = mapDocument()->map()->objectGroups();
QMenu menu;
QAction *duplicateAction = menu.addAction(tr("Duplicate %n Object(s)", "", selection.size()),
this, SLOT(duplicateObjects()));
QAction *removeAction = menu.addAction(tr("Remove %n Object(s)", "", selection.size()),
this, SLOT(removeObjects()));
duplicateAction->setIcon(QIcon(QLatin1String(":/images/16x16/stock-duplicate-16.png")));
removeAction->setIcon(QIcon(QLatin1String(":/images/16x16/edit-delete.png")));
menu.addSeparator();
menu.addAction(tr("Flip Horizontally"), this, SLOT(flipHorizontally()), QKeySequence(tr("X")));
menu.addAction(tr("Flip Vertically"), this, SLOT(flipVertically()), QKeySequence(tr("Y")));
ObjectGroup *objectGroup = RaiseLowerHelper::sameObjectGroup(selection);
if (objectGroup && objectGroup->drawOrder() == ObjectGroup::IndexOrder) {
menu.addSeparator();
menu.addAction(tr("Raise Object"), this, SLOT(raise()), QKeySequence(tr("PgUp")));
menu.addAction(tr("Lower Object"), this, SLOT(lower()), QKeySequence(tr("PgDown")));
menu.addAction(tr("Raise Object to Top"), this, SLOT(raiseToTop()), QKeySequence(tr("Home")));
menu.addAction(tr("Lower Object to Bottom"), this, SLOT(lowerToBottom()), QKeySequence(tr("End")));
}
if (objectGroups.size() > 1) {
menu.addSeparator();
QMenu *moveToLayerMenu = menu.addMenu(tr("Move %n Object(s) to Layer",
"", selectedObjects.size()));
for (ObjectGroup *objectGroup : objectGroups) {
QAction *action = moveToLayerMenu->addAction(objectGroup->name());
action->setData(QVariant::fromValue(objectGroup));
}
}
menu.addSeparator();
QIcon propIcon(QLatin1String(":images/16x16/document-properties.png"));
QAction *propertiesAction = menu.addAction(propIcon,
tr("Object &Properties..."));
// TODO: Implement editing of properties for multiple objects
propertiesAction->setEnabled(selectedObjects.size() == 1);
Utils::setThemeIcon(removeAction, "edit-delete");
Utils::setThemeIcon(propertiesAction, "document-properties");
QAction *action = menu.exec(screenPos);
if (!action)
return;
if (action == propertiesAction) {
MapObject *mapObject = selectedObjects.first();
mapDocument()->setCurrentObject(mapObject);
mapDocument()->emitEditCurrentObject();
return;
}
if (ObjectGroup *objectGroup = action->data().value<ObjectGroup*>()) {
mapDocument()->moveObjectsToGroup(mapDocument()->selectedObjects(),
objectGroup);
}
}
bool AddThr::add(const QStringList &urls, QTreeWidgetItem *parent, const Functions::DemuxersInfo &demuxersInfo, QStringList *existingEntries, bool loadList)
{
const bool displayOnlyFileName = QMPlay2Core.getSettings().getBool("DisplayOnlyFileName");
QTreeWidgetItem *currentItem = parent;
QSet<int> playlistIndexesToSkip;
bool added = false;
if (!loadList && QMPlay2Core.getSettings().getBool("SkipPlaylistsWithinFiles"))
{
// Don't load playlist within other files
const auto e = Playlist::extensions();
for (int i = 0; i < urls.size(); ++i)
{
const QString ext = Functions::fileExt(urls.at(i)).toLower();
if (e.contains(ext))
playlistIndexesToSkip.insert(i);
}
if (playlistIndexesToSkip.count() == urls.count())
playlistIndexesToSkip.clear();
}
for (int i = 0; i < urls.size(); ++i)
{
if (ioCtrl.isAborted())
break;
if (playlistIndexesToSkip.contains(i))
continue;
const QString entryName = QMPlay2Core.getNameForUrl(urls.at(i)); // Get the default entry name - it'll be used if doesn't exist in stream
QString url = Functions::Url(urls.at(i));
int insertChildAt = -1;
if (existingEntries)
{
//For quick group sync only - find where to place the new item
const QString newUrl = url.startsWith("file://") ? url.mid(7) : url;
const QString newFileName = Functions::fileName(newUrl);
const QString filePath = Functions::filePath(newUrl);
const bool newIsDir = QFileInfo(newUrl).isDir();
insertChildAt = existingEntries->count();
for (int i = 0; i < insertChildAt; ++i)
{
const QString fileName = existingEntries->at(i);
const bool isDir = QFileInfo(filePath + fileName).isDir();
if ((newIsDir && !isDir) || (newIsDir == isDir && fileName > newFileName))
{
insertChildAt = i;
break;
}
}
}
QString name;
const Playlist::Entries entries = Playlist::read(url, &name);
if (!name.isEmpty()) //Loading playlist
{
QTreeWidgetItem *playlistParent = currentItem;
if (loadList) //Loading QMPlay2 playlist on startup
pLW.clear(); //This can be executed only from GUI thread!
else
{
const QString groupName = Functions::fileName(url, false);
if (sync != FILE_SYNC)
playlistParent = pLW.newGroup(groupName, url, currentItem, insertChildAt, existingEntries); //Adding a new playlist group
else
{
//Reuse current playlist group
QMetaObject::invokeMethod(this, "changeItemText0", Q_ARG(QTreeWidgetItem *, currentItem), Q_ARG(QString, groupName));
sync = NO_SYNC;
}
}
QTreeWidgetItem *tmpFirstItem = insertPlaylistEntries(entries, playlistParent, demuxersInfo, insertChildAt, existingEntries);
if (!firstItem)
firstItem = tmpFirstItem;
added = !entries.isEmpty();
if (loadList)
break;
}
else if (!loadList)
void CGrid::renderGrid(int type, SKMATRIX *mat, mapView_t *mapView, CSkPainter *pPainter, bool eqOnly)
//////////////////////////////////////////////////////////////////////////////////////////////////////
{
double spc;
double cx, cy;
setSetFont(FONT_GRID, pPainter);
trfGetScreenSize(scrWidth, scrHeight);
QColor col = g_skSet.map.grid[type].color;
pPainter->setPen(col);
pPainter->drawRect(clipSize, clipSize, scrWidth - clipSize * 2, scrHeight - clipSize * 2);
if (type == SMCT_ECL || type == SMCT_ALT_AZM)
{
radec_t rd;
SKPOINT pt;
double sx, sy;
trfGetCenter(sx, sy);
trfConvScrPtToXY(sx, sy, cx, cy);
rd.Ra = cx;
rd.Dec = cy;
precess(&rd.Ra, &rd.Dec, mapView->jd, JD2000);
SKMATRIX matInv;
SKMATRIXInverse(&matInv, mat);
trfRaDecToPointNoCorrect(&rd, &pt, &matInv);
cx = -atan2(pt.w.x, pt.w.z);
cy = atan2(-pt.w.y, sqrt(pt.w.x * pt.w.x + pt.w.z * pt.w.z));
rangeDbl(&cx, R360);
if (type == SMCT_ALT_AZM)
{
cy += cAstro.getAtmRef(cy);
}
}
else
{
double sx, sy;
trfGetCenter(sx, sy);
trfConvScrPtToXY(sx, sy, cx, cy);
if (mapView->coordType == SMCT_RA_DEC && mapView->epochJ2000)
{
precess(&cx, &cy, mapView->jd, JD2000);
}
}
if (mapView->fov > D2R(45)) spc = 10;
else
if (mapView->fov > D2R(10)) spc = 5;
else
if (mapView->fov > D2R(5)) spc = 2;
else
if (mapView->fov > D2R(1)) spc = 1;
else
if (mapView->fov > D2R(0.5)) spc = 0.5;
else
if (mapView->fov > D2R(0.25)) spc = 0.1;
else spc = (0.05);
mSet.clear();
double spcx = spc;
double spcy = spc;
if (qAbs(mapView->y) > D2R(80))
{
spcx *= 40;
}
else
if (qAbs(mapView->y) > D2R(60))
{
spcx *= 5;
}
else
if (qAbs(mapView->y) > D2R(45))
{
spcx *= 2;
}
spcx = CLAMP(spcx, 0.25, 10);
spcy = CLAMP(spcy, 0.25, 10);
double x = R2D(cx - fmod(cx, D2R(spcx)));
double y;
if (cy >= 0)
{
y = R2D(cy - fmod(cy, D2R(spcy)));
}
else
{
y = -(R2D(qAbs(cy) - fmod(qAbs(cy), D2R(spcy))) + spcy);
if (y < -90) y = -90;
}
depth = 0;
ren = 0;
render(type, mat, mapView, pPainter, eqOnly, FROMRA(x), FROMDEC(y), FROMRA(spcx), FROMRA(spcy));
}
/**
* Shows the context menu for map objects. The menu allows you to duplicate and
* remove the map objects, or to edit their properties.
*/
void AbstractObjectTool::showContextMenu(MapObjectItem *clickedObjectItem,
QPoint screenPos)
{
QSet<MapObjectItem *> selection = mMapScene->selectedObjectItems();
if (clickedObjectItem && !selection.contains(clickedObjectItem)) {
selection.clear();
selection.insert(clickedObjectItem);
mMapScene->setSelectedObjectItems(selection);
}
if (selection.isEmpty())
return;
const QList<MapObject*> &selectedObjects = mapDocument()->selectedObjects();
const QList<ObjectGroup*> objectGroups = mapDocument()->map()->objectGroups();
QMenu menu;
QAction *duplicateAction = menu.addAction(tr("Duplicate %n Object(s)", "", selection.size()),
this, SLOT(duplicateObjects()));
QAction *removeAction = menu.addAction(tr("Remove %n Object(s)", "", selection.size()),
this, SLOT(removeObjects()));
duplicateAction->setIcon(QIcon(QLatin1String(":/images/16x16/stock-duplicate-16.png")));
removeAction->setIcon(QIcon(QLatin1String(":/images/16x16/edit-delete.png")));
bool anyTileObjectSelected = std::any_of(selectedObjects.begin(),
selectedObjects.end(),
isTileObject);
if (anyTileObjectSelected) {
auto resetTileSizeAction = menu.addAction(tr("Reset Tile Size"), this, SLOT(resetTileSize()));
resetTileSizeAction->setEnabled(std::any_of(selectedObjects.begin(),
selectedObjects.end(),
isResizedTileObject));
auto changeTileAction = menu.addAction(tr("Replace Tile"), this, SLOT(changeTile()));
changeTileAction->setEnabled(tile());
}
// Create action for replacing an object with a template
auto selectedTemplate = objectTemplate();
auto replaceTemplateAction = menu.addAction(tr("Replace With Template"), this, SLOT(replaceObjectsWithTemplate()));
if (selectedTemplate) {
QString name = QFileInfo(selectedTemplate->fileName()).fileName();
replaceTemplateAction->setText(tr("Replace With Template \"%1\"").arg(name));
} else {
replaceTemplateAction->setEnabled(false);
}
if (selectedObjects.size() == 1) {
MapObject *currentObject = selectedObjects.first();
if (!(currentObject->isTemplateBase() || currentObject->isTemplateInstance())) {
const Cell cell = selectedObjects.first()->cell();
// Saving objects with embedded tilesets is disabled
if (cell.isEmpty() || cell.tileset()->isExternal())
menu.addAction(tr("Save As Template"), this, SLOT(saveSelectedObject()));
}
if (currentObject->isTemplateBase()) { // Hide this operations for template base
duplicateAction->setVisible(false);
removeAction->setVisible(false);
replaceTemplateAction->setVisible(false);
}
}
bool anyIsTemplateInstance = std::any_of(selectedObjects.begin(),
selectedObjects.end(),
[](MapObject *object) { return object->isTemplateInstance(); });
if (anyIsTemplateInstance) {
menu.addAction(tr("Detach"), this, SLOT(detachSelectedObjects()));
auto resetToTemplateAction = menu.addAction(tr("Reset Template Instance(s)"), this, SLOT(resetInstances()));
resetToTemplateAction->setEnabled(std::any_of(selectedObjects.begin(),
selectedObjects.end(),
isChangedTemplateInstance));
}
menu.addSeparator();
menu.addAction(tr("Flip Horizontally"), this, SLOT(flipHorizontally()), QKeySequence(tr("X")));
menu.addAction(tr("Flip Vertically"), this, SLOT(flipVertically()), QKeySequence(tr("Y")));
ObjectGroup *objectGroup = RaiseLowerHelper::sameObjectGroup(selection);
if (objectGroup && objectGroup->drawOrder() == ObjectGroup::IndexOrder) {
menu.addSeparator();
menu.addAction(tr("Raise Object"), this, SLOT(raise()), QKeySequence(tr("PgUp")));
menu.addAction(tr("Lower Object"), this, SLOT(lower()), QKeySequence(tr("PgDown")));
menu.addAction(tr("Raise Object to Top"), this, SLOT(raiseToTop()), QKeySequence(tr("Home")));
menu.addAction(tr("Lower Object to Bottom"), this, SLOT(lowerToBottom()), QKeySequence(tr("End")));
}
if (objectGroups.size() > 1) {
menu.addSeparator();
QMenu *moveToLayerMenu = menu.addMenu(tr("Move %n Object(s) to Layer",
"", selectedObjects.size()));
for (ObjectGroup *objectGroup : objectGroups) {
QAction *action = moveToLayerMenu->addAction(objectGroup->name());
action->setData(QVariant::fromValue(objectGroup));
}
}
menu.addSeparator();
QIcon propIcon(QLatin1String(":images/16x16/document-properties.png"));
QAction *propertiesAction = menu.addAction(propIcon,
tr("Object &Properties..."));
Utils::setThemeIcon(removeAction, "edit-delete");
Utils::setThemeIcon(propertiesAction, "document-properties");
QAction *action = menu.exec(screenPos);
if (!action)
return;
if (action == propertiesAction) {
MapObject *mapObject = selectedObjects.first();
mapDocument()->setCurrentObject(mapObject);
emit mapDocument()->editCurrentObject();
return;
}
if (ObjectGroup *objectGroup = action->data().value<ObjectGroup*>()) {
mapDocument()->moveObjectsToGroup(mapDocument()->selectedObjects(),
objectGroup);
}
}
void resetWidgets()
{
currentWidgetList.clear();
qDeleteAll(currentAuxWidgets);
currentAuxWidgets.clear();
}
void PokePersonal::runCheck()
{
if (!PokemonInfo::Exists(num(), gen())) {
reset();
return;
}
if (!PokemonInfo::AFormesShown(num())) {
num() = num().original();
}
if (gen() <= 2) {
ability() = 0;
nature() = 0;
} else {
AbilityGroup ab = PokemonInfo::Abilities(num(), gen());
if (ability() == 0 || (ability() != ab.ab(2) && ability() != ab.ab(1)))
ability() = ab.ab(0);
}
if (gen().num == 2)
controlGender();
if (!ItemInfo::Exists(item(), gen())) {
item() = 0;
}
for (int i = 0; i < 6; i++)
controlEVs(i);
if (gen() <= 2) {
for (int i = 0; i < 6; i++) {
if (DV(i) >= 15)
setDV(i, 15);
}
}
if (gen().num == 2) {
setEV(SpDefense, EV(SpAttack));
setDV(SpDefense, DV(SpAttack));
}
int avail = PokemonInfo::Gender(num());
if (avail != Pokemon::MaleAndFemaleAvail) {
gender() = avail;
} else if (gender() == Pokemon::Neutral){
gender() = Pokemon::Male;
}
int minLevel = PokemonInfo::AbsoluteMinLevel(num(), gen());
if (MoveSetChecker::enforceMinLevels && level() < minLevel) {
level() = minLevel;
}
QSet<int> invalidMoves;
MoveSetChecker::isValid(num(), gen(), move(0), move(1), move(2), move(3), ability(), gender(), level(), false, &invalidMoves);
while (invalidMoves.size() > 0) {
for (int i = 0; i < 4; i++) {
if (invalidMoves.contains(move(i))) {
setMove(0, i, false);
}
}
invalidMoves.clear();
MoveSetChecker::isValid(num(), gen(), move(0), move(1), move(2), move(3), ability(), gender(), level(), false, &invalidMoves);
}
if (num().pokenum == Pokemon::Keldeo) {
if (move(0) == Move::SecretSword || move(1) == Move::SecretSword || move(2) == Move::SecretSword || move(3) == Move::SecretSword) {
num() = Pokemon::Keldeo_R;
} else {
num() = num().original();
}
}
}
