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;
}