void mythfile_open_register_callback(const char *pathname, void* object, callback_t func) { m_callbackLock.lock(); QString path(pathname); if (m_fileOpenCallbacks.contains(path)) { // if we already have a callback registered for this path with this // object then remove the callback and return (i.e. end callback) QMutableHashIterator<QString,Callback> it(m_fileOpenCallbacks); while (it.hasNext()) { it.next(); if (object == it.value().m_object) { it.remove(); VERBOSE(VB_PLAYBACK, LOC + QString("Removing fileopen callback for %1").arg(path)); VERBOSE(VB_PLAYBACK, LOC + QString("%1 callbacks remaining") .arg(m_fileOpenCallbacks.size())); m_callbackLock.unlock(); return; } } } Callback new_callback(object, func); m_fileOpenCallbacks.insert(path, new_callback); VERBOSE(VB_PLAYBACK, LOC + QString("Added fileopen callback for %1").arg(path)); VERBOSE(VB_PLAYBACK, LOC + QString("%1 callbacks open") .arg(m_fileOpenCallbacks.size())); m_callbackLock.unlock(); }
void tst_QVersitDocument::testRemoveProperty() { // Remove an empty property. QCOMPARE(mVersitDocument->properties().count(), 0); QVersitProperty property; mVersitDocument->addProperty(property); mVersitDocument->removeProperty(property); QCOMPARE(mVersitDocument->properties().count(), 0); // A full property. property.setName(QLatin1String("TEL")); property.setGroups(QStringList(QLatin1String("HOME"))); QMultiHash<QString, QString> params; params.insert(QLatin1String("TYPE"), QLatin1String("HOME")); property.setParameters(params); property.setValue(QLatin1String("123")); mVersitDocument->addProperty(property); QCOMPARE(mVersitDocument->properties().count(), 1); QVersitProperty property2; property2.setName(QLatin1String("TEL")); // Remove with a partial property fails. mVersitDocument->removeProperty(property2); QCOMPARE(mVersitDocument->properties().count(), 1); property2.setGroups(QStringList(QLatin1String("HOME"))); property2.setParameters(params); property2.setValue(QLatin1String("123")); // Remove with a fully specified property succeeds. mVersitDocument->removeProperty(property2); QCOMPARE(mVersitDocument->properties().count(), 0); }
void CDspVmAutoTaskManagerBase::Init() { WRITE_TRACE( DBG_DEBUG, "Initializing %s manager", getManagerName() ); QMultiHash<QString , SmartPtr<CVmConfiguration> > hashAllVms = CDspService::instance()->getVmDirHelper().getAllVmList(); QMultiHash<QString , SmartPtr<CVmConfiguration> >::iterator it; for(it = hashAllVms.begin(); it != hashAllVms.end(); ++it) { SmartPtr<CVmConfiguration> pVmConfig = it.value(); PRL_ASSERT(pVmConfig); if (isEnabled(pVmConfig, true)) { PRL_RESULT res = tryToRegisterVm(pVmConfig, it.key()); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, "Can't register VM %s in Auto-task Manager during starting dispetcher." "Error: 0x%x, (%s).", QSTR2UTF8(pVmConfig->getVmIdentification()->getVmUuid()), res, PRL_RESULT_TO_STRING(res) ); } } m_bInitialized = true; }
bool ProjectCollection::addProject(const QString& name, const QString& author, const QString& description, const QMultiHash<int, QString> & users) { if (!k->db->exists(name)) { if (!k->projects.contains(name)) { QMultiHash<SProject::UserType, QString> newusers; foreach (int type, users.uniqueKeys()) { foreach (QString login, users.values(type)) newusers.insert( SProject::UserType(type), login); } if (newusers.values(SProject::Owner).empty()) return false; SProject *project = new SProject( kAppProp->cacheDir() +"/"+ k->db->nextFileName()); project->setProjectName(name); project->setAuthor(author); project->setDescription(description); bool okAddProject = false; project->setUsers(newusers); bool okSaveProject = project->save(); if (okSaveProject) okAddProject = k->db->addProject(project); delete project; return okAddProject; } }
void CodeAtlas::FuzzyDependBuilder::buildProjDepend( const SymbolNode::Ptr& proj ) { QList<SymbolNode::Ptr> globalSymList; SymbolTree::getGlobalSymbols(proj, globalSymList); ProjectAttr::Ptr projAttr = proj->getOrAddAttr<ProjectAttr>(); projAttr->setGlobalSymList(globalSymList); QMultiHash<QString, ChildPack> childList; bool* isNonVar = new bool[globalSymList.size()]; for (int ithGloSym = 0; ithGloSym < globalSymList.size(); ++ithGloSym) { ChildPack p; SymbolNode::Ptr pSym = globalSymList[ithGloSym]; pSym->getOrAddAttr<GlobalSymAttr>(); p.m_info = pSym->getSymInfo(); p.m_code = collectFuzzyDepend(pSym); p.m_pNode = pSym; p.m_index = ithGloSym; childList.insertMulti(p.m_info.name(), p); isNonVar[ithGloSym] = (p.m_info.elementType() & SymbolInfo::Variable) == 0; } FuzzyDependAttr::Ptr pAttr = proj->getOrAddAttr<FuzzyDependAttr>(); buildChildDepend(childList,pAttr->vtxEdgeMatrix(), pAttr->edgeWeightVector(), pAttr->dependPairList()); buildSubGraphLevel(pAttr->vtxEdgeMatrix(), isNonVar, globalSymList.size(), pAttr->levelVector()); delete[] isNonVar; }
/*! * \brief The OfflineMessageManager::offlineMessageManagerReply method parse an offline message query an return response * \param iqXML * \param iqFrom * \return QByteArray */ QByteArray OfflineMessageManager::offlineMessageManagerReply(QDomDocument document, QString iqFrom) { QString id = document.documentElement().attribute("id", Utils::generateId()); QString offlineFirstChildTagName = document.documentElement().firstChildElement().firstChildElement().tagName(); if (offlineFirstChildTagName == "fetch") { QMultiHash<QString, QByteArray> messageList = getAllOfflineMessage(Utils::getBareJid(iqFrom)); QList<QString> keyList = messageList.keys(); QByteArray allMessages; foreach (QString key, keyList) { QDomDocument document; document.setContent(messageList.value(key)); QDomElement offlineElement = document.createElement("offline"); offlineElement.setAttribute("xmlns", "http://jabber.org/protocol/offline"); QDomElement item = document.createElement("item"); item.setAttribute("node", key); offlineElement.appendChild(item); document.documentElement().appendChild(offlineElement); allMessages += document.toByteArray(); }
void searchInCoordinateIndex(QString const &pathToIndex, QString const &pathToCoordinateIndex) { IndexLoader loader(pathToIndex); QMultiHash<QString, QString> hashTable = loader.loadedIndex(); if (hashTable.isEmpty()) { qDebug() << "Index is not loaded"; } CoordinateIndexLoader coordinateLoader(pathToCoordinateIndex); QHash<QString, QMultiHash<QString, QString>> coordinateHashTable = coordinateLoader.loadedIndex(); if (coordinateHashTable.isEmpty()) { qDebug() << "Coordinate index is not loaded"; } qDebug() << "Requests: \n"; QString line = ""; Searcher search(hashTable); CoordinateIndexSearcher coordinateSearch(coordinateHashTable); QTextStream in(stdin); in.setCodec(QTextCodec::codecForName("IBM 866")); do { line = in.readLine(); if (line != ":q") { QStringList result = search.processRequest(line); coordinateSearch.processRequest(result, line); } } while (line != ":q"); }
QStringList createSuffixesList() { QStringList list; list.append( PartOfSpeechCategories.values( suffix ) ); list.append( PartOfSpeechCategories.values( nounSuffix ) ); return list; }
QStringList createExpressionsList() { QStringList list; list.append( PartOfSpeechCategories.values( expression ) ); list.append( PartOfSpeechCategories.values( idiomaticExpression ) ); return list; }
// Return the current class info list. QList<ClassInfo> qpycore_get_class_info_list() { PyFrameObject *frame = PyEval_GetFrame(); QList<ClassInfo> class_info_list = class_info_hash.values(frame); class_info_hash.remove(frame); return class_info_list; }
void XKCommon::saveClusters(QDataStream&stream,SuperVoxelClusters&clusters) { QMultiHash<uint32_t,QByteArray> qClusters; foreach (SuperVoxelClusters::value_type v, clusters) { QByteArray data; QDataStream stream(&data,QIODevice::WriteOnly); saveSuperVoxel(stream,*v.second); qClusters.insert(v.first,data); }
void CodeAtlas::FuzzyDependBuilder::buildChildDepend( QMultiHash<QString, ChildPack>& childList , Eigen::SparseMatrix<double>& vtxEdgeMat, Eigen::VectorXd& edgeWeightVec, QList<FuzzyDependAttr::DependPair>& dependPair) { QStringList codeList; QVector<ChildPack*> childPackPtr; for (QMultiHash<QString, ChildPack>::Iterator pChild = childList.begin(); pChild != childList.end(); ++pChild) { codeList.push_back(pChild.value().m_code); childPackPtr.push_back(&pChild.value()); } std::vector<Triplet> tripletArray; QVector<double> edgeWeightArray; // add dependency edges between child nodes int ithSrc = 0; for (QMultiHash<QString, ChildPack>::Iterator pChild = childList.begin(); pChild != childList.end(); ++pChild, ++ithSrc) { // for each child, find number of occurrences of this child's name ChildPack& srcChild = pChild.value(); const QString& srcName = pChild.key(); QVector<int> occurence; WordExtractor::findOccurrence(srcName, codeList, occurence); for (int ithTar = 0; ithTar < childPackPtr.size(); ++ithTar) { int nOccur = occurence[ithTar]; if (nOccur == 0 || ithTar == ithSrc) continue; ChildPack& tarChild = *childPackPtr[ithTar]; SymbolEdge::Ptr pEdge = SymbolTree::getOrAddEdge(srcChild.m_pNode, tarChild.m_pNode, SymbolEdge::EDGE_FUZZY_DEPEND); pEdge->clear(); pEdge->strength() = nOccur; int nEdge = tripletArray.size()/2; tripletArray.push_back(Triplet(srcChild.m_index, nEdge ,1.0)); tripletArray.push_back(Triplet(tarChild.m_index, nEdge ,-1.0)); edgeWeightArray.push_back(nOccur); dependPair.push_back(FuzzyDependAttr::DependPair(srcChild.m_pNode, tarChild.m_pNode, nOccur)); } } if (int nEdges = tripletArray.size()/2) { vtxEdgeMat.resize(childList.size(),nEdges); vtxEdgeMat.setFromTriplets(tripletArray.begin(), tripletArray.end()); edgeWeightVec.resize(nEdges); memcpy(edgeWeightVec.data(), edgeWeightArray.data(), sizeof(double)* nEdges); } }
Component xapianDocToComponent(Xapian::Document document) { Component component; // kind QString kindString = value (document, XapianValues::TYPE); component.setKind(Component::stringToKind(kindString)); // Identifier QString id = value(document, XapianValues::IDENTIFIER); component.setId(id); // Component name QString name = value(document,XapianValues::CPTNAME); component.setName(name); // Package name QStringList packageNames = value(document,XapianValues::PKGNAME).split("\n",QString::SkipEmptyParts); component.setPackageNames(packageNames); // URLs QString concatUrlStrings = value(document, XapianValues::URLS); QStringList urlStrings = concatUrlStrings.split('\n',QString::SkipEmptyParts); if(urlStrings.size() %2 == 0) { QMultiHash<Component::UrlKind, QUrl> urls; for(int i = 0; i < urlStrings.size(); i=i+2) { Component::UrlKind ukind = Component::stringToUrlKind(urlStrings.at(i)); QUrl url = QUrl::fromUserInput(urlStrings.at(i+1)); urls.insertMulti(ukind, url); } component.setUrls(urls); } else { qWarning("Bad url strings for component: '%s' (%s)", qPrintable(id), qPrintable(concatUrlStrings)); } // Provided items QString concatProvides = value(document, XapianValues::PROVIDED_ITEMS); QStringList providesList = concatProvides.split('\n',QString::SkipEmptyParts); QList<Provides> provideslist; Q_FOREACH(const QString& string, providesList) { QStringList providesParts = string.split(';',QString::SkipEmptyParts); if(providesParts.size() < 2) { qWarning("Bad component parts for component: '%s' (%s)", qPrintable(id), qPrintable(string)); continue; } QString kindString = providesParts.takeFirst(); Provides::Kind kind = Provides::stringToKind(kindString); Provides provides; provides.setKind(kind); QString value = providesParts.takeFirst(); provides.setValue(value); QString extraData = providesParts.join(";"); provides.setExtraData(extraData); provideslist << provides; }
SessionsManagerDialog::SessionsManagerDialog(QWidget *parent) : Dialog(parent), m_ui(new Ui::SessionsManagerDialog) { m_ui->setupUi(this); m_ui->openInExistingWindowCheckBox->setChecked(SettingsManager::getValue(SettingsManager::Sessions_OpenInExistingWindowOption).toBool()); const QStringList sessions(SessionsManager::getSessions()); QMultiHash<QString, SessionInformation> information; for (int i = 0; i < sessions.count(); ++i) { const SessionInformation session(SessionsManager::getSession(sessions.at(i))); information.insert((session.title.isEmpty() ? tr("(Untitled)") : session.title), session); } QStandardItemModel *model(new QStandardItemModel(this)); model->setHorizontalHeaderLabels(QStringList({tr("Title"), tr("Identifier"), tr("Windows")})); const QList<SessionInformation> sorted(information.values()); const QString currentSession(SessionsManager::getCurrentSession()); int row(0); for (int i = 0; i < sorted.count(); ++i) { int windows(0); for (int j = 0; j < sorted.at(i).windows.count(); ++j) { windows += sorted.at(i).windows.at(j).windows.count(); } if (sorted.at(i).path == currentSession) { row = i; } QList<QStandardItem*> items({new QStandardItem(sorted.at(i).title.isEmpty() ? tr("(Untitled)") : sorted.at(i).title), new QStandardItem(sorted.at(i).path), new QStandardItem(tr("%n window(s) (%1)", "", sorted.at(i).windows.count()).arg(tr("%n tab(s)", "", windows)))}); items[0]->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); items[1]->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); items[2]->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); model->appendRow(items); } m_ui->sessionsViewWidget->setModel(model); connect(m_ui->openButton, SIGNAL(clicked()), this, SLOT(openSession())); connect(m_ui->deleteButton, SIGNAL(clicked()), this, SLOT(deleteSession())); connect(m_ui->sessionsViewWidget, SIGNAL(needsActionsUpdate()), this, SLOT(updateActions())); m_ui->sessionsViewWidget->setCurrentIndex(m_ui->sessionsViewWidget->getIndex(row, 0)); }
void MainWindow::menuSessionsAboutToShow() { if (m_sessionsGroup) { m_sessionsGroup->deleteLater(); QAction *saveSessionAction = m_ui->menuSessions->actions().at(0); saveSessionAction->setParent(this); QAction *manageSessionsAction = m_ui->menuSessions->actions().at(1); manageSessionsAction->setParent(this); m_ui->menuSessions->clear(); m_ui->menuSessions->addAction(saveSessionAction); m_ui->menuSessions->addAction(manageSessionsAction); m_ui->menuSessions->addSeparator(); } m_sessionsGroup = new QActionGroup(this); m_sessionsGroup->setExclusive(true); const QStringList sessions = SessionsManager::getSessions(); QMultiHash<QString, SessionInformation> information; for (int i = 0; i < sessions.count(); ++i) { const SessionInformation session = SessionsManager::getSession(sessions.at(i)); information.insert((session.title.isEmpty() ? tr("(Untitled)") : session.title), session); } const QList<SessionInformation> sorted = information.values(); const QString currentSession = SessionsManager::getCurrentSession(); for (int i = 0; i < sorted.count(); ++i) { int windows = 0; for (int j = 0; j < sorted.at(i).windows.count(); ++j) { windows += sorted.at(i).windows.at(j).windows.count(); } QAction *action = m_ui->menuSessions->addAction(tr("%1 (%n tab(s))", "", windows).arg(sorted.at(i).title.isEmpty() ? tr("(Untitled)") : QString(sorted.at(i).title).replace(QLatin1Char('&'), QLatin1String("&&")))); action->setData(sorted.at(i).path); action->setCheckable(true); action->setChecked(sorted.at(i).path == currentSession); m_sessionsGroup->addAction(action); } }
int QxtRPCServiceIntrospector::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { // Qt's signal dispatch mechanism invokes qt_metacall for each slot connected to the object. // The metacall protocol expects slots to be checked from the bottom up, starting with QObject and proceeding to // the more derived classes. qt_metacall returns a negative number to indicate that the request was processed or a // positive number to indicate the greatest method ID that was checked. moc-generated qt_metacall implementations // subtract the return value from _id so that slots on a given class can be counted starting at 0, allowing the // subclasses to add new signals or slots without breaking compatibility. QxtRPCService doesn't need this because // it just asks its base class how many methods it has before adding slots. if(QObject::qt_metacall(_c, _id, _a) < 0) return _id; // qt_metacall is also used for other behaviors besides just invoking methods; we don't implement any of these, so // we just return here. if(_c != QMetaObject::InvokeMetaMethod) return _id; // Construct an array of QVariants based on the parameters passed through _a. QVariant v[8]; const QList<int>& types = signalParameters.at(idToParams.value(_id)); int ct = types.count(); for(int i = 0; i < ct; i++) { // The qt_metacall implementation is expected to already know the data types in _a, so that's why we tracked it. v[i] = QVariant(types.at(i), _a[i+1]); } foreach(const QString& rpcName, idToRpc.values(_id)) { // Invoke each RPC message connected to the requested dynamic slot ID. rpc->call(rpcName, v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]); } // Inform the calling function that we handled the call. return -1; }
SessionsManagerDialog::SessionsManagerDialog(QWidget *parent) : Dialog(parent), m_ui(new Ui::SessionsManagerDialog) { m_ui->setupUi(this); m_ui->openInExistingWindowCheckBox->setChecked(SettingsManager::getValue(QLatin1String("Sessions/OpenInExistingWindow")).toBool()); const QStringList sessions = SessionsManager::getSessions(); QMultiHash<QString, SessionInformation> information; for (int i = 0; i < sessions.count(); ++i) { const SessionInformation session = SessionsManager::getSession(sessions.at(i)); information.insert((session.title.isEmpty() ? tr("(Untitled)") : session.title), session); } const QList<SessionInformation> sorted = information.values(); const QString currentSession = SessionsManager::getCurrentSession(); int index = 0; m_ui->sessionsWidget->setRowCount(sorted.count()); for (int i = 0; i < sorted.count(); ++i) { int windows = 0; for (int j = 0; j < sorted.at(i).windows.count(); ++j) { windows += sorted.at(i).windows.at(j).windows.count(); } if (sorted.at(i).path == currentSession) { index = i; } m_ui->sessionsWidget->setItem(i, 0, new QTableWidgetItem(sorted.at(i).title.isEmpty() ? tr("(Untitled)") : sorted.at(i).title)); m_ui->sessionsWidget->setItem(i, 1, new QTableWidgetItem(sorted.at(i).path)); m_ui->sessionsWidget->setItem(i, 2, new QTableWidgetItem(QStringLiteral("%1 (%2)").arg(sorted.at(i).windows.count()).arg(windows))); } connect(m_ui->openButton, SIGNAL(clicked()), this, SLOT(openSession())); connect(m_ui->deleteButton, SIGNAL(clicked()), this, SLOT(deleteSession())); connect(m_ui->sessionsWidget, SIGNAL(currentCellChanged(int,int,int,int)), this, SLOT(currentChanged(int))); m_ui->sessionsWidget->setCurrentCell(index, 0); }
QList<Action *> Menu::findActions(const QMultiHash<int, QVariant> AData, bool ASearchInSubMenu /*= false*/) const { QList<Action *> actionList; QList<int> keys = AData.keys(); foreach(Action *action,FActions) { foreach (int key, keys) { if (AData.values(key).contains(action->data(key))) { actionList.append(action); break; } } if (ASearchInSubMenu && action->menu()) actionList += action->menu()->findActions(AData,ASearchInSubMenu); }
void tst_QVersitProperty::testParameters() { QString typeParameterName(QLatin1String("TYPE")); QString name(QLatin1String("type")); QString value1(QLatin1String("home")); mVersitProperty->insertParameter(name,value1); QMultiHash<QString,QString> parameters = mVersitProperty->parameters(); QCOMPARE(parameters.count(), 1); QVERIFY(parameters.contains(typeParameterName,QLatin1String("home"))); QString value2(QLatin1String("voice")); mVersitProperty->insertParameter(name,value2); parameters = mVersitProperty->parameters(); QCOMPARE(parameters.count(), 2); QVERIFY(parameters.contains(typeParameterName,QLatin1String("home"))); QVERIFY(parameters.contains(typeParameterName,QLatin1String("voice"))); mVersitProperty->removeParameter(name,value1); QCOMPARE(mVersitProperty->parameters().count(), 1); QVERIFY(parameters.contains(typeParameterName,QLatin1String("home"))); mVersitProperty->removeParameter(name,value2); QCOMPARE(mVersitProperty->parameters().count(), 0); mVersitProperty->insertParameter(name, value1); mVersitProperty->insertParameter(name, value2); QCOMPARE(mVersitProperty->parameters().count(), 2); mVersitProperty->removeParameters(name); QCOMPARE(mVersitProperty->parameters().count(), 0); }
QStringList createVerbsList() { QStringList list; list.append( PartOfSpeechCategories.values( verb ) ); list.append( IchidanVerbs ); list.append( GodanVerbs ); list.append( FukisokuVerbs ); return list; }
bool QVCardRestoreHandler::propertyProcessed( const QVersitProperty& property, QList<QContactDetail>* updatedDetails) { bool success = false; QString group; if (!property.groups().isEmpty()) group = property.groups().first(); if (property.name() == PropertyName) { if (property.groups().size() != 1) return false; QMultiHash<QString, QString> parameters = property.parameters(); QContactDetail::DetailType detailType = QContactDetail::DetailType(parameters.value(DetailTypeParameter).toUInt()); QString fieldName = parameters.value(FieldParameter); // Find a detail previously seen with the same definitionName, which was generated from // a property from the same group QContactDetail detail(detailType); foreach (const QContactDetail& previousDetail, mDetailGroupMap.detailsInGroup(group)) { if (previousDetail.type() == detailType) { detail = previousDetail; } } // If not found, it's a new empty detail with the definitionName set. detail.setValue(fieldName.toInt(), deserializeValue(property)); // Replace the equivalent detail in updatedDetails with the new one QMutableListIterator<QContactDetail> it(*updatedDetails); while (it.hasNext()) { if (it.next().key() == detail.key()) { it.remove(); break; } } updatedDetails->append(detail); success = true; } if (!group.isEmpty()) { // Keep track of which details were generated from which Versit groups foreach (const QContactDetail& detail, *updatedDetails) { mDetailGroupMap.insert(group, detail); } }
MergeConfirmationDialog::MergeConfirmationDialog(DatabaseManager* dbm, const QList<long long>& BIDs, OutParams* outParams, QWidget* parent) : QDialog(parent), ui(new Ui::MergeConfirmationDialog), dbm(dbm), canShowTheDialog(false), outParams(outParams) { ui->setupUi(this); QStringList bookmarkNames; QMultiHash<long long, QString> bookmarkURLs; canShowTheDialog = dbm->bms.RetrieveBookmarkNames(BIDs, bookmarkNames); if (!canShowTheDialog) return; canShowTheDialog = dbm->bms.RetrieveBookmarkFullURLs(BIDs, bookmarkURLs); if (!canShowTheDialog) return; radioContext = new RichRadioButtonContext(); for (int i = 0; i < BIDs.count(); i++) { long long BID = BIDs[i]; //Create formatted URLs for display. //Reverse the urls to get the original order, as QMultiHash docs say: // "The items that share the same key are available from most recently to least recently inserted." QStringList urls = bookmarkURLs.values(BID); std::reverse(urls.begin(), urls.end()); QString urlsSeparated = ""; const QString sep = ""; foreach (const QString& url, urls) urlsSeparated += "<li style=\"color: blue;\">" + Util::FullyPercentDecodedUrl(url).toHtmlEscaped() + "</li>" + sep; urlsSeparated.chop(sep.length()); QString radioText = QString("<strong>%1</strong>\n<ul>%2</ul>").arg(bookmarkNames[i], urlsSeparated); RichRadioButton* bmRadio = new RichRadioButton(radioText, BID, (i == 0), radioContext); ui->mainVerticalLayout->insertWidget(ui->mainVerticalLayout->count() -2, bmRadio); } }
void ContextManager::setFixtureSelection(quint32 fxID, bool enable) { if (m_selectedFixtures.contains(fxID)) { if (enable == false) m_selectedFixtures.removeAll(fxID); else return; } else { if (enable) m_selectedFixtures.append(fxID); else return; } if (m_DMXView->isEnabled()) m_DMXView->updateFixtureSelection(fxID, enable); if (m_2DView->isEnabled()) m_2DView->updateFixtureSelection(fxID, enable); QMultiHash<int, SceneValue> channels = m_fixtureManager->setFixtureCapabilities(fxID, enable); if(channels.keys().isEmpty()) return; qDebug() << "[ContextManager] found" << channels.keys().count() << "capabilities"; QHashIterator<int, SceneValue>it(channels); while(it.hasNext()) { it.next(); quint32 chType = it.key(); SceneValue sv = it.value(); if (enable) m_channelsMap.insert(chType, sv); else m_channelsMap.remove(chType, sv); } emit selectedFixturesChanged(); }
QDebug operator<<(QDebug dbg, const QVersitProperty& property) { QStringList groups = property.groups(); QString name = property.name(); QMultiHash<QString,QString> parameters = property.parameters(); dbg.nospace() << "QVersitProperty("; foreach (const QString& group, groups) { dbg.nospace() << group << '.'; } dbg.nospace() << name; QHash<QString,QString>::const_iterator it; for (it = parameters.constBegin(); it != parameters.constEnd(); ++it) { dbg.nospace() << ';' << it.key() << '=' << it.value(); } if (property.valueType() == QVersitProperty::VersitDocumentType) dbg.nospace() << ':' << property.value<QVersitDocument>(); else dbg.nospace() << ':' << property.variantValue(); dbg.nospace() << ')'; return dbg.maybeSpace(); }
void PersonsModel::onContactsFetched() { Q_D(PersonsModel); KABC::Addressee::Map addresseeMap; //fetch all already loaded contacts from plugins Q_FOREACH (const AllContactsMonitorPtr &contactWatcher, d->m_sourceMonitors) { addresseeMap.unite(contactWatcher->contacts()); } //add metacontacts QMultiHash<QString, QString> contactMapping = PersonManager::instance()->allPersons(); Q_FOREACH (const QString &key, contactMapping.uniqueKeys()) { KABC::Addressee::Map contacts; Q_FOREACH (const QString &contact, contactMapping.values(key)) { d->contactToPersons[contact] = key; if (addresseeMap.contains(contact)) { contacts[contact] = addresseeMap.take(contact); } } if (!contacts.isEmpty()) { addPerson(MetaContact(key, contacts)); } } //add remaining contacts KABC::Addressee::Map::const_iterator i; for (i = addresseeMap.constBegin(); i != addresseeMap.constEnd(); ++i) { addPerson(MetaContact(i.key(), i.value())); } Q_FOREACH(const AllContactsMonitorPtr monitor, d->m_sourceMonitors) { connect(monitor.data(), SIGNAL(contactAdded(QString,KABC::Addressee)), SLOT(onContactAdded(QString,KABC::Addressee))); connect(monitor.data(), SIGNAL(contactChanged(QString,KABC::Addressee)), SLOT(onContactChanged(QString,KABC::Addressee))); connect(monitor.data(), SIGNAL(contactRemoved(QString)), SLOT(onContactRemoved(QString))); } }
void QxtRPCServiceIntrospector::disconnectObject(QObject* obj) { const QMetaObject* meta = obj->metaObject(); foreach(const SignalDef& sig, signalToId.keys()) { // Iterate through all tracked connections and skip any that don't match the incoming object. if(sig.first != obj) continue; int methodID = methodIDs[qMakePair(meta, sig.second)]; foreach(int id, signalToId.values(sig)) { // Iterate through all of the different connections for the object and explicitly disconnect them. QMetaObject::disconnect(obj, methodID, this, id); // Remove the connection from our mappings. idToRpc.remove(id); idToParams.remove(id); } // Remove the object/signal from the mapping. signalToId.remove(sig); } }
int main() { QSet<QString *> s; qDeleteAll(s); qDeleteAll(s.begin(), s.end()); qDeleteAll(s.values()); // warning QHash<int, QString *> h; qDeleteAll(h); qDeleteAll(h.begin(), h.end()); qDeleteAll(h.values()); // warning QMap<int*, QString *> m; qDeleteAll(m); qDeleteAll(m.begin(), m.end()); qDeleteAll(m.values()); // warning QMultiHash<int, QString *> mh; qDeleteAll(mh); qDeleteAll(mh.begin(), mh.end()); qDeleteAll(mh.values()); // warning QMultiMap<int, QString *> mm; qDeleteAll(mm); qDeleteAll(mm.begin(), mm.end()); qDeleteAll(mm.values()); // warning qDeleteAll(values()); // ok Foo foo; qDeleteAll(foo.values()); // ok qDeleteAll(foo.doSomethingWithValues(h.values())); // ok qDeleteAll(m.keys()); // warning qDeleteAll(keys()); // ok qDeleteAll(h.values(1)); // warning }
QString CodeAtlas::FuzzyDependBuilder::collectFuzzyDepend( SymbolNode::Ptr& node ) { // ignore dependency under a function SymbolInfo nodeInfo = node->getSymInfo(); if (nodeInfo.elementType() & SymbolInfo::Variable) return nodeInfo.type() + " " + nodeInfo.name(); QString nodeCode; CodeAttr::Ptr pCode = node->getAttr<CodeAttr>(); if (pCode) nodeCode = pCode->getCode(); if (nodeInfo.elementType() & SymbolInfo::Function) return nodeCode; QMultiHash<QString, ChildPack> childList; int ithChild = 0; bool* isNonVar = new bool[node->childCount()]; for (SymbolNode::ChildIterator pChild = node->childBegin(); pChild != node->childEnd(); ++pChild, ++ithChild) { ChildPack p; p.m_info = pChild.key(); p.m_code = collectFuzzyDepend(pChild.value()); p.m_pNode = pChild.value(); p.m_index = ithChild; childList.insertMulti(p.m_info.name(), p); isNonVar[ithChild] = (p.m_info.elementType() & SymbolInfo::Variable) == 0; nodeCode += "\n" + p.m_code; } FuzzyDependAttr::Ptr pAttr = node->getOrAddAttr<FuzzyDependAttr>(); buildChildDepend(childList, pAttr->vtxEdgeMatrix(), pAttr->edgeWeightVector(), pAttr->dependPairList()); buildSubGraphLevel(pAttr->vtxEdgeMatrix(), isNonVar, ithChild, pAttr->levelVector()); delete[] isNonVar; return nodeCode; }
void IcecastService::ParseDirectoryFinished( QFuture<IcecastBackend::StationList> future) { IcecastBackend::StationList all_stations = future.result(); sort(all_stations.begin(), all_stations.end(), StationSorter<IcecastBackend::Station>()); // Remove duplicates by name. These tend to be multiple URLs for the same // station. IcecastBackend::StationList::iterator it = unique(all_stations.begin(), all_stations.end(), StationEquality<IcecastBackend::Station>()); all_stations.erase(it, all_stations.end()); // Cluster stations by genre. QMultiHash<QString, IcecastBackend::Station*> genres; // Add stations. for (int i = 0; i < all_stations.count(); ++i) { IcecastBackend::Station& s = all_stations[i]; genres.insert(s.genre, &s); } QSet<QString> genre_set = genres.keys().toSet(); // Merge genres with only 1 or 2 stations into "Other". for (const QString& genre : genre_set) { if (genres.count(genre) < 3) { const QList<IcecastBackend::Station*>& small_genre = genres.values(genre); for (IcecastBackend::Station* s : small_genre) { s->genre = "Other"; } } } backend_->ClearAndAddStations(all_stations); app_->task_manager()->SetTaskFinished(load_directory_task_id_); load_directory_task_id_ = 0; }
bool PtDrugDatatabaseStep::createDatabase() { Q_EMIT progressLabelChanged(tr("Preparing raw source files")); Q_EMIT progressRangeChanged(0, 1); Q_EMIT progress(0); if (!DrugsDB::Tools::createMasterDrugInteractionDatabase()) return false; QMultiHash<QString, QVariant> labels; labels.insert("fr","Base de données thérapeutique du portugaise"); labels.insert("en","Portuguese therapeutic database"); labels.insert("de","Portugiesische Therapeutische Datenbank"); if (DrugsDB::Tools::createNewDrugsSource(Core::Constants::MASTER_DATABASE_NAME, PT_DRUGS_DATABASE_NAME, labels) == -1) { LOG_ERROR("Unable to create the PT drugs sources"); return false; } LOG(QString("Database schema created")); Q_EMIT progress(1); return true; }