QT_BEGIN_NAMESPACE
// Find out if our parent process is gdb by looking at the 'exe' symlink under /proc,.
// or, for older Linuxes, read out 'cmdline'.
static bool runningUnderDebugger()
{
#if defined(QT_DEBUG) && defined(Q_OS_LINUX)
const QString parentProc = QLatin1String("/proc/") + QString::number(getppid());
const QFileInfo parentProcExe(parentProc + QLatin1String("/exe"));
if (parentProcExe.isSymLink())
return parentProcExe.symLinkTarget().endsWith(QLatin1String("/gdb"));
QFile f(parentProc + QLatin1String("/cmdline"));
if (!f.open(QIODevice::ReadOnly))
return false;
QByteArray s;
char c;
while (f.getChar(&c) && c) {
if (c == '/')
s.clear();
else
s += c;
}
return s == "gdb";
#else
return false;
#endif
}
void FileBrowserWindow::itemDoubleClicked(const QModelIndex &)
{
// Check what kind of item has been double clicked and if it is a file, then
// let people know about it being double clicked
QString fileName = mFileBrowserWidget->currentPath();
QFileInfo fileInfo = fileName;
if (fileInfo.isFile()) {
// We are dealing with a file (as opposed to a folder), so let's see
// whether we can let people know about it having been double clicked
if (fileInfo.isSymLink()) {
// The file is actually a symbolic link, so retrieve its target and
// check that it exists, and if it does then let people know about
// it having been double clicked
fileName = fileInfo.symLinkTarget();
if (QFileInfo(fileName).exists())
emit filesOpened(QStringList() << fileName);
} else {
// This is a 'normal' file, so just go ahead and let people know
// about it having been double clicked
emit filesOpened(QStringList() << fileName);
}
}
}
void listOpenedFd()
{
qDebug() << Q_FUNC_INFO;
pid_t pid = getpid();
qDebug() << Q_FUNC_INFO << pid;
QString path("/proc/");
path.append(QString::number(pid));
path.append("/fd");
QDir pidDir(path);
qDebug() << Q_FUNC_INFO << path;
QStringList list = pidDir.entryList();
QStringList::const_iterator it = list.begin();
QStringList::const_iterator itEnd = list.end();
QFileInfo fi;
for(; it != itEnd; ++it)
{
QString file_path = pidDir.filePath(*it);
fi.setFile(file_path);
qDebug() << Q_FUNC_INFO << fi.isSymLink() << fi.symLinkTarget();
}
}
int QBookDevel::getPid(const char *exe) {
static struct dirent *ent;
DIR *dir = opendir("/proc");
if (!dir)
return 0;
while( (ent = readdir(dir)) ) {
if(!ent || !ent->d_name) {
closedir(dir);
return 0;
}
if(*ent->d_name < '0' || *ent->d_name > '9')
continue;
QString *path = new QString();
path->append("/proc/");
path->append(ent->d_name);
path->append("/exe");
qDebug () << *path;
QFileInfo f = QFileInfo(*path);
if (f.isSymLink()) {
QFileInfo l = QFileInfo (f.symLinkTarget());
if (l.completeBaseName() == exe) {
closedir(dir);
return atoi(ent->d_name);
}
}
// We need to check also cmdline as a lot of binaries are links to busybox
path = new QString();
path->append("/proc/");
path->append(ent->d_name);
path->append("/cmdline");
QFile *file = new QFile(*path);
delete path;
if (!file->open(QIODevice::ReadOnly))
continue;
QTextStream stream(file);
QString line = stream.readLine();
file->close();
delete file;
QStringList args = line.split((QChar)0); // cmdline is separated with NULLs!
if (args.size() > 0) {
f = QFileInfo (args.at(0));
if (f.completeBaseName() == exe) {
closedir(dir);
return atoi(ent->d_name);
}
}
}
closedir(dir);
return 0;
}
/*!
\internal
Returns the canonicalized form of \a path (i.e., with all symlinks
resolved, and all redundant path elements removed.
*/
QString QFSFileEnginePrivate::canonicalized(const QString &path)
{
if (path.isEmpty())
return path;
QFileInfo fi;
const QChar slash(QLatin1Char('/'));
QString tmpPath = path;
int separatorPos = 0;
QSet<QString> nonSymlinks;
QSet<QString> known;
known.insert(path);
do {
#ifdef Q_OS_WIN
// UNC, skip past the first two elements
if (separatorPos == 0 && tmpPath.startsWith(QLatin1String("//")))
separatorPos = tmpPath.indexOf(slash, 2);
if (separatorPos != -1)
#endif
separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
if (
#ifdef Q_OS_SYMBIAN
// Symbian doesn't support directory symlinks, so do not check for link unless we
// are handling the last path element. This not only slightly improves performance,
// but also saves us from lot of unnecessary platform security check failures
// when dealing with files under *:/private directories.
separatorPos == -1 &&
#endif
!nonSymlinks.contains(prefix)) {
fi.setFile(prefix);
if (fi.isSymLink()) {
QString target = fi.symLinkTarget();
if (separatorPos != -1) {
if (fi.isDir() && !target.endsWith(slash))
target.append(slash);
target.append(tmpPath.mid(separatorPos));
}
tmpPath = QDir::cleanPath(target);
separatorPos = 0;
if (known.contains(tmpPath))
return QString();
known.insert(tmpPath);
} else {
nonSymlinks.insert(prefix);
}
}
} while (separatorPos != -1);
return QDir::cleanPath(tmpPath);
}
static void disablePtrace()
{
#if HAVE_PR_SET_DUMPABLE
// Allow ptrace when running inside gdb
const qint64 pid = QCoreApplication::applicationPid();
const QFileInfo process(QStringLiteral("/proc/%1/exe").arg(pid));
if (process.isSymLink() && process.symLinkTarget().endsWith(QLatin1String("/gdb")))
return;
::prctl(PR_SET_DUMPABLE, 0);
#endif
}
/**
* Returns if a file is supported by nomacs or not.
* Note: this function only checks for a valid extension.
* @param fileInfo the file info of the file to be validated.
* @return bool true if the file format is supported.
**/
bool DkUtils::isValid(const QFileInfo& fileInfo) {
printf("accepting file...\n");
QFileInfo fInfo = fileInfo;
if (fInfo.isSymLink())
fInfo = fileInfo.symLinkTarget();
if (!fInfo.exists())
return false;
QString fileName = fInfo.fileName();
return hasValidSuffix(fileName);
}
/*!
\internal
Returns the canonicalized form of \a path (i.e., with all symlinks
resolved, and all redundant path elements removed.
*/
QString QFSFileEnginePrivate::canonicalized(const QString &path)
{
if (path.isEmpty())
return path;
QFileInfo fi;
const QChar slash(QLatin1Char('/'));
QString tmpPath = path;
int separatorPos = 0;
QSet<QString> nonSymlinks;
QSet<QString> known;
do {
#ifdef Q_OS_WIN
// UNC, skip past the first two elements
if (separatorPos == 0 && tmpPath.startsWith(QLatin1String("//")))
separatorPos = tmpPath.indexOf(slash, 2);
if (separatorPos != -1)
#endif
separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
if (!nonSymlinks.contains(prefix)) {
if (known.contains(prefix))
return QString();
known.insert(prefix);
fi.setFile(prefix);
if (fi.isSymLink()) {
QString target = fi.symLinkTarget();
if (separatorPos != -1) {
if (fi.isDir() && !target.endsWith(slash))
target.append(slash);
target.append(tmpPath.mid(separatorPos));
}
tmpPath = target;
separatorPos = 0;
} else {
nonSymlinks.insert(prefix);
}
}
} while (separatorPos != -1);
return QDir::cleanPath(tmpPath);
}
bool ServiceHost::FormatResponse( HTTPRequest *pRequest, QFileInfo oInfo )
{
QString sName = oInfo.absoluteFilePath();
if (oInfo.exists())
{
if (oInfo.isSymLink())
pRequest->FormatFileResponse( oInfo.symLinkTarget() );
else
pRequest->FormatFileResponse( oInfo.absoluteFilePath() );
}
else
{
// force return as a 404...
pRequest->FormatFileResponse( "" );
}
return true;
}
QSharedPointer<QByteArray> DkImageContainer::loadFileToBuffer(const QFileInfo fileInfo) {
QFileInfo fInfo = fileInfo.isSymLink() ? fileInfo.symLinkTarget() : fileInfo;
#ifdef WITH_QUAZIP
if (isFromZip())
return zipData->extractImage(zipData->getZipFileInfo(), zipData->getImageFileInfo());
#endif
if (fInfo.suffix().contains("psd")) { // for now just psd's are not cached because their file might be way larger than the part we need to read
return QSharedPointer<QByteArray>(new QByteArray());
}
QFile file(fInfo.absoluteFilePath());
file.open(QIODevice::ReadOnly);
QSharedPointer<QByteArray> ba(new QByteArray(file.readAll()));
file.close();
return ba;
}
FileTreeItem::FileTreeItem(const QFileInfo & fileInfo,const FileTreeItem * parentItem,
bool scan_subdirs,bool encripted) {
m_path = (parentItem->rootItem?"":parentItem->archivePath()) + fileInfo.fileName();
if (fileInfo.isDir()) m_path += "/";
m_perms = permissions(fileInfo);
m_user = fileInfo.owner();
m_group = fileInfo.group();
m_link_to = fileInfo.symLinkTarget();
m_file_size = fileInfo.size();
m_date = fileInfo.lastModified();
m_parentItem = (FileTreeItem *)parentItem;
m_encripted = encripted;
rootItem = false;
if (is_dir()) {
if (scan_subdirs) {
QDirIterator di(fileInfo.filePath(),QDir::AllEntries | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot);
while (di.hasNext()) {
di.next();
appendChild(new FileTreeItem(QFileInfo(di.filePath()),this,true,encripted));
}
}
}
}
QT_BEGIN_NAMESPACE
/*!
\internal
Returns the canonicalized form of \a path (i.e., with all symlinks
resolved, and all redundant path elements removed.
*/
QString QFileSystemEngine::slowCanonicalized(const QString &path)
{
if (path.isEmpty())
return path;
QFileInfo fi;
const QChar slash(QLatin1Char('/'));
QString tmpPath = path;
int separatorPos = 0;
QSet<QString> nonSymlinks;
QSet<QString> known;
known.insert(path);
do {
#ifdef Q_OS_WIN
if (separatorPos == 0) {
if (tmpPath.size() >= 2 && tmpPath.at(0) == slash && tmpPath.at(1) == slash) {
// UNC, skip past the first two elements
separatorPos = tmpPath.indexOf(slash, 2);
} else if (tmpPath.size() >= 3 && tmpPath.at(1) == QLatin1Char(':') && tmpPath.at(2) == slash) {
// volume root, skip since it can not be a symlink
separatorPos = 2;
}
}
if (separatorPos != -1)
#endif
separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
if (!nonSymlinks.contains(prefix)) {
fi.setFile(prefix);
if (fi.isSymLink()) {
QString target = fi.symLinkTarget();
if(QFileInfo(target).isRelative())
target = fi.absolutePath() + slash + target;
if (separatorPos != -1) {
if (fi.isDir() && !target.endsWith(slash))
target.append(slash);
target.append(tmpPath.mid(separatorPos));
}
tmpPath = QDir::cleanPath(target);
separatorPos = 0;
if (known.contains(tmpPath))
return QString();
known.insert(tmpPath);
} else {
nonSymlinks.insert(prefix);
}
}
} while (separatorPos != -1);
return QDir::cleanPath(tmpPath);
}
QT_BEGIN_NAMESPACE
/*!
\internal
Returns the canonicalized form of \a path (i.e., with all symlinks
resolved, and all redundant path elements removed.
*/
QString QFileSystemEngine::slowCanonicalized(const QString &path)
{
if (path.isEmpty())
return path;
QFileInfo fi;
const QChar slash(QLatin1Char('/'));
QString tmpPath = path;
int separatorPos = 0;
QSet<QString> nonSymlinks;
QSet<QString> known;
known.insert(path);
do {
#ifdef Q_OS_WIN
if (separatorPos == 0) {
if (tmpPath.size() >= 2 && tmpPath.at(0) == slash && tmpPath.at(1) == slash) {
// UNC, skip past the first two elements
separatorPos = tmpPath.indexOf(slash, 2);
} else if (tmpPath.size() >= 3 && tmpPath.at(1) == QLatin1Char(':') && tmpPath.at(2) == slash) {
// volume root, skip since it can not be a symlink
separatorPos = 2;
}
}
if (separatorPos != -1)
#endif
separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
if (
#ifdef Q_OS_SYMBIAN
// Symbian doesn't support directory symlinks, so do not check for link unless we
// are handling the last path element. This not only slightly improves performance,
// but also saves us from lot of unnecessary platform security check failures
// when dealing with files under *:/private directories.
separatorPos == -1 &&
#endif
!nonSymlinks.contains(prefix)) {
fi.setFile(prefix);
if (fi.isSymLink()) {
QString target = fi.symLinkTarget();
if(QFileInfo(target).isRelative())
target = fi.absolutePath() + slash + target;
if (separatorPos != -1) {
if (fi.isDir() && !target.endsWith(slash))
target.append(slash);
target.append(tmpPath.mid(separatorPos));
}
tmpPath = QDir::cleanPath(target);
separatorPos = 0;
if (known.contains(tmpPath))
return QString();
known.insert(tmpPath);
} else {
nonSymlinks.insert(prefix);
}
}
} while (separatorPos != -1);
return QDir::cleanPath(tmpPath);
}
/*!
\internal
Returns the canonicalized form of \a path (i.e., with all symlinks
resolved, and all redundant path elements removed.
*/
QString QFSFileEnginePrivate::canonicalized(const QString &path)
{
if (path.isEmpty())
return path;
// FIXME let's see if this stuff works, then we might be able to remove some of the other code.
#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
if (path.size() == 1 && path.at(0) == QLatin1Char('/'))
return path;
#endif
#if defined(Q_OS_LINUX) || defined(Q_OS_SYMBIAN) || defined(Q_OS_MAC)
// ... but Linux with uClibc does not have it
#if !defined(__UCLIBC__)
char *ret = 0;
#if defined(Q_OS_MAC) && !defined(Q_OS_IPHONE)
// Mac OS X 10.5.x doesn't support the realpath(X,0) extension we use here.
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) {
ret = realpath(path.toLocal8Bit().constData(), (char*)0);
} else {
// on 10.5 we can use FSRef to resolve the file path.
FSRef fsref;
if (FSPathMakeRef((const UInt8 *)QDir::cleanPath(path).toUtf8().data(), &fsref, 0) == noErr) {
CFURLRef urlref = CFURLCreateFromFSRef(NULL, &fsref);
CFStringRef canonicalPath = CFURLCopyFileSystemPath(urlref, kCFURLPOSIXPathStyle);
QString ret = QCFString::toQString(canonicalPath);
CFRelease(canonicalPath);
CFRelease(urlref);
return ret;
}
}
#else
ret = realpath(path.toLocal8Bit().constData(), (char*)0);
#endif
if (ret) {
QString canonicalPath = QDir::cleanPath(QString::fromLocal8Bit(ret));
free(ret);
return canonicalPath;
}
#endif
#endif
QFileInfo fi;
const QChar slash(QLatin1Char('/'));
QString tmpPath = path;
int separatorPos = 0;
QSet<QString> nonSymlinks;
QSet<QString> known;
known.insert(path);
do {
#ifdef Q_OS_WIN
// UNC, skip past the first two elements
if (separatorPos == 0 && tmpPath.startsWith(QLatin1String("//")))
separatorPos = tmpPath.indexOf(slash, 2);
if (separatorPos != -1)
#endif
separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
if (
#ifdef Q_OS_SYMBIAN
// Symbian doesn't support directory symlinks, so do not check for link unless we
// are handling the last path element. This not only slightly improves performance,
// but also saves us from lot of unnecessary platform security check failures
// when dealing with files under *:/private directories.
separatorPos == -1 &&
#endif
!nonSymlinks.contains(prefix)) {
fi.setFile(prefix);
if (fi.isSymLink()) {
QString target = fi.symLinkTarget();
if (separatorPos != -1) {
if (fi.isDir() && !target.endsWith(slash))
target.append(slash);
target.append(tmpPath.mid(separatorPos));
}
tmpPath = QDir::cleanPath(target);
separatorPos = 0;
if (known.contains(tmpPath))
return QString();
known.insert(tmpPath);
} else {
nonSymlinks.insert(prefix);
}
}
} while (separatorPos != -1);
return QDir::cleanPath(tmpPath);
}
/**
* Loads the thumbnail from the metadata.
* If no thumbnail is embedded, the whole image
* is loaded and downsampled in a fast manner.
* @param file the file to be loaded
* @return QImage the loaded image. Null if no image
* could be loaded at all.
**/
QImage DkThumbNail::computeIntern(const QFileInfo file, const QSharedPointer<QByteArray> ba,
int forceLoad, int maxThumbSize, int minThumbSize,
bool rescale) {
DkTimer dt;
//qDebug() << "[thumb] file: " << file.absoluteFilePath();
// see if we can read the thumbnail from the exif data
QImage thumb;
DkMetaDataT metaData;
try {
if (!ba || ba->isEmpty())
metaData.readMetaData(file);
else
metaData.readMetaData(file, ba);
// read the full image if we want to create new thumbnails
if (forceLoad != force_save_thumb)
thumb = metaData.getThumbnail();
}
catch(...) {
// do nothing - we'll load the full file
}
removeBlackBorder(thumb);
if (thumb.isNull() && forceLoad == force_exif_thumb)
return QImage();
bool exifThumb = !thumb.isNull();
int orientation = metaData.getOrientation();
int imgW = thumb.width();
int imgH = thumb.height();
int tS = minThumbSize;
// as found at: http://olliwang.com/2010/01/30/creating-thumbnail-images-in-qt/
QString filePath = (file.isSymLink()) ? file.symLinkTarget() : file.absoluteFilePath();
QImageReader* imageReader;
if (!ba || ba->isEmpty())
imageReader = new QImageReader(filePath);
else {
QBuffer buffer;
buffer.setData(ba->data());
buffer.open(QIODevice::ReadOnly);
imageReader = new QImageReader(&buffer, QFileInfo(filePath).suffix().toStdString().c_str());
buffer.close();
}
if (thumb.isNull() || thumb.width() < tS && thumb.height() < tS) {
imgW = imageReader->size().width();
imgH = imageReader->size().height(); // locks the file!
}
//else if (!thumb.isNull())
// qDebug() << "EXIV thumb loaded: " << thumb.width() << " x " << thumb.height();
if (rescale && (imgW > maxThumbSize || imgH > maxThumbSize)) {
if (imgW > imgH) {
imgH = (float)maxThumbSize / imgW * imgH;
imgW = maxThumbSize;
}
else if (imgW < imgH) {
imgW = (float)maxThumbSize / imgH * imgW;
imgH = maxThumbSize;
}
else {
imgW = maxThumbSize;
imgH = maxThumbSize;
}
}
if (thumb.isNull() || thumb.width() < tS && thumb.height() < tS || forceLoad == force_full_thumb || forceLoad == force_save_thumb) {
// flip size if the image is rotated by 90°
if (metaData.isTiff() && abs(orientation) == 90) {
int tmpW = imgW;
imgW = imgH;
imgH = tmpW;
qDebug() << "EXIV size is flipped...";
}
QSize initialSize = imageReader->size();
imageReader->setScaledSize(QSize(imgW, imgH));
thumb = imageReader->read();
// try to read the image
if (thumb.isNull()) {
DkBasicLoader loader;
if (loader.loadGeneral(file, ba, true, true))
thumb = loader.image();
}
// the image is not scaled correctly yet
if (rescale && !thumb.isNull() && (imgW == -1 || imgH == -1)) {
imgW = thumb.width();
imgH = thumb.height();
if (imgW > maxThumbSize || imgH > maxThumbSize) {
if (imgW > imgH) {
imgH = (float)maxThumbSize / imgW * imgH;
imgW = maxThumbSize;
}
else if (imgW < imgH) {
imgW = (float)maxThumbSize / imgH * imgW;
imgH = maxThumbSize;
}
else {
imgW = maxThumbSize;
imgH = maxThumbSize;
}
}
thumb = thumb.scaled(QSize(imgW*2, imgH*2), Qt::KeepAspectRatio, Qt::FastTransformation);
thumb = thumb.scaled(QSize(imgW, imgH), Qt::KeepAspectRatio, Qt::SmoothTransformation);
}
// is there a nice solution to do so??
imageReader->setFileName("josef"); // image reader locks the file -> but there should not be one so we just set it to another file...
delete imageReader;
}
else if (rescale) {
thumb = thumb.scaled(QSize(imgW, imgH), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
//qDebug() << "thumb loaded from exif...";
}
if (orientation != -1 && orientation != 0 && (metaData.isJpg() || metaData.isRaw())) {
QTransform rotationMatrix;
rotationMatrix.rotate((double)orientation);
thumb = thumb.transformed(rotationMatrix);
}
// save the thumbnail if the caller either forces it, or the save thumb is requested and the image did not have any before
if (forceLoad == force_save_thumb || (forceLoad == save_thumb && !exifThumb)) {
try {
QImage sThumb = thumb.copy();
if (orientation != -1 && orientation != 0) {
QTransform rotationMatrix;
rotationMatrix.rotate(-(double)orientation);
sThumb = sThumb.transformed(rotationMatrix);
}
metaData.setThumbnail(sThumb);
if (!ba || ba->isEmpty())
metaData.saveMetaData(file);
else
metaData.saveMetaData(file, ba);
qDebug() << "[thumb] saved to exif data";
}
catch(...) {
qDebug() << "Sorry, I could not save the metadata";
}
}
if (!thumb.isNull())
qDebug() << "[thumb] " << file.fileName() << " loaded in: " << dt.getTotal() << ((exifThumb) ? " from EXIV" : " from File");
//if (!thumb.isNull())
// qDebug() << "thumb: " << thumb.width() << " x " << thumb.height();
return thumb;
}
void FileOrganiserWidget::addFile(const QString &pFileName,
QStandardItem *pDropItem,
const QAbstractItemView::DropIndicatorPosition &pDropPosition)
{
if (!pDropItem)
// pDropItem is not valid, so...
return;
// Check that we are indeed dealing with a file
QFileInfo fileInfo = pFileName;
if (!fileInfo.isFile())
// We are not dealing with a file, so...
return;
// Check whether we are dropping a symbolic link
QString fileName = pFileName;
if (fileInfo.isSymLink())
// We are dropping a symbolic link, so retrieve its target
fileName = fileInfo.symLinkTarget();
// Check whether the file exists
if (QFileInfo(fileName).exists()) {
// The target file exists, so add it above/on/below pDropItem, depending
// on the drop position and only if the file isn't already present
// First, determine the item that will own the file
QStandardItem *newParentItem = parentItem(pDropItem, pDropPosition);
// Second, if the file is not already owned, then add it to
// newParentItem and this to the right place, depending on the value of
// pDropPosition
if (!ownedBy(fileName, newParentItem)) {
QStandardItem *newFileItem = new QStandardItem(QIcon(FileIcon),
QFileInfo(fileName).fileName());
newFileItem->setData(fileName, Item::Path);
dropItem(pDropItem, pDropPosition, newParentItem, newFileItem);
// Add the file to our file manager
// Note: it doesn't matter whether or not the file is already being
// monitored, since if that's the case then the current
// instance will be ignored
mFileManager->manage(fileName);
// Resize the widget, just in case the new file takes more space
// than is visible
resizeToContents();
} else {
// The file is already owned by newParentItem, so just repaint the
// widget to make sure that the dragging & dropping overlay
// disappears
repaint();
}
}
}
bool CopyDirectoryOperation::performOperation()
{
const QStringList args = arguments();
if (args.count() != 2) {
setError(InvalidArguments);
setErrorString(tr("Invalid arguments in %0: %1 arguments given, 2 expected.").arg(name())
.arg(args.count()));
return false;
}
const QString sourcePath = args.at(0);
const QString targetPath = args.at(1);
const QFileInfo sourceInfo(sourcePath);
const QFileInfo targetInfo(targetPath);
if (!sourceInfo.exists() || !sourceInfo.isDir() || !targetInfo.exists() || !targetInfo.isDir()) {
setError(InvalidArguments);
setErrorString(tr("Invalid arguments in %0: Directories are invalid: %1 %2").arg(name())
.arg(sourcePath).arg(targetPath));
return false;
}
const QDir sourceDir = sourceInfo.absoluteDir();
const QDir targetDir = targetInfo.absoluteDir();
AutoPush autoPush(this);
QDirIterator it(sourceInfo.absoluteFilePath(), QDir::NoDotAndDotDot | QDir::AllEntries | QDir::Hidden,
QDirIterator::Subdirectories);
while (it.hasNext()) {
const QString itemName = it.next();
const QFileInfo itemInfo(sourceDir.absoluteFilePath(itemName));
const QString relativePath = sourceDir.relativeFilePath(itemName);
if (itemInfo.isSymLink()) {
// Check if symlink target is inside copied directory
const QString linkTarget = itemInfo.symLinkTarget();
if (linkTarget.startsWith(sourceDir.absolutePath())) {
// create symlink to copied location
const QString linkTargetRelative = sourceDir.relativeFilePath(linkTarget);
QFile(targetDir.absoluteFilePath(linkTargetRelative))
.link(targetDir.absoluteFilePath(relativePath));
} else {
// create symlink pointing to original location
QFile(linkTarget).link(targetDir.absoluteFilePath(relativePath));
}
// add file entry
autoPush.m_files.prepend(targetDir.absoluteFilePath(relativePath));
emit outputTextChanged(autoPush.m_files.first());
} else if (itemInfo.isDir()) {
if (!targetDir.mkpath(targetDir.absoluteFilePath(relativePath))) {
setError(InvalidArguments);
setErrorString(tr("Could not create %0").arg(targetDir.absoluteFilePath(relativePath)));
return false;
}
} else {
if (!QFile::copy(sourceDir.absoluteFilePath(itemName), targetDir.absoluteFilePath(relativePath))) {
setError(InvalidArguments);
setErrorString(tr("Could not copy %0 to %1").arg(sourceDir.absoluteFilePath(itemName))
.arg(targetDir.absoluteFilePath(relativePath)));
return false;
}
autoPush.m_files.prepend(targetDir.absoluteFilePath(relativePath));
emit outputTextChanged(autoPush.m_files.first());
}
}
return true;
}
bool CopyDirectoryOperation::performOperation()
{
if (!checkArgumentCount(2, 3, tr("<source> <target> [\"forceOverwrite\"]")))
return false;
const QStringList args = arguments();
const QString sourcePath = args.at(0);
const QString targetPath = args.at(1);
bool overwrite = false;
if (args.count() > 2) {
const QString overwriteStr = args.at(2);
if (overwriteStr == QLatin1String("forceOverwrite")) {
overwrite = true;
} else {
setError(InvalidArguments);
setErrorString(tr("Invalid argument in %1: Third argument needs to be forceOverwrite, "
"if specified.").arg(name()));
return false;
}
}
const QFileInfo sourceInfo(sourcePath);
const QFileInfo targetInfo(targetPath);
foreach (const QFileInfo &dir, QList<QFileInfo>() << sourceInfo << targetInfo) {
if (!dir.exists() || !dir.isDir()) {
setError(InvalidArguments);
setErrorString(tr("Invalid argument in %1: Directory \"%2\" is invalid.").arg(name())
.arg(QDir::toNativeSeparators(sourcePath)));
return false;
}
}
const QDir sourceDir = sourceInfo.absoluteDir();
const QDir targetDir = targetInfo.absoluteDir();
AutoPush autoPush(this);
QDirIterator it(sourceInfo.absoluteFilePath(), QDir::NoDotAndDotDot | QDir::AllEntries | QDir::Hidden,
QDirIterator::Subdirectories);
while (it.hasNext()) {
const QString itemName = it.next();
const QFileInfo itemInfo(sourceDir.absoluteFilePath(itemName));
const QString relativePath = sourceDir.relativeFilePath(itemName);
if (itemInfo.isSymLink()) {
// Check if symlink target is inside copied directory
const QString linkTarget = itemInfo.symLinkTarget();
if (linkTarget.startsWith(sourceDir.absolutePath())) {
// create symlink to copied location
const QString linkTargetRelative = sourceDir.relativeFilePath(linkTarget);
QFile(targetDir.absoluteFilePath(linkTargetRelative))
.link(targetDir.absoluteFilePath(relativePath));
} else {
// create symlink pointing to original location
QFile(linkTarget).link(targetDir.absoluteFilePath(relativePath));
}
// add file entry
autoPush.m_files.prepend(targetDir.absoluteFilePath(relativePath));
emit outputTextChanged(autoPush.m_files.first());
} else if (itemInfo.isDir()) {
if (!targetDir.mkpath(targetDir.absoluteFilePath(relativePath))) {
setError(InvalidArguments);
setErrorString(tr("Cannot create directory \"%1\".").arg(
QDir::toNativeSeparators(targetDir.absoluteFilePath(relativePath))));
return false;
}
} else {
const QString absolutePath = targetDir.absoluteFilePath(relativePath);
if (overwrite && QFile::exists(absolutePath) && !deleteFileNowOrLater(absolutePath)) {
setError(UserDefinedError);
setErrorString(tr("Failed to overwrite \"%1\".").arg(QDir::toNativeSeparators(absolutePath)));
return false;
}
QFile file(sourceDir.absoluteFilePath(itemName));
if (!file.copy(absolutePath)) {
setError(UserDefinedError);
setErrorString(tr("Cannot copy file \"%1\" to \"%2\": %3").arg(
QDir::toNativeSeparators(sourceDir.absoluteFilePath(itemName)),
QDir::toNativeSeparators(targetDir.absoluteFilePath(relativePath)),
file.errorString()));
return false;
}
autoPush.m_files.prepend(targetDir.absoluteFilePath(relativePath));
emit outputTextChanged(autoPush.m_files.first());
}
}
return true;
}
bool CopyDirectoryOperation::performOperation()
{
const QStringList args = arguments();
if (args.count() < 2 || args.count() > 3) {
setError(InvalidArguments);
setErrorString(tr("Invalid arguments in %0: %1 arguments given, %2 expected%3.")
.arg(name()).arg(arguments().count()).arg(tr("2 or 3"), tr(" (<source> <target> [forceOverwrite])")));
return false;
}
const QString sourcePath = args.at(0);
const QString targetPath = args.at(1);
bool overwrite = false;
if (args.count() > 2) {
const QString overwriteStr = args.at(2);
if (overwriteStr == QLatin1String("forceOverwrite")) {
overwrite = true;
} else {
setError(InvalidArguments);
setErrorString(tr("Invalid argument in %0: Third argument needs to be forceOverwrite, "
"if specified").arg(name()));
return false;
}
}
const QFileInfo sourceInfo(sourcePath);
const QFileInfo targetInfo(targetPath);
if (!sourceInfo.exists() || !sourceInfo.isDir() || !targetInfo.exists() || !targetInfo.isDir()) {
setError(InvalidArguments);
setErrorString(tr("Invalid arguments in %0: Directories are invalid: %1 %2").arg(name())
.arg(sourcePath).arg(targetPath));
return false;
}
const QDir sourceDir = sourceInfo.absoluteDir();
const QDir targetDir = targetInfo.absoluteDir();
AutoPush autoPush(this);
QDirIterator it(sourceInfo.absoluteFilePath(), QDir::NoDotAndDotDot | QDir::AllEntries | QDir::Hidden,
QDirIterator::Subdirectories);
while (it.hasNext()) {
const QString itemName = it.next();
const QFileInfo itemInfo(sourceDir.absoluteFilePath(itemName));
const QString relativePath = sourceDir.relativeFilePath(itemName);
if (itemInfo.isSymLink()) {
// Check if symlink target is inside copied directory
const QString linkTarget = itemInfo.symLinkTarget();
if (linkTarget.startsWith(sourceDir.absolutePath())) {
// create symlink to copied location
const QString linkTargetRelative = sourceDir.relativeFilePath(linkTarget);
QFile(targetDir.absoluteFilePath(linkTargetRelative))
.link(targetDir.absoluteFilePath(relativePath));
} else {
// create symlink pointing to original location
QFile(linkTarget).link(targetDir.absoluteFilePath(relativePath));
}
// add file entry
autoPush.m_files.prepend(targetDir.absoluteFilePath(relativePath));
emit outputTextChanged(autoPush.m_files.first());
} else if (itemInfo.isDir()) {
if (!targetDir.mkpath(targetDir.absoluteFilePath(relativePath))) {
setError(InvalidArguments);
setErrorString(tr("Could not create %0").arg(targetDir.absoluteFilePath(relativePath)));
return false;
}
} else {
const QString absolutePath = targetDir.absoluteFilePath(relativePath);
if (overwrite && QFile::exists(absolutePath) && !deleteFileNowOrLater(absolutePath)) {
setError(UserDefinedError);
setErrorString(tr("Failed to overwrite %1").arg(absolutePath));
return false;
}
QFile file(sourceDir.absoluteFilePath(itemName));
if (!file.copy(absolutePath)) {
setError(UserDefinedError);
setErrorString(tr("Could not copy %0 to %1, error was: %3").arg(sourceDir.absoluteFilePath(itemName),
targetDir.absoluteFilePath(relativePath),
file.errorString()));
return false;
}
autoPush.m_files.prepend(targetDir.absoluteFilePath(relativePath));
emit outputTextChanged(autoPush.m_files.first());
}
}
return true;
}
FileErrorDialog::FileErrorDialog(QWidget *parent, QFileInfo fileInfo, std::string errorString, const ErrorType &errorType) :
QDialog(parent),
ui(new Ui::fileErrorDialog)
{
Qt::WindowFlags flags = windowFlags();
#ifdef Q_OS_LINUX
flags=flags & ~Qt::X11BypassWindowManagerHint;
#endif
flags=flags | Qt::WindowStaysOnTopHint;
setWindowFlags(flags);
ui->setupUi(this);
action=FileError_Cancel;
ui->label_error->setText(QString::fromStdString(errorString));
if(fileInfo.exists())
{
ui->label_content_file_name->setText(QString::fromStdString(TransferThread::resolvedName(fileInfo)));
if(ui->label_content_file_name->text().isEmpty())
{
ui->label_content_file_name->setText(fileInfo.absoluteFilePath());
ui->label_folder->setVisible(false);
ui->label_content_folder->setVisible(false);
}
else
{
QString folder=fileInfo.absolutePath();
if(folder.size()>80)
folder=folder.mid(0,38)+"..."+folder.mid(folder.size()-38);
ui->label_content_folder->setText(fileInfo.absolutePath());
}
ui->label_content_size->setText(QString::number(fileInfo.size()));
QDateTime maxTime(QDate(ULTRACOPIER_PLUGIN_MINIMALYEAR,1,1));
if(maxTime<fileInfo.lastModified())
{
ui->label_modified->setVisible(true);
ui->label_content_modified->setVisible(true);
ui->label_content_modified->setText(fileInfo.lastModified().toString());
}
else
{
ui->label_modified->setVisible(false);
ui->label_content_modified->setVisible(false);
}
if(fileInfo.isDir())
{
this->setWindowTitle(tr("Error on folder"));
ui->label_size->hide();
ui->label_content_size->hide();
ui->label_file_name->setText(tr("Folder name"));
}
ui->label_file_destination->setVisible(fileInfo.isSymLink());
ui->label_content_file_destination->setVisible(fileInfo.isSymLink());
if(fileInfo.isSymLink())
ui->label_content_file_destination->setText(fileInfo.symLinkTarget());
}
else
{
ui->label_content_file_name->setText(QString::fromStdString(TransferThread::resolvedName(fileInfo)));
if(ui->label_content_file_name->text().isEmpty())
{
ui->label_content_file_name->setText(fileInfo.absoluteFilePath());
ui->label_folder->setVisible(false);
ui->label_content_folder->setVisible(false);
}
else
ui->label_content_folder->setText(fileInfo.absolutePath());
ui->label_file_destination->hide();
ui->label_content_file_destination->hide();
ui->label_size->hide();
ui->label_content_size->hide();
ui->label_modified->hide();
ui->label_content_modified->hide();
}
if(errorType==ErrorType_Folder || errorType==ErrorType_FolderWithRety)
ui->PutToBottom->hide();
if(errorType==ErrorType_Folder)
ui->Retry->hide();
ui->Rights->hide();
#ifdef ULTRACOPIER_PLUGIN_RIGHTS
if(isInAdmin)
ui->Rights->hide();
#ifdef Q_OS_WIN32
if(errorType!=ErrorType_Rights)
ui->Rights->hide();
#else
ui->Rights->hide();
#endif
#else
ui->Rights->hide();
#endif
}
QIcon WinIconProvider::icon(const QFileInfo& info) const
{
QIcon retIcon;
QString fileExtension = info.suffix().toLower();
if (fileExtension == "png" ||
fileExtension == "bmp" ||
fileExtension == "jpg" ||
fileExtension == "jpeg")
{
retIcon = QIcon(info.filePath());
}
else if (fileExtension == "cpl")
{
HICON hIcon;
QString filePath = QDir::toNativeSeparators(info.filePath());
ExtractIconEx((LPCWSTR)filePath.utf16(), 0, &hIcon, NULL, 1);
retIcon = QIcon(QtWin::fromHICON(hIcon));
DestroyIcon(hIcon);
}
else
{
// This 64 bit mapping needs to go away if we produce a 64 bit build of launchy
QString filePath = wicon_aliasTo64(QDir::toNativeSeparators(info.filePath()));
// Get the icon index using SHGetFileInfo
SHFILEINFO sfi = {0};
QRegExp re("\\\\\\\\([a-z0-9\\-]+\\\\?)?$", Qt::CaseInsensitive);
if (re.exactMatch(filePath))
{
// To avoid network hangs, explicitly fetch the My Computer icon for UNCs
LPITEMIDLIST pidl;
if (SHGetSpecialFolderLocation(NULL, CSIDL_DRIVES, &pidl) == S_OK)
{
SHGetFileInfo((LPCTSTR)pidl, 0, &sfi, sizeof(sfi), SHGFI_PIDL | SHGFI_SYSICONINDEX);
// Set the file path to the My Computer GUID for any later fetches
filePath = "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}";
}
}
if (sfi.iIcon == 0)
{
SHGetFileInfo((LPCWSTR)filePath.utf16(), 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX);
}
// An icon index of 3 is the generic file icon
if (sfi.iIcon > 0 && sfi.iIcon != 3)
{
// Retrieve the system image list.
// To get the 48x48 icons, use SHIL_EXTRALARGE
// To get the 256x256 icons (Vista only), use SHIL_JUMBO
int imageListIndex;
if (preferredSize <= 16)
imageListIndex = SHIL_SMALL;
else if (preferredSize <= 32)
imageListIndex = SHIL_LARGE;
else if (preferredSize <= 48)
imageListIndex = SHIL_EXTRALARGE;
else
imageListIndex = SHIL_JUMBO;
// If the OS supports SHCreateItemFromParsingName, get a 256x256 icon
if (!addIconFromShellFactory(filePath, retIcon))
{
// otherwise get the largest appropriate size
if (!addIconFromImageList(imageListIndex, sfi.iIcon, retIcon) && imageListIndex == SHIL_JUMBO)
addIconFromImageList(SHIL_EXTRALARGE, sfi.iIcon, retIcon);
}
// Ensure there's also a 32x32 icon - extralarge and above often only contain
// a large frame with the 32x32 icon in the middle or looks blurry
if (imageListIndex == SHIL_EXTRALARGE || imageListIndex == SHIL_JUMBO)
addIconFromImageList(SHIL_LARGE, sfi.iIcon, retIcon);
}
else if (info.isSymLink() || fileExtension == "lnk") // isSymLink is case sensitive when it perhaps shouldn't be
{
QFileInfo targetInfo(info.symLinkTarget());
retIcon = icon(targetInfo);
}
else
{
retIcon = QFileIconProvider::icon(info);
}
}
return retIcon;
}