void KeePass2Writer::writeDatabase(QIODevice* device, Database* db) { m_error = false; m_errorStr.clear(); QByteArray masterSeed = randomGen()->randomArray(32); QByteArray encryptionIV = randomGen()->randomArray(16); QByteArray protectedStreamKey = randomGen()->randomArray(32); QByteArray startBytes = randomGen()->randomArray(32); QByteArray endOfHeader = "\r\n\r\n"; CryptoHash hash(CryptoHash::Sha256); hash.addData(masterSeed); Q_ASSERT(!db->transformedMasterKey().isEmpty()); hash.addData(db->transformedMasterKey()); QByteArray finalKey = hash.result(); QBuffer header; header.open(QIODevice::WriteOnly); m_device = &header; CHECK_RETURN(writeData(Endian::int32ToBytes(KeePass2::SIGNATURE_1, KeePass2::BYTEORDER))); CHECK_RETURN(writeData(Endian::int32ToBytes(KeePass2::SIGNATURE_2, KeePass2::BYTEORDER))); CHECK_RETURN(writeData(Endian::int32ToBytes(KeePass2::FILE_VERSION, KeePass2::BYTEORDER))); CHECK_RETURN(writeHeaderField(KeePass2::CipherID, db->cipher().toByteArray())); CHECK_RETURN(writeHeaderField(KeePass2::CompressionFlags, Endian::int32ToBytes(db->compressionAlgo(), KeePass2::BYTEORDER))); CHECK_RETURN(writeHeaderField(KeePass2::MasterSeed, masterSeed)); CHECK_RETURN(writeHeaderField(KeePass2::TransformSeed, db->transformSeed())); CHECK_RETURN(writeHeaderField(KeePass2::TransformRounds, Endian::int64ToBytes(db->transformRounds(), KeePass2::BYTEORDER))); CHECK_RETURN(writeHeaderField(KeePass2::EncryptionIV, encryptionIV)); CHECK_RETURN(writeHeaderField(KeePass2::ProtectedStreamKey, protectedStreamKey)); CHECK_RETURN(writeHeaderField(KeePass2::StreamStartBytes, startBytes)); CHECK_RETURN(writeHeaderField(KeePass2::InnerRandomStreamID, Endian::int32ToBytes(KeePass2::Salsa20, KeePass2::BYTEORDER))); CHECK_RETURN(writeHeaderField(KeePass2::EndOfHeader, endOfHeader)); header.close(); m_device = device; QByteArray headerHash = CryptoHash::hash(header.data(), CryptoHash::Sha256); CHECK_RETURN(writeData(header.data())); SymmetricCipherStream cipherStream(device, SymmetricCipher::Aes256, SymmetricCipher::Cbc, SymmetricCipher::Encrypt, finalKey, encryptionIV); cipherStream.open(QIODevice::WriteOnly); m_device = &cipherStream; CHECK_RETURN(writeData(startBytes)); HashedBlockStream hashedStream(&cipherStream); hashedStream.open(QIODevice::WriteOnly); QScopedPointer<QtIOCompressor> ioCompressor; if (db->compressionAlgo() == Database::CompressionNone) { m_device = &hashedStream; } else { ioCompressor.reset(new QtIOCompressor(&hashedStream)); ioCompressor->setStreamFormat(QtIOCompressor::GzipFormat); ioCompressor->open(QIODevice::WriteOnly); m_device = ioCompressor.data(); } KeePass2RandomStream randomStream(protectedStreamKey); KeePass2XmlWriter xmlWriter; xmlWriter.writeDatabase(m_device, db, &randomStream, headerHash); }
int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); QString serialPortName; QString serialPortFriendlyName; QString sisFile; QString exeFile; QStringList cmdLine; QStringList args = QCoreApplication::arguments(); QTextStream outstream(stdout); QTextStream errstream(stderr); QString uploadLocalFile; QString uploadRemoteFile; QString downloadRemoteFile; QString downloadLocalFile; QString dstName = "c:\\data\\testtemp.sis"; int loglevel=1; int timeout=0; bool crashlog = true; enum {AgentUnknown, AgentCoda, AgentTRK} debugAgent = AgentUnknown; QString crashlogpath; QListIterator<QString> it(args); it.next(); //skip name of program while (it.hasNext()) { QString arg = it.next(); if (arg.startsWith("-")) { if (arg == "--portname" || arg == "-p") { CHECK_PARAMETER_EXISTS serialPortName = it.next(); } else if (arg == "--portfriendlyname" || arg == "-f") { CHECK_PARAMETER_EXISTS serialPortFriendlyName = it.next(); } else if (arg == "--sis" || arg == "-s") { CHECK_PARAMETER_EXISTS sisFile = it.next(); if (!QFileInfo(sisFile).exists()) { errstream << "Sis file (" << sisFile << ") doesn't exist" << endl; return 1; } } else if (arg == "--upload" || arg == "-u") { CHECK_PARAMETER_EXISTS uploadLocalFile = it.next(); if (!QFileInfo(uploadLocalFile).exists()) { errstream << "Executable file (" << uploadLocalFile << ") doesn't exist" << endl; return 1; } CHECK_PARAMETER_EXISTS uploadRemoteFile = it.next(); } else if (arg == "--download" || arg == "-d") { CHECK_PARAMETER_EXISTS downloadRemoteFile = it.next(); CHECK_PARAMETER_EXISTS downloadLocalFile = it.next(); QFileInfo downloadInfo(downloadLocalFile); if (downloadInfo.exists() && !downloadInfo.isFile()) { errstream << downloadLocalFile << " is not a file." << endl; return 1; } } else if (arg == "--timeout" || arg == "-t") { CHECK_PARAMETER_EXISTS bool ok; timeout = it.next().toInt(&ok); if (!ok) { errstream << "Timeout must be specified in milliseconds" << endl; return 1; } } else if (arg == "--coda") debugAgent = AgentCoda; else if (arg == "--trk") debugAgent = AgentTRK; else if (arg == "--tempfile" || arg == "-T") { CHECK_PARAMETER_EXISTS dstName = it.next(); } else if (arg == "--verbose" || arg == "-v") loglevel=2; else if (arg == "--quiet" || arg == "-q") loglevel=0; else if (arg == "--nocrashlog") crashlog = false; else if (arg == "--crashlogpath") { CHECK_PARAMETER_EXISTS crashlogpath = it.next(); } else errstream << "unknown command line option " << arg << endl; } else { exeFile = arg; while(it.hasNext()) { cmdLine.append(it.next()); } } } if (exeFile.isEmpty() && sisFile.isEmpty() && (uploadLocalFile.isEmpty() || uploadRemoteFile.isEmpty()) && (downloadLocalFile.isEmpty() || downloadRemoteFile.isEmpty())) { printUsage(outstream, args[0]); return 1; } if (!uploadLocalFile.isEmpty() && (!downloadLocalFile.isEmpty() || !downloadRemoteFile.isEmpty())) { errstream << "Upload option can't be used together with download" << endl; printUsage(outstream, args[0]); return 1; } if (serialPortName.isEmpty()) { if (loglevel > 0) outstream << "Detecting serial ports" << endl; foreach (const SerialPortId &id, enumerateSerialPorts(loglevel)) { if (loglevel > 0) outstream << "Port Name: " << id.portName << ", " << "Friendly Name:" << id.friendlyName << endl; if (!id.friendlyName.isEmpty() && serialPortFriendlyName.isEmpty() && (id.friendlyName.contains("symbian", Qt::CaseInsensitive) || id.friendlyName.contains("s60", Qt::CaseInsensitive) || id.friendlyName.contains("nokia", Qt::CaseInsensitive))) { serialPortName = id.portName; break; } else if (!id.friendlyName.isEmpty() && !serialPortFriendlyName.isEmpty() && id.friendlyName.contains(serialPortFriendlyName)) { serialPortName = id.portName; break; } } if (serialPortName.isEmpty()) { errstream << "No phone found, ensure USB cable is connected or specify manually with -p" << endl; return 1; } } CodaSignalHandler codaHandler; QScopedPointer<trk::Launcher> launcher; TrkSignalHandler trkHandler; QFileInfo info(exeFile); QFileInfo uploadInfo(uploadLocalFile); if (debugAgent == AgentUnknown) { outstream << "detecting debug agent..." << endl; CodaSignalHandler codaDetector; //auto detect agent codaDetector.setSerialPortName(serialPortName); codaDetector.setLogLevel(loglevel); codaDetector.setActionType(ActionPingOnly); codaDetector.setTimeout(1000); if (!codaDetector.run()) { debugAgent = AgentCoda; outstream << " - Coda is found" << endl; } else { debugAgent = AgentTRK; outstream << " - Coda is not found, defaulting to TRK" << endl; } } if (debugAgent == AgentCoda) { codaHandler.setSerialPortName(serialPortName); codaHandler.setLogLevel(loglevel); if (!sisFile.isEmpty()) { codaHandler.setActionType(ActionCopyInstall); codaHandler.setCopyFileName(sisFile, dstName); } else if (!uploadLocalFile.isEmpty() && uploadInfo.exists()) { codaHandler.setActionType(ActionCopy); codaHandler.setCopyFileName(uploadLocalFile, uploadRemoteFile); } if (!exeFile.isEmpty()) { codaHandler.setActionType(ActionRun); codaHandler.setAppFileName(QString("c:\\sys\\bin\\") + info.fileName()); codaHandler.setCommandLineArgs(cmdLine.join(QLatin1String(", "))); } if (!downloadRemoteFile.isEmpty() && !downloadLocalFile.isEmpty()) { codaHandler.setActionType(ActionDownload); codaHandler.setDownloadFileName(downloadRemoteFile, downloadLocalFile); } if (loglevel > 0) outstream << "Connecting to target via " << serialPortName << endl; if (timeout > 0) codaHandler.setTimeout(timeout); QObject::connect(OsSignalConverter::instance(), SIGNAL(terminate()), &codaHandler, SLOT(terminate()), Qt::QueuedConnection); return codaHandler.run(); } else { launcher.reset(new trk::Launcher(trk::Launcher::ActionPingOnly, SymbianUtils::SymbianDeviceManager::instance()->acquireDevice(serialPortName))); QStringList srcNames, dstNames; if (!sisFile.isEmpty()) { launcher->addStartupActions(trk::Launcher::ActionCopyInstall); srcNames.append(sisFile); dstNames.append(dstName); launcher->setInstallFileNames(QStringList(dstName)); } if (!uploadLocalFile.isEmpty() && uploadInfo.exists()) { launcher->addStartupActions(trk::Launcher::ActionCopy); srcNames.append(uploadLocalFile); dstNames.append(uploadRemoteFile); } launcher->setCopyFileNames(srcNames, dstNames); if (!exeFile.isEmpty()) { launcher->addStartupActions(trk::Launcher::ActionRun); launcher->setFileName(QString("c:\\sys\\bin\\") + info.fileName()); launcher->setCommandLineArgs(cmdLine.join(QLatin1String(" "))); } if (!downloadRemoteFile.isEmpty() && !downloadLocalFile.isEmpty()) { launcher->addStartupActions(trk::Launcher::ActionDownload); launcher->setDownloadFileName(downloadRemoteFile, downloadLocalFile); } if (loglevel > 0) outstream << "Connecting to target via " << serialPortName << endl; launcher->setTrkServerName(serialPortName); if (loglevel > 1) launcher->setVerbose(1); trkHandler.setLogLevel(loglevel); trkHandler.setCrashLogging(crashlog); trkHandler.setCrashLogPath(crashlogpath); QObject::connect(launcher.data(), SIGNAL(copyingStarted(const QString &)), &trkHandler, SLOT(copyingStarted(const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotConnect(const QString &)), &trkHandler, SLOT(canNotConnect(const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotCreateFile(const QString &, const QString &)), &trkHandler, SLOT(canNotCreateFile(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotWriteFile(const QString &, const QString &)), &trkHandler, SLOT(canNotWriteFile(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotCloseFile(const QString &, const QString &)), &trkHandler, SLOT(canNotCloseFile(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(installingStarted(const QString &)), &trkHandler, SLOT(installingStarted(const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotInstall(const QString &, const QString &)), &trkHandler, SLOT(canNotInstall(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(installingFinished()), &trkHandler, SLOT(installingFinished())); QObject::connect(launcher.data(), SIGNAL(startingApplication()), &trkHandler, SLOT(startingApplication())); QObject::connect(launcher.data(), SIGNAL(applicationRunning(uint)), &trkHandler, SLOT(applicationRunning(uint))); QObject::connect(launcher.data(), SIGNAL(canNotRun(const QString &)), &trkHandler, SLOT(canNotRun(const QString &))); QObject::connect(launcher.data(), SIGNAL(applicationOutputReceived(const QString &)), &trkHandler, SLOT(applicationOutputReceived(const QString &))); QObject::connect(launcher.data(), SIGNAL(copyProgress(int)), &trkHandler, SLOT(copyProgress(int))); QObject::connect(launcher.data(), SIGNAL(stateChanged(int)), &trkHandler, SLOT(stateChanged(int))); QObject::connect(launcher.data(), SIGNAL(processStopped(uint,uint,uint,QString)), &trkHandler, SLOT(stopped(uint,uint,uint,QString))); QObject::connect(launcher.data(), SIGNAL(libraryLoaded(trk::Library)), &trkHandler, SLOT(libraryLoaded(trk::Library))); QObject::connect(launcher.data(), SIGNAL(libraryUnloaded(trk::Library)), &trkHandler, SLOT(libraryUnloaded(trk::Library))); QObject::connect(launcher.data(), SIGNAL(registersAndCallStackReadComplete(const QList<uint> &,const QByteArray &)), &trkHandler, SLOT(registersAndCallStackReadComplete(const QList<uint> &,const QByteArray &))); QObject::connect(&trkHandler, SIGNAL(resume(uint,uint)), launcher.data(), SLOT(resumeProcess(uint,uint))); QObject::connect(&trkHandler, SIGNAL(terminate()), launcher.data(), SLOT(terminate())); QObject::connect(&trkHandler, SIGNAL(getRegistersAndCallStack(uint,uint)), launcher.data(), SLOT(getRegistersAndCallStack(uint,uint))); QObject::connect(launcher.data(), SIGNAL(finished()), &trkHandler, SLOT(finished())); QObject::connect(OsSignalConverter::instance(), SIGNAL(terminate()), launcher.data(), SLOT(terminate()), Qt::QueuedConnection); QTimer timer; timer.setSingleShot(true); QObject::connect(&timer, SIGNAL(timeout()), &trkHandler, SLOT(timeout())); if (timeout > 0) { timer.start(timeout); } QString errorMessage; if (!launcher->startServer(&errorMessage)) { errstream << errorMessage << endl; return 1; } } return a.exec(); }
void PrimerLibrary::initPrimerUdr(U2OpStatus &os) { CHECK(NULL == AppContext::getUdrSchemaRegistry()->getSchemaById(PRIMER_UDR_ID), ); UdrSchema::FieldDesc name("name", UdrSchema::STRING); UdrSchema::FieldDesc sequence("sequence", UdrSchema::STRING); UdrSchema::FieldDesc gc("GC", UdrSchema::DOUBLE); UdrSchema::FieldDesc tm("Tm", UdrSchema::DOUBLE); QScopedPointer<UdrSchema> primerSchema(new UdrSchema(PRIMER_UDR_ID)); primerSchema->addField(name, os); primerSchema->addField(sequence, os); primerSchema->addField(gc, os); primerSchema->addField(tm, os); CHECK_OP(os, ); AppContext::getUdrSchemaRegistry()->registerSchema(primerSchema.data(), os); if (!os.hasError()) { primerSchema.take(); } } void PrimerLibrary::addPrimer(const Primer &primer, U2OpStatus &os) { QList<UdrValue> values; values << UdrValue(primer.name); values << UdrValue(primer.sequence); values << UdrValue(primer.gc); values << UdrValue(primer.tm); UdrRecordId record = udrDbi->addRecord(PRIMER_UDR_ID, values, os); CHECK_OP(os, ); emit si_primerAdded(record.getRecordId());
TankInfoModel *TankInfoModel::instance() { static QScopedPointer<TankInfoModel> self(new TankInfoModel()); return self.data(); }
void QgsVectorLayerRenderer::drawRendererV2Levels( QgsFeatureIterator& fit ) { QHash< QgsSymbolV2*, QList<QgsFeature> > features; // key = symbol, value = array of features QgsSingleSymbolRendererV2* selRenderer = nullptr; if ( !mSelectedFeatureIds.isEmpty() ) { selRenderer = new QgsSingleSymbolRendererV2( QgsSymbolV2::defaultSymbol( mGeometryType ) ); selRenderer->symbol()->setColor( mContext.selectionColor() ); selRenderer->setVertexMarkerAppearance( mVertexMarkerStyle, mVertexMarkerSize ); selRenderer->startRender( mContext, mFields ); } QgsExpressionContextScope* symbolScope = QgsExpressionContextUtils::updateSymbolScope( nullptr, new QgsExpressionContextScope() ); mContext.expressionContext().appendScope( symbolScope ); // 1. fetch features QgsFeature fet; while ( fit.nextFeature( fet ) ) { if ( mContext.renderingStopped() ) { qDebug( "rendering stop!" ); stopRendererV2( selRenderer ); delete mContext.expressionContext().popScope(); return; } if ( !fet.constGeometry() ) continue; // skip features without geometry mContext.expressionContext().setFeature( fet ); QgsSymbolV2* sym = mRendererV2->symbolForFeature( fet, mContext ); if ( !sym ) { continue; } if ( !features.contains( sym ) ) { features.insert( sym, QList<QgsFeature>() ); } features[sym].append( fet ); if ( mCache ) { // Cache this for the use of (e.g.) modifying the feature's uncommitted geometry. mCache->cacheGeometry( fet.id(), *fet.constGeometry() ); } if ( mContext.labelingEngine() ) { mContext.expressionContext().setFeature( fet ); if ( mLabeling ) { mContext.labelingEngine()->registerFeature( mLayerID, fet, mContext ); } if ( mDiagrams ) { mContext.labelingEngine()->registerDiagramFeature( mLayerID, fet, mContext ); } } // new labeling engine if ( mContext.labelingEngineV2() ) { QScopedPointer<QgsGeometry> obstacleGeometry; QgsSymbolV2List symbols = mRendererV2->originalSymbolsForFeature( fet, mContext ); if ( !symbols.isEmpty() && fet.constGeometry()->type() == QGis::Point ) { obstacleGeometry.reset( QgsVectorLayerLabelProvider::getPointObstacleGeometry( fet, mContext, symbols ) ); } if ( !symbols.isEmpty() ) { QgsExpressionContextUtils::updateSymbolScope( symbols.at( 0 ), symbolScope ); } if ( mLabelProvider ) { mLabelProvider->registerFeature( fet, mContext, obstacleGeometry.data() ); } if ( mDiagramProvider ) { mDiagramProvider->registerFeature( fet, mContext, obstacleGeometry.data() ); } } } delete mContext.expressionContext().popScope(); // find out the order QgsSymbolV2LevelOrder levels; QgsSymbolV2List symbols = mRendererV2->symbols( mContext ); for ( int i = 0; i < symbols.count(); i++ ) { QgsSymbolV2* sym = symbols[i]; for ( int j = 0; j < sym->symbolLayerCount(); j++ ) { int level = sym->symbolLayer( j )->renderingPass(); if ( level < 0 || level >= 1000 ) // ignore invalid levels continue; QgsSymbolV2LevelItem item( sym, j ); while ( level >= levels.count() ) // append new empty levels levels.append( QgsSymbolV2Level() ); levels[level].append( item ); } } // 2. draw features in correct order for ( int l = 0; l < levels.count(); l++ ) { QgsSymbolV2Level& level = levels[l]; for ( int i = 0; i < level.count(); i++ ) { QgsSymbolV2LevelItem& item = level[i]; if ( !features.contains( item.symbol() ) ) { QgsDebugMsg( "level item's symbol not found!" ); continue; } int layer = item.layer(); QList<QgsFeature>& lst = features[item.symbol()]; QList<QgsFeature>::iterator fit; for ( fit = lst.begin(); fit != lst.end(); ++fit ) { if ( mContext.renderingStopped() ) { stopRendererV2( selRenderer ); return; } bool sel = mSelectedFeatureIds.contains( fit->id() ); // maybe vertex markers should be drawn only during the last pass... bool drawMarker = ( mDrawVertexMarkers && mContext.drawEditingInformation() && ( !mVertexMarkerOnlyForSelection || sel ) ); mContext.expressionContext().setFeature( *fit ); try { mRendererV2->renderFeature( *fit, mContext, layer, sel, drawMarker ); } catch ( const QgsCsException &cse ) { Q_UNUSED( cse ); QgsDebugMsg( QString( "Failed to transform a point while drawing a feature with ID '%1'. Ignoring this feature. %2" ) .arg( fet.id() ).arg( cse.what() ) ); } } } } stopRendererV2( selRenderer ); }
int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); QString serialPortName; QString serialPortFriendlyName; QString sisFile; QString exeFile; QStringList cmdLine; QStringList args = QCoreApplication::arguments(); QTextStream outstream(stdout); QTextStream errstream(stderr); QString downloadRemoteFile; QString downloadLocalFile; int loglevel=1; int timeout=0; QListIterator<QString> it(args); it.next(); //skip name of program while (it.hasNext()) { QString arg = it.next(); if (arg.startsWith("-")) { if (arg == "--portname" || arg == "-p") { CHECK_PARAMETER_EXISTS serialPortName = it.next(); } else if (arg == "--portfriendlyname" || arg == "-f") { CHECK_PARAMETER_EXISTS serialPortFriendlyName = it.next(); } else if (arg == "--sis" || arg == "-s") { CHECK_PARAMETER_EXISTS sisFile = it.next(); } else if (arg == "--download" || arg == "-d") { CHECK_PARAMETER_EXISTS downloadRemoteFile = it.next(); CHECK_PARAMETER_EXISTS downloadLocalFile = it.next(); } else if (arg == "--timeout" || arg == "-t") { CHECK_PARAMETER_EXISTS bool ok; timeout = it.next().toInt(&ok); if (!ok) { errstream << "Timeout must be specified in milliseconds" << endl; return 1; } } else if (arg == "--verbose" || arg == "-v") loglevel=2; else if (arg == "--quiet" || arg == "-q") loglevel=0; else errstream << "unknown command line option " << arg << endl; } else { exeFile = arg; while(it.hasNext()) { cmdLine.append(it.next()); } } } if (exeFile.isEmpty() && sisFile.isEmpty() && (downloadLocalFile.isEmpty() || downloadRemoteFile.isEmpty())) { printUsage(outstream, args[0]); return 1; } if (serialPortName.isEmpty()) { if (loglevel > 0) outstream << "Detecting serial ports" << endl; foreach (const SerialPortId &id, enumerateSerialPorts()) { if (loglevel > 0) outstream << "Port Name: " << id.portName << ", " << "Friendly Name:" << id.friendlyName << endl; if (!id.friendlyName.isEmpty() && serialPortFriendlyName.isEmpty() && (id.friendlyName.contains("symbian", Qt::CaseInsensitive) || id.friendlyName.contains("s60", Qt::CaseInsensitive) || id.friendlyName.contains("nokia", Qt::CaseInsensitive))) { serialPortName = id.portName; break; } else if (!id.friendlyName.isEmpty() && !serialPortFriendlyName.isEmpty() && id.friendlyName.contains(serialPortFriendlyName)) { serialPortName = id.portName; break; } } if (serialPortName.isEmpty()) { errstream << "No phone found, ensure USB cable is connected or specify manually with -p" << endl; return 1; } } QScopedPointer<trk::Launcher> launcher; launcher.reset(new trk::Launcher(trk::Launcher::ActionPingOnly)); QFileInfo info(exeFile); if (!sisFile.isEmpty()) { launcher->addStartupActions(trk::Launcher::ActionCopyInstall); launcher->setCopyFileName(sisFile, "c:\\data\\testtemp.sis"); launcher->setInstallFileName("c:\\data\\testtemp.sis"); } else if (info.exists()) { launcher->addStartupActions(trk::Launcher::ActionCopy); launcher->setCopyFileName(exeFile, QString("c:\\sys\\bin\\") + info.fileName()); } if (!exeFile.isEmpty()) { launcher->addStartupActions(trk::Launcher::ActionRun); launcher->setFileName(QString("c:\\sys\\bin\\") + info.fileName()); launcher->setCommandLineArgs(cmdLine); } if (!downloadRemoteFile.isEmpty() && !downloadLocalFile.isEmpty()) { launcher->addStartupActions(trk::Launcher::ActionDownload); launcher->setDownloadFileName(downloadRemoteFile, downloadLocalFile); } if (loglevel > 0) outstream << "Connecting to target via " << serialPortName << endl; launcher->setTrkServerName(serialPortName); if (loglevel > 1) launcher->setVerbose(1); TrkSignalHandler handler; handler.setLogLevel(loglevel); QObject::connect(launcher.data(), SIGNAL(copyingStarted()), &handler, SLOT(copyingStarted())); QObject::connect(launcher.data(), SIGNAL(canNotConnect(const QString &)), &handler, SLOT(canNotConnect(const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotCreateFile(const QString &, const QString &)), &handler, SLOT(canNotCreateFile(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotWriteFile(const QString &, const QString &)), &handler, SLOT(canNotWriteFile(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(canNotCloseFile(const QString &, const QString &)), &handler, SLOT(canNotCloseFile(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(installingStarted()), &handler, SLOT(installingStarted())); QObject::connect(launcher.data(), SIGNAL(canNotInstall(const QString &, const QString &)), &handler, SLOT(canNotInstall(const QString &, const QString &))); QObject::connect(launcher.data(), SIGNAL(installingFinished()), &handler, SLOT(installingFinished())); QObject::connect(launcher.data(), SIGNAL(startingApplication()), &handler, SLOT(startingApplication())); QObject::connect(launcher.data(), SIGNAL(applicationRunning(uint)), &handler, SLOT(applicationRunning(uint))); QObject::connect(launcher.data(), SIGNAL(canNotRun(const QString &)), &handler, SLOT(canNotRun(const QString &))); QObject::connect(launcher.data(), SIGNAL(applicationOutputReceived(const QString &)), &handler, SLOT(applicationOutputReceived(const QString &))); QObject::connect(launcher.data(), SIGNAL(copyProgress(int)), &handler, SLOT(copyProgress(int))); QObject::connect(launcher.data(), SIGNAL(stateChanged(int)), &handler, SLOT(stateChanged(int))); QObject::connect(launcher.data(), SIGNAL(processStopped(uint,uint,uint,QString)), &handler, SLOT(stopped(uint,uint,uint,QString))); QObject::connect(&handler, SIGNAL(resume(uint,uint)), launcher.data(), SLOT(resumeProcess(uint,uint))); QObject::connect(&handler, SIGNAL(terminate()), launcher.data(), SLOT(terminate())); QObject::connect(launcher.data(), SIGNAL(finished()), &handler, SLOT(finished())); QTimer timer; timer.setSingleShot(true); QObject::connect(&timer, SIGNAL(timeout()), &handler, SLOT(timeout())); if (timeout > 0) { timer.start(timeout); } QString errorMessage; if (!launcher->startServer(&errorMessage)) { errstream << errorMessage << endl; return 1; } return a.exec(); }
WSInfoModel *WSInfoModel::instance() { static QScopedPointer<WSInfoModel> self(new WSInfoModel()); return self.data(); }
/****************************************************************************** * This is the high-level rendering function, which invokes the renderer to generate one or more * output images of the scene. All rendering parameters are specified in the RenderSettings object. ******************************************************************************/ bool DataSet::renderScene(RenderSettings* settings, Viewport* viewport, QSharedPointer<FrameBuffer> frameBuffer, FrameBufferWindow* frameBufferWindow) { OVITO_CHECK_OBJECT_POINTER(settings); OVITO_CHECK_OBJECT_POINTER(viewport); // If the caller did not supply a frame buffer, get the default frame buffer for the output image, or create a temporary one if necessary. if(!frameBuffer) { if(Application::instance().guiMode()) { OVITO_ASSERT(mainWindow()); frameBufferWindow = mainWindow()->frameBufferWindow(); frameBuffer = frameBufferWindow->frameBuffer(); } if(!frameBuffer) { frameBuffer.reset(new FrameBuffer(settings->outputImageWidth(), settings->outputImageHeight())); } } // Get the selected scene renderer. SceneRenderer* renderer = settings->renderer(); if(!renderer) throw Exception(tr("No renderer has been selected.")); bool wasCanceled = false; try { // Set up the frame buffer for the output image. if(frameBufferWindow && frameBufferWindow->frameBuffer() != frameBuffer) { frameBufferWindow->setFrameBuffer(frameBuffer); frameBufferWindow->resize(frameBufferWindow->sizeHint()); } if(frameBuffer->size() != QSize(settings->outputImageWidth(), settings->outputImageHeight())) { frameBuffer->setSize(QSize(settings->outputImageWidth(), settings->outputImageHeight())); frameBuffer->clear(); if(frameBufferWindow) frameBufferWindow->resize(frameBufferWindow->sizeHint()); } if(frameBufferWindow) { if(frameBufferWindow->isHidden()) { // Center frame buffer window in main window. if(frameBufferWindow->parentWidget()) { QSize s = frameBufferWindow->frameGeometry().size(); frameBufferWindow->move(frameBufferWindow->parentWidget()->geometry().center() - QPoint(s.width() / 2, s.height() / 2)); } frameBufferWindow->show(); } frameBufferWindow->activateWindow(); } // Show progress dialog. std::unique_ptr<QProgressDialog> progressDialog; if(Application::instance().guiMode()) { progressDialog.reset(new QProgressDialog(frameBufferWindow ? (QWidget*)frameBufferWindow : (QWidget*)mainWindow())); progressDialog->setWindowModality(Qt::WindowModal); progressDialog->setAutoClose(false); progressDialog->setAutoReset(false); progressDialog->setMinimumDuration(0); progressDialog->setValue(0); } // Don't update viewports while rendering. ViewportSuspender noVPUpdates(this); // Initialize the renderer. if(renderer->startRender(this, settings)) { VideoEncoder* videoEncoder = nullptr; #ifdef OVITO_VIDEO_OUTPUT_SUPPORT QScopedPointer<VideoEncoder> videoEncoderPtr; // Initialize video encoder. if(settings->saveToFile() && settings->imageInfo().isMovie()) { if(settings->imageFilename().isEmpty()) throw Exception(tr("Cannot save rendered images to movie file. Output filename has not been specified.")); videoEncoderPtr.reset(new VideoEncoder()); videoEncoder = videoEncoderPtr.data(); videoEncoder->openFile(settings->imageFilename(), settings->outputImageWidth(), settings->outputImageHeight(), animationSettings()->framesPerSecond()); } #endif if(settings->renderingRangeType() == RenderSettings::CURRENT_FRAME) { // Render a single frame. TimePoint renderTime = animationSettings()->time(); int frameNumber = animationSettings()->timeToFrame(renderTime); if(frameBufferWindow) frameBufferWindow->setWindowTitle(tr("Frame %1").arg(frameNumber)); if(!renderFrame(renderTime, frameNumber, settings, renderer, viewport, frameBuffer.data(), videoEncoder, progressDialog.get())) wasCanceled = true; } else if(settings->renderingRangeType() == RenderSettings::ANIMATION_INTERVAL || settings->renderingRangeType() == RenderSettings::CUSTOM_INTERVAL) { // Render an animation interval. TimePoint renderTime; int firstFrameNumber, numberOfFrames; if(settings->renderingRangeType() == RenderSettings::ANIMATION_INTERVAL) { renderTime = animationSettings()->animationInterval().start(); firstFrameNumber = animationSettings()->timeToFrame(animationSettings()->animationInterval().start()); numberOfFrames = (animationSettings()->timeToFrame(animationSettings()->animationInterval().end()) - firstFrameNumber + 1); } else { firstFrameNumber = settings->customRangeStart(); renderTime = animationSettings()->frameToTime(firstFrameNumber); numberOfFrames = (settings->customRangeEnd() - firstFrameNumber + 1); } numberOfFrames = (numberOfFrames + settings->everyNthFrame() - 1) / settings->everyNthFrame(); if(numberOfFrames < 1) throw Exception(tr("Invalid rendering range: Frame %1 to %2").arg(settings->customRangeStart()).arg(settings->customRangeEnd())); if(progressDialog) progressDialog->setMaximum(numberOfFrames); // Render frames, one by one. for(int frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) { if(progressDialog) progressDialog->setValue(frameIndex); int frameNumber = firstFrameNumber + frameIndex * settings->everyNthFrame() + settings->fileNumberBase(); if(frameBufferWindow) frameBufferWindow->setWindowTitle(tr("Frame %1").arg(animationSettings()->timeToFrame(renderTime))); if(!renderFrame(renderTime, frameNumber, settings, renderer, viewport, frameBuffer.data(), videoEncoder, progressDialog.get())) { wasCanceled = true; break; } if(progressDialog && progressDialog->wasCanceled()) break; // Go to next animation frame. renderTime += animationSettings()->ticksPerFrame() * settings->everyNthFrame(); } } #ifdef OVITO_VIDEO_OUTPUT_SUPPORT // Finalize movie file. if(videoEncoder) videoEncoder->closeFile(); #endif } // Shutdown renderer. renderer->endRender(); if(progressDialog && progressDialog->wasCanceled()) wasCanceled = true; } catch(...) { // Shutdown renderer. renderer->endRender(); throw; } return !wasCanceled; }
bool QWindowsInputContext::composition(HWND hwnd, LPARAM lParamIn) { const int lParam = int(lParamIn); qCDebug(lcQpaInputMethods) << '>' << __FUNCTION__ << m_compositionContext.focusObject << debugComposition(lParam) << " composing=" << m_compositionContext.isComposing; if (m_compositionContext.focusObject.isNull() || m_compositionContext.hwnd != hwnd || !lParam) return false; const HIMC himc = ImmGetContext(m_compositionContext.hwnd); if (!himc) return false; QScopedPointer<QInputMethodEvent> event; if (lParam & (GCS_COMPSTR | GCS_COMPATTR | GCS_CURSORPOS)) { if (!m_compositionContext.isComposing) startContextComposition(); // Some intermediate composition result. Parametrize event with // attribute sequence specifying the formatting of the converted part. int selStart, selLength; m_compositionContext.composition = getCompositionString(himc, GCS_COMPSTR); m_compositionContext.position = ImmGetCompositionString(himc, GCS_CURSORPOS, 0, 0); getCompositionStringConvertedRange(himc, &selStart, &selLength); if ((lParam & CS_INSERTCHAR) && (lParam & CS_NOMOVECARET)) { // make Korean work correctly. Hope this is correct for all IMEs selStart = 0; selLength = m_compositionContext.composition.size(); } if (!selLength) selStart = 0; event.reset(new QInputMethodEvent(m_compositionContext.composition, intermediateMarkup(m_compositionContext.position, m_compositionContext.composition.size(), selStart, selLength))); } if (event.isNull()) event.reset(new QInputMethodEvent); if (lParam & GCS_RESULTSTR) { // A fixed result, return the converted string event->setCommitString(getCompositionString(himc, GCS_RESULTSTR)); endContextComposition(); } const bool result = QCoreApplication::sendEvent(m_compositionContext.focusObject, event.data()); qCDebug(lcQpaInputMethods) << '<' << __FUNCTION__ << "sending markup=" << event->attributes().size() << " commit=" << event->commitString() << " to " << m_compositionContext.focusObject << " returns " << result; update(Qt::ImQueryAll); ImmReleaseContext(m_compositionContext.hwnd, himc); return result; }
int main(int argc, char *argv[]) { QApplication a(argc, argv); // Set data for QSettings QCoreApplication::setOrganizationName("ulduzsoft"); QCoreApplication::setOrganizationDomain("ulduzsoft.com"); QCoreApplication::setApplicationName("spivak"); // Init logger after crash settings Logger::init(); QScopedPointer<MainWindow> p (new MainWindow()); p.data()->show(); QCommandLineParser parser; const QCommandLineOption fullScreenOption( QStringList() << "fs" << "fullScreen", "Toggle full screen" ); const QCommandLineOption fileNameOption( QStringList() << "file" << "fileName", "File name to play", "File name to play" ); const QCommandLineOption displayOption( QStringList() << "d" << "displayNumber", "Display number", "Screen" ); parser.addOption( fullScreenOption ); parser.addOption( fileNameOption ); parser.addOption( displayOption ); parser.addHelpOption(); #if defined (Q_OS_WIN) const QCommandLineOption showConsoleOption( QStringList() << "c" << "console", "Show debug console" ); parser.addOption( showConsoleOption ); #endif parser.process(a); #if defined (Q_OS_WIN) // Show console on Windows if ( parser.isSet( showConsoleOption ) ) { AllocConsole(); freopen("CONOUT$", "w", stdout); freopen("CONOUT$", "w", stderr); COORD coordInfo; coordInfo.X = 130; coordInfo.Y = 9000; SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coordInfo); SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE),ENABLE_QUICK_EDIT_MODE| ENABLE_EXTENDED_FLAGS); } #endif const int displayNumber = parser.value(displayOption).toInt(); if ( displayNumber && displayNumber < a.screens().size() ) { const QRect resolution = a.screens()[displayNumber] ->availableGeometry(); p.data()->move( resolution.x(), resolution.y() ); } if ( parser.isSet(fullScreenOption) ) { p.data()->toggleFullscreen(); } const QString fileName = parser.value(fileNameOption); if(!fileName.isEmpty()) { p.data()->enqueueSong(fileName); QObject::connect( pActionHandler, &ActionHandler::actionKaraokePlayerStop, qApp, &QApplication::quit ); } return a.exec(); }
bool KexiCSVExport::exportData(KDbTableOrQuerySchema *tableOrQuery, const Options& options, int recordCount, QTextStream *predefinedTextStream) { KDbConnection* conn = tableOrQuery->connection(); if (!conn) return false; KDbQuerySchema* query = tableOrQuery->query(); QList<QVariant> queryParams; if (!query) { query = tableOrQuery->table()->query(); } else { queryParams = KexiMainWindowIface::global()->currentParametersForQuery(query->id()); } if (recordCount == -1) recordCount = KDb::recordCount(tableOrQuery, queryParams); if (recordCount == -1) return false; //! @todo move this to non-GUI location so it can be also used via command line //! @todo add a "finish" page with a progressbar. //! @todo look at recordCount whether the data is really large; //! if so: avoid copying to clipboard (or ask user) because of system memory //! @todo OPTIMIZATION: use fieldsExpanded(true /*UNIQUE*/) //! @todo OPTIMIZATION? (avoid multiple data retrieving) look for already fetched data within KexiProject.. KDbQueryColumnInfo::Vector fields(query->fieldsExpanded(KDbQuerySchema::WithInternalFields)); QString buffer; QScopedPointer<QSaveFile> kSaveFile; QTextStream *stream = 0; QScopedPointer<QTextStream> kSaveFileTextStream; const bool copyToClipboard = options.mode == Clipboard; if (copyToClipboard) { //! @todo (during exporting): enlarge bufSize by factor of 2 when it became too small int bufSize = qMin((recordCount < 0 ? 10 : recordCount) * fields.count() * 20, 128000); buffer.reserve(bufSize); if (buffer.capacity() < bufSize) { qWarning() << "Cannot allocate memory for " << bufSize << " characters"; return false; } } else { if (predefinedTextStream) { stream = predefinedTextStream; } else { if (options.fileName.isEmpty()) {//sanity qWarning() << "Fname is empty"; return false; } kSaveFile.reset(new QSaveFile(options.fileName)); qDebug() << "QSaveFile Filename:" << kSaveFile->fileName(); if (kSaveFile->open(QIODevice::WriteOnly)) { kSaveFileTextStream.reset(new QTextStream(kSaveFile.data())); stream = kSaveFileTextStream.data(); qDebug() << "have a stream"; } if (QFileDevice::NoError != kSaveFile->error() || !stream) {//sanity qWarning() << "Status != 0 or stream == 0"; //! @todo show error return false; } } } //! @todo escape strings #define _ERR \ if (kSaveFile) { kSaveFile->cancelWriting(); } \ return false #define APPEND(what) \ if (copyToClipboard) buffer.append(what); else (*stream) << (what) // use native line ending for copying, RFC 4180 one for saving to file #define APPEND_EOLN \ if (copyToClipboard) { APPEND('\n'); } else { APPEND("\r\n"); } qDebug() << 0 << "Columns: " << query->fieldsExpanded().count(); // 0. Cache information const int fieldsCount = query->fieldsExpanded().count(); //real fields count without internals const QByteArray delimiter(options.delimiter.left(1).toLatin1()); const bool hasTextQuote = !options.textQuote.isEmpty(); const QString textQuote(options.textQuote.left(1)); const QByteArray escapedTextQuote((textQuote + textQuote).toLatin1()); //ok? //cache for faster checks QScopedArrayPointer<bool> isText(new bool[fieldsCount]); QScopedArrayPointer<bool> isDateTime(new bool[fieldsCount]); QScopedArrayPointer<bool> isTime(new bool[fieldsCount]); QScopedArrayPointer<bool> isBLOB(new bool[fieldsCount]); QScopedArrayPointer<int> visibleFieldIndex(new int[fieldsCount]); // bool isInteger[fieldsCount]; //cache for faster checks // bool isFloatingPoint[fieldsCount]; //cache for faster checks for (int i = 0; i < fieldsCount; i++) { KDbQueryColumnInfo* ci; const int indexForVisibleLookupValue = fields[i]->indexForVisibleLookupValue(); if (-1 != indexForVisibleLookupValue) { ci = query->expandedOrInternalField(indexForVisibleLookupValue); visibleFieldIndex[i] = indexForVisibleLookupValue; } else { ci = fields[i]; visibleFieldIndex[i] = i; } const KDbField::Type t = ci->field->type(); // cache: evaluating type of expressions can be expensive isText[i] = KDbField::isTextType(t); isDateTime[i] = t == KDbField::DateTime; isTime[i] = t == KDbField::Time; isBLOB[i] = t == KDbField::BLOB; // isInteger[i] = KDbField::isIntegerType(t) // || t == KDbField::Boolean; // isFloatingPoint[i] = KDbField::isFPNumericType(t); } // 1. Output column names if (options.addColumnNames) { for (int i = 0; i < fieldsCount; i++) { //qDebug() << "Adding column names"; if (i > 0) { APPEND(delimiter); } if (hasTextQuote) { APPEND(textQuote + fields[i]->captionOrAliasOrName().replace(textQuote, escapedTextQuote) + textQuote); } else { APPEND(fields[i]->captionOrAliasOrName()); } } APPEND_EOLN } KexiGUIMessageHandler handler; KDbCursor *cursor = conn->executeQuery(query, queryParams); if (!cursor) { handler.showErrorMessage(conn->result()); _ERR; } for (cursor->moveFirst(); !cursor->eof() && !cursor->result().isError(); cursor->moveNext()) { //qDebug() << "Adding records"; const int realFieldCount = qMin(cursor->fieldCount(), fieldsCount); for (int i = 0; i < realFieldCount; i++) { const int real_i = visibleFieldIndex[i]; if (i > 0) { APPEND(delimiter); } if (cursor->value(real_i).isNull()) { continue; } if (isText[real_i]) { if (hasTextQuote) APPEND(textQuote + QString(cursor->value(real_i).toString()).replace(textQuote, escapedTextQuote) + textQuote); else APPEND(cursor->value(real_i).toString()); } else if (isDateTime[real_i]) { //avoid "T" in ISO DateTime APPEND(cursor->value(real_i).toDateTime().date().toString(Qt::ISODate) + " " + cursor->value(real_i).toDateTime().time().toString(Qt::ISODate)); } else if (isTime[real_i]) { //time is temporarily stored as null date + time... APPEND(cursor->value(real_i).toTime().toString(Qt::ISODate)); } else if (isBLOB[real_i]) { //BLOB is escaped in a special way if (hasTextQuote) //! @todo add options to suppport other types from KDbBLOBEscapingType enum... APPEND(textQuote + KDb::escapeBLOB(cursor->value(real_i).toByteArray(), KDb::BLOBEscapeHex) + textQuote); else APPEND(KDb::escapeBLOB(cursor->value(real_i).toByteArray(), KDb::BLOBEscapeHex)); } else {//other types APPEND(cursor->value(real_i).toString()); } } APPEND_EOLN } if (copyToClipboard) buffer.squeeze(); if (!conn->deleteCursor(cursor)) { handler.showErrorMessage(conn->result()); _ERR; } if (copyToClipboard) QApplication::clipboard()->setText(buffer, QClipboard::Clipboard); qDebug() << "Done"; if (kSaveFile) { stream->flush(); if (!kSaveFile->commit()) { qWarning() << "Error commiting the file" << kSaveFile->fileName(); } } return true; }
void MainWindow::onPlaylistWidgetContextMenuRequested(const QPoint&) { settings_t *settings = config_get_ptr(); QScopedPointer<QMenu> menu; QScopedPointer<QMenu> associateMenu; QScopedPointer<QMenu> hiddenPlaylistsMenu; QScopedPointer<QAction> hideAction; QScopedPointer<QAction> newPlaylistAction; QScopedPointer<QAction> deletePlaylistAction; QPointer<QAction> selectedAction; QPoint cursorPos = QCursor::pos(); QListWidgetItem *selectedItem = m_listWidget->itemAt(m_listWidget->viewport()->mapFromGlobal(cursorPos)); QDir playlistDir(settings->paths.directory_playlist); QString playlistDirAbsPath = playlistDir.absolutePath(); QString currentPlaylistDirPath; QString currentPlaylistPath; QString currentPlaylistFileName; QFile currentPlaylistFile; QByteArray currentPlaylistFileNameArray; QFileInfo currentPlaylistFileInfo; QMap<QString, const core_info_t*> coreList; core_info_list_t *core_info_list = NULL; union string_list_elem_attr attr = {0}; struct string_list *stnames = NULL; struct string_list *stcores = NULL; unsigned i = 0; int j = 0; size_t found = 0; const char *currentPlaylistFileNameData = NULL; char new_playlist_names[PATH_MAX_LENGTH]; char new_playlist_cores[PATH_MAX_LENGTH]; bool specialPlaylist = false; bool foundHiddenPlaylist = false; new_playlist_names[0] = new_playlist_cores[0] = '\0'; stnames = string_split(settings->arrays.playlist_names, ";"); stcores = string_split(settings->arrays.playlist_cores, ";"); if (selectedItem) { currentPlaylistPath = selectedItem->data(Qt::UserRole).toString(); currentPlaylistFile.setFileName(currentPlaylistPath); currentPlaylistFileInfo = QFileInfo(currentPlaylistPath); currentPlaylistFileName = currentPlaylistFileInfo.fileName(); currentPlaylistDirPath = currentPlaylistFileInfo.absoluteDir().absolutePath(); currentPlaylistFileNameArray.append(currentPlaylistFileName); currentPlaylistFileNameData = currentPlaylistFileNameArray.constData(); } menu.reset(new QMenu(this)); menu->setObjectName("menu"); hiddenPlaylistsMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDDEN_PLAYLISTS), this)); newPlaylistAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST)) + "...", this)); hiddenPlaylistsMenu->setObjectName("hiddenPlaylistsMenu"); menu->addAction(newPlaylistAction.data()); if (currentPlaylistFile.exists()) { deletePlaylistAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DELETE_PLAYLIST)) + "...", this)); menu->addAction(deletePlaylistAction.data()); } if (selectedItem) { hideAction.reset(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDE), this)); menu->addAction(hideAction.data()); } for (j = 0; j < m_listWidget->count(); j++) { QListWidgetItem *item = m_listWidget->item(j); bool hidden = m_listWidget->isItemHidden(item); if (hidden) { QAction *action = hiddenPlaylistsMenu->addAction(item->text()); action->setProperty("row", j); action->setProperty("core_path", item->data(Qt::UserRole).toString()); foundHiddenPlaylist = true; } } if (!foundHiddenPlaylist) { QAction *action = hiddenPlaylistsMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE)); action->setProperty("row", -1); } menu->addMenu(hiddenPlaylistsMenu.data()); if (currentPlaylistDirPath != playlistDirAbsPath) { /* special playlists like history etc. can't have an association */ specialPlaylist = true; } if (!specialPlaylist) { associateMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ASSOCIATE_CORE), this)); associateMenu->setObjectName("associateMenu"); core_info_get_list(&core_info_list); for (i = 0; i < core_info_list->count && core_info_list->count > 0; i++) { const core_info_t *core = &core_info_list->list[i]; coreList[core->core_name] = core; } { QMapIterator<QString, const core_info_t*> coreListIterator(coreList); QVector<QHash<QString, QString> > cores; while (coreListIterator.hasNext()) { QString key; const core_info_t *core = NULL; QString name; QHash<QString, QString> hash; coreListIterator.next(); key = coreListIterator.key(); core = coreList.value(key); if (string_is_empty(core->core_name)) name = core->display_name; else name = core->core_name; if (name.isEmpty()) continue; hash["name"] = name; hash["core_path"] = core->path; cores.append(hash); } std::sort(cores.begin(), cores.end(), comp_hash_name_key_lower); for (j = 0; j < cores.count(); j++) { const QHash<QString, QString> &hash = cores.at(j); QAction *action = associateMenu->addAction(hash.value("name")); action->setProperty("core_path", hash.value("core_path")); } } menu->addMenu(associateMenu.data()); } selectedAction = menu->exec(cursorPos); if (!selectedAction) goto end; if (!specialPlaylist && selectedAction->parent() == associateMenu.data()) { found = string_list_find_elem(stnames, currentPlaylistFileNameData); if (found) string_list_set(stcores, static_cast<unsigned>(found - 1), selectedAction->property("core_path").toString().toUtf8().constData()); else { string_list_append(stnames, currentPlaylistFileNameData, attr); string_list_append(stcores, "DETECT", attr); found = string_list_find_elem(stnames, currentPlaylistFileNameData); if (found) string_list_set(stcores, static_cast<unsigned>(found - 1), selectedAction->property("core_path").toString().toUtf8().constData()); } string_list_join_concat(new_playlist_names, sizeof(new_playlist_names), stnames, ";"); string_list_join_concat(new_playlist_cores, sizeof(new_playlist_cores), stcores, ";"); strlcpy(settings->arrays.playlist_names, new_playlist_names, sizeof(settings->arrays.playlist_names)); strlcpy(settings->arrays.playlist_cores, new_playlist_cores, sizeof(settings->arrays.playlist_cores)); } else if (selectedItem && selectedAction == deletePlaylistAction.data()) { if (currentPlaylistFile.exists()) { if (showMessageBox(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CONFIRM_DELETE_PLAYLIST)).arg(selectedItem->text()), MainWindow::MSGBOX_TYPE_QUESTION_YESNO, Qt::ApplicationModal, false)) { if (currentPlaylistFile.remove()) reloadPlaylists(); else showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_DELETE_FILE), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false); } } } else if (selectedAction == newPlaylistAction.data()) { QString name = QInputDialog::getText(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ENTER_NEW_PLAYLIST_NAME)); QString newPlaylistPath = playlistDirAbsPath + "/" + name + file_path_str(FILE_PATH_LPL_EXTENSION); QFile file(newPlaylistPath); if (file.open(QIODevice::WriteOnly)) file.close(); reloadPlaylists(); } else if (selectedItem && selectedAction == hideAction.data()) { int row = m_listWidget->row(selectedItem); if (row >= 0) { QStringList hiddenPlaylists = m_settings->value("hidden_playlists").toStringList(); if (!hiddenPlaylists.contains(currentPlaylistFileName)) { hiddenPlaylists.append(currentPlaylistFileName); m_settings->setValue("hidden_playlists", hiddenPlaylists); } m_listWidget->setRowHidden(row, true); } } else if (selectedAction->parent() == hiddenPlaylistsMenu.data()) { QVariant rowVariant = selectedAction->property("row"); if (rowVariant.isValid()) { QStringList hiddenPlaylists = m_settings->value("hidden_playlists").toStringList(); int row = rowVariant.toInt(); if (row >= 0) { QString playlistPath = selectedAction->property("core_path").toString(); QFileInfo playlistFileInfo(playlistPath); QString playlistFileName = playlistFileInfo.fileName(); if (hiddenPlaylists.contains(playlistFileName)) { hiddenPlaylists.removeOne(playlistFileName); m_settings->setValue("hidden_playlists", hiddenPlaylists); } m_listWidget->setRowHidden(row, false); } } } setCoreActions(); end: if (stnames) string_list_free(stnames); if (stcores) string_list_free(stcores); }
Q_SLOT void rendererReady() { m_renderer.reset(m_future.result()); m_renderer->moveToThread(thread()); setRenderer(m_renderer.data()); }
gettextFromC *gettextFromC::instance() { static QScopedPointer<gettextFromC> self(new gettextFromC()); return self.data(); }
void QgsComposerHtml::loadHtml( const bool useCache, const QgsExpressionContext *context ) { if ( !mWebPage ) { return; } const QgsExpressionContext* evalContext = context; QScopedPointer< QgsExpressionContext > scopedContext; if ( !evalContext ) { scopedContext.reset( createExpressionContext() ); evalContext = scopedContext.data(); } QString loadedHtml; switch ( mContentMode ) { case QgsComposerHtml::Url: { QString currentUrl = mUrl.toString(); //data defined url set? QVariant exprVal; if ( dataDefinedEvaluate( QgsComposerObject::SourceUrl, exprVal, *evalContext ) ) { currentUrl = exprVal.toString().trimmed(); QgsDebugMsg( QString( "exprVal Source Url:%1" ).arg( currentUrl ) ); } if ( currentUrl.isEmpty() ) { return; } if ( !( useCache && currentUrl == mLastFetchedUrl ) ) { loadedHtml = fetchHtml( QUrl( currentUrl ) ); mLastFetchedUrl = currentUrl; } else { loadedHtml = mFetchedHtml; } break; } case QgsComposerHtml::ManualHtml: loadedHtml = mHtml; break; } //evaluate expressions if ( mEvaluateExpressions ) { loadedHtml = QgsExpression::replaceExpressionText( loadedHtml, evalContext, nullptr, mDistanceArea ); } mLoaded = false; //reset page size. otherwise viewport size increases but never decreases again mWebPage->setViewportSize( QSize( maxFrameWidth() * mHtmlUnitsToMM, 0 ) ); //set html, using the specified url as base if in Url mode mWebPage->mainFrame()->setHtml( loadedHtml, mContentMode == QgsComposerHtml::Url ? QUrl( mActualFetchedUrl ) : QUrl() ); //set user stylesheet QWebSettings* settings = mWebPage->settings(); if ( mEnableUserStylesheet && ! mUserStylesheet.isEmpty() ) { QByteArray ba; ba.append( mUserStylesheet.toUtf8() ); QUrl cssFileURL = QUrl( "data:text/css;charset=utf-8;base64," + ba.toBase64() ); settings->setUserStyleSheetUrl( cssFileURL ); } else { settings->setUserStyleSheetUrl( QUrl() ); } while ( !mLoaded ) { qApp->processEvents(); } recalculateFrameSizes(); //trigger a repaint emit contentsChanged(); }
// The address returned here will only be valid until next time this function is called. // The program is return bound. QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineShaderProg &prog) { for (int i = 0; i < cachedPrograms.size(); ++i) { QGLEngineShaderProg *cachedProg = cachedPrograms[i]; if (*cachedProg == prog) { // Move the program to the top of the list as a poor-man's cache algo cachedPrograms.move(i, 0); cachedProg->program->bind(); return cachedProg; } } QScopedPointer<QGLEngineShaderProg> newProg; do { QByteArray fragSource; // Insert the custom stage before the srcPixel shader to work around an ATI driver bug // where you cannot forward declare a function that takes a sampler as argument. if (prog.srcPixelFragShader == CustomImageSrcFragmentShader) fragSource.append(prog.customStageSource); fragSource.append(qShaderSnippets[prog.mainFragShader]); fragSource.append(qShaderSnippets[prog.srcPixelFragShader]); if (prog.compositionFragShader) fragSource.append(qShaderSnippets[prog.compositionFragShader]); if (prog.maskFragShader) fragSource.append(qShaderSnippets[prog.maskFragShader]); QByteArray vertexSource; vertexSource.append(qShaderSnippets[prog.mainVertexShader]); vertexSource.append(qShaderSnippets[prog.positionVertexShader]); QScopedPointer<QGLShaderProgram> shaderProgram(new QGLShaderProgram(ctxGuard.context(), 0)); CachedShader shaderCache(fragSource, vertexSource); bool inCache = shaderCache.load(shaderProgram.data(), ctxGuard.context()); if (!inCache) { QScopedPointer<QGLShader> fragShader(new QGLShader(QGLShader::Fragment, ctxGuard.context(), 0)); QByteArray description; #if defined(QT_DEBUG) // Name the shader for easier debugging description.append("Fragment shader: main="); description.append(snippetNameStr(prog.mainFragShader)); description.append(", srcPixel="); description.append(snippetNameStr(prog.srcPixelFragShader)); if (prog.compositionFragShader) { description.append(", composition="); description.append(snippetNameStr(prog.compositionFragShader)); } if (prog.maskFragShader) { description.append(", mask="); description.append(snippetNameStr(prog.maskFragShader)); } fragShader->setObjectName(QString::fromLatin1(description)); #endif if (!fragShader->compileSourceCode(fragSource)) { qWarning() << "Warning:" << description << "failed to compile!"; break; } QScopedPointer<QGLShader> vertexShader(new QGLShader(QGLShader::Vertex, ctxGuard.context(), 0)); #if defined(QT_DEBUG) // Name the shader for easier debugging description.clear(); description.append("Vertex shader: main="); description.append(snippetNameStr(prog.mainVertexShader)); description.append(", position="); description.append(snippetNameStr(prog.positionVertexShader)); vertexShader->setObjectName(QString::fromLatin1(description)); #endif if (!vertexShader->compileSourceCode(vertexSource)) { qWarning() << "Warning:" << description << "failed to compile!"; break; } shaders.append(vertexShader.data()); shaders.append(fragShader.data()); shaderProgram->addShader(vertexShader.take()); shaderProgram->addShader(fragShader.take()); // We have to bind the vertex attribute names before the program is linked: shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR); if (prog.useTextureCoords) shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR); if (prog.useOpacityAttribute) shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR); if (prog.usePmvMatrixAttribute) { shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR); shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR); shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR); } } newProg.reset(new QGLEngineShaderProg(prog)); newProg->program = shaderProgram.take(); newProg->program->link(); if (newProg->program->isLinked()) { if (!inCache) shaderCache.store(newProg->program, ctxGuard.context()); } else { QLatin1String none("none"); QLatin1String br("\n"); QString error; error = QLatin1String("Shader program failed to link,"); #if defined(QT_DEBUG) error += QLatin1String("\n Shaders Used:\n"); for (int i = 0; i < newProg->program->shaders().count(); ++i) { QGLShader *shader = newProg->program->shaders().at(i); error += QLatin1String(" ") + shader->objectName() + QLatin1String(": \n") + QLatin1String(shader->sourceCode()) + br; } #endif error += QLatin1String(" Error Log:\n") + QLatin1String(" ") + newProg->program->log(); qWarning() << error; break; } newProg->program->bind(); if (newProg->maskFragShader != QGLEngineSharedShaders::NoMaskFragmentShader) { GLuint location = newProg->program->uniformLocation("maskTexture"); newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT); } if (cachedPrograms.count() > 30) { // The cache is full, so delete the last 5 programs in the list. // These programs will be least used, as a program us bumped to // the top of the list when it's used. for (int i = 0; i < 5; ++i) { delete cachedPrograms.last(); cachedPrograms.removeLast(); } } cachedPrograms.insert(0, newProg.data()); } while (false); return newProg.take(); }
Database* KeePass2Reader::readDatabase(QIODevice* device, const CompositeKey& key) { QScopedPointer<Database> db(new Database()); m_db = db.data(); QPointer<QIODevice> m_device = device; m_error = false; m_errorStr = QString(); m_headerEnd = false; m_xmlData.clear(); m_masterSeed.clear(); m_transformSeed.clear(); m_encryptionIV.clear(); m_streamStartBytes.clear(); m_protectedStreamKey.clear(); StoreDataStream headerStream(m_device); headerStream.open(QIODevice::ReadOnly); m_headerStream = &headerStream; bool ok; quint32 signature1 = Endian::readUInt32(m_headerStream, KeePass2::BYTEORDER, &ok); if (!ok || signature1 != KeePass2::SIGNATURE_1) { raiseError(tr("Not a KeePass database.")); return Q_NULLPTR; } quint32 signature2 = Endian::readUInt32(m_headerStream, KeePass2::BYTEORDER, &ok); if (!ok || signature2 != KeePass2::SIGNATURE_2) { raiseError(tr("Not a KeePass database.")); return Q_NULLPTR; } quint32 version = Endian::readUInt32(m_headerStream, KeePass2::BYTEORDER, &ok) & KeePass2::FILE_VERSION_CRITICAL_MASK; quint32 maxVersion = KeePass2::FILE_VERSION & KeePass2::FILE_VERSION_CRITICAL_MASK; if (!ok || (version < KeePass2::FILE_VERSION_MIN) || (version > maxVersion)) { raiseError(tr("Unsupported KeePass database version.")); return Q_NULLPTR; } while (readHeaderField() && !hasError()) { } headerStream.close(); // check if all required headers were present if (m_masterSeed.isEmpty() || m_transformSeed.isEmpty() || m_encryptionIV.isEmpty() || m_streamStartBytes.isEmpty() || m_protectedStreamKey.isEmpty() || m_db->cipher().isNull()) { raiseError(""); return Q_NULLPTR; } m_db->setKey(key, m_transformSeed, false); CryptoHash hash(CryptoHash::Sha256); hash.addData(m_masterSeed); hash.addData(m_db->transformedMasterKey()); QByteArray finalKey = hash.result(); SymmetricCipherStream cipherStream(m_device, SymmetricCipher::Aes256, SymmetricCipher::Cbc, SymmetricCipher::Decrypt, finalKey, m_encryptionIV); cipherStream.open(QIODevice::ReadOnly); QByteArray realStart = cipherStream.read(32); if (realStart != m_streamStartBytes) { raiseError(tr("Wrong key or database file is corrupt.")); return Q_NULLPTR; } HashedBlockStream hashedStream(&cipherStream); hashedStream.open(QIODevice::ReadOnly); QIODevice* xmlDevice; QScopedPointer<QtIOCompressor> ioCompressor; if (m_db->compressionAlgo() == Database::CompressionNone) { xmlDevice = &hashedStream; } else { ioCompressor.reset(new QtIOCompressor(&hashedStream)); ioCompressor->setStreamFormat(QtIOCompressor::GzipFormat); ioCompressor->open(QIODevice::ReadOnly); xmlDevice = ioCompressor.data(); } KeePass2RandomStream randomStream(m_protectedStreamKey); QScopedPointer<QBuffer> buffer; if (m_saveXml) { m_xmlData = xmlDevice->readAll(); buffer.reset(new QBuffer(&m_xmlData)); buffer->open(QIODevice::ReadOnly); xmlDevice = buffer.data(); } KeePass2XmlReader xmlReader; xmlReader.readDatabase(xmlDevice, m_db, &randomStream); if (xmlReader.hasError()) { raiseError(xmlReader.errorString()); return Q_NULLPTR; } Q_ASSERT(version < 0x00030001 || !xmlReader.headerHash().isEmpty()); if (!xmlReader.headerHash().isEmpty()) { QByteArray headerHash = CryptoHash::hash(headerStream.storedData(), CryptoHash::Sha256); if (headerHash != xmlReader.headerHash()) { raiseError(""); return Q_NULLPTR; } } return db.take(); }
void TestGooString::testFormat() { { const QScopedPointer<GooString> goo(GooString::format("{0:d},{1:x}", 1, 0xF)); QCOMPARE(goo->getCString(), "1,f"); } { const QScopedPointer<GooString> goo(GooString::format("{0:d},{0:x},{0:X},{0:o},{0:b},{0:w}", 0xA)); QCOMPARE(goo->getCString(), "10,a,A,12,1010, "); } { const QScopedPointer<GooString> goo(GooString::format("{0:d},{0:x},{0:X},{0:o},{0:b}", -0xA)); QCOMPARE(goo->getCString(), "-10,-a,-A,-12,-1010"); } { const QScopedPointer<GooString> goo(GooString::format("{0:c}{1:c}{2:c}{3:c}", 'T', (char)'E', (short)'S', (int)'T')); QCOMPARE(goo->getCString(), "TEST"); const QScopedPointer<GooString> goo2(GooString::format("{0:s} {1:t}", "TEST", goo.data())); QCOMPARE(goo2->getCString(), "TEST TEST"); } { const QScopedPointer<GooString> goo(GooString::format("{0:ud} {1:d} {2:d}", UINT_MAX, INT_MAX, INT_MIN)); const QByteArray expected = QString("%1 %2 %3").arg(UINT_MAX).arg(INT_MAX).arg(INT_MIN).toLatin1(); QCOMPARE(goo->getCString(), expected.constData()); } { const QScopedPointer<GooString> goo(GooString::format("{0:uld} {1:ld} {2:ld}", ULONG_MAX, LONG_MAX, LONG_MIN)); const QByteArray expected = QString("%1 %2 %3").arg(ULONG_MAX).arg(LONG_MAX).arg(LONG_MIN).toLatin1(); QCOMPARE(goo->getCString(), expected.constData()); } { const QScopedPointer<GooString> goo(GooString::format("{0:ulld} {1:lld} {2:lld}", ULLONG_MAX, LLONG_MAX, LLONG_MIN)); const QByteArray expected = QString("%1 %2 %3").arg(ULLONG_MAX).arg(LLONG_MAX).arg(LLONG_MIN).toLatin1(); QCOMPARE(goo->getCString(), expected.constData()); } { const QScopedPointer<GooString> gooD(GooString::format("{0:.1f} {0:.1g} {0:.1gs} | {1:.1f} {1:.1g} {1:.1gs}", 1., .012)); const QScopedPointer<GooString> gooF(GooString::format("{0:.1f} {0:.1g} {0:.1gs} | {1:.1f} {1:.1g} {1:.1gs}", 1.f, .012f)); QCOMPARE(gooD->getCString(), "1.0 1 1 | 0.0 0 0.01"); QCOMPARE(gooF->getCString(), "1.0 1 1 | 0.0 0 0.01"); } { const QScopedPointer<GooString> goo(GooString::format("{0:.4f} {0:.4g} {0:.4gs}", .012)); QCOMPARE(goo->getCString(), "0.0120 0.012 0.012"); } { const QScopedPointer<GooString> goo(GooString::format("{{ SomeText {0:d} }}", 1)); QCOMPARE(goo->getCString(), "{ SomeText 1 }"); } { const QScopedPointer<GooString> goo(GooString::format("{{{{ {{ SomeText {0:d}", 2)); QCOMPARE(goo->getCString(), "{{ { SomeText 2"); } { const QScopedPointer<GooString> goo(GooString::format("SomeText {0:d} }} }}}}", 3)); QCOMPARE(goo->getCString(), "SomeText 3 } }}"); } }
GasSelectionModel *GasSelectionModel::instance() { static QScopedPointer<GasSelectionModel> self(new GasSelectionModel()); return self.data(); }
DivePlannerPointsModel *DivePlannerPointsModel::instance() { static QScopedPointer<DivePlannerPointsModel> self(new DivePlannerPointsModel()); return self.data(); }
CylindersModel *CylindersModel::instance() { static QScopedPointer<CylindersModel> self(new CylindersModel()); return self.data(); }
bool VideoEncoderFFmpeg::encode(const VideoFrame &frame) { DPTR_D(VideoEncoderFFmpeg); QScopedPointer<AVFrame, ScopedAVFrameDeleter> f; // hwupload AVPixelFormat pixfmt = AVPixelFormat(frame.pixelFormatFFmpeg()); if (frame.isValid()) { f.reset(av_frame_alloc()); f->format = pixfmt; f->width = frame.width(); f->height = frame.height(); // f->quality = d.avctx->global_quality; switch (timestampMode()) { case TimestampCopy: f->pts = int64_t(frame.timestamp()*frameRate()); // TODO: check monotically increase and fix if not. or another mode? break; case TimestampMonotonic: f->pts = d.nb_encoded+1; break; default: break; } // pts is set in muxer const int nb_planes = frame.planeCount(); for (int i = 0; i < nb_planes; ++i) { f->linesize[i] = frame.bytesPerLine(i); f->data[i] = (uint8_t*)frame.constBits(i); } if (d.avctx->width <= 0) { d.avctx->width = frame.width(); } if (d.avctx->height <= 0) { d.avctx->height = frame.width(); } #ifdef HAVE_AVHWCTX if (d.avctx->hw_frames_ctx) { // TODO: try to map to SourceSurface // checl valid sw_formats if (!d.hwframes_ref) { qWarning("no hw frame context for uploading"); return false; } if (pixfmt != d.hwframes->sw_format) { // reinit or got an unsupported format. assume parameters will not change, so it's the 1st init // check constraints bool init_frames_ctx = d.hwframes->sw_format == AVPixelFormat(-1); if (d.sw_fmts.contains(pixfmt)) { // format changed init_frames_ctx = true; } else { // convert to supported sw format pixfmt = d.sw_fmts[0]; f->format = pixfmt; VideoFrame converted = frame.to(VideoFormat::pixelFormatFromFFmpeg(pixfmt)); for (int i = 0; i < converted.planeCount(); ++i) { f->linesize[i] = converted.bytesPerLine(i); f->data[i] = (uint8_t*)frame.constBits(i); } } if (init_frames_ctx) { d.hwframes->sw_format = pixfmt; d.hwframes->width = frame.width(); d.hwframes->height = frame.height(); AV_ENSURE(av_hwframe_ctx_init(d.hwframes_ref), false); } } // upload QScopedPointer<AVFrame, ScopedAVFrameDeleter> hwf( av_frame_alloc()); AV_ENSURE(av_hwframe_get_buffer(d.hwframes_ref, hwf.data(), 0), false); //hwf->format = d.hwframes->format; // not necessary //hwf->width = f->width; //hwf->height = f->height; AV_ENSURE(av_hwframe_transfer_data(hwf.data(), f.data(), 0), false); AV_ENSURE(av_frame_copy_props(hwf.data(), f.data()), false); av_frame_unref(f.data()); av_frame_move_ref(f.data(), hwf.data()); } #endif //HAVE_AVHWCTX } AVPacket pkt; av_init_packet(&pkt); pkt.data = (uint8_t*)d.buffer.constData(); pkt.size = d.buffer.size(); int got_packet = 0; int ret = avcodec_encode_video2(d.avctx, &pkt, f.data(), &got_packet); if (ret < 0) { qWarning("error avcodec_encode_video2: %s" ,av_err2str(ret)); return false; //false } d.nb_encoded++; if (!got_packet) { qWarning("no packet got"); d.packet = Packet(); // invalid frame means eof return frame.isValid(); } // qDebug("enc avpkt.pts: %lld, dts: %lld.", pkt.pts, pkt.dts); d.packet = Packet::fromAVPacket(&pkt, av_q2d(d.avctx->time_base)); // qDebug("enc packet.pts: %.3f, dts: %.3f.", d.packet.pts, d.packet.dts); return true; }
void QgsVectorLayerRenderer::drawRendererV2( QgsFeatureIterator& fit ) { QgsExpressionContextScope* symbolScope = QgsExpressionContextUtils::updateSymbolScope( nullptr, new QgsExpressionContextScope() ); mContext.expressionContext().appendScope( symbolScope ); QgsFeature fet; while ( fit.nextFeature( fet ) ) { try { if ( mContext.renderingStopped() ) { QgsDebugMsg( QString( "Drawing of vector layer %1 cancelled." ).arg( layerID() ) ); break; } if ( !fet.constGeometry() ) continue; // skip features without geometry mContext.expressionContext().setFeature( fet ); bool sel = mContext.showSelection() && mSelectedFeatureIds.contains( fet.id() ); bool drawMarker = ( mDrawVertexMarkers && mContext.drawEditingInformation() && ( !mVertexMarkerOnlyForSelection || sel ) ); if ( mCache ) { // Cache this for the use of (e.g.) modifying the feature's uncommitted geometry. mCache->cacheGeometry( fet.id(), *fet.constGeometry() ); } // render feature bool rendered = mRendererV2->renderFeature( fet, mContext, -1, sel, drawMarker ); // labeling - register feature if ( rendered ) { if ( mContext.labelingEngine() ) { if ( mLabeling ) { mContext.labelingEngine()->registerFeature( mLayerID, fet, mContext ); } if ( mDiagrams ) { mContext.labelingEngine()->registerDiagramFeature( mLayerID, fet, mContext ); } } // new labeling engine if ( mContext.labelingEngineV2() ) { QScopedPointer<QgsGeometry> obstacleGeometry; QgsSymbolV2List symbols = mRendererV2->originalSymbolsForFeature( fet, mContext ); if ( !symbols.isEmpty() && fet.constGeometry()->type() == QGis::Point ) { obstacleGeometry.reset( QgsVectorLayerLabelProvider::getPointObstacleGeometry( fet, mContext, symbols ) ); } if ( !symbols.isEmpty() ) { QgsExpressionContextUtils::updateSymbolScope( symbols.at( 0 ), symbolScope ); } if ( mLabelProvider ) { mLabelProvider->registerFeature( fet, mContext, obstacleGeometry.data() ); } if ( mDiagramProvider ) { mDiagramProvider->registerFeature( fet, mContext, obstacleGeometry.data() ); } } } } catch ( const QgsCsException &cse ) { Q_UNUSED( cse ); QgsDebugMsg( QString( "Failed to transform a point while drawing a feature with ID '%1'. Ignoring this feature. %2" ) .arg( fet.id() ).arg( cse.what() ) ); } } delete mContext.expressionContext().popScope(); stopRendererV2( nullptr ); }
void tst_QScopedPointer::dataSignature() { const QScopedPointer<int> p; /* data() should be const. */ p.data(); }
QgsLabelFeature* QgsVectorLayerDiagramProvider::registerDiagram( QgsFeature& feat, QgsRenderContext &context, QgsGeometry* obstacleGeometry ) { const QgsMapSettings& mapSettings = mEngine->mapSettings(); QgsDiagramRendererV2* dr = mSettings.renderer; if ( dr ) { QList<QgsDiagramSettings> settingList = dr->diagramSettings(); if ( !settingList.isEmpty() && settingList.at( 0 ).scaleBasedVisibility ) { double minScale = settingList.at( 0 ).minScaleDenominator; if ( minScale > 0 && context.rendererScale() < minScale ) { return nullptr; } double maxScale = settingList.at( 0 ).maxScaleDenominator; if ( maxScale > 0 && context.rendererScale() > maxScale ) { return nullptr; } } } //convert geom to geos const QgsGeometry* geom = feat.constGeometry(); QScopedPointer<QgsGeometry> extentGeom( QgsGeometry::fromRect( mapSettings.visibleExtent() ) ); if ( !qgsDoubleNear( mapSettings.rotation(), 0.0 ) ) { //PAL features are prerotated, so extent also needs to be unrotated extentGeom->rotate( -mapSettings.rotation(), mapSettings.visibleExtent().center() ); } const GEOSGeometry* geos_geom = nullptr; QScopedPointer<QgsGeometry> preparedGeom; if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, mSettings.ct, extentGeom.data() ) ) { preparedGeom.reset( QgsPalLabeling::prepareGeometry( geom, context, mSettings.ct, extentGeom.data() ) ); if ( !preparedGeom.data() ) return nullptr; geos_geom = preparedGeom.data()->asGeos(); } else { geos_geom = geom->asGeos(); } if ( !geos_geom ) return nullptr; // invalid geometry GEOSGeometry* geomCopy = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom ); const GEOSGeometry* geosObstacleGeom = nullptr; QScopedPointer<QgsGeometry> scopedObstacleGeom; if ( mSettings.obstacle && obstacleGeometry && QgsPalLabeling::geometryRequiresPreparation( obstacleGeometry, context, mSettings.ct, extentGeom.data() ) ) { scopedObstacleGeom.reset( QgsPalLabeling::prepareGeometry( obstacleGeometry, context, mSettings.ct, extentGeom.data() ) ); geosObstacleGeom = scopedObstacleGeom.data()->asGeos(); } else if ( mSettings.obstacle && obstacleGeometry ) { geosObstacleGeom = obstacleGeometry->asGeos(); } GEOSGeometry* geosObstacleGeomClone = nullptr; if ( geosObstacleGeom ) { geosObstacleGeomClone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geosObstacleGeom ); } double diagramWidth = 0; double diagramHeight = 0; if ( dr ) { QSizeF diagSize = dr->sizeMapUnits( feat, context ); if ( diagSize.isValid() ) { diagramWidth = diagSize.width(); diagramHeight = diagSize.height(); } } // feature to the layer bool alwaysShow = mSettings.showAll; int ddColX = mSettings.xPosColumn; int ddColY = mSettings.yPosColumn; double ddPosX = 0.0; double ddPosY = 0.0; bool ddPos = ( ddColX >= 0 && ddColY >= 0 ); if ( ddPos ) { bool posXOk, posYOk; ddPosX = feat.attribute( ddColX ).toDouble( &posXOk ); ddPosY = feat.attribute( ddColY ).toDouble( &posYOk ); if ( !posXOk || !posYOk ) { ddPos = false; } else { const QgsCoordinateTransform* ct = mSettings.ct; if ( ct ) { double z = 0; ct->transformInPlace( ddPosX, ddPosY, z ); } //data defined diagram position is always centered ddPosX -= diagramWidth / 2.0; ddPosY -= diagramHeight / 2.0; } } QgsDiagramLabelFeature* lf = new QgsDiagramLabelFeature( feat.id(), geomCopy, QSizeF( diagramWidth, diagramHeight ) ); lf->setHasFixedPosition( ddPos ); lf->setFixedPosition( QgsPoint( ddPosX, ddPosY ) ); lf->setHasFixedAngle( true ); lf->setFixedAngle( 0 ); lf->setAlwaysShow( alwaysShow ); lf->setIsObstacle( mSettings.obstacle ); if ( geosObstacleGeomClone ) { lf->setObstacleGeometry( geosObstacleGeomClone ); } if ( dr ) { //append the diagram attributes to lbl lf->setAttributes( feat.attributes() ); } QgsPoint ptZero = mSettings.xform->toMapCoordinates( 0, 0 ); QgsPoint ptOne = mSettings.xform->toMapCoordinates( 1, 0 ); lf->setDistLabel( qAbs( ptOne.x() - ptZero.x() ) * mSettings.dist ); return lf; }
void tst_QScopedPointer::defaultConstructor() { /* Check that the members, one, is correctly initialized. */ QScopedPointer<int> p; QCOMPARE(p.data(), static_cast<int *>(0)); }
Database* KeePass2Reader::readDatabase(QIODevice* device, const CompositeKey& key, bool keepDatabase) { QScopedPointer<Database> db(new Database()); m_db = db.data(); m_device = device; m_error = false; m_errorStr.clear(); m_headerEnd = false; m_xmlData.clear(); m_masterSeed.clear(); m_transformSeed.clear(); m_encryptionIV.clear(); m_streamStartBytes.clear(); m_protectedStreamKey.clear(); StoreDataStream headerStream(m_device); headerStream.open(QIODevice::ReadOnly); m_headerStream = &headerStream; bool ok; quint32 signature1 = Endian::readUInt32(m_headerStream, KeePass2::BYTEORDER, &ok); if (!ok || signature1 != KeePass2::SIGNATURE_1) { raiseError(tr("Not a KeePass database.")); return nullptr; } quint32 signature2 = Endian::readUInt32(m_headerStream, KeePass2::BYTEORDER, &ok); if (ok && signature2 == KeePass1::SIGNATURE_2) { raiseError(tr("The selected file is an old KeePass 1 database (.kdb).\n\n" "You can import it by clicking on Database > 'Import KeePass 1 database'.\n" "This is a one-way migration. You won't be able to open the imported " "database with the old KeePassX 0.4 version.")); return nullptr; } else if (!ok || signature2 != KeePass2::SIGNATURE_2) { raiseError(tr("Not a KeePass database.")); return nullptr; } quint32 version = Endian::readUInt32(m_headerStream, KeePass2::BYTEORDER, &ok) & KeePass2::FILE_VERSION_CRITICAL_MASK; quint32 maxVersion = KeePass2::FILE_VERSION & KeePass2::FILE_VERSION_CRITICAL_MASK; if (!ok || (version < KeePass2::FILE_VERSION_MIN) || (version > maxVersion)) { raiseError(tr("Unsupported KeePass database version.")); return nullptr; } while (readHeaderField() && !hasError()) { } headerStream.close(); if (hasError()) { return nullptr; } // check if all required headers were present if (m_masterSeed.isEmpty() || m_transformSeed.isEmpty() || m_encryptionIV.isEmpty() || m_streamStartBytes.isEmpty() || m_protectedStreamKey.isEmpty() || m_db->cipher().isNull()) { raiseError("missing database headers"); return nullptr; } if (!m_db->setKey(key, m_transformSeed, false)) { raiseError(tr("Unable to calculate master key")); return nullptr; } CryptoHash hash(CryptoHash::Sha256); hash.addData(m_masterSeed); hash.addData(m_db->transformedMasterKey()); QByteArray finalKey = hash.result(); SymmetricCipherStream cipherStream(m_device, SymmetricCipher::Aes256, SymmetricCipher::Cbc, SymmetricCipher::Decrypt); if (!cipherStream.init(finalKey, m_encryptionIV)) { raiseError(cipherStream.errorString()); return nullptr; } if (!cipherStream.open(QIODevice::ReadOnly)) { raiseError(cipherStream.errorString()); return nullptr; } QByteArray realStart = cipherStream.read(32); if (realStart != m_streamStartBytes) { raiseError(tr("Wrong key or database file is corrupt.")); return nullptr; } HashedBlockStream hashedStream(&cipherStream); if (!hashedStream.open(QIODevice::ReadOnly)) { raiseError(hashedStream.errorString()); return nullptr; } QIODevice* xmlDevice; QScopedPointer<QtIOCompressor> ioCompressor; if (m_db->compressionAlgo() == Database::CompressionNone) { xmlDevice = &hashedStream; } else { ioCompressor.reset(new QtIOCompressor(&hashedStream)); ioCompressor->setStreamFormat(QtIOCompressor::GzipFormat); if (!ioCompressor->open(QIODevice::ReadOnly)) { raiseError(ioCompressor->errorString()); return nullptr; } xmlDevice = ioCompressor.data(); } KeePass2RandomStream randomStream; if (!randomStream.init(m_protectedStreamKey)) { raiseError(randomStream.errorString()); return nullptr; } QScopedPointer<QBuffer> buffer; if (m_saveXml) { m_xmlData = xmlDevice->readAll(); buffer.reset(new QBuffer(&m_xmlData)); buffer->open(QIODevice::ReadOnly); xmlDevice = buffer.data(); } KeePass2XmlReader xmlReader; xmlReader.readDatabase(xmlDevice, m_db, &randomStream); if (xmlReader.hasError()) { raiseError(xmlReader.errorString()); if (keepDatabase) { return db.take(); } else { return nullptr; } } Q_ASSERT(version < 0x00030001 || !xmlReader.headerHash().isEmpty()); if (!xmlReader.headerHash().isEmpty()) { QByteArray headerHash = CryptoHash::hash(headerStream.storedData(), CryptoHash::Sha256); if (headerHash != xmlReader.headerHash()) { raiseError("Header doesn't match hash"); return Q_NULLPTR; } } return db.take(); }
void tst_QScopedPointer::dataOnDefaultConstructed() { QScopedPointer<int> p; QCOMPARE(p.data(), static_cast<int *>(0)); }
QVariant QgsAggregateCalculator::calculate( QgsAggregateCalculator::Aggregate aggregate, const QString& fieldOrExpression, QgsExpressionContext* context, bool* ok ) const { if ( ok ) *ok = false; if ( !mLayer ) return QVariant(); QScopedPointer<QgsExpression> expression; QScopedPointer<QgsExpressionContext> defaultContext; if ( !context ) { defaultContext.reset( createContext() ); context = defaultContext.data(); } int attrNum = mLayer->fieldNameIndex( fieldOrExpression ); if ( attrNum == -1 ) { Q_ASSERT( context ); context->setFields( mLayer->fields() ); // try to use expression expression.reset( new QgsExpression( fieldOrExpression ) ); if ( expression->hasParserError() || !expression->prepare( context ) ) { return QVariant(); } } QStringList lst; if ( expression.isNull() ) lst.append( fieldOrExpression ); else lst = expression->referencedColumns(); QgsFeatureRequest request = QgsFeatureRequest() .setFlags(( expression.data() && expression->needsGeometry() ) ? QgsFeatureRequest::NoFlags : QgsFeatureRequest::NoGeometry ) .setSubsetOfAttributes( lst, mLayer->fields() ); if ( !mFilterExpression.isEmpty() ) request.setFilterExpression( mFilterExpression ); if ( context ) request.setExpressionContext( *context ); //determine result type QVariant::Type resultType = QVariant::Double; if ( attrNum == -1 ) { // evaluate first feature, check result type QgsFeatureRequest testRequest( request ); testRequest.setLimit( 1 ); QgsFeature f; QgsFeatureIterator fit = mLayer->getFeatures( testRequest ); if ( !fit.nextFeature( f ) ) { //no matching features if ( ok ) *ok = true; return QVariant(); } if ( context ) context->setFeature( f ); QVariant v = expression->evaluate( context ); resultType = v.type(); } else { resultType = mLayer->fields().at( attrNum ).type(); } QgsFeatureIterator fit = mLayer->getFeatures( request ); return calculate( aggregate, fit, resultType, attrNum, expression.data(), mDelimiter, context, ok ); }
// -------------------------------------------------------------------------- int appLauncherMain(int argc, char** argv) { #ifdef QT_MAC_USE_COCOA // See http://doc.trolltech.com/4.7/qt.html#ApplicationAttribute-enum // Setting the application to be a plugin will avoid the loading of qt_menu.nib files QCoreApplication::setAttribute(Qt::AA_MacPluginApplication, true); #endif ctkAppArguments appArguments(argc, argv); // See http://qt-project.org/doc/qt-4.8/qapplication.html#QApplication appArguments.setArgumentToFilterList( ctkAppArguments::ArgToFilterListType() << ctkAppArguments::ArgToFilterType("-style", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE | ctkAppArguments::ARG_TO_FILTER_SPACE_VALUE) << ctkAppArguments::ArgToFilterType("-stylesheet", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE | ctkAppArguments::ARG_TO_FILTER_SPACE_VALUE) << ctkAppArguments::ArgToFilterType("-session", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE | ctkAppArguments::ARG_TO_FILTER_SPACE_VALUE) << ctkAppArguments::ArgToFilterType("-widgetcount") << ctkAppArguments::ArgToFilterType("-reverse") << ctkAppArguments::ArgToFilterType("-graphicssystem") << ctkAppArguments::ArgToFilterType("-qmljsdebugger=", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE) #ifdef QT_DEBUG << ctkAppArguments::ArgToFilterType("-nograb") #endif #ifdef Q_WS_X11 << ctkAppArguments::ArgToFilterType("-display") << ctkAppArguments::ArgToFilterType("-geometry") << ctkAppArguments::ArgToFilterType("-fn") << ctkAppArguments::ArgToFilterType("-font") << ctkAppArguments::ArgToFilterType("-bg") << ctkAppArguments::ArgToFilterType("-background") << ctkAppArguments::ArgToFilterType("-fg") << ctkAppArguments::ArgToFilterType("-foreground") << ctkAppArguments::ArgToFilterType("-btn") << ctkAppArguments::ArgToFilterType("-button") << ctkAppArguments::ArgToFilterType("-name") << ctkAppArguments::ArgToFilterType("-title") << ctkAppArguments::ArgToFilterType("-visual") << ctkAppArguments::ArgToFilterType("-ncols") << ctkAppArguments::ArgToFilterType("-cmap") << ctkAppArguments::ArgToFilterType("-im") << ctkAppArguments::ArgToFilterType("-inputstyle") # ifdef QT_DEBUG << ctkAppArguments::ArgToFilterType("-dograb") << ctkAppArguments::ArgToFilterType("-sync") # endif #endif ); QFileInfo launcherFile(QDir::current(), QString(argv[0])); // Initialize resources in static libs Q_INIT_RESOURCE(CTKAppLauncherBase); QScopedPointer<ctkAppLauncher> appLauncher(new ctkAppLauncher); appLauncher->setArguments(appArguments.arguments()); bool exec = appLauncher->initialize(launcherFile.absoluteFilePath()); exec = appLauncher->configure() && exec; if (!exec) { return EXIT_SUCCESS; } QScopedPointer<QCoreApplication> app; if (appLauncher->disableSplash()) { app.reset(new QCoreApplication( appArguments.argumentCount(ctkAppArguments::ARG_REGULAR_LIST), appArguments.argumentValues(ctkAppArguments::ARG_REGULAR_LIST))); } else { app.reset(new QApplication( appArguments.argumentCount(ctkAppArguments::ARG_REGULAR_LIST), appArguments.argumentValues(ctkAppArguments::ARG_REGULAR_LIST))); } appLauncher->setApplication(*app.data()); QTimer::singleShot(0, appLauncher.data(), SLOT(startLauncher())); int res = app->exec(); // Delete application launcher appLauncher before the application app so that // graphical items such as pixmaps, widgets, etc can be released. appLauncher.reset(); return res; }