//@Override /*protected*/ /*synchronized*/ void SmlBeanTableDataModel::updateNameList() { // first, remove listeners from the individual objects if (act->signalMastLogicList != NULL) { for (int i = 0; i < act->signalMastLogicList->size(); i++) { // if object has been deleted, it's not here; ignore it QHash<SignalMastLogic*, SignalMast*>* b = act->signalMastLogicList->at(i); QListIterator<SignalMastLogic*> en = b->keys(); while (en.hasNext()) { SignalMastLogic* sm = en.next(); SignalMast* dest = b->value(sm); //sm.removePropertyChangeListener(this); disconnect(sm->pcs, SIGNAL(propertyChange(PropertyChangeEvent*)), this, SLOT(propertyChange(PropertyChangeEvent*))); //sm.getSourceMast().removePropertyChangeListener(this); disconnect(sm->getSourceMast()->pcs, SIGNAL(propertyChange(PropertyChangeEvent*)), this, SLOT(propertyChange(PropertyChangeEvent*))); //dest.removePropertyChangeListener(this); disconnect(dest, SIGNAL(propertyChange(PropertyChangeEvent*)), this, SLOT(propertyChange(PropertyChangeEvent*))); } } } for (int i = 0; i < source.size(); i++) { QList<SignalMast*> destList = source.at(i)->getDestinationList(); //source.at(i).addPropertyChangeListener(this); connect(source.at(i)->pcs, SIGNAL(propertyChange(PropertyChangeEvent*)), this, SLOT(propertyChange(PropertyChangeEvent*))); //source.get(i).getSourceMast().addPropertyChangeListener(this); connect(source.at(i)->pcs, SIGNAL(propertyChange(PropertyChangeEvent*)), this, SLOT(propertyChange(PropertyChangeEvent*))); for (int j = 0; j < destList.size(); j++) { QHash<SignalMastLogic*, SignalMast*>* hash = new QHash<SignalMastLogic*, SignalMast*>(/*1*/); hash->insert(source.at(i), destList.at(j)); //destList.a(j).addPropertyChangeListener(this); connect(destList.at(i), SIGNAL(propertyChange(PropertyChangeEvent*)), this, SLOT(propertyChange(PropertyChangeEvent*))); act->signalMastLogicList->append(hash); } } }
double dist_pt_to_swc(const XYZ & pt, const NeuronTree * p_tree) { //first find all the edge end point distances if (!p_tree) return -1; V3DLONG p_tree_sz = p_tree->listNeuron.size(); NeuronSWC *tp1, *tp2; if (p_tree_sz<2) { tp1 = (NeuronSWC *)(&(p_tree->listNeuron.at(0))); return norm(pt - XYZ(tp1->x, tp1->y, tp1->z)); } QHash<int, int> h = generate_neuron_swc_hash(p_tree); //generate a hash lookup table from a neuron swc graph V3DLONG i; double min_dist; bool b_first=false; for (i=0;i<p_tree->listNeuron.size();i++) { //first find the two ends of a line seg tp1 = (NeuronSWC *)(&(p_tree->listNeuron.at(i))); if (tp1->pn < 0 || tp1->pn >= p_tree_sz) continue; tp2 = (NeuronSWC *)(&(p_tree->listNeuron.at(h.value(tp1->pn)))); //use hash table //now compute the distance between the pt and the current segment double cur_d = dist_pt_to_line_seg(pt, XYZ(tp1->x,tp1->y,tp1->z), XYZ(tp2->x,tp2->y,tp2->z)); //now find the min distance if (b_first==false) {min_dist = cur_d; b_first=true;} else min_dist = (min_dist>cur_d) ? cur_d : min_dist; } return min_dist; }
static QScriptValue js_label(QScriptContext *context, QScriptEngine *engine) { QString label = context->argument(0).toString(); QScriptValue ret = engine->newObject(); if (labels.contains(label)) { labeltype p = labels.value(label); if (p.type == AREA || p.type == POSITION) { ret.setProperty("x", map_coord(p.p1.x), QScriptValue::ReadOnly); ret.setProperty("y", map_coord(p.p1.y), QScriptValue::ReadOnly); } if (p.type == AREA) { ret.setProperty("x2", map_coord(p.p2.x), QScriptValue::ReadOnly); ret.setProperty("xy", map_coord(p.p2.y), QScriptValue::ReadOnly); } else if (p.type == OBJ_DROID) { DROID *psDroid = IdToDroid(p.id, p.player); if (psDroid) ret = convDroid(psDroid, engine); } else if (p.type == OBJ_STRUCTURE) { STRUCTURE *psStruct = IdToStruct(p.id, p.player); if (psStruct) ret = convStructure(psStruct, engine); } else if (p.type == OBJ_FEATURE) { FEATURE *psFeature = IdToFeature(p.id, p.player); if (psFeature) ret = convFeature(psFeature, engine); } } else debug(LOG_ERROR, "label %s not found!", label.toUtf8().constData()); return ret; }
void KStandardItemModel::changeItem(int index, KStandardItem* item) { if (index < 0 || index >= count() || !item) { delete item; return; } item->m_model = this; QSet<QByteArray> changedRoles; KStandardItem* oldItem = m_items[index]; const QHash<QByteArray, QVariant> oldData = oldItem->data(); const QHash<QByteArray, QVariant> newData = item->data(); // Determine which roles have been changed QHashIterator<QByteArray, QVariant> it(oldData); while (it.hasNext()) { it.next(); const QByteArray role = it.key(); const QVariant oldValue = it.value(); if (newData.contains(role) && newData.value(role) != oldValue) { changedRoles.insert(role); } } m_indexesForItems.remove(oldItem); delete oldItem; oldItem = 0; m_items[index] = item; m_indexesForItems.insert(item, index); onItemChanged(index, changedRoles); emit itemsChanged(KItemRangeList() << KItemRange(index, 1), changedRoles); }
QByteArray convertToId(const QMetaObject *mo) { QByteArray className(mo->className()); if (!className.isEmpty()) return convertToId(className); // likely a metaobject generated for an extended qml object if (mo->superClass()) { className = convertToId(mo->superClass()); className.append("_extended"); return className; } static QHash<const QMetaObject *, QByteArray> generatedNames; className = generatedNames.value(mo); if (!className.isEmpty()) return className; std::cerr << "Found a QMetaObject without a className, generating a random name" << std::endl; className = QByteArray("error-unknown-name-"); className.append(QByteArray::number(generatedNames.size())); generatedNames.insert(mo, className); return className; }
HRESULT STDMETHODCALLTYPE DirectWriteFontFileLoader::CreateStreamFromKey( void const *fontFileReferenceKey, UINT32 fontFileReferenceKeySize, IDWriteFontFileStream **fontFileStream) { Q_UNUSED(fontFileReferenceKeySize); if (fontFileReferenceKeySize != sizeof(const void *)) { qWarning("DirectWriteFontFileLoader::CreateStreamFromKey: Wrong key size"); return E_FAIL; } const void *key = *reinterpret_cast<void * const *>(fontFileReferenceKey); *fontFileStream = NULL; if (!m_fontDatas.contains(key)) return E_FAIL; QByteArray fontData = m_fontDatas.value(key); DirectWriteFontFileStream *stream = new DirectWriteFontFileStream(fontData); stream->AddRef(); *fontFileStream = stream; return S_OK; }
static bool x11EventFilter(void *message, long *result) { #ifdef HAVE_XDAMAGE XEvent *event = (XEvent *)message; if (event->type == xDamageEventBase + XDamageNotify) { XDamageNotifyEvent *xevent = (XDamageNotifyEvent *) event; // notify status bar MDeclarativeStatusBar *statusBar = damageMap.value(xevent->damage); if (statusBar) { statusBar->update(); return true; } } #else Q_UNUSED(message); #endif if (oldEventFilter) { return oldEventFilter(message, result); } else return false; }
static bool saveUids(const QHash<QString, int> &drugs_uids) { QString content; content += "// /***************************************************************************\n" "// * FreeMedicalForms *\n" "// * (C) 2008-2015 by Eric MAEKER, MD *\n" "// * [email protected] *\n" "// * All rights reserved. *\n" "// ***************************************************************************/\n" "// /***************************************************************************\n" "// * Owner : Eric MAEKER, MD <*****@*****.**> *\n" "// ***************************************************************************/\n" "// /***************************************************************************\n" "// * - Autogenerated file for the Portuguese drugs database *\n" "// * This file presents all known drugs and their *\n" "// * FreeDiams autogenerated UID *\n" "// * !!!! The content MUST NOT be changed by hand !!!! *\n" "// ***************************************************************************/\n" "// \n"; QStringList names = drugs_uids.keys(); qSort(names); foreach(const QString &drug, names) { content += drug + ";" + QString::number(drugs_uids.value(drug)) + "\n"; }
void SatellitesPlugin::setSettings( const QHash<QString, QVariant> &settings ) { RenderPlugin::setSettings( settings ); // add default data sources if( !settings.contains( "dataSources" ) ) { QStringList dsList; dsList << "http://www.celestrak.com/NORAD/elements/visual.txt"; m_settings.insert( "dataSources", dsList ); m_settings.insert( "idList", dsList ); } else { // HACK: KConfig can't guess the type of the settings, when we use // KConfigGroup::readEntry() in marble_part it returns a QString which // is then wrapped into a QVariant when added to the settings hash. // QVariant can handle the conversion for some types, like toDateTime() // but when calling toStringList() on a QVariant::String, it will // return a one element list if( settings.value( "dataSources" ).type() == QVariant::String ) { m_settings.insert( "dataSources", settings.value( "dataSources" ).toString().split(QLatin1Char( ',' ) ) ); } if( settings.value( "idList" ).type() == QVariant::String ) { m_settings.insert( "idList", settings.value( "idList" ).toString().split(QLatin1Char( ',' ) ) ); } } // add default user data source if( !settings.contains( "userDataSources" ) ) { QStringList udsList; udsList << "http://files.kde.org/marble/satellites/PlanetarySatellites.msc"; m_settings.insert( "userDataSources", udsList ); userDataSourceAdded( udsList[0] ); } else if( settings.value( "userDataSources" ).type() == QVariant::String ) { // same HACK as above m_settings.insert( "userDataSources", settings.value( "userDataSources" ).toString().split(QLatin1Char( ',' ) ) ); } emit settingsChanged( nameId() ); }
void QGraphicsHelperGL4::bindFragDataLocation(GLuint shader, const QHash<QString, int> &outputs) { Q_FOREACH (const QString &name, outputs.keys()) m_funcs->glBindFragDataLocation(shader, outputs.value(name), name.toStdString().c_str()); }
QString SqlRelationalTableModel::selectStatement() const { QString query; if (tableName().isEmpty()) return query; QString tList; QString jList; QString fList; QString where; QSqlRecord rec = record(); QStringList tables; // Count how many times each field name occurs in the record QHash<QString, int> fieldNames; QStringList fieldList; for (int i = 0; i < rec.count(); ++i) { SqlRelation relation = this->relation(i); QString name; if (relation.isValid()) { // Count the display column name, not the original foreign key name = relation.displayColumn(); if (database().driver()->isIdentifierEscaped(name, QSqlDriver::FieldName)) name = database().driver()->stripDelimiters(name, QSqlDriver::FieldName); QSqlRecord rec = database().record(relation.tableName()); for (int i = 0; i < rec.count(); ++i) { if (name.compare(rec.fieldName(i), Qt::CaseInsensitive) == 0) { name = rec.fieldName(i); break; } } } else name = rec.fieldName(i); fieldNames.insert(name, fieldNames.value(name, 0) + 1); fieldList.append(name); } for (int i = 0; i < rec.count(); ++i) { SqlRelation relation = this->relation(i); if (relation.isValid()) { QString relTableAlias = QString::fromLatin1("relTblAl_%1").arg(i); if (!fList.isEmpty()) fList.append(QLatin1String(", ")); fList.append(relationField(relTableAlias,relation.displayColumn())); // If there are duplicate field names they must be aliased if (fieldNames.value(fieldList[i]) > 1) { QString relTableName = relation.tableName().section(QChar::fromLatin1('.'), -1, -1); if (database().driver()->isIdentifierEscaped(relTableName, QSqlDriver::TableName)) relTableName = database().driver()->stripDelimiters(relTableName, QSqlDriver::TableName); QString displayColumn = relation.displayColumn(); if (database().driver()->isIdentifierEscaped(displayColumn, QSqlDriver::FieldName)) displayColumn = database().driver()->stripDelimiters(displayColumn, QSqlDriver::FieldName); fList.append(QString::fromLatin1(" AS %1_%2_%3").arg(relTableName).arg(displayColumn).arg(fieldNames.value(fieldList[i]))); fieldNames.insert(fieldList[i], fieldNames.value(fieldList[i])-1); } // this needs fixing!! the below if is borken. //tables.append(relation.tableName().append(QLatin1Char(' ')).append(relTableAlias)); //if(!where.isEmpty()) //where.append(QLatin1String(" AND ")); switch(relation.getJoinKind()){ case SqlRelation::RIGHT: jList.append(QLatin1String(" RIGHT JOIN ")); break; case SqlRelation::LEFT: jList.append(QLatin1String(" LEFT JOIN ")); break; case SqlRelation::OUTER: jList.append(QLatin1String(" FULL OUTER JOIN ")); break; case SqlRelation::INNER: jList.append(QLatin1String(" INNER JOIN ")); break; default: jList.append(QLatin1String(" JOIN ")); break; } jList.append(relation.tableName().append(QLatin1Char(' ')).append(relTableAlias)); jList.append(QLatin1String(" ON ")); jList.append(relationField(tableName(), database().driver()->escapeIdentifier(rec.fieldName(i), QSqlDriver::FieldName))); jList.append(QLatin1String(" = ")); jList.append(relationField(relTableAlias, relation.indexColumn())); } else { if (!fList.isEmpty()) fList.append(QLatin1String(", ")); fList.append(relationField(tableName(), database().driver()->escapeIdentifier(rec.fieldName(i), QSqlDriver::FieldName))); } } for(int i = 0; i < rec.count(); ++i) { SqlRelation relation = this->relation(i); if(relation.isValid()){ fList.append(QLatin1String(", ")); fList.append(relationField(QString::fromLatin1("relTblAl_%1").arg(i),relation.indexColumn())); fList.append(QString::fromLatin1(" AS %1_%2").arg(relation.tableName().section(QChar::fromLatin1('.'), -1, -1)).arg(relation.indexColumn())); } } if(!additionalField.isEmpty()) fList.append(additionalField+" "); if (!tables.isEmpty()) tList.append(tables.join(QLatin1String(", "))); if (fList.isEmpty()) return query; if(!tList.isEmpty()) tList.prepend(QLatin1String(", ")); tList.prepend(tableName()); query.append(QLatin1String("SELECT ")); query.append(fList).append(QLatin1String(" FROM ")).append(tList); query.append(jList); query = qAppendWhereClause(query, where, filter()); query.append(groupByClause); QString orderBy = orderByClause(); if (!orderBy.isEmpty()) query.append(QLatin1Char(' ')).append(orderBy); return query; }
void QWebSettingsPrivate::apply() { if (settings) { settings->setTextAreasAreResizable(true); QWebSettingsPrivate* global = QWebSettings::globalSettings()->d; QString family = fontFamilies.value(QWebSettings::StandardFont, global->fontFamilies.value(QWebSettings::StandardFont)); settings->setStandardFontFamily(family); family = fontFamilies.value(QWebSettings::FixedFont, global->fontFamilies.value(QWebSettings::FixedFont)); settings->setFixedFontFamily(family); family = fontFamilies.value(QWebSettings::SerifFont, global->fontFamilies.value(QWebSettings::SerifFont)); settings->setSerifFontFamily(family); family = fontFamilies.value(QWebSettings::SansSerifFont, global->fontFamilies.value(QWebSettings::SansSerifFont)); settings->setSansSerifFontFamily(family); family = fontFamilies.value(QWebSettings::CursiveFont, global->fontFamilies.value(QWebSettings::CursiveFont)); settings->setCursiveFontFamily(family); family = fontFamilies.value(QWebSettings::FantasyFont, global->fontFamilies.value(QWebSettings::FantasyFont)); settings->setFantasyFontFamily(family); int size = fontSizes.value(QWebSettings::MinimumFontSize, global->fontSizes.value(QWebSettings::MinimumFontSize)); settings->setMinimumFontSize(size); size = fontSizes.value(QWebSettings::MinimumLogicalFontSize, global->fontSizes.value(QWebSettings::MinimumLogicalFontSize)); settings->setMinimumLogicalFontSize(size); size = fontSizes.value(QWebSettings::DefaultFontSize, global->fontSizes.value(QWebSettings::DefaultFontSize)); settings->setDefaultFontSize(size); size = fontSizes.value(QWebSettings::DefaultFixedFontSize, global->fontSizes.value(QWebSettings::DefaultFixedFontSize)); settings->setDefaultFixedFontSize(size); bool value = attributes.value(QWebSettings::AutoLoadImages, global->attributes.value(QWebSettings::AutoLoadImages)); settings->setLoadsImagesAutomatically(value); value = attributes.value(QWebSettings::DnsPrefetchEnabled, global->attributes.value(QWebSettings::DnsPrefetchEnabled)); settings->setDNSPrefetchingEnabled(value); value = attributes.value(QWebSettings::JavascriptEnabled, global->attributes.value(QWebSettings::JavascriptEnabled)); settings->setScriptEnabled(value); #if USE(ACCELERATED_COMPOSITING) value = attributes.value(QWebSettings::AcceleratedCompositingEnabled, global->attributes.value(QWebSettings::AcceleratedCompositingEnabled)); settings->setAcceleratedCompositingEnabled(value); settings->setAcceleratedCompositingFor3DTransformsEnabled(value); settings->setAcceleratedCompositingForAnimationEnabled(value); #if USE(TEXTURE_MAPPER) settings->setAcceleratedCompositingForVideoEnabled(false); settings->setAcceleratedCompositingForPluginsEnabled(false); #endif #endif #if ENABLE(WEBGL) value = attributes.value(QWebSettings::WebGLEnabled, global->attributes.value(QWebSettings::WebGLEnabled)); settings->setWebGLEnabled(value); #if USE(ACCELERATED_COMPOSITING) settings->setAcceleratedCompositingForCanvasEnabled(value); #endif #endif value = attributes.value(QWebSettings::HyperlinkAuditingEnabled, global->attributes.value(QWebSettings::HyperlinkAuditingEnabled)); settings->setHyperlinkAuditingEnabled(value); value = attributes.value(QWebSettings::JavascriptCanOpenWindows, global->attributes.value(QWebSettings::JavascriptCanOpenWindows)); settings->setJavaScriptCanOpenWindowsAutomatically(value); value = attributes.value(QWebSettings::JavascriptCanCloseWindows, global->attributes.value(QWebSettings::JavascriptCanCloseWindows)); settings->setAllowScriptsToCloseWindows(value); value = attributes.value(QWebSettings::JavaEnabled, global->attributes.value(QWebSettings::JavaEnabled)); settings->setJavaEnabled(value); value = attributes.value(QWebSettings::PluginsEnabled, global->attributes.value(QWebSettings::PluginsEnabled)); settings->setPluginsEnabled(value); value = attributes.value(QWebSettings::PrivateBrowsingEnabled, global->attributes.value(QWebSettings::PrivateBrowsingEnabled)); settings->setPrivateBrowsingEnabled(value); value = attributes.value(QWebSettings::SpatialNavigationEnabled, global->attributes.value(QWebSettings::SpatialNavigationEnabled)); settings->setSpatialNavigationEnabled(value); value = attributes.value(QWebSettings::JavascriptCanAccessClipboard, global->attributes.value(QWebSettings::JavascriptCanAccessClipboard)); settings->setDOMPasteAllowed(value); settings->setJavaScriptCanAccessClipboard(value); value = attributes.value(QWebSettings::DeveloperExtrasEnabled, global->attributes.value(QWebSettings::DeveloperExtrasEnabled)); settings->setDeveloperExtrasEnabled(value); value = attributes.value(QWebSettings::FrameFlatteningEnabled, global->attributes.value(QWebSettings::FrameFlatteningEnabled)); settings->setFrameFlatteningEnabled(value); QUrl location = !userStyleSheetLocation.isEmpty() ? userStyleSheetLocation : global->userStyleSheetLocation; settings->setUserStyleSheetLocation(WebCore::KURL(location)); QString encoding = !defaultTextEncoding.isEmpty() ? defaultTextEncoding: global->defaultTextEncoding; settings->setDefaultTextEncodingName(encoding); QString storagePath = !localStoragePath.isEmpty() ? localStoragePath : global->localStoragePath; settings->setLocalStorageDatabasePath(storagePath); QString path = !pluginSupplementalPath.isEmpty() ? pluginSupplementalPath : global->pluginSupplementalPath; settings->setPluginSupplementalPath(path); value = attributes.value(QWebSettings::PrintElementBackgrounds, global->attributes.value(QWebSettings::PrintElementBackgrounds)); settings->setShouldPrintBackgrounds(value); #if ENABLE(SQL_DATABASE) value = attributes.value(QWebSettings::OfflineStorageDatabaseEnabled, global->attributes.value(QWebSettings::OfflineStorageDatabaseEnabled)); WebCore::AbstractDatabase::setIsAvailable(value); #endif value = attributes.value(QWebSettings::OfflineWebApplicationCacheEnabled, global->attributes.value(QWebSettings::OfflineWebApplicationCacheEnabled)); settings->setOfflineWebApplicationCacheEnabled(value); value = attributes.value(QWebSettings::LocalStorageEnabled, global->attributes.value(QWebSettings::LocalStorageEnabled)); settings->setLocalStorageEnabled(value); value = attributes.value(QWebSettings::LocalContentCanAccessRemoteUrls, global->attributes.value(QWebSettings::LocalContentCanAccessRemoteUrls)); settings->setAllowUniversalAccessFromFileURLs(value); value = attributes.value(QWebSettings::LocalContentCanAccessFileUrls, global->attributes.value(QWebSettings::LocalContentCanAccessFileUrls)); settings->setAllowFileAccessFromFileURLs(value); value = attributes.value(QWebSettings::XSSAuditingEnabled, global->attributes.value(QWebSettings::XSSAuditingEnabled)); settings->setXSSAuditorEnabled(value); #if USE(TILED_BACKING_STORE) value = attributes.value(QWebSettings::TiledBackingStoreEnabled, global->attributes.value(QWebSettings::TiledBackingStoreEnabled)); settings->setTiledBackingStoreEnabled(value); #endif value = attributes.value(QWebSettings::SiteSpecificQuirksEnabled, global->attributes.value(QWebSettings::SiteSpecificQuirksEnabled)); settings->setNeedsSiteSpecificQuirks(value); settings->setUsesPageCache(WebCore::pageCache()->capacity()); #if ENABLE(VIDEO) && USE(WEBOS_MULTIMEDIA) QString moptions = !mediaPipelineOptions.isEmpty() ? mediaPipelineOptions: global->mediaPipelineOptions; settings->setMediaPipelineOptions( moptions ); #endif } else { QList<QWebSettingsPrivate*> settings = *::allSettings(); for (int i = 0; i < settings.count(); ++i) settings[i]->apply(); } }
ConnectionPointer<Connection> ConnectionManager2::getConnWithConfig(quint8 type, const QHash<QString, QVariant> &cfg) { this->refresh(); #ifdef HAVE_LIBYB // We want to receive first USB enumeration events, // so that connections created here can be opened QApplication::processEvents(); #endif Connection *enumCon = NULL; for(int i = 0; i < m_conns.size(); ++i) { if(m_conns[i]->getType() != type) continue; switch(type) { case CONNECTION_SERIAL_PORT: { SerialPort *sp = (SerialPort*)m_conns[i]; if(sp->deviceName() == cfg["device_name"]) { if(!sp->removable()) enumCon = sp; else if(sp->baudRate() == cfg["baud_rate"]) return ConnectionPointer<Connection>::fromPtr(sp); } break; } case CONNECTION_TCP_SOCKET: { TcpSocket *socket = (TcpSocket*)m_conns[i]; if(socket->host() == cfg["host"] && socket->port() == cfg["port"]) return ConnectionPointer<Connection>::fromPtr(socket); break; } case CONNECTION_UDP_SOCKET: { UdpSocket *socket = (UdpSocket*)m_conns[i]; if (socket->name() == cfg["name"] && socket->host() == cfg["host"] && socket->port() == cfg["port"]) return ConnectionPointer<Connection>::fromPtr(socket); break; } case CONNECTION_PROXY_TUNNEL: { ProxyTunnel *tunnel = (ProxyTunnel*)m_conns[i]; if(tunnel->name() == cfg["name"]) return ConnectionPointer<Connection>::fromPtr(tunnel); break; } case CONNECTION_SHUPITO_TUNNEL: { QHash<QString, QVariant> c = cfg.value("companions").toHash(); QHash<QString, QVariant>::iterator itr = c.find(ShupitoTunnel::getCompanionName()); if(itr == c.end()) return ConnectionPointer<Connection>(); qint64 id = itr.value().toLongLong(); if(id != 0 && id == m_conns[i]->getCompanionId(ShupitoTunnel::getCompanionName())) return ConnectionPointer<Connection>::fromPtr((ShupitoTunnel*)m_conns[i]); break; } case CONNECTION_SHUPITO_SPI_TUNNEL: { QHash<QString, QVariant> c = cfg.value("companions").toHash(); QHash<QString, QVariant>::iterator itr = c.find(ShupitoSpiTunnelConn::getCompanionName()); if(itr == c.end()) return ConnectionPointer<Connection>(); qint64 id = itr.value().toLongLong(); if(id != 0 && id == m_conns[i]->getCompanionId(ShupitoSpiTunnelConn::getCompanionName())) return ConnectionPointer<Connection>::fromPtr((ShupitoSpiTunnelConn*)m_conns[i]); break; } #ifdef HAVE_LIBYB case CONNECTION_USB_ACM2: { UsbAcmConnection2 *usb = (UsbAcmConnection2*)m_conns[i]; if (usb->vid() == cfg.value("vid", 0).toInt() && usb->pid() == cfg.value("pid", 0).toInt() && usb->serialNumber() == cfg.value("serial_number").toString() && usb->intfName() == cfg.value("intf_name").toString() && usb->baudRate() == cfg.value("baud_rate", 115200).toInt() && usb->stopBits() == cfg.value("stop_bits", 0).toInt() && usb->parity() == (UsbAcmConnection2::parity_t)cfg.value("parity", 0).toInt() && usb->dataBits() == cfg.value("data_bits", 8).toInt()) { usb->applyConfig(cfg); return ConnectionPointer<Connection>::fromPtr(usb); } break; } case CONNECTION_SHUPITO23: { UsbShupito23Connection *usb = (UsbShupito23Connection*)m_conns[i]; if (usb->vid() == cfg.value("vid", 0).toInt() && usb->pid() == cfg.value("pid", 0).toInt() && usb->serialNumber() == cfg.value("serial_number").toString() && usb->intfName() == cfg.value("intf_name").toString()) { usb->applyConfig(cfg); return ConnectionPointer<Connection>::fromPtr(usb); } break; } case CONNECTION_STM32: { STM32Connection *stm32 = (STM32Connection*)m_conns[i]; if (stm32->vid() == cfg.value("vid", 0).toInt() && stm32->pid() == cfg.value("pid", 0).toInt() && stm32->serialNumber() == cfg.value("serial_number").toString() && stm32->intfName() == cfg.value("intf_name").toString()) { return ConnectionPointer<Connection>::fromPtr(stm32); } break; } #endif default: return ConnectionPointer<Connection>(); } } if(enumCon) { enumCon->applyConfig(cfg); return ConnectionPointer<Connection>::fromPtr(enumCon); } if(type == CONNECTION_SHUPITO_TUNNEL) { QHash<QString, QVariant> c = cfg.value("companions").toHash(); QHash<QString, QVariant>::iterator itr = c.find(ShupitoTunnel::getCompanionName()); if(itr == c.end()) return ConnectionPointer<Connection>(); qint64 id = itr.value().toLongLong(); if(id == 0) return ConnectionPointer<Connection>(); ConnectionPointer<Connection> tunnel(new ShupitoTunnel()); tunnel->applyConfig(cfg); tunnel->setRemovable(false); this->addConnection(tunnel.data()); return tunnel; } else if(type == CONNECTION_SHUPITO_SPI_TUNNEL) { QHash<QString, QVariant> c = cfg.value("companions").toHash(); QHash<QString, QVariant>::iterator itr = c.find(ShupitoSpiTunnelConn::getCompanionName()); if(itr == c.end()) return ConnectionPointer<Connection>(); qint64 id = itr.value().toLongLong(); if(id == 0) return ConnectionPointer<Connection>(); ConnectionPointer<Connection> tunnel(new ShupitoSpiTunnelConn()); tunnel->applyConfig(cfg); tunnel->setRemovable(false); this->addConnection(tunnel.data()); return tunnel; } #ifdef HAVE_LIBYB else if(type == CONNECTION_USB_ACM2) { ConnectionPointer<Connection> usb(createUsbAcmConn()); usb->applyConfig(cfg); return usb; } else if(type == CONNECTION_STM32) { ConnectionPointer<Connection> stm32(createSTM32Conn()); stm32->applyConfig(cfg); return stm32; } #endif return ConnectionPointer<Connection>(); }
PwDatabaseV3::ErrorCode PwDatabaseV3::readContent(QDataStream& stream) { setPhaseProgressRawTarget(header.getGroupCount() + header.getEntryCount()); QList<PwGroupV3*> groups; ErrorCode err = readAllGroups(stream, groups); if (err != SUCCESS) return err; QList<PwEntryV3*> entries; err = readAllEntries(stream, entries); if (err != SUCCESS) return err; // make a group-by-ID lookup hashtable; // also find the maximum group level int maxLevel = 0; quint16 level; PwGroupV3* group; QHash<qint32, PwGroupV3*> groupById; for (int i = 0; i < groups.size(); i++) { group = groups.at(i); groupById.insert(group->getId(), group); level = group->getLevel(); if (level > maxLevel) maxLevel = level; } // restore group hierarchy PwGroupV3* rootGroupV3 = new PwGroupV3(); rootGroupV3->setDatabase(this); rootGroupV3->setLevel(-1); // because its children should have level 0 rootGroupV3->setIconId(PwGroup::DEFAULT_ICON_ID); // created subgroups will use this icon // give the "virtual" root group some meaningful name rootGroupV3->setName(getDatabaseFileName()); _rootGroup = rootGroupV3; PwGroupV3* parentGroup = (PwGroupV3*)_rootGroup; for (quint16 level = 0; level <= maxLevel; level++) { quint16 prevLevel = level - 1; for (int i = 0; i < groups.size(); i++) { PwGroupV3* group = groups.at(i); quint16 curLevel = group->getLevel(); if (curLevel == level) { parentGroup->addSubGroup(group); } else if (curLevel == prevLevel) { parentGroup = group; } } } // put entries to their groups PwEntryV3* entry; for (int i = 0; i < entries.size(); i++) { entry = entries.at(i); if (entry->isMetaStream()) { // meta streams are kept in their own list, invisibly for the user metaStreamEntries.append(entry); } else { qint32 groupId = entry->getGroupId(); if (!groupById.contains(groupId)) { LOG("There is an entry %s with unknown groupId: %d", entry->toString().toUtf8().constData(), groupId); return ORPHANED_ENTRY_ERROR; } PwGroupV3* group = groupById.value(groupId); entry->setDeleted(group->isDeleted()); group->addEntry(entry); } } return SUCCESS; }
void ChessProtocol::receiveMessage(const QString &msg) { QHash<QString, QString> hash = analyse(msg); qDebug() << hash; if(!hash.contains("TYPE")) { Chess_Error("has no message type: "+msg); return; } QString type = hash.value("TYPE"); QString body = hash.value("BODY"); if(type == "CHAT") { emit receiveChatMessage(body); } else if(type == "CHESS") { int fid = -1; int fx = -1; int fy = -1; int tid = -1; int tx = -1; int ty = -1; if(body.size() == 8) { fid = body.mid(0, 2).toInt(); fx = body.mid(2, 1).toInt(); fy = body.mid(3, 1).toInt(); tid = body.mid(4, 2).toInt(); tx = body.mid(6, 1).toInt(); ty = body.mid(7, 1).toInt(); } else if(body.size() == 4) { body = body.toLower(); // fx = body.at(0).toAscii() - 'a'; // fy = 9 - (body.at(1).toAscii() - '0'); // fid = ChessData::instance()->isWho(QPoint(fx, fy)); // tx = body.at(2).toAscii() - 'a'; // ty = 9 - (body.at(3).toAscii() - '0'); fx = body.at(0).toLatin1() - 'a'; fy = 9 - (body.at(1).toLatin1() - '0'); fid = ChessData::instance()->isWho(QPoint(fx, fy)); tx = body.at(2).toLatin1() - 'a'; ty = 9 - (body.at(3).toLatin1() - '0'); tid = ChessData::instance()->isWho(QPoint(tx, ty)); } emit receiveChessMessage(fid, tid, QPoint(fx, fy), QPoint(tx, ty)); } else if(type == "START") { emit receiveStartMessage(); } else { Chess_Error("unknown message type: "+type); } }
void QAuthenticatorPrivate::parseHttpResponse(const QList<QPair<QByteArray, QByteArray> > &values, bool isProxy) { const char *search = isProxy ? "proxy-authenticate" : "www-authenticate"; method = None; /* Fun from the HTTP 1.1 specs, that we currently ignore: User agents are advised to take special care in parsing the WWW- Authenticate field value as it might contain more than one challenge, or if more than one WWW-Authenticate header field is provided, the contents of a challenge itself can contain a comma-separated list of authentication parameters. */ QByteArray headerVal; for (int i = 0; i < values.size(); ++i) { const QPair<QByteArray, QByteArray> ¤t = values.at(i); if (current.first.toLower() != search) continue; QByteArray str = current.second.toLower(); if (method < Basic && str.startsWith("basic")) { method = Basic; headerVal = current.second.mid(6); } else if (method < Ntlm && str.startsWith("ntlm")) { method = Ntlm; headerVal = current.second.mid(5); } else if (method < DigestMd5 && str.startsWith("digest")) { method = DigestMd5; headerVal = current.second.mid(7); } } challenge = headerVal.trimmed(); QHash<QByteArray, QByteArray> options = parseDigestAuthenticationChallenge(challenge); switch(method) { case Basic: this->options[QLatin1String("realm")] = realm = QString::fromLatin1(options.value("realm")); if (user.isEmpty() && password.isEmpty()) phase = Done; break; case Ntlm: // #### extract from header if (user.isEmpty() && password.isEmpty()) phase = Done; break; case DigestMd5: { this->options[QLatin1String("realm")] = realm = QString::fromLatin1(options.value("realm")); if (options.value("stale").toLower() == "true") phase = Start; if (user.isEmpty() && password.isEmpty()) phase = Done; break; } default: realm.clear(); challenge = QByteArray(); phase = Invalid; } }
QHash<QByteArray, QByteArray> QAuthenticatorPrivate::parseDigestAuthenticationChallenge(const QByteArray &challenge) { QHash<QByteArray, QByteArray> options; // parse the challenge const char *d = challenge.constData(); const char *end = d + challenge.length(); while (d < end) { while (d < end && (*d == ' ' || *d == '\n' || *d == '\r')) ++d; const char *start = d; while (d < end && *d != '=') ++d; QByteArray key = QByteArray(start, d - start); ++d; if (d >= end) break; bool quote = (*d == '"'); if (quote) ++d; if (d >= end) break; start = d; QByteArray value; while (d < end) { bool backslash = false; if (*d == '\\' && d < end - 1) { ++d; backslash = true; } if (!backslash) { if (quote) { if (*d == '"') break; } else { if (*d == ',') break; } } value += *d; ++d; } while (d < end && *d != ',') ++d; ++d; options[key] = value; } QByteArray qop = options.value("qop"); if (!qop.isEmpty()) { QList<QByteArray> qopoptions = qop.split(','); if (!qopoptions.contains("auth")) return QHash<QByteArray, QByteArray>(); // #### can't do auth-int currently // if (qop.contains("auth-int")) // qop = "auth-int"; // else if (qop.contains("auth")) // qop = "auth"; // else // qop = QByteArray(); options["qop"] = "auth"; } return options; }
KNMusicPlaylistModel *KNMusicPlaylistiTunesXMLParser::read( const QString &filePath) { //Get the plist file. QFile plistFile(filePath); //Open the playlist file first. if(!plistFile.open(QIODevice::ReadOnly)) { return nullptr; } //Generate a dom document to parse the file. QDomDocument plistDocument; //Use QDomDocument to parse the file. if(!plistDocument.setContent(&plistFile, true)) { //If there's any error, return nullptr. return nullptr; } //Close the playlist file. plistFile.close(); //Get the 'plist' element from the document. QDomElement plistRoot=plistDocument.documentElement(); //Check the 'plist' element. if(plistRoot.nodeName()!="plist" || !plistRoot.hasAttribute("version") || plistRoot.attribute("version")!="1.0") { return nullptr; } //Get the dict elements from the 'plist'. QDomNodeList root=plistRoot.elementsByTagName("dict"); //Check the list data. if(root.isEmpty()) { return nullptr; } //Pick out the 'dict' element. QDomNodeList dictElement=root.at(0).toElement().childNodes(); //Check 'dict' childe nodes size. if(dictElement.isEmpty()) { return nullptr; } //Initial the track info hash. QHash<QString, QString> musicLocateHash; QStringList playlistIndexList; //Prepare the playlist. KNMusicPlaylistModel *model=new KNMusicPlaylistModel(thread()); //Get the first node. QDomElement keyNode=dictElement.at(0).toElement(), valueNode=keyNode.nextSiblingElement(); //Check the current key node. while(!keyNode.isNull() && !keyNode.isNull()) { //Check the name of the node. //For 'tracks': if(keyNode.text()=="Tracks") { //Check whether the child nodes is empty. if(!valueNode.childNodes().isEmpty()) { //Get all the tracks information. QDomElement trackKeyNode= valueNode.childNodes().at(0).toElement(), trackValueNode= trackKeyNode.nextSiblingElement(); //Pick out all the tracks. while(!trackKeyNode.isNull() && !trackValueNode.isNull()) { //Parse the track dict information. QDomElement songKeyNode= trackValueNode.childNodes().at(0).toElement(), songValueNode= songKeyNode.nextSiblingElement(); //If all the information is valid. while(!songKeyNode.isNull() && !songValueNode.isNull()) { //Get the location of the song. if(songKeyNode.text()=="Location") { //Get the url from the file. //Use QUrl to translate it to a readable string. QString rawUrlText= QUrl::fromPercentEncoding( songValueNode.text().toUtf8()); //Remove the protocol name. if(rawUrlText.length()>17 && rawUrlText.left(17)=="file://localhost/") { rawUrlText.remove(0, 17); } else { rawUrlText=QUrl(rawUrlText).path(); } //Set the hash. musicLocateHash.insert( trackKeyNode.text(), QFileInfo(rawUrlText).absoluteFilePath() ); break; } //Switch to the next song elements. songKeyNode=songValueNode.nextSiblingElement(); songValueNode=songKeyNode.nextSiblingElement(); } //Switch to the track elements. trackKeyNode=trackValueNode.nextSiblingElement(); trackValueNode=trackKeyNode.nextSiblingElement(); } } } //For 'Playlists'. else if(keyNode.text()=="Playlists") { //Check the node size. if(valueNode.childNodes().size()!=0) { //Get the dict of the playlist. QDomElement playlistDict= valueNode.childNodes().at(0).toElement(); //Check the size of playlist dict. if(playlistDict.childNodes().size()!=0) { //Get the playlist keys. QDomElement playlistKey= playlistDict.childNodes().at(0).toElement(), playlistValue= playlistKey.nextSiblingElement(); //Read the playlist information. while(!playlistKey.isNull() && !playlistValue.isNull()) { //For 'Name' element, it stored the name of the //playlist. if(playlistKey.text()=="Name") { //Set the title to model. model->setTitle(playlistValue.text()); } //For 'Playlist Items' element, it stored the file path //information of the songs. else if(playlistKey.text()=="Playlist Items") { //Check the array is empty or not. QDomNodeList itemsArray=playlistValue.childNodes(); if(!itemsArray.isEmpty()) { //Get all the information from the items array. for(int i=0; i<itemsArray.size(); i++) { QDomElement currentTrack= itemsArray.at(i).toElement(); if(currentTrack.childNodes().size()==2) { QDomElement trackElement= currentTrack. childNodes(). at(0).toElement(), trackIndex= trackElement. nextSiblingElement(); //Check if the track element is //'Track ID' we will save track info. if(trackElement.text()=="Track ID") { //Insert the track. playlistIndexList.append( trackIndex.text()); } } } } } //Switch to the next playlist key. playlistKey=playlistValue.nextSiblingElement(); playlistValue=playlistKey.nextSiblingElement(); } } } } //Switch to the next elements. keyNode=valueNode.nextSiblingElement(); valueNode=keyNode.nextSiblingElement(); } //Prepare the file list. QStringList fileList; //Translate the index list to file list. for(auto i=playlistIndexList.constBegin(); i!=playlistIndexList.constEnd(); ++i) { //Get the file path according to the hash table. QString filePath=musicLocateHash.value((*i), QString()); //If the file is not empty, if(!filePath.isEmpty()) { //Add to file list. fileList.append(filePath); } } //Add the file list to model. model->appendFiles(fileList); //Set the changed flag. model->setChanged(true); //Give back the model. return model; }
bool TcxFileReader::writeRideFile(MainWindow *mainWindow, const RideFile *ride, QFile &file) const { QDomText text; QDomDocument doc; QDomProcessingInstruction hdr = doc.createProcessingInstruction("xml","version=\"1.0\""); doc.appendChild(hdr); // pwx QDomElement tcx = doc.createElementNS("http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2", "TrainingCenterDatabase"); tcx.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"); tcx.setAttribute("xsi:schemaLocation", "http://www.garmin.com/xmlschemas/ActivityExtension/v2 http://www.garmin.com/xmlschemas/ActivityExtensionv2.xsd http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2 http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd"); //tcx.setAttribute("version", "2.0"); doc.appendChild(tcx); // activities, we just serialise one ride QString sport = ride->getTag("Sport", "Biking"); if (sport == QObject::tr("Biking") || sport == QObject::tr("Cycling") || sport == QObject::tr("Cycle") || sport == QObject::tr("Bike")) { sport = "Biking"; } QDomElement activities = doc.createElement("Activities"); tcx.appendChild(activities); QDomElement activity = doc.createElement("Activity"); activity.setAttribute("Sport", sport); // was ride->getTag("Sport", "Biking") but must be Biking, Running or Other activities.appendChild(activity); // time QDomElement id = doc.createElement("Id"); text = doc.createTextNode(ride->startTime().toUTC().toString(Qt::ISODate)); id.appendChild(text); activity.appendChild(id); QDomElement lap = doc.createElement("Lap"); lap.setAttribute("StartTime", ride->startTime().toUTC().toString(Qt::ISODate)); activity.appendChild(lap); const char *metrics[] = { "total_distance", "workout_time", "total_work", "average_hr", "max_heartrate", "average_cad", "max_cadence", "average_power", "max_power", "max_speed", "average_speed", NULL }; QStringList worklist = QStringList(); for (int i=0; metrics[i];i++) worklist << metrics[i]; QHash<QString, RideMetricPtr> computed = RideMetric::computeMetrics(mainWindow, ride, mainWindow->zones(), mainWindow->hrZones(), worklist); QDomElement lap_time = doc.createElement("TotalTimeSeconds"); text = doc.createTextNode(QString("%1").arg(computed.value("workout_time")->value(true))); //text = doc.createTextNode(ride->dataPoints().last()->secs); lap_time.appendChild(text); lap.appendChild(lap_time); QDomElement lap_distance = doc.createElement("DistanceMeters"); text = doc.createTextNode(QString("%1").arg(1000*computed.value("total_distance")->value(true))); //text = doc.createTextNode(ride->dataPoints().last()->km); lap_distance.appendChild(text); lap.appendChild(lap_distance); QDomElement max_speed = doc.createElement("MaximumSpeed"); text = doc.createTextNode(QString("%1").arg(computed.value("max_speed")->value(true))); max_speed.appendChild(text); lap.appendChild(max_speed); QDomElement lap_calories = doc.createElement("Calories"); text = doc.createTextNode(QString("%1").arg((int)computed.value("total_work")->value(true))); lap_calories.appendChild(text); lap.appendChild(lap_calories); QDomElement avg_heartrate = doc.createElement("AverageHeartRateBpm"); QDomElement value = doc.createElement("Value"); text = doc.createTextNode(QString("%1").arg((int)computed.value("average_hr")->value(true))); value.appendChild(text); avg_heartrate.appendChild(value); lap.appendChild(avg_heartrate); QDomElement max_heartrate = doc.createElement("MaximumHeartRateBpm"); value = doc.createElement("Value"); text = doc.createTextNode(QString("%1").arg((int)computed.value("max_heartrate")->value(true))); value.appendChild(text); max_heartrate.appendChild(value); lap.appendChild(max_heartrate); QDomElement lap_intensity = doc.createElement("Intensity"); text = doc.createTextNode("Active"); lap_intensity.appendChild(text); lap.appendChild(lap_intensity); QDomElement lap_triggerMethod = doc.createElement("TriggerMethod"); text = doc.createTextNode("Manual"); lap_triggerMethod.appendChild(text); lap.appendChild(lap_triggerMethod); // samples // data points: timeoffset, dist, hr, spd, pwr, torq, cad, lat, lon, alt if (!ride->dataPoints().empty()) { QDomElement track = doc.createElement("Track"); lap.appendChild(track); foreach (const RideFilePoint *point, ride->dataPoints()) { QDomElement trackpoint = doc.createElement("Trackpoint"); track.appendChild(trackpoint); // time QDomElement time = doc.createElement("Time"); text = doc.createTextNode(ride->startTime().toUTC().addSecs(point->secs).toString(Qt::ISODate)); time.appendChild(text); trackpoint.appendChild(time); // position if (ride->areDataPresent()->lat && point->lat > -90.0 && point->lat < 90.0 && point->lat != 0.0 && ride->areDataPresent()->lon && point->lon > -180.00 && point->lon < 180.00 && point->lon != 0.0 ) { QDomElement position = doc.createElement("Position"); trackpoint.appendChild(position); // lat QDomElement lat = doc.createElement("LatitudeDegrees"); text = doc.createTextNode(QString("%1").arg(point->lat, 0, 'g', 11)); lat.appendChild(text); position.appendChild(lat); // lon QDomElement lon = doc.createElement("LongitudeDegrees"); text = doc.createTextNode(QString("%1").arg(point->lon, 0, 'g', 11)); lon.appendChild(text); position.appendChild(lon); } // alt if (ride->areDataPresent()->alt && point->alt != 0.0) { QDomElement alt = doc.createElement("AltitudeMeters"); text = doc.createTextNode(QString("%1").arg(point->alt)); alt.appendChild(text); trackpoint.appendChild(alt); } // distance - meters if (ride->areDataPresent()->km) { QDomElement dist = doc.createElement("DistanceMeters"); text = doc.createTextNode(QString("%1").arg((int)(point->km*1000))); dist.appendChild(text); trackpoint.appendChild(dist); } // HeartRate hack for Garmin Training Center // It needs an hr datapoint for every trackpoint or else the // hr graph in TC won't display. Schema defines the datapoint // as a positive int (> 0) int tHr = 1; if (ride->areDataPresent()->hr && point->hr >0.00) { tHr = (int)point->hr; } QDomElement hr = doc.createElement("HeartRateBpm"); hr.setAttribute("xsi:type", "HeartRateInBeatsPerMinute_t"); QDomElement value = doc.createElement("Value"); text = doc.createTextNode(QString("%1").arg(tHr)); value.appendChild(text); hr.appendChild(value); trackpoint.appendChild(hr); // cad if (ride->areDataPresent()->cad && point->cad < 255) { //xsd maxInclusive value="254" QDomElement cad = doc.createElement("Cadence"); text = doc.createTextNode(QString("%1").arg((int)(point->cad))); cad.appendChild(text); trackpoint.appendChild(cad); } if (ride->areDataPresent()->kph || ride->areDataPresent()->watts) { QDomElement extension = doc.createElement("Extensions"); trackpoint.appendChild(extension); QDomElement tpx = doc.createElement("TPX"); tpx.setAttribute("xmlns", "http://www.garmin.com/xmlschemas/ActivityExtension/v2"); extension.appendChild(tpx); // spd - meters per second if (ride->areDataPresent()->kph) { QDomElement spd = doc.createElement("Speed"); text = doc.createTextNode(QString("%1").arg(point->kph / 3.6)); spd.appendChild(text); tpx.appendChild(spd); } // pwr if (ride->areDataPresent()->watts) { QDomElement pwr = doc.createElement("Watts"); text = doc.createTextNode(QString("%1").arg((int)point->watts)); pwr.appendChild(text); tpx.appendChild(pwr); } } } }
m_serialPortMenu = new QMenu(tr("Select port"), this); currentMenu->addMenu(m_serialPortMenu); m_serialPortActionGroup = new QActionGroup(this); updateSerialPorts(); connect(m_serialPortMenu, SIGNAL(triggered(QAction*)), this, SLOT(setPort(QAction*))); connect(m_serialPortMenu, SIGNAL(aboutToShow()), this, SLOT(updateSerialPorts()), Qt::DirectConnection); m_programmerMenu = new QMenu(tr("Select programmer"), this); currentMenu->addMenu(m_programmerMenu); m_programmerActionGroup = new QActionGroup(this); QHash<QString, QString> programmerNames = getProgrammerNames(); foreach (QString name, programmerNames.keys()) { addProgrammer(name, programmerNames.value(name)); } connect(m_programmerMenu, SIGNAL(triggered(QAction*)), this, SLOT(setProgrammer(QAction*))); currentMenu->addSeparator(); m_programAction = new QAction(tr("Program"), this); m_programAction->setStatusTip(tr("Load the current program onto a microcontroller")); m_programAction->setEnabled(false); connect(m_programAction, SIGNAL(triggered()), this, SLOT(sendProgram())); currentMenu->addAction(m_programAction); if (!linkedFiles.isEmpty()) { bool firstTime = true; foreach (LinkedFile * linkedFile, linkedFiles) {
/*! Sets the item's transient state using given \a state data. */ void HbAbstractViewItem::setTransientState(const QHash<QString, QVariant> &state) { Q_D( HbAbstractViewItem ); d->mFocused = state.value("focused").toBool(); d->mCheckState = (Qt::CheckState)state.value("checkState").toInt(); }
bool Metadata::containsType(const QHash<QString,QVariant>& data) const { return data.contains(otp::storage::Storage::OTP_TOKEN_TYPE) && !data.value(otp::storage::Storage::OTP_TOKEN_TYPE).isNull(); }
void AutoProfileWatcher::runAppCheck() { //qDebug() << qApp->applicationFilePath(); QString appLocation; QString baseAppFileName; guidSet.clear(); // Check whether program path needs to be parsed. Removes processing time // and need to run Linux specific code searching /proc. #ifdef Q_OS_LINUX if (!appProfileAssignments.isEmpty()) { appLocation = findAppLocation(); } #else // In Windows, get program location no matter what. appLocation = findAppLocation(); if (!appLocation.isEmpty()) { baseAppFileName = QFileInfo(appLocation).fileName(); } #endif // More portable check for whether antimicro is the current application // with focus. QWidget *focusedWidget = qApp->activeWindow(); QString nowWindow; QString nowWindowClass; QString nowWindowName; #ifdef Q_OS_WIN nowWindowName = WinExtras::getCurrentWindowText(); #else unsigned long currentWindow = X11Extras::getInstance()->getWindowInFocus(); if (currentWindow > 0) { unsigned long tempWindow = X11Extras::getInstance()->findParentClient(currentWindow); if (tempWindow > 0) { currentWindow = tempWindow; } nowWindow = QString::number(currentWindow); nowWindowClass = X11Extras::getInstance()->getWindowClass(currentWindow); nowWindowName = X11Extras::getInstance()->getWindowTitle(currentWindow); //qDebug() << nowWindowClass; //qDebug() << nowWindowName; } #endif bool checkForTitleChange = windowNameProfileAssignments.size() > 0; #ifdef Q_OS_WIN if (!focusedWidget && ((!appLocation.isEmpty() && appLocation != currentApplication) || (checkForTitleChange && nowWindowName != currentAppWindowTitle))) #else if (!focusedWidget && ((!nowWindow.isEmpty() && nowWindow != currentApplication) || (checkForTitleChange && nowWindowName != currentAppWindowTitle))) #endif { #ifdef Q_OS_WIN currentApplication = appLocation; #else currentApplication = nowWindow; #endif currentAppWindowTitle = nowWindowName; //currentApplication = appLocation; QSet<AutoProfileInfo*> fullSet; if (!appLocation.isEmpty() && appProfileAssignments.contains(appLocation)) { QSet<AutoProfileInfo*> tempSet; tempSet = appProfileAssignments.value(appLocation).toSet(); fullSet.unite(tempSet); } else if (!baseAppFileName.isEmpty() && appProfileAssignments.contains(baseAppFileName)) { QSet<AutoProfileInfo*> tempSet; tempSet = appProfileAssignments.value(baseAppFileName).toSet(); fullSet.unite(tempSet); } if (!nowWindowClass.isEmpty() && windowClassProfileAssignments.contains(nowWindowClass)) { QSet<AutoProfileInfo*> tempSet; tempSet = windowClassProfileAssignments.value(nowWindowClass).toSet(); fullSet.unite(tempSet); } if (!nowWindowName.isEmpty() && windowNameProfileAssignments.contains(nowWindowName)) { QSet<AutoProfileInfo*> tempSet; tempSet = windowNameProfileAssignments.value(nowWindowName).toSet(); fullSet = fullSet.unite(tempSet); } QHash<QString, int> highestMatchCount; QHash<QString, AutoProfileInfo*> highestMatches; QSetIterator<AutoProfileInfo*> fullSetIter(fullSet); while (fullSetIter.hasNext()) { AutoProfileInfo *info = fullSetIter.next(); if (info->isActive()) { int numProps = 0; numProps += !info->getExe().isEmpty() ? 1 : 0; numProps += !info->getWindowClass().isEmpty() ? 1 : 0; numProps += !info->getWindowName().isEmpty() ? 1 : 0; int numMatched = 0; numMatched += info->getExe() == appLocation ? 1 : 0; numMatched += info->getWindowClass() == nowWindowClass ? 1 : 0; numMatched += info->getWindowName() == nowWindowName ? 1 : 0; if (numProps == numMatched) { if (highestMatchCount.contains(info->getGUID())) { int currentHigh = highestMatchCount.value(info->getGUID()); if (numMatched > currentHigh) { highestMatchCount.insert(info->getGUID(), numMatched); highestMatches.insert(info->getGUID(), info); } } else { highestMatchCount.insert(info->getGUID(), numMatched); highestMatches.insert(info->getGUID(), info); } } } } QHashIterator<QString, AutoProfileInfo*> highIter(highestMatches); while (highIter.hasNext()) { AutoProfileInfo *info = highIter.next().value(); guidSet.insert(info->getGUID()); emit foundApplicableProfile(info); } if ((!defaultProfileAssignments.isEmpty() || allDefaultInfo) && !focusedWidget) //antiProgramLocation != appLocation) { if (allDefaultInfo) { if (allDefaultInfo->isActive() && !guidSet.contains("all")) { emit foundApplicableProfile(allDefaultInfo); } } QHashIterator<QString, AutoProfileInfo*> iter(defaultProfileAssignments); while (iter.hasNext()) { iter.next(); AutoProfileInfo *info = iter.value(); if (info->isActive() && !guidSet.contains(info->getGUID())) { emit foundApplicableProfile(info); } } } } }
bool QQmlListModelWorkerAgent::event(QEvent *e) { if (e->type() == QEvent::User) { bool cc = false; QMutexLocker locker(&mutex); if (m_orig) { Sync *s = static_cast<Sync *>(e); const QList<Change> &changes = s->data.changes; cc = m_orig->count() != s->list->count(); QHash<int, QQmlListModel *> targetModelDynamicHash; QHash<int, ListModel *> targetModelStaticHash; Q_ASSERT(m_orig->m_dynamicRoles == s->list->m_dynamicRoles); if (m_orig->m_dynamicRoles) QQmlListModel::sync(s->list, m_orig, &targetModelDynamicHash); else ListModel::sync(s->list->m_listModel, m_orig->m_listModel, &targetModelStaticHash); for (int ii = 0; ii < changes.count(); ++ii) { const Change &change = changes.at(ii); QQmlListModel *model = 0; if (m_orig->m_dynamicRoles) { model = targetModelDynamicHash.value(change.modelUid); } else { ListModel *lm = targetModelStaticHash.value(change.modelUid); if (lm) model = lm->m_modelCache; } if (model) { switch (change.type) { case Change::Inserted: model->beginInsertRows( QModelIndex(), change.index, change.index + change.count - 1); model->endInsertRows(); break; case Change::Removed: model->beginRemoveRows( QModelIndex(), change.index, change.index + change.count - 1); model->endRemoveRows(); break; case Change::Moved: model->beginMoveRows( QModelIndex(), change.index, change.index + change.count - 1, QModelIndex(), change.to > change.index ? change.to + change.count : change.to); model->endMoveRows(); break; case Change::Changed: emit model->dataChanged( model->createIndex(change.index, 0), model->createIndex(change.index + change.count - 1, 0), change.roles); break; } } } } syncDone.wakeAll(); locker.unlock(); if (cc) emit m_orig->countChanged(); return true; } return QObject::event(e); }
int main(int argc, char **argv) { QCoreApplication app(argc, argv); QStringList args = app.arguments(); QTranslator translator; if (translator.load(QLatin1String("lrelease_") + QLocale::system().name())) app.installTranslator(&translator); bool verbose = true; // the default is true starting with Qt 4.2 bool ignoreUnfinished = false; // the default mode is SaveEverything starting with Qt 4.2 TranslatorSaveMode mode = SaveEverything; bool removeIdentical = false; Translator tor; QString outputFile; int numFiles = 0; for (int i = 1; i < argc; ++i) { if (args[i] == QLatin1String("-compress")) { mode = SaveStripped; continue; } else if (args[i] == QLatin1String("-nocompress")) { mode = SaveEverything; continue; } else if (args[i] == QLatin1String("-removeidentical")) { removeIdentical = true; continue; } else if (args[i] == QLatin1String("-nounfinished")) { ignoreUnfinished = true; continue; } else if (args[i] == QLatin1String("-silent")) { verbose = false; continue; } else if (args[i] == QLatin1String("-verbose")) { verbose = true; continue; } else if (args[i] == QLatin1String("-version")) { printOut(QCoreApplication::tr( "lrelease version %1\n").arg(QLatin1String(QT_VERSION_STR)) ); return 0; } else if (args[i] == QLatin1String("-qm")) { if (i == argc - 1) { printUsage(); return 1; } i++; outputFile = args[i]; } else if (args[i] == QLatin1String("-help")) { printUsage(); return 0; } else if (args[i][0] == QLatin1Char('-')) { printUsage(); return 1; } else { numFiles++; } } if (numFiles == 0) { printUsage(); return 1; } for (int i = 1; i < argc; ++i) { if (args[i][0] == QLatin1Char('-') || args[i] == outputFile) continue; if (args[i].endsWith(QLatin1String(".pro"), Qt::CaseInsensitive) || args[i].endsWith(QLatin1String(".pri"), Qt::CaseInsensitive)) { QHash<QByteArray, QStringList> varMap; bool ok = evaluateProFile(args[i], verbose, &varMap ); if (ok) { QStringList translations = varMap.value("TRANSLATIONS"); if (translations.isEmpty()) { qWarning("lrelease warning: Met no 'TRANSLATIONS' entry in" " project file '%s'\n", qPrintable(args[i])); } else { foreach (const QString &trans, translations) if (!releaseTsFile(trans, verbose, ignoreUnfinished, removeIdentical, mode)) return 1; } } else { qWarning("error: lrelease encountered project file functionality that is currently not supported.\n" "You might want to consider using .ts files as input instead of a project file.\n" "Try the following syntax:\n" " lrelease [options] ts-files [-qm qm-file]\n"); } } else {
static void syncId(ModelNode &outputNode, const ModelNode &inputNode, const QHash<QString, QString> &idRenamingHash) { if (!inputNode.id().isEmpty()) { outputNode.setId(idRenamingHash.value(inputNode.id())); } }
void AutoProfileWatcher::syncProfileAssignment() { QListIterator<QList<AutoProfileInfo*> > iterDelete(appProfileAssignments.values()); while (iterDelete.hasNext()) { QList<AutoProfileInfo*> templist = iterDelete.next(); QListIterator<AutoProfileInfo*> iterAuto(templist); while (iterAuto.hasNext()) { AutoProfileInfo *info = iterAuto.next(); if (info) { delete info; info = 0; } } } appProfileAssignments.clear(); QListIterator<AutoProfileInfo*> iterDefaultsDelete(defaultProfileAssignments.values()); while (iterDefaultsDelete.hasNext()) { AutoProfileInfo *info = iterDefaultsDelete.next(); if (info) { delete info; info = 0; } } defaultProfileAssignments.clear(); allDefaultInfo = 0; currentApplication = ""; //QStringList assignments = settings->allKeys(); //QStringListIterator iter(assignments); settings->beginGroup("DefaultAutoProfiles"); QString exe; QString guid; QString profile; QString active; QStringList defaultkeys = settings->allKeys(); settings->endGroup(); QString allProfile = settings->value(QString("DefaultAutoProfileAll/Profile"), "").toString(); QString allActive = settings->value(QString("DefaultAutoProfileAll/Active"), "0").toString(); if (!allProfile.isEmpty()) { bool defaultActive = allActive == "1" ? true : false; allDefaultInfo = new AutoProfileInfo("all", profile, defaultActive, this); allDefaultInfo->setDefaultState(true); } QStringListIterator iter(defaultkeys); while (iter.hasNext()) { QString tempkey = iter.next(); QString guid = QString(tempkey).replace("GUID", ""); QString profile = settings->value(QString("DefaultAutoProfile-%1/Profile").arg(guid), "").toString(); QString active = settings->value(QString("DefaultAutoProfile-%1/Active").arg(guid), "").toString(); if (!guid.isEmpty() && !profile.isEmpty()) { bool profileActive = active == "1" ? true : false; if (guid != "all") { AutoProfileInfo *info = new AutoProfileInfo(guid, profile, profileActive, this); info->setDefaultState(true); defaultProfileAssignments.insert(guid, info); } } } settings->beginGroup("AutoProfiles"); bool quitSearch = false; QHash<QString, QList<QString> > tempAssociation; for (int i = 1; !quitSearch; i++) { exe = settings->value(QString("AutoProfile%1Exe").arg(i), "").toString(); guid = settings->value(QString("AutoProfile%1GUID").arg(i), "").toString(); profile = settings->value(QString("AutoProfile%1Profile").arg(i), "").toString(); active = settings->value(QString("AutoProfile%1Active").arg(i), 0).toString(); // Check if all required elements exist. If not, assume that the end of the // list has been reached. if (!exe.isEmpty() && !guid.isEmpty() && !profile.isEmpty()) { bool profileActive = active == "1" ? true : false; QList<AutoProfileInfo*> templist; if (appProfileAssignments.contains(exe)) { templist = appProfileAssignments.value(exe); } QList<QString> tempguids; if (tempAssociation.contains(exe)) { tempguids = tempAssociation.value(exe); } if (!tempguids.contains(guid)) { AutoProfileInfo *info = new AutoProfileInfo(guid, profile, profileActive, this); tempguids.append(guid); tempAssociation.insert(exe, tempguids); templist.append(info); appProfileAssignments.insert(exe, templist); } } else { quitSearch = true; } } settings->endGroup(); }
void IntervalSummaryWindow::calcInterval(IntervalItem* interval, QString& html) { const RideFile* ride = context->currentRide(); bool metricUnits = context->athlete->useMetricUnits; RideFile f(ride->startTime(), ride->recIntSecs()); f.context = context; int start = ride->timeIndex(interval->start); int end = ride->timeIndex(interval->stop); for (int i = start; i <= end; ++i) { const RideFilePoint *p = ride->dataPoints()[i]; f.appendPoint(p->secs, p->cad, p->hr, p->km, p->kph, p->nm, p->watts, p->alt, p->lon, p->lat, p->headwind, p->slope, p->temp, p->lrbalance, p->lte, p->rte, p->lps, p->rps, p->smo2, p->thb, 0); // derived data RideFilePoint *l = f.dataPoints().last(); l->np = p->np; l->xp = p->xp; l->apower = p->apower; } if (f.dataPoints().size() == 0) { // Interval empty, do not compute any metrics html += "<i>" + tr("empty interval") + "</tr>"; } QString s; if (appsettings->contains(GC_SETTINGS_INTERVAL_METRICS)) s = appsettings->value(this, GC_SETTINGS_INTERVAL_METRICS).toString(); else s = GC_SETTINGS_INTERVAL_METRICS_DEFAULT; QStringList intervalMetrics = s.split(","); QHash<QString,RideMetricPtr> metrics = RideMetric::computeMetrics(context, &f, context->athlete->zones(), context->athlete->hrZones(), intervalMetrics); html += "<b>" + interval->text(0) + "</b>"; html += "<table align=\"center\" width=\"90%\" "; html += "cellspacing=0 border=0>"; foreach (QString symbol, intervalMetrics) { RideMetricPtr m = metrics.value(symbol); if (!m) continue; html += "<tr>"; // left column (names) html += "<td align=\"right\" valign=\"bottom\">" + m->name() + "</td>"; // right column (values) QString s("<td align=\"center\">%1</td>"); if (m->units(metricUnits) == "seconds" || m->units(metricUnits) == tr("seconds")) html += s.arg(time_to_string(m->value(metricUnits))); else if (m->internalName() == "Pace") { html += s.arg(QTime(0,0,0,0).addSecs(m->value(metricUnits)*60).toString("mm:ss")); } else html += s.arg(m->value(metricUnits), 0, 'f', m->precision()); html += "<td align=\"left\" valign=\"bottom\">"; if (m->units(metricUnits) == "seconds" || m->units(metricUnits) == tr("seconds")) ; // don't do anything else if (m->units(metricUnits).size() > 0) html += m->units(metricUnits); html += "</td>"; html += "</tr>"; }
void GLC_Mesh::copyIndex(int lodIndex, GLC_Mesh* pLodMesh, QHash<GLuint, GLuint>& sourceToTargetIndexMap, QHash<GLuint, GLuint>& tagetToSourceIndexMap, int& maxIndex, int targetLod) { //! The list of LOD material ID QList<GLuint> materialId= m_PrimitiveGroups.value(lodIndex)->keys(); const int materialCount= materialId.size(); for (int i= 0; i < materialCount; ++i) { GLuint currentMaterialId= materialId.at(i); GLC_Material* pCurrentMaterial= GLC_Geometry::material(currentMaterialId); // Triangles if (containsTriangles(lodIndex, currentMaterialId)) { QVector<GLuint> sourceTriangleIndex= getTrianglesIndex(lodIndex, currentMaterialId); QList<GLuint> targetTriangleIndex; const int triangleIndexCount= sourceTriangleIndex.size(); for (int i= 0; i < triangleIndexCount; ++i) { const GLuint currentIndex= sourceTriangleIndex.at(i); if (!sourceToTargetIndexMap.contains(currentIndex)) { sourceToTargetIndexMap.insert(currentIndex, ++maxIndex); tagetToSourceIndexMap.insert(maxIndex, currentIndex); targetTriangleIndex.append(maxIndex); } else { targetTriangleIndex.append(sourceToTargetIndexMap.value(currentIndex)); } } pLodMesh->addTriangles(pCurrentMaterial, targetTriangleIndex, targetLod, m_MeshData.getLod(lodIndex)->accuracy()); } //Triangles strips if (containsStrips(lodIndex, currentMaterialId)) { QList<QVector<GLuint> > sourceStripIndex= getStripsIndex(lodIndex, currentMaterialId); const int stripCount= sourceStripIndex.size(); for (int stripIndex= 0; stripIndex < stripCount; ++stripIndex) { QVector<GLuint> sourceTriangleStripIndex= sourceStripIndex.at(stripIndex); QList<GLuint> targetTriangleStripIndex; const int triangleStripIndexCount= sourceTriangleStripIndex.size(); for (int i= 0; i < triangleStripIndexCount; ++i) { const GLuint currentIndex= sourceTriangleStripIndex.at(i); if (!sourceToTargetIndexMap.contains(currentIndex)) { sourceToTargetIndexMap.insert(currentIndex, ++maxIndex); tagetToSourceIndexMap.insert(maxIndex, currentIndex); targetTriangleStripIndex.append(maxIndex); } else { targetTriangleStripIndex.append(sourceToTargetIndexMap.value(currentIndex)); } } pLodMesh->addTrianglesStrip(pCurrentMaterial, targetTriangleStripIndex, targetLod, m_MeshData.getLod(lodIndex)->accuracy()); } } //Triangles fans if (containsFans(lodIndex, currentMaterialId)) { QList<QVector<GLuint> > sourceFanIndex= getFansIndex(lodIndex, currentMaterialId); const int fanCount= sourceFanIndex.size(); for (int fanIndex= 0; fanIndex < fanCount; ++fanIndex) { QVector<GLuint> sourceTriangleFanIndex= sourceFanIndex.at(fanIndex); QList<GLuint> targetTriangleFanIndex; const int triangleFanIndexCount= sourceTriangleFanIndex.size(); for (int i= 0; i < triangleFanIndexCount; ++i) { const GLuint currentIndex= sourceTriangleFanIndex.at(i); if (!sourceToTargetIndexMap.contains(currentIndex)) { sourceToTargetIndexMap.insert(currentIndex, ++maxIndex); tagetToSourceIndexMap.insert(maxIndex, currentIndex); targetTriangleFanIndex.append(maxIndex); } else { targetTriangleFanIndex.append(sourceToTargetIndexMap.value(currentIndex)); } } pLodMesh->addTrianglesFan(pCurrentMaterial, targetTriangleFanIndex, targetLod, m_MeshData.getLod(lodIndex)->accuracy()); } } } }
void GraphUtils::minCut(QList<ConnectorItem *> & connectorItems, QList<SketchWidget *> & foreignSketchWidgets, ConnectorItem * source, ConnectorItem * sink, QList<ConnectorEdge *> & minCut) { // this helped: http://boost.2283326.n4.nabble.com/graph-edmund-karp-max-flow-vs-kolmogorov-max-flow-color-map-td2565611.html using namespace boost; typedef adjacency_list_traits < vecS, vecS, directedS > Traits; typedef property < vertex_color_t, boost::default_color_type > COLOR; typedef property < vertex_index_t, long, COLOR > VERTEX; typedef property < edge_reverse_t, Traits::edge_descriptor > REVERSE; typedef property < edge_residual_capacity_t, long, REVERSE > RESIDUAL; typedef property < edge_capacity_t, long, RESIDUAL > EDGE; typedef adjacency_list < listS, vecS, directedS, VERTEX, EDGE > Graph; Graph g; property_map < Graph, edge_capacity_t >::type capacity = get(edge_capacity, g); property_map < Graph, edge_residual_capacity_t >::type residual_capacity = get(edge_residual_capacity, g); property_map < Graph, edge_reverse_t >::type reverse = get(edge_reverse, g); property_map < Graph, vertex_color_t >::type color = get(vertex_color, g); property_map < Graph, vertex_index_t >::type index = get(vertex_index, g); Traits::vertex_descriptor s, t; QList<Wire *> visitedWires; QList<int> indexes; QHash<ConnectorItem *, int> vertices; QList<ConnectorEdge *> edges; QVector<Traits::vertex_descriptor> verts; vertices.insert(source, 0); vertices.insert(sink, 1); verts.append(s = add_vertex(g)); verts.append(t = add_vertex(g)); foreach (ConnectorItem * connectorItem, connectorItems) { //connectorItem->debugInfo("input"); if (connectorItem->attachedToItemType() == ModelPart::Wire) { Wire * wire = qobject_cast<Wire *>(connectorItem->attachedTo()); if (visitedWires.contains(wire)) continue; QList<Wire *> wires; QList<ConnectorItem *> ends; wire->collectChained(wires, ends); visitedWires.append(wires); if (ends.count() < 2) continue; foreach (ConnectorItem * end, ends) { appendVertIf(end, vertices, verts); } for (int i = 0; i < ends.count(); i++) { ConnectorItem * end = ends[i]; for (int j = i + 1; j < ends.count(); j++) { ConnectorEdge * connectorEdge = makeConnectorEdge(edges, end, ends[j], 1000, wire); connectorEdge->setHeadTail(vertices.value(connectorEdge->c0), vertices.value(connectorEdge->c1)); } } continue; }