Esempio n. 1
0
    bool StreamMail::LoadFile(const QString file) {
        ////qFatal(" unable to read ... ");
        bool filled = false;
        if (clear()) {

            QFile *f = new QFile(file);

            if (f->exists()) {
                /////
                if (f->open(QIODevice::ReadOnly)) {
                    //// read line by line 
                    if (f->isReadable()) {
                        linenr = -1;
                        while (!f->atEnd()) {
                            linenr++;
                            QByteArray crk = f->read(76);
                            d->write(crk);
                        }
                        f->close();
                        d->write(QByteArray("\n--\n--\n--\n--"));
                    }
                } else {
                    qDebug() << "######## file errors:" << f->errorString() << "\n";
                }
            }
        }

        if (d->bytesAvailable() > 23) {
            filled = true;
        }
        d->seek(0);
        return filled;
    }
Esempio n. 2
0
void ExtractImages::acceptImage(DomImage *image)
{
    QString format = image->elementData()->attributeFormat();
    QString extension = format.left(format.indexOf(QLatin1Char('.'))).toLower();
    QString fname = m_imagesDir.absoluteFilePath(image->attributeName() + QLatin1Char('.') + extension);

    *m_output << "        <file>images/" << image->attributeName() << QLatin1Char('.') + extension << "</file>\n";

    QFile f;
    f.setFileName(fname);
    const bool isXPM_GZ = format == QLatin1String("XPM.GZ");
    QIODevice::OpenMode openMode = QIODevice::WriteOnly;
    if (isXPM_GZ)
        openMode |= QIODevice::Text;
    if (!f.open(openMode)) {
        fprintf(stderr, "%s: Error: Could not create image file %s: %s",
                qPrintable(m_option.messagePrefix()),
                qPrintable(fname), qPrintable(f.errorString()));
        return;
    }

    if (isXPM_GZ) {
        QTextStream *imageOut = new QTextStream(&f);
        imageOut->setCodec(QTextCodec::codecForName("UTF-8"));

        CPP::WriteIconData::writeImage(*imageOut, QString(), m_option.limitXPM_LineLength, image);
        delete imageOut;
    } else {
        CPP::WriteIconData::writeImage(f, image);
    }

    f.close();
}
Esempio n. 3
0
void SaveBurstsDual(const QVector<BurstDual> &burstVectorDual, const QString filename)
{
    QFile file;
    if(filename.isEmpty()) qFatal("SaveBursts: enter a valid filename");
    else file.setFileName(filename);
    if(burstVectorDual.size()==0) AlexEvalLog::warning("No dual bursts to save!");
    if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) AlexEvalLog::warning(file.errorString());
    QTextStream out(&file);
    out.setRealNumberPrecision(11);
    out <<"# ALEX dual bursts\n# "<<burstVectorDual.size()<<" bursts were analyzed.\n";

    out<<burstVectorDual.first().toStringHeader().c_str();
    for(int i=0;i<burstVectorDual.size();++i) {
        out<<burstVectorDual.at(i).toString("",", ").c_str()<<"\n";
    }
    AlexEvalLog::text(burstVectorDual.size()+"bursts written to file "+file.fileName());
    file.close();

    //    out <<"# start time in s\tburst duration in ms\tproximity ratio\tstoichiometry ratio\tnumber of photons\tn_Dem_Dex\tn_Aem_Dex\tn_Dem_Aex\tn_Aem_Aex\tduration Dem in ms\tduration Aem in ms\tPR_RAW\tS_RAW\ttype\n";

    //    for(int i=0;i<burstVectorDual.size();++i) {
    //        out <<burstVectorDual.at(i).startTime<<"\t"<<burstVectorDual.at(i).duration*1e3<<"\t"
    //           <<burstVectorDual.at(i).proximityRatio<<"\t"<<burstVectorDual.at(i).stoichiometryRatio<<"\t"<<burstVectorDual.at(i).numberOfPhotons<<"\t"
    //           <<burstVectorDual.at(i).n_Dem_Dex<<"\t"<<burstVectorDual.at(i).n_Aem_Dex<<"\t"<<burstVectorDual.at(i).n_Dem_Aex<<"\t"<<burstVectorDual.at(i).n_Aem_Aex<<"\t"<<burstVectorDual.at(i).durationDonor*1e3<<"\t"<<burstVectorDual.at(i).durationAcceptor*1e3<<"\t"<<burstVectorDual.at(i).proximityRatioRaw<<"\t"<<burstVectorDual.at(i).stoichiometryRatioRaw<<"\t"<<(int)burstVectorDual.at(i).type<<"\n";
    //    }

}
Esempio n. 4
0
/*-------------------------------------------------------------------------------------------------
 * on_buttonSaveFile_clicked --
 *-----------------------------------------------------------------------------------------------*/
void SetupDialog::on_buttonSaveFile_clicked ()
{
    QByteArray ba = "Font=";
    ba += fontEdit->text ();
    ba += "\nConfig=";
    ba += configEdit->text ();
    ba += "\nBoot=";
    ba += bootEdit->text ();
    ba += '\n';

    QString fileName = QFileDialog::getSaveFileName(this, "setup save file name", "",
									    "setup (*.b4s)");
    if (!fileName.endsWith (".b4s"))
	fileName.append (".b4s");

    QFile file (fileName);;
    if (!file.open(QIODevice::WriteOnly)) {
	QMessageBox::warning(this, tr ("setup file"),
		tr ("Cannot create file %1:%2.")
		.arg(fileName)
		.arg(file.errorString()));
	return;
    }

    file.write (ba);
    file.close ();
}
Esempio n. 5
0
	Document::Document (const QString& filename, QObject *plugin)
	: DocURL_ (QUrl::fromLocalFile (filename))
	, Plugin_ (plugin)
	{
		QFile file (filename);
		if (!file.open (QIODevice::ReadOnly))
		{
			qWarning () << Q_FUNC_INFO
					<< "unable to open file"
					<< file.fileName ()
					<< file.errorString ();
			return;
		}

		QDomDocument doc;
		if (!doc.setContent (file.readAll (), true))
		{
			qWarning () << Q_FUNC_INFO
					<< "malformed XML in"
					<< filename;
			return;
		}

		FB2Converter conv (this, doc);
		auto textDoc = conv.GetResult ();
		SetDocument (textDoc);
		Info_ = conv.GetDocumentInfo ();
		TOC_ = conv.GetTOC ();
	}
void DomainContentBackupManager::setup() {
    for (auto& rule : _backupRules) {
        removeOldBackupVersions(rule);
    }

    auto backups = getAllBackups();
    for (auto& backup : backups) {
        QFile backupFile { backup.absolutePath };
        if (!backupFile.open(QIODevice::ReadOnly)) {
            qCritical() << "Could not open file:" << backup.absolutePath;
            qCritical() << "    ERROR:" << backupFile.errorString();
            continue;
        }

        QuaZip zip { &backupFile };
        if (!zip.open(QuaZip::mdUnzip)) {
            qCritical() << "Could not open backup archive:" << backup.absolutePath;
            qCritical() << "    ERROR:" << zip.getZipError();
            continue;
        }

        for (auto& handler : _backupHandlers) {
            handler->loadBackup(backup.id, zip);
        }

        zip.close();
    }

    for (auto& handler : _backupHandlers) {
        handler->loadingComplete();
    }
}
Esempio n. 7
0
void AddressBook::chargerFichier() {
    QString nomFichier = QFileDialog::getOpenFileName(this,
                                                      tr ("Charger depuis un fichier"),
                                                      "",
                                                      tr ("Carnet d'adresse (*.abk);;Tous les fichiers (*)"));
    if (nomFichier.isEmpty())
        return;
    else {
        QFile fichier (nomFichier);
        if (!fichier.open(QIODevice::ReadOnly)) {
            QMessageBox::information(this,
                                     tr ("Erreur de chargement"),
                                     fichier.errorString());
            return;
        }
        QDataStream in (&fichier);
        in.setVersion(QDataStream::Qt_4_7);
        listeContacts.empty();
        in >> listeContacts;
        if (listeContacts.isEmpty()) {
            QMessageBox::information (this ,
                                      tr ("Pas de contacts"),
                                      tr ("Aucun contact à importer dans le fichier"));
        } else {
            QMap<QString , QString>::iterator i = listeContacts.begin();
            nomLineEdit->setText(i.key());
            adresseTextEdit->setText(i.value());
        }

    }
    updateInterface(NavigationMode);
}
Esempio n. 8
0
void MainWindow::checkAndGenerateNecessaryFile()
{
  QDir dir;
  QString path = dir.absolutePath();
  
  if(!dir.exists(path + "/data"))
    dir.mkdir(path + "/data");
  
  if(!dir.exists(path + "/data/.temp"))
    dir.mkdir(path + "/data/.temp");
  
  if(!dir.exists(path + "/data/.temp/VirtualFence"))
    dir.mkdir(path + "/data/.temp/VirtualFence");
  
  QFile file;
  path = path + "/data/.temp/VirtualFence/";
  if (!file.exists(path + "config.ini"))
  {
    QString fileName = path + "config.ini";
    QFile file2(fileName);
    if (!file2.open(QFile::WriteOnly | QFile::Text))
    {
      QMessageBox::warning(this, tr("Create ini file"),
                           tr("Cannot create ini file %1:\n%2.")
                           .arg(fileName)
                           .arg(file.errorString()));
      return;
    }
    
    //write the ini file content here
    QTextStream out(&file2);         
    helper::writeDefautlVirtualFecingIni(out);
    file2.close();     
  }
}
void AutomatedRssDownloader::on_importBtn_clicked()
{
    QString selectedFilter {m_formatFilterJSON};
    QString path = QFileDialog::getOpenFileName(
                this, tr("Import RSS rules"), QDir::homePath()
                , QString("%1;;%2").arg(m_formatFilterJSON, m_formatFilterLegacy), &selectedFilter);
    if (path.isEmpty() || !QFile::exists(path))
        return;

    QFile file {path};
    if (!file.open(QIODevice::ReadOnly)) {
        QMessageBox::critical(
                    this, tr("I/O Error")
                    , tr("Failed to open the file. Reason: %1").arg(file.errorString()));
        return;
    }

    const RSS::AutoDownloader::RulesFileFormat format {
        (selectedFilter == m_formatFilterJSON)
                ? RSS::AutoDownloader::RulesFileFormat::JSON
                : RSS::AutoDownloader::RulesFileFormat::Legacy
    };

    try {
        RSS::AutoDownloader::instance()->importRules(file.readAll(),format);
    }
    catch (const RSS::ParsingError &error) {
        QMessageBox::critical(
                    this, tr("Import Error")
                    , tr("Failed to import the selected rules file. Reason: %1").arg(error.message()));
    }
}
Esempio n. 10
0
int QMacPasteboardMimeQt3Any::registerMimeType(const QString &mime)
{
    if(!mime_registry.contains(mime)) {
        if(!loadMimeRegistry()) {
            qWarning("QMacPasteboardMimeAnyQt3Mime: Internal error");
            return 0;
        }
        if(!mime_registry.contains(mime)) {
            if(!library_file.isOpen()) {
                if(!library_file.open(QIODevice::WriteOnly)) {
                    qWarning("QMacPasteboardMimeAnyQt3Mime: Failure to open %s -- %s", library_file.fileName().toLatin1().constData(),
                             library_file.errorString().toLatin1().constData());
                    return false;
                }
            }
            int ret = ++current_max;
            mime_registry_loaded = QFileInfo(library_file).lastModified();
            QTextStream stream(&library_file);
            stream << mime << endl;
            stream << ret << endl;
            mime_registry.insert(mime, ret);
            library_file.flush(); //flush and set mtime
            return ret;
        }
    }
    return mime_registry[mime];
}
Esempio n. 11
0
			void StartupFirstPage::handleAccepted ()
			{
				for (int i = 0; i < Ui_.Tree_->topLevelItemCount (); ++i)
				{
					QTreeWidgetItem *item = Ui_.Tree_->topLevelItem (i);
					if (item->checkState (0) != Qt::Checked)
						continue;

					QString set = item->data (0, RoleSet).toString ();
					QString filename = item->data (0, RoleFile).toString ();
					QString full = QString (":/resources/default/%1/%2")
						.arg (set)
						.arg (filename);
					QFile file (full);
					if (!file.open (QIODevice::ReadOnly))
					{
						qWarning () << Q_FUNC_INFO
							<< "could not open file for read only"
							<< full
							<< file.errorString ();
						continue;
					}

					QString contents = QTextCodec::codecForName ("UTF-8")->
						toUnicode (file.readAll ());
					Core::Instance ().HandleEntity (contents,
							static_cast<QLineEdit*> (Ui_.Tree_->itemWidget (item, 1))->text ());
				}
			}
Esempio n. 12
0
QStringList Read (const QString& path)
{
    QFile file (path);
    if (!file.open (QIODevice::ReadOnly))
    {
        qWarning () << Q_FUNC_INFO
                    << "unable to open"
                    << path
                    << file.errorString ();
        return QStringList ();
    }

    QDomDocument doc;
    if (!doc.setContent (file.readAll ()))
    {
        qWarning () << Q_FUNC_INFO
                    << "unable to parse"
                    << path;
        return QStringList ();
    }

    QStringList result;
    auto track = doc.documentElement ()
                 .firstChildElement ("trackList")
                 .firstChildElement ("track");
    while (!track.isNull ())
    {
        const auto& loc = track.firstChildElement ("location").text ();
        if (!loc.isEmpty ())
            result << loc;

        track = track.nextSiblingElement ("track");
    }
    return result;
}
Esempio n. 13
0
	void TodoTab::handleImport ()
	{
		const QString& filename = QFileDialog::getOpenFileName (this,
				tr ("Import tasks"),
				QDir::homePath (),
				tr ("iCalendar files (*.ics)"));

		QFile file (filename);
		if (!file.open (QIODevice::ReadOnly))
		{
			QMessageBox::critical (this,
					tr ("Tasks import"),
					tr ("Unable to open %1: %2.")
						.arg ("<em>" + filename + "</em>")
						.arg (file.errorString ()));
			return;
		}

		const auto& items = ICalParser ().Parse (file.readAll ());
		if (items.isEmpty ())
			return;

		ItemsMergeDialog dia (items.size (), this);
		if (dia.exec () != QDialog::Accepted)
			return;

		auto storage = Core::Instance ().GetTodoManager ()->GetTodoStorage ();
		auto ourItems = storage->GetAllItems ();
		for (const auto& item : items)
		{
			const auto& itemId = item->GetID ();
			auto pos = std::find_if (ourItems.begin (), ourItems.end (),
					[&itemId] (const auto& ourItem) { return ourItem->GetID () == itemId; });
			if (pos != ourItems.end ())
			{
				if (dia.GetPriority () == ItemsMergeDialog::Priority::Imported)
				{
					(*pos)->CopyFrom (item);
					storage->HandleUpdated (*pos);
				}
				continue;
			}

			const auto& itemTitle = item->GetTitle ();
			pos = std::find_if (ourItems.begin (), ourItems.end (),
					[itemTitle] (const auto& ourItem) { return ourItem->GetTitle () == itemTitle; });
			if (pos != ourItems.end ())
			{
				if (dia.GetPriority () == ItemsMergeDialog::Priority::Imported &&
						dia.GetSameTitle () == ItemsMergeDialog::SameTitle::Merge)
				{
					(*pos)->CopyFrom (item);
					storage->HandleUpdated (*pos);
				}
				continue;
			}

			storage->AddItem (item);
		}
	}
int createProject(const QString &outFileName)
{
    QDir currentDir = QDir::current();
    QString currentDirName = currentDir.dirName();
    if (currentDirName.isEmpty())
        currentDirName = QLatin1String("root");

    QFile file;
    bool isOk = false;
    if (outFileName.isEmpty()) {
        isOk = file.open(stdout, QFile::WriteOnly | QFile::Text);
    } else {
        file.setFileName(outFileName);
        isOk = file.open(QFile::WriteOnly | QFile::Text);
    }
    if (!isOk) {
        fprintf(stderr, "Unable to open %s: %s\n",
                outFileName.isEmpty() ? qPrintable(outFileName) : "standard output",
                qPrintable(file.errorString()));
        return 1;
    }

    QTextStream out(&file);
    out << QLatin1String("<!DOCTYPE RCC><RCC version=\"1.0\">\n"
                         "<qresource>\n");

    // use "." as dir to get relative file pathes
    dumpRecursive(QDir(QLatin1String(".")), out);

    out << QLatin1String("</qresource>\n"
                         "</RCC>\n");

    return 0;
}
Esempio n. 15
0
		QList<Filter> ParseToFilters (const QStringList& paths)
		{
			QList<Filter> result;
			for (const auto& filePath : paths)
			{
				QFile file (filePath);
				if (!file.open (QIODevice::ReadOnly))
				{
					qWarning () << Q_FUNC_INFO
						<< "could not open file"
						<< filePath
						<< file.errorString ();
					result << Filter ();
					continue;
				}

				const auto& data = QString::fromUtf8 (file.readAll ());
				auto rawLines = data.split ('\n', QString::SkipEmptyParts);
				if (!rawLines.isEmpty ())
					rawLines.removeAt (0);
				const auto& lines = Util::Map (rawLines, Util::QStringTrimmed {});

				Filter f;
				std::for_each (lines.begin (), lines.end (), LineParser (&f));

				f.SD_.Filename_ = QFileInfo (filePath).fileName ();

				result << f;
			}
			return result;
		}
Esempio n. 16
0
		QList<Filter> ParseToFilters (const QStringList& paths)
		{
			QList<Filter> result;
			for (const auto& filePath : paths)
			{
				QFile file (filePath);
				if (!file.open (QIODevice::ReadOnly))
				{
					qWarning () << Q_FUNC_INFO
						<< "could not open file"
						<< filePath
						<< file.errorString ();
					result << Filter ();
					continue;
				}

				const auto& data = QString::fromUtf8 (file.readAll ());
				QStringList rawLines = data.split ('\n', QString::SkipEmptyParts);
				if (rawLines.size ())
					rawLines.removeAt (0);
				QStringList lines;
				std::transform (rawLines.begin (), rawLines.end (),
						std::back_inserter (lines),
						[] (const QString& t) { return t.trimmed (); });

				Filter f;
				std::for_each (lines.begin (), lines.end (), LineParser (&f));

				f.SD_.Filename_ = QFileInfo (filePath).fileName ();

				result << f;
			}
			return result;
		}
Esempio n. 17
0
 /// Takes the error string from given file and emits an error indication.
 /// Closes the files and stops the copy. Always returns false
 bool error(QFile & f) {
     m_error = f.errorString();
     m_error.append(QStringLiteral("(in %1 file").arg(f.objectName()));
     emit finished(false, m_error);
     close();
     return false;
 }
Esempio n. 18
0
int SaveBursts(const QVector<Burst> &burstVector, const BurstSearchParams_t BurstSearchParams, const QString filename)
{
    QFile file;
    if(filename.isEmpty()) qFatal("SaveBursts: enter a valid filename");
    else file.setFileName(filename);

    if(burstVector.size()==0) {
        AlexEvalLog::warning("vector is empty");
        return EXIT_FAILURE;
    }
    if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        AlexEvalLog::warning(file.errorString());
        return EXIT_FAILURE;
    }
    QTextStream out(&file);
    out << BurstSearchParams.toString("# ","\t") //Burst Search with parameters\tM="<<BurstSearchParams.M<<"\tL="<<BurstSearchParams.L()<<" \tT="<<BurstSearchParams.T*1e6<<" us.\t"
       <<".\t" <<burstVector.size()<<" bursts were found.\n";
    out <<"# start photon \tstart time in s \tnumber of photons \tburst duration in ms\n";
    out.setRealNumberPrecision(11);
    for(int i=0;i<burstVector.size();++i) {
        out <<burstVector[i].startIdx<<"\t"<<burstVector[i].startTime<<"\t"
           <<burstVector[i].numberOfPhotons<<"\t"<<burstVector[i].duration*1e3<<"\n";
    }

    AlexEvalLog::text(burstVector.size() + "bursts written to file " + file.fileName());
    file.close();
    return EXIT_SUCCESS;

}
Esempio n. 19
0
	void Plugin::hookItemLoad (IHookProxy_ptr, Item *item)
	{
		if (!FetchedItems_.contains (item->ItemID_))
			return;

		const quint64 id = item->ItemID_;
		if (!ContentsCache_.contains (id))
		{
			QDir dir = StorageDir_;

			dir.cd (QString::number (id % 10));
			QFile file (dir.filePath (QString ("%1.html").arg (id)));
			if (!file.open (QIODevice::ReadOnly))
			{
				qWarning () << Q_FUNC_INFO
						<< "unable to open file:"
						<< file.fileName ()
						<< file.errorString ();
				return;
			}

			ContentsCache_ [id] = QString::fromUtf8 (file.readAll ());
		}

		const QString& contents = ContentsCache_ [id];
		if (!contents.isEmpty ())
			item->Description_ = contents;
	}
Esempio n. 20
0
/**
 * Throws FileOpenError
 *
 * @param filename
 * @param regexp
 * @return
 */
bool findInFile (const QString &filename, QRegExp &regexp)
{
	QFile file (filename);
	if (!file.open (QIODevice::ReadOnly))
		throw FileOpenError (filename, file.error (), file.errorString ());

	return findInIoDevice (file, regexp);
}
Esempio n. 21
0
TorrentInfo TorrentInfo::loadFromFile(const QString &path, QString *error) noexcept
{
    if (error)
        error->clear();

    QFile file {path};
    if (!file.open(QIODevice::ReadOnly)) {
        if (error)
            *error = file.errorString();
        return TorrentInfo();
    }

    const qint64 fileSizeLimit = 100 * 1024 * 1024;  // 100 MB
    if (file.size() > fileSizeLimit) {
        if (error)
            *error = tr("File size exceeds max limit %1").arg(fileSizeLimit);
        return TorrentInfo();
    }

    const QByteArray data = file.read(fileSizeLimit);
    if (data.size() != file.size()) {
        if (error)
            *error = tr("Torrent file read error");
        return TorrentInfo();
    }

    file.close();

    // 2-step construction to overcome default limits of `depth_limit` & `token_limit` which are
    // used in `torrent_info()` constructor
    const int depthLimit = 100;
    const int tokenLimit = 10000000;
    libt::error_code ec;

#if LIBTORRENT_VERSION_NUM < 10100
    libt::lazy_entry node;
    libt::lazy_bdecode(data.constData(), (data.constData() + data.size()), node, ec
        , nullptr, depthLimit, tokenLimit);
#else
    libt::bdecode_node node;
    bdecode(data.constData(), (data.constData() + data.size()), node, ec
        , nullptr, depthLimit, tokenLimit);
#endif
    if (ec) {
        if (error)
            *error = QString::fromStdString(ec.message());
        return TorrentInfo();
    }

    TorrentInfo info {NativePtr(new libt::torrent_info(node, ec))};
    if (ec) {
        if (error)
            *error = QString::fromStdString(ec.message());
        return TorrentInfo();
    }

    return info;
}
Esempio n. 22
0
	Playlist Read2Sources (const QString& path)
	{
		QFile file (path);
		if (!file.open (QIODevice::ReadOnly))
		{
			qWarning () << Q_FUNC_INFO
					<< "unable to open"
					<< path
					<< file.errorString ();
			return {};
		}

		const auto& m3uDir = QFileInfo (path).absoluteDir ();

		QVariantMap lastMetadata;

		Playlist result;
		while (!file.atEnd ())
		{
			const auto& line = file.readLine ().trimmed ();
			if (line.startsWith ('#'))
			{
				const auto& pair = ParseMetadata (line);
				if (!pair.first.isEmpty ())
					lastMetadata [pair.first] = pair.second;
				continue;
			}

			const auto& url = QUrl::fromEncoded (line);
			auto src = QString::fromUtf8 (line);

			const auto mdGuard = std::shared_ptr<void> (nullptr,
					[&lastMetadata] (void*) { lastMetadata.clear (); });

#ifdef Q_OS_WIN32
			if (url.scheme ().size () > 1)
#else
			if (!url.scheme ().isEmpty ())
#endif
			{
				result.Append ({ url, lastMetadata });
				continue;
			}

			src.replace ('\\', '/');

			const QFileInfo fi (src);
			if (fi.isRelative ())
				src = m3uDir.absoluteFilePath (src);

			if (fi.suffix () == "m3u" || fi.suffix () == "m3u8")
				result += Read2Sources (src);
			else
				result.Append ({ src, lastMetadata });
		}
		return result;
	}
Esempio n. 23
0
			void KinotifyWidget::LoadTheme (const QString& themePath)
			{
				if (ThemeCache_.contains (themePath))
				{
					Theme_ = ThemeCache_ [themePath];
					return;
				}

				Theme_.clear ();

				QFile content (themePath + "/tmp.html");
				if (!content.open (QIODevice::ReadOnly))
				{
					qWarning () << Q_FUNC_INFO
							<< "could not open theme file at"
							<< content.fileName ()
							<< content.errorString ();
					return;
				}

				Theme_ = content.readAll ();

				const QPalette& palette = QApplication::palette ();

#define REPLACE1(a) { const QColor& c = palette.color (QPalette::a); \
					  Theme_.replace ("{Color"#a "}", QString ("%1, %2, %3").arg (c.red ()).arg (c.green ()).arg (c.blue ())); }
				REPLACE1 (Window);
				REPLACE1 (WindowText);
				REPLACE1 (Base);
				REPLACE1 (AlternateBase);
				REPLACE1 (ToolTipBase);
				REPLACE1 (ToolTipText);
				REPLACE1 (Text);
				REPLACE1 (Button);
				REPLACE1 (ButtonText);
				REPLACE1 (BrightText);
				REPLACE1 (Light);
				REPLACE1 (Midlight);
				REPLACE1 (Dark);
				REPLACE1 (Mid);
				REPLACE1 (Shadow);
				REPLACE1 (Link);
				REPLACE1 (LinkVisited);
				REPLACE1 (Highlight);
				REPLACE1 (HighlightedText);
#undef REPLACE1

				QDir imgDir (themePath + "/img");
				Q_FOREACH (QString elem, imgDir.entryList (QStringList ("*.png")))
					Theme_.replace (QString ("{%1}").arg (elem.left (elem.size () - 4)),
							MakeImage (themePath + "/img/" + elem));

				if (ThemeCache_.size () > 3)
					ThemeCache_.clear ();

				ThemeCache_ [themePath] = Theme_;
			}
Esempio n. 24
0
	void DriveManager::handleUploadRequestFinished ()
	{
		QNetworkReply *reply = qobject_cast<QNetworkReply*> (sender ());
		if (!reply)
			return;

		reply->deleteLater ();
		QString path = Reply2FilePath_.take (reply);

		const int code = reply->
				attribute (QNetworkRequest::HttpStatusCodeAttribute).toInt ();
		if (code != 200)
		{
			qWarning () << Q_FUNC_INFO
					<< "upload initiating failed with code:"
					<< code;
			return;
		}

		emit uploadStatusChanged (tr ("Uploading..."), path);

		QFile *file = new QFile (path);
		if (!file->open (QIODevice::ReadOnly))
		{
			qWarning () << Q_FUNC_INFO
					<< "unable to open file: "
					<< file->errorString ();
			return;
		}

		QUrl url (reply->rawHeader ("Location"));
		QNetworkRequest request (url);
#ifdef HAVE_MAGIC
		request.setHeader (QNetworkRequest::ContentTypeHeader,
				magic_file (Magic_, path.toUtf8 ()));
#endif
		request.setHeader (QNetworkRequest::ContentLengthHeader,
				QString::number (QFileInfo (path).size ()).toUtf8 ());

		QNetworkReply *uploadReply = Core::Instance ().GetProxy ()->
				GetNetworkAccessManager ()->put (request, file);
		file->setParent (uploadReply);
		Reply2FilePath_ [uploadReply] = path;

		connect (uploadReply,
				SIGNAL (finished ()),
				this,
				SLOT (handleUploadFinished ()));
		connect (uploadReply,
				SIGNAL (error (QNetworkReply::NetworkError)),
				this,
				SLOT (handleUploadError (QNetworkReply::NetworkError)));
		connect (uploadReply,
				SIGNAL (uploadProgress (qint64, qint64)),
				this,
				SLOT (handleUploadProgress (qint64, qint64)));
	}
Esempio n. 25
0
int EventItemModel::loadFile(QString &filename)
{
	QFile input;
	input.setFileName(filename);
	if (!input.open(QIODevice::ReadOnly)) {
		qDebug() << "Couldn't open event stream file: " << input.errorString();
		return -1;
	}
	return _events.load(input);
}
Esempio n. 26
0
bool LuaParser::OpenFile(QFile File)
{
    if(!File.open(QIODevice::ReadOnly))
    {
        QMessageBox::information(0, "error", File.errorString());
        return false;
    };

    return true;
}
Esempio n. 27
0
void Updater::writeUpdate()
{
    if(m_netReply->bytesAvailable() != 0)
    {
        QFileInfo file(m_urlExe);
        QString executableName = file.fileName();

        if(QFile::exists(executableName))
        {
            if(QFile::exists("_old_" + executableName))
                QFile::remove("_old_" + executableName);
            QFile::rename(executableName, "_old_" + executableName);
        }
        QFile fileToWrite (QFileInfo(m_urlExe).fileName(), this);
        if(fileToWrite.open(QFile::WriteOnly | QIODevice::Truncate))
        {
            fileToWrite.write(m_netReply->readAll());
            fileToWrite.close();

            QMessageBox endBox (nullptr);
            endBox.setWindowTitle(tr("Mise à jour terminée ! "));
            endBox.setText(tr("La mise à jour %1 a pu être appliquée avec succès\n"
                              "Voulez-vous lancer à nouveau %2?").arg(m_newAppVersion).arg(m_appName));
            endBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            endBox.setDefaultButton(QMessageBox::Yes);
            endBox.setButtonText(QMessageBox::Yes, tr("Relancer %1").arg(m_appName));
            endBox.setButtonText(QMessageBox::No, tr("Pas maintenant"));
            int reply = endBox.exec(); //Awaiting user reply
            if(reply == QMessageBox::Yes)
                QDesktopServices::openUrl(QUrl::fromLocalFile(executableName));
            exit(0);
        }
        else
        {
            qDebug() << fileToWrite.errorString();
            QMessageBox::critical(nullptr, tr("Erreur"),
                                  tr("La mise à jour n'a pas pu être écrite : ") +
                                  fileToWrite.errorString());
            exit(1);
        }
    }

}
Esempio n. 28
0
bool Shader::compileSourceFile (CGcontext context,
                                const QString& file, const QString& entryPoint)
{
    QFile dev (file);
    if (!dev.open(QIODevice::ReadOnly)) {
        qWarning("failed to open file: %s", qPrintable(dev.errorString()));
        return false;
    }
    return compileSourceCode(context, dev.readAll(), entryPoint);
}
bool ExportHelper::exportHTML(const int qryheadid, ParameterList &params, QString &filename, QString &errmsg)
{
  if (DEBUG)
    qDebug("ExportHelper::exportHTML(%d, %d params, %s, errmsg) entered",
           qryheadid, params.size(), qPrintable(filename));
  bool returnVal = false;

  XSqlQuery setq;
  setq.prepare("SELECT * FROM qryhead WHERE qryhead_id=:id;");
  setq.bindValue(":id", qryheadid);
  setq.exec();
  if (setq.first())
  {
    if (filename.isEmpty())
    {
      QFileInfo fileinfo(setq.value("qryhead_name").toString());
      filename = fileinfo.absoluteFilePath();
    }

    QFile *exportfile = new QFile(filename);
    if (! exportfile->open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text))
      errmsg = tr("Could not open %1: %2.")
                                      .arg(filename, exportfile->errorString());
    else
    {
      if (exportfile->write(generateHTML(qryheadid, params, errmsg).toUtf8()) < 0)
        errmsg = tr("Error writing to %1: %2")
                                      .arg(filename, exportfile->errorString());
      exportfile->close();
    }
  }
  else if (setq.lastError().type() != QSqlError::NoError)
    errmsg = setq.lastError().text();
  else
    errmsg = tr("<p>Cannot export data because the query set with "
                "id %1 was not found.").arg(qryheadid);

  if (DEBUG)
    qDebug("ExportHelper::exportHTML returning %d, filename %s, and errmsg %s",
           returnVal, qPrintable(filename), qPrintable(errmsg));

  return returnVal;
}
Esempio n. 30
0
bool Project::save()
{
    saveOpenTexts();
    serializeConfigurationXml();

    // indebted to: http://stackoverflow.com/questions/2598117/zipping-a-folder-file-using-qt
    QuaZip zip(mProjectPath);
    QuaZipFile outFile(&zip);

    if (!zip.open(QuaZip::mdCreate))
    {
        qWarning() << "zip.open()" << zip.getZipError();
        return false;
    }
    char c;
    QFile inFile;
    QDir tempDir = getTempDir();
    tempDir.setNameFilters(QStringList("*"));
    QStringList files = tempDir.entryList(QDir::Files,QDir::Name);
    for(int i=0; i<files.count(); i++)
    {
        inFile.setFileName( tempDir.absoluteFilePath(files.at(i)) );
        if( !inFile.open(QIODevice::ReadOnly))
        {
            qWarning() << inFile.errorString();
            return false;
        }
        if( !outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(files.at(i) , tempDir.absoluteFilePath(files.at(i)) )))
        {
            qWarning() << outFile.errorString();
            return false;
        }
        while (inFile.getChar(&c) && outFile.putChar(c));

        if (outFile.getZipError() != UNZ_OK)
        {
            qWarning() << outFile.getZipError();
            return false;
        }

        outFile.close();

        if (outFile.getZipError() != UNZ_OK)
        {
            qWarning() << outFile.getZipError();
            return false;
        }

        inFile.close();
    }

    mChanged = false;

    return true;
}