CloudImageProvider::CloudImageProvider(QObject *parent) : QObject(parent),
QQuickImageProvider(QQuickImageProvider::Image , QQmlImageProviderBase::ForceAsynchronousImageLoading)
// QDeclarativeImageProvider(QDeclarativeImageProvider::Image)
{
// This space intentionally left blank.
mgr = new QNetworkAccessManager;
connect(mgr,SIGNAL(finished(QNetworkReply*)),this,SLOT(loadfinished(QNetworkReply*)));
// load cache
// fetch workdir+"/imgcache" directory
QDir dir;
dir.mkpath(workDir+"/imgcache/");
dir.setPath(workDir+"/imgcache/");
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Size | QDir::Reversed);
QFileInfoList list = dir.entryInfoList();
//std::cout << " Bytes Filename" << std::endl;
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
if (fileInfo.suffix() == "jpg") {
// qWarning()<<"load ["<< fileInfo.baseName()<<"]="+fileInfo.absoluteFilePath();
cache[fileInfo.baseName()] = QImage(fileInfo.absoluteFilePath());
}
}
}
// Return installed API files.
QStringList QsciAPIs::installedAPIFiles() const
{
const char *qtdir = getenv("QTDIR");
if (!qtdir)
return QStringList();
QDir apidir = QDir(QString("%1/qsci/api/%2").arg(qtdir).arg(lexer()->lexer()));
QStringList filenames;
const QFileInfoList *flist = apidir.entryInfoList("*.api", QDir::Files, QDir::IgnoreCase);
if (flist)
{
QPtrListIterator<QFileInfo> it(*flist);
QFileInfo *fi;
while ((fi = it.current()) != 0)
{
filenames << fi->absFilePath();
++it;
}
}
return filenames;
}
bool FacilityLib::rmpath(const QDir &dir)
{
if(!dir.exists())
return true;
bool allHaveWork=true;
QFileInfoList list = dir.entryInfoList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::Hidden|QDir::System,QDir::DirsFirst);
for (int i = 0; i < list.size(); ++i)
{
QFileInfo fileInfo(list.at(i));
if(!fileInfo.isDir())
{
if(!QFile(fileInfo.absoluteFilePath()).remove())
allHaveWork=false;
}
else
{
//return the fonction for scan the new folder
if(!FacilityLib::rmpath(dir.absolutePath()+FacilityLib::text_slash+fileInfo.fileName()+FacilityLib::text_slash))
allHaveWork=false;
}
}
if(!allHaveWork)
return false;
allHaveWork=dir.rmdir(dir.absolutePath());
return allHaveWork;
}
void common::fill_graphicfiles_combobox(std::string directory, QComboBox *comboWidget)
{
comboWidget->clear(); // delete all previous entries
std::string str_filepath(FILEPATH+directory);
QString filepath(str_filepath.c_str());
QDir dir = QDir(filepath);
if (!dir.exists()) {
//std::cout << ">> MainWindow::fill_graphicfiles_listwidget ERROR: Directory '" << str_filepath << " does not exist. <<" << std::endl;
exit(-1);
}
dir.setFilter(QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot);
dir.setSorting(QDir::Size | QDir::Reversed);
QFileInfoList list = dir.entryInfoList();
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
if (fileInfo.fileName().length() > 30) {
std::cout << "ERROR: file '" << fileInfo.fileName().toStdString() << "' surpasses the maximum number of file-characters (" << CHAR_FILENAME_SIZE << ")" << std::endl;
} else {
std::string filename = FILEPATH + directory + "/" + fileInfo.fileName().toStdString();
QIcon icon(filename.c_str());
comboWidget->addItem(icon, fileInfo.fileName());
}
}
comboWidget->repaint();
}
void MainWindow::updateFileList()
{
QFileInfoList tmp_list;
QDir dir;
if (this->directoryPath == "")
this->directoryPath = dir.absolutePath();
this->fileList.clear();
dir.cd(this->directoryPath);
tmp_list = dir.entryInfoList();
for (int i = 0; i < tmp_list.size(); ++i)
{
QString tmp_name = tmp_list.at(i).fileName();
if (tmp_name.endsWith(".jpg", Qt::CaseInsensitive) == 1 ||
tmp_name.endsWith(".bmp", Qt::CaseInsensitive) == 1 ||
tmp_name.endsWith(".png", Qt::CaseInsensitive) == 1)
{
MyFile new_file;
new_file.name = tmp_list.at(i).fileName();
new_file.sent = false;
new_file.path = this->directoryPath;
new_file.plate = "";
this->fileList.push_back(new_file);
}
}
}
void FindFiles(QString sDirectoryName,QStringList *pList,bool bSubDirs)
{
QDir dir;
dir.setPath(sDirectoryName);
QFileInfoList fi=dir.entryInfoList();
for(int i=0; i<fi.count(); i++)
{
if(fi.at(i).fileName()==".")
{
continue;
}
if(fi.at(i).fileName()=="..")
{
continue;
}
else if(fi.at(i).isFile())
{
pList->append(fi.at(i).absoluteFilePath());
}
if(fi.at(i).isDir()&&(bSubDirs))
{
FindFiles(fi.at(i).absoluteFilePath(),pList,bSubDirs);
}
}
}
void common::fill_files_combo(std::string directory, QComboBox* combo, bool show_none)
{
combo->clear(); // delete all previous entries
combo->addItem(QString("")); // for "empty"
std::string str_filepath(FILEPATH+directory);
QString filepath(str_filepath.c_str());
QDir dir = QDir(filepath);
if (!dir.exists()) {
std::cout << ">> MainWindow::fill_files_combo ERROR: Directory '" << str_filepath << " does not exist. <<" << std::endl;
exit(-1);
}
dir.setFilter(QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot);
dir.setSorting(QDir::Size | QDir::Reversed);
if (show_none == true) {
combo->addItem(QString("None"));
}
QFileInfoList list = dir.entryInfoList();
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
if (fileInfo.fileName().length() > 30) {
std::cout << "ERROR: file '" << fileInfo.fileName().toStdString() << "' surpasses the maximum number of file-characters (" << CHAR_FILENAME_SIZE << ")" << std::endl;
} else {
combo->addItem(QString(fileInfo.fileName()));
}
}
combo->repaint();
}
void
MultiplayerDialog::updateLandscapesList()
{
QDir pluginsDirectory = QDir( m_environment.getLandscapesDirectory() );
if ( !pluginsDirectory.exists() )
return;
QStringList filesFilter;
filesFilter.push_back( Core::LandscapeModel::Resources::LandscapeFileFilter );
QFileInfoList filesList = pluginsDirectory.entryInfoList( filesFilter );
if ( filesList.empty() )
return;
for ( int i = 0; i < filesList.size(); ++i )
{
QFileInfo fileInfo = filesList.at( i );
m_landscapesList->addItem( fileInfo.fileName() );
}
m_landscapesList->setCurrentItem( m_landscapesList->item( 0 ) );
} // MultiplayerDialog::updateLandscapesList
void Enhancededitorwindow::read_formula()
{
_names_list.clear();
ui->cb_AtomFormula->clear();
QString contents;
QFile formula_file(QDir::homePath() + "/" + "Matching-Pursuit-Toolbox/user.fml");
if (formula_file.open(QIODevice::ReadOnly | QIODevice::Text))
{
while(!formula_file.atEnd())
{
contents = formula_file.readLine(0).constData();
ui->cb_AtomFormula->addItem(QIcon(":/images/icons/formel.png"), contents.trimmed());
}
}
formula_file.close();
QDir dictDir = QDir(QDir::homePath() + "/" + "Matching-Pursuit-Toolbox");
QStringList filterList;
filterList.append("*.dict");
filterList.append("*.pdict");
QFileInfoList fileList = dictDir.entryInfoList(filterList);
for(int i = 0; i < fileList.length(); i++)
_names_list.append(fileList.at(i).baseName());
if(ui->cb_AtomFormula->count() != 0)
ui->cb_AtomFormula->setCurrentIndex(0);
}
void FilesModel::setCurrentFolder( QString folder )
{
// doing some checks
if( true == folder.isEmpty() )
return;
QDir directory;
directory.setPath( folder );
QStringList folderContent = directory.entryList();
// removing the "."
folderContent.removeAt(0);
setStringList( folderContent );
m_fileInfoList = directory.entryInfoList();
// removing info for "."
m_fileInfoList.removeAt(0);
// storing the folder beeing displaied
m_currentFolder = directory.absolutePath();
}
//*******************************************************************
// read_dir PRIVATE
//-------------------------------------------------------------------
// Rekursywne odczytywanie calej zawartosci wskazanego katalogu.
// Odczytana zawrtosc katalogu jest zapamietywania w hash-tablicy.
//*******************************************************************
void QBtCompareDirsDialog::read_dir( const QString& in_parent,
const QString& in_dir,
DirMap& out_data ) const
{
static const int sflag = QDir::AllDirs
| QDir::Files
| QDir::NoDotAndDotDot
| QDir::Readable
| QDir::Writable
| QDir::Hidden;
const QDir dir( in_dir, "*", QDir::Unsorted, QFlags<QDir::Filter>( sflag ) );
const QFileInfoList items = dir.entryInfoList();
FileMap files_map = FileMap();
QFileInfoList::const_iterator it = items.begin();
const QFileInfoList::const_iterator end = items.end();
while( continue_ && ( it != end ) ) {
if( it->isDir() ) read_dir( in_parent, it->absoluteFilePath(), out_data );
else files_map.insert( it->fileName(), *it );
++it;
}
QString path = in_dir;
out_data.insert( path.remove( in_parent ), files_map );
}
/** remplace QDir::rmpath() because it return false if the folder not exists
and seam bug with parent folder */
bool copyEngineUnitTester::rmpath(const QDir &dir)
{
if(!dir.exists())
return true;
bool allHaveWork=true;
QFileInfoList list = dir.entryInfoList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::Hidden|QDir::System,QDir::DirsFirst);
for (int i = 0; i < list.size(); ++i)
{
QFileInfo fileInfo(list.at(i));
if(!fileInfo.isDir())
{
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"found a file: "+fileInfo.fileName());
allHaveWork=false;
}
else
{
//return the fonction for scan the new folder
if(!rmpath(dir.absolutePath()+'/'+fileInfo.fileName()+'/'))
allHaveWork=false;
}
}
if(!allHaveWork)
return allHaveWork;
allHaveWork=dir.rmdir(dir.absolutePath());
if(!allHaveWork)
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"unable to remove the folder: "+dir.absolutePath());
return allHaveWork;
}
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
ui->setupUi(this);
midi = new MistyMidi();
loadPortNames();
connect(ui->intputList, SIGNAL(currentTextChanged(QString)), midi, SLOT(input_changed(QString)));
connect(midi, SIGNAL(send_message(QString)), this, SLOT(updatelog(QString)));
ui->actionE_xit->setShortcut(QKeySequence::Quit);
ui->synthList->setRowCount(1);
ui->synthList->setItem(0, 0, new QTableWidgetItem("Piano", QTableWidgetItem::Type));
SynthSelector *combo = new SynthSelector(ui->synthList, outputs);
ui->synthList->setCellWidget(0, 1, combo);
QDir mididir ("MIDI");
if(mididir.exists()) {
mididir.setFilter(QDir::Files | QDir::NoSymLinks);
mididir.setNameFilters(QStringList("*.mid"));
QFileInfoList files = mididir.entryInfoList();
for(int i=0; i<files.size(); i++) {
ui->accompanimentList->addItem(files.at(i).fileName());
}
} else {
ui->accompanimentList->addItem(QString("Midi Directory %1 Not Found").arg(mididir.absolutePath()));
}
}
bool cceDirRemoverHelper::RecursiveRemoveDir(QDir aDir)
{
bool allOk = true;
if (aDir.exists())//QDir::NoDotAndDotDot
{
QFileInfoList entries = aDir.entryInfoList( QDir::NoDotAndDotDot |
QDir::Dirs |
QDir::Files);
foreach (QFileInfo entryInfo, entries)
{
QString path = entryInfo.absoluteFilePath();
if (entryInfo.isDir())
{
allOk = RecursiveRemoveDir(QDir(path));
}
else
{
QFile file(path);
if (!file.remove())
{
allOk = false;
}
}
if (!allOk)
{
break;
}
}
bool MythRemoveDirectory(QDir &aDir)
{
if (!aDir.exists())//QDir::NoDotAndDotDot
return false;
QFileInfoList entries = aDir.entryInfoList(QDir::NoDotAndDotDot |
QDir::Dirs | QDir::Files);
int count = entries.size();
bool has_err = false;
for (int idx = 0; idx < count && !has_err; idx++)
{
QFileInfo entryInfo = entries[idx];
QString path = entryInfo.absoluteFilePath();
if (entryInfo.isDir())
{
QDir dir(path);
has_err = MythRemoveDirectory(dir);
}
else
{
QFile file(path);
if (!file.remove())
has_err = true;
}
}
if (!has_err && !aDir.rmdir(aDir.absolutePath()))
has_err = true;
return(has_err);
}
void processShaderFiles()
{
QString workingShaderDirPath = QString(workingAssetsDir) + "Shaders\\";
QDir workingShaderDir (workingShaderDirPath);
if(workingShaderDir.exists())
{
QStringList shaderFileFilters;
shaderFileFilters << "*.glsl";
workingShaderDir.setFilter(QDir::Files | QDir::NoSymLinks);
workingShaderDir.setNameFilters(shaderFileFilters);
QFileInfoList workingShaderFiles = workingShaderDir.entryInfoList();
for(int i = 0; i < workingShaderFiles.size(); i++)
{
QFileInfo workingShader = workingShaderFiles.at(i);
QFileInfo outShader(QString(outAssetsDir) + "Shaders\\" + workingShader.fileName());
bool needsCopy = (!outShader.exists() || (outShader.lastModified() < workingShader.lastModified()));
if(needsCopy)
{
QString copyCommand("echo f|xcopy /y \"" + QDir::toNativeSeparators(workingShader.absoluteFilePath()) + "\" \"" + QDir::toNativeSeparators(outShader.absoluteFilePath()) + "\"");
int result = system(copyCommand.toUtf8().constData());
}
}
}
else
{
qDebug("No working Shader folder.");
}
}
bool IfBattery::If(QMap<QString, QVariant> Parameters)
{
bool matching = false;
#if defined(Q_OS_WIN)
// TODO: Add battery API
#else
QDir* procdir = new QDir( "/sys/class/power_supply/" );
QFileInfoList powersources = procdir->entryInfoList( QDir::Dirs );
foreach( QFileInfo powersource, powersources )
{
if( powersource.fileName() != "." && powersource.fileName() != ".." )
{
/*
QFileInfo* statusinfo = new QFileInfo( "/sys/class/power_supply/" + powersource.fileName() + "/status" );
*/
}
}
#endif
return matching;
}
void processImageFiles()
{
QString workingImageDirPath = QString(workingAssetsDir) + "Textures\\";
QDir workingImageDir (workingImageDirPath);
if(workingImageDir.exists())
{
QStringList imageFileFilters;
imageFileFilters << "*.png";
workingImageDir.setFilter(QDir::Files | QDir::NoSymLinks);
workingImageDir.setNameFilters(imageFileFilters);
QFileInfoList workingImageFiles = workingImageDir.entryInfoList();
for(int i = 0; i < workingImageFiles.size(); i++)
{
QFileInfo unprocessedImageFile = workingImageFiles.at(i);
QFileInfo outImage(QString(outAssetsDir) + "Textures\\" + unprocessedImageFile.fileName());
bool needsCopy = (!outImage.exists() || (outImage.lastModified() < unprocessedImageFile.lastModified()));
if(needsCopy)
{
QDir::root().mkpath(outImage.absolutePath());
QImage workingImage = QImage(QDir::toNativeSeparators(unprocessedImageFile.absoluteFilePath()));
workingImage = QGLWidget::convertToGLFormat(workingImage);
bool saved = workingImage.save(outImage.absoluteFilePath(), "PNG");
}
}
}
else
{
qDebug("No working Image folder.");
}
}
QT_BEGIN_NAMESPACE
QFileInfoList alternativeFilePaths(const QString &path, const QStringList &nameFilters,
QDir::Filters filters = QDir::NoFilter, QDir::SortFlags sort = QDir::NoSort,
bool uniqueFileNames = true)
{
QFileInfoList result;
// Prepare a 'soft to hard' drive list: W:, X: ... A:, Z:
QStringList driveStrings;
foreach (const QFileInfo &drive, QDir::drives())
driveStrings.append(drive.absolutePath());
driveStrings.sort();
const QString zDriveString(QLatin1String("Z:/"));
driveStrings.removeAll(zDriveString);
driveStrings.prepend(zDriveString);
QStringList uniqueFileNameList;
for (int i = driveStrings.count() - 1; i >= 0; --i) {
const QDir dirOnDrive(driveStrings.at(i) + path);
const QFileInfoList entriesOnDrive = dirOnDrive.entryInfoList(nameFilters, filters, sort);
if (uniqueFileNames) {
foreach(const QFileInfo &entry, entriesOnDrive) {
if (!uniqueFileNameList.contains(entry.fileName())) {
uniqueFileNameList.append(entry.fileName());
result.append(entry);
}
}
} else {
result.append(entriesOnDrive);
}
}
void K3ChessSettings::enumPiecesStyles(QDir dir)
{
dir.setFilter(QDir::Files | QDir::Dirs);
QFileInfoList items = dir.entryInfoList();
foreach(QFileInfo fi, items)
{
if(fi.isDir())
{
if(!fi.fileName().startsWith("."))
enumPiecesStyles(fi.filePath());
}
else if(fi.fileName().contains('.'))
{
QString ext = fi.fileName().section('.', -1, -1);
QString name = fi.fileName().left(fi.fileName().length()-ext.length()-1);
if(ext=="png" || ext=="bmp" || ext=="jpg")
{
piecesStyles_.insert(std::make_pair(name, fi.filePath()));
}
}
}
//
if(!piecesStyles_.empty() &&
piecesStyles_.find(settings_.value("Board/PiecesStyle",
QString()).toString())==piecesStyles_.end())
{
settings_.setValue("Board/PiecesStyle", piecesStyles_.begin()->first);
}
}
void common::fill_graphicfiles_listwidget(std::string directory, QListWidget* listWidget)
{
listWidget->clear();
QListWidgetItem* item;
std::string str_filepath(FILEPATH+directory);
QString filepath(str_filepath.c_str());
QDir dir = QDir(filepath);
if (!dir.exists()) {
//std::cout << ">> MainWindow::fill_graphicfiles_listwidget ERROR: Directory '" << str_filepath << " does not exist. <<" << std::endl;
exit(-1);
}
dir.setFilter(QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot);
dir.setSorting(QDir::Size | QDir::Reversed);
QFileInfoList list = dir.entryInfoList();
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
if (fileInfo.fileName().length() > 30) {
std::cout << "ERROR: file '" << fileInfo.fileName().toStdString() << "' surpasses the maximum number of file-characters (" << CHAR_FILENAME_SIZE << ")" << std::endl;
} else {
item = new QListWidgetItem;
item->setText(fileInfo.fileName());
std::string filename = FILEPATH + directory + "/" + fileInfo.fileName().toStdString();
//std::cout << ">> MainWindow::fill_graphicfiles_listwidget DEBUG: filename: '" << filename << std::endl;
QPixmap image(filename.c_str());
image = image.copy(0, 0, image.width(), image.height());
image = image.scaled(32, 32);
item->setIcon(image);
listWidget->addItem(item);
}
}
listWidget->repaint();
}
void K3ChessSettings::enumLocales(QDir dir)
{
dir.setFilter(QDir::Files | QDir::Dirs);
QFileInfoList items = dir.entryInfoList();
foreach(QFileInfo fi, items)
{
if(fi.isDir())
{
if(!fi.fileName().startsWith("."))
enumLocales(fi.filePath());
}
else if(fi.fileName().endsWith(".ini"))
{
QSettings ini(fi.filePath(), QSettings::IniFormat);
ini.setIniCodec(QTextCodec::codecForName("UTF-8"));
QString name = ini.value("Info/LocaleName", QString()).toString();
if(!name.isEmpty())
{
locales_.insert(std::make_pair(name, fi.filePath()));
}
}
}
//
QString lname = settings_.value("Locale",
cDefaultLocaleName).toString();
//
if((!locales_.empty() && locales_.find(lname)==locales_.end()) ||
(locales_.empty() && lname!=cDefaultLocaleName))
{
settings_.setValue("Locale", cDefaultLocaleName);
}
}
void RouteMapDock::populateTable(int /*flag*/)/*{{{*/
{
_listModel->clear();
QDir routes;
routes.setFilter(QDir::Files | QDir::NoSymLinks);
if(!routes.cd(routePath))
return;
QFileInfoList files = routes.entryInfoList();
for(int it = 0; it < files.size(); ++it)
{
QFileInfo f = files.at(it);
QString note = oom->noteForRouteMapping(f.filePath());
QList<QStandardItem*> rowData;
QStandardItem *chk = new QStandardItem(f.filePath());
QStandardItem *tname = new QStandardItem(f.baseName());
tname->setToolTip(note);
chk->setToolTip(note);
rowData.append(chk);
rowData.append(tname);
_listModel->blockSignals(true);
_listModel->insertRow(_listModel->rowCount(), rowData);
_listModel->blockSignals(false);
routeList->setRowHeight(_listModel->rowCount(), 25);
}
updateTableHeader();
//routeList->resizeRowsToContents();
}/*}}}*/
void FileViewer::slotShow(QDir dir)
{
QStringList string;
string << "*" ;
QFileInfoList list=dir.entryInfoList (string,QDir::AllEntries,QDir::DirsFirst);
showFileInfoList(list);
}
void
SendLogsDialog::send()
{
SendLogsRequest* request = new SendLogsRequest( ui.moreInfoTextEdit->toPlainText() );
connect( request, SIGNAL( success() ), SLOT( onSuccess() ) );
connect( request, SIGNAL( error() ), SLOT( onError() ) );
QDir logDir = CoreDir::logs();
QStringList logExt( "*.log" );
// find logs
logDir.setFilter( QDir::Files | QDir::Readable );
logDir.setNameFilters( logExt );
QList<QFileInfo> logFiles = logDir.entryInfoList();
foreach( QFileInfo log, logFiles )
request->addLog( log.completeBaseName(), log.absoluteFilePath() );
request->addLogData( "clientinfo", clientInformationString() );
request->addLogData( "sysinfo", systemInformationString() );
request->send();
ui.buttonBox->setEnabled( false );
ui.moreInfoTextEdit->setEnabled( false );
ui.spinner->show();
ui.spinner->movie()->start();
}
QList<StorageObjectInfo> StorageGit::objectsList(const QString & url, const QStringList & nameFilters,
QDir::Filters filters, QDir::SortFlags sort, bool * ok)
{
QList<StorageObjectInfo> list;
QString absoluteFilePath = convertToLocal(url);
if (absoluteFilePath.isEmpty()) {
if (ok)
*ok = false;
return list;
}
QDir dir (absoluteFilePath);
if (!dir.exists()) {
m_lastError = "Url path does not exist";
if (ok)
*ok = false;
return list;
}
QFileInfoList infoList = dir.entryInfoList(nameFilters, filters | QDir::NoDotAndDotDot, sort);
foreach (const QFileInfo &fileInfo, infoList) {
StorageObjectInfo objectInfo;
objectInfo.url = urlScheme() + ":" + pathCutOff(fileInfo.absoluteFilePath());
objectInfo.size = fileInfo.size();
objectInfo.type = fileInfo.isDir() ? FileDir : FileUnknown;
list.append(objectInfo);
}
bool MainWindow::rmpath(const QDir &dir)
{
if(!dir.exists())
return true;
bool allHaveWork=true;
QFileInfoList list = dir.entryInfoList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::Hidden|QDir::System,QDir::DirsFirst);
for (int i = 0; i < list.size(); ++i)
{
QFileInfo fileInfo(list.at(i));
if(!fileInfo.isDir())
{
if(!QFile(fileInfo.absoluteFilePath()).remove())
{
qDebug() << "Unable the remove the file: " << fileInfo.absoluteFilePath();
allHaveWork=false;
}
}
else
{
//return the fonction for scan the new folder
if(!rmpath(dir.absolutePath()+'/'+fileInfo.fileName()+'/'))
allHaveWork=false;
}
}
if(!allHaveWork)
return allHaveWork;
if(!dir.rmdir(dir.absolutePath()))
{
qDebug() << "Unable the remove the file: " << dir.absolutePath();
return false;
}
return true;
}
Updater::Updater(const UpdateInformation &information, QObject *parent) : QObject(parent),
m_transfer(NULL),
m_transfersCount(0),
m_transfersSuccessful(true)
{
const QString path = QStandardPaths::writableLocation(QStandardPaths::TempLocation) + QLatin1String("/OtterBrowser/");
QDir directory = QDir(path);
if (!directory.exists())
{
QDir().mkdir(path);
}
else if (directory.entryInfoList(QDir::NoDotAndDotDot | QDir::AllEntries).count() > 0)
{
directory.setNameFilters(QStringList() << QLatin1String("*.*"));
directory.setFilter(QDir::Files);
for (int i = 0; i < directory.entryList().count(); ++i)
{
directory.remove(directory.entryList().at(i));
}
}
clearUpdate();
downloadFile(information.scriptUrl, path);
m_transfer = downloadFile(information.fileUrl, path);
m_transfer->setUpdateInterval(500);
connect(m_transfer, SIGNAL(progressChanged(qint64,qint64)), this, SLOT(updateProgress(qint64,qint64)));
}
QFileInfoList ResourceLoader::List (const QString& option,
const QStringList& nameFilters, QDir::Filters filters) const
{
QSet<QString> alreadyListed;
QFileInfoList result;
Q_FOREACH (const QString& prefix,
LocalPrefixesChain_ + GlobalPrefixesChain_)
{
const QString& path = prefix + RelativePath_ + option;
QDir dir (path);
const QFileInfoList& list =
dir.entryInfoList (nameFilters, filters);
Q_FOREACH (const QFileInfo& info, list)
{
const QString& fname = info.fileName ();
if (alreadyListed.contains (fname))
continue;
alreadyListed << fname;
result << info;
}
}
return result;
}
// Copies Qt FLMs to correct location under epocroot.
// This is not done by configure as it is possible to change epocroot after configure.
void SymbianSbsv2MakefileGenerator::exportFlm()
{
static bool flmExportDone = false;
if (!flmExportDone) {
QDir sourceDir = QDir(QLibraryInfo::location(QLibraryInfo::PrefixPath) + FLM_SOURCE_DIR);
QFileInfoList sourceInfos = sourceDir.entryInfoList(QDir::Files);
QDir destDir(qt_epocRoot() + FLM_DEST_DIR);
if (!destDir.exists()) {
if (destDir.mkpath(destDir.absolutePath()))
generatedDirs << destDir.absolutePath();
}
foreach(QFileInfo item, sourceInfos) {
QFileInfo destInfo = QFileInfo(destDir.absolutePath() + "/" + item.fileName());
if (!destInfo.exists() || destInfo.lastModified() != item.lastModified()) {
if (destInfo.exists())
QFile::remove(destInfo.absoluteFilePath());
if (QFile::copy(item.absoluteFilePath(), destInfo.absoluteFilePath()))
generatedFiles << destInfo.absoluteFilePath();
else
fprintf(stderr, "Error: Could not copy '%s' -> '%s'\n",
qPrintable(item.absoluteFilePath()),
qPrintable(destInfo.absoluteFilePath()));
}
}
