Adds support for local paths and project bundles

include/PathUtil.h

@@ -12,9 +12,14 @@ namespace PathUtil
 		LocalDir };
 
 	//! Return the directory associated with a given base as a QString
-	QString LMMS_EXPORT baseLocation(const Base base);
-	//! Return the directory associated with a given base as a QDir
-	QDir LMMS_EXPORT baseQDir (const Base base);
+	//! Optionally, if a pointer to boolean is given the method will
+	//! use it to indicate whether the prefix could be resolved properly
+	//! or not.
+	QString LMMS_EXPORT baseLocation(const Base base, bool* ok = nullptr);
+	//! Return the directory associated with a given base as a QDir.
+	//! Optional pointer to boolean to indicate if the prefix could
+	//! be resolved properly.
+	QDir LMMS_EXPORT baseQDir (const Base base, bool* ok = nullptr);
 	//! Return the prefix used to denote this base in path strings
 	QString LMMS_EXPORT basePrefix(const Base base);
 	//! Check the prefix of a path and return the base it corresponds to
@@ -29,13 +34,15 @@ namespace PathUtil
 	//! Upgrade prefix-less relative paths to the new format
 	QString LMMS_EXPORT oldRelativeUpgrade(const QString & input);
 
-	//! Make this path absolute
-	QString LMMS_EXPORT toAbsolute(const QString & input);
+	//! Make this path absolute. If a pointer to boolean is given
+	//! it will indicate whether the path was converted successfully
+	QString LMMS_EXPORT toAbsolute(const QString & input, bool* ok = nullptr);
 	//! Make this path relative to a given base, return an absolute path if that fails
 	QString LMMS_EXPORT relativeOrAbsolute(const QString & input, const Base base);
 	//! Make this path relative to any base, choosing the shortest if there are
-	//! multiple options. Defaults to an absolute path if all bases fail.
-	QString LMMS_EXPORT toShortestRelative(const QString & input);
+	//! multiple options. allowLocal defines whether local paths should be considered.
+	//! Defaults to an absolute path if all bases fail.
+	QString LMMS_EXPORT toShortestRelative(const QString & input, bool allowLocal = false);
 
 }
 

src/core/DataFile.cpp

@@ -432,10 +432,11 @@ bool DataFile::copyResources(const QString& resourcesDir)
 				if (el.hasAttribute(*res))
 				{
 					// Get absolute path to resource
-					QString resPath = PathUtil::toAbsolute(el.attribute(*res));
+					bool ok;
+					QString resPath = PathUtil::toAbsolute(el.attribute(*res), &ok);
 					// If we are running without the project loaded (from CLI), "local:" base
 					// prefixes aren't converted, so we need to convert it ourselves
-					if (PathUtil::baseLookup(resPath) == PathUtil::Base::LocalDir)
+					if (!ok)
 					{
 						resPath = QFileInfo(m_fileName).path() + "/" + resPath.remove(0,
 							PathUtil::basePrefix(PathUtil::Base::LocalDir).length());

src/core/PathUtil.cpp

@@ -14,8 +14,11 @@ namespace PathUtil
 		Base::UserLADSPA, Base::DefaultLADSPA, Base::UserSoundfont, Base::DefaultSoundfont, Base::UserGIG, Base::DefaultGIG,
 		Base::LocalDir };
 
-	QString baseLocation(const Base base)
+	QString baseLocation(const Base base, bool* ok /* = nullptr*/)
 	{
+		// ok is true unless something goes wrong
+		if (ok) { *ok = true; }
+
 		QString loc = "";
 		switch (base)
 		{
@@ -37,28 +40,30 @@ namespace PathUtil
 			case Base::LocalDir:
 			{
 				const Song* s = Engine::getSong();
+				QString projectPath;
 				if (s)
 				{
-					QString projectPath = s->projectFileName();
+					projectPath = s->projectFileName();
 					loc = QFileInfo(projectPath).path();
 				}
-				else
-				{
-					// Keeps the base prefix so the method calling this
-					// can handle the situation.
-					return basePrefix(Base::LocalDir);
-				}
+				// We resolved it properly if we had an open Song and the project
+				// filename wasn't empty
+				if (ok) { *ok = (s && !projectPath.isEmpty()); }
 				break;
 			}
 			default                   : return QString("");
 		}
 		return QDir::cleanPath(loc) + "/";
 	}
 
-	QDir baseQDir (const Base base)
+	QDir baseQDir (const Base base, bool* ok /* = nullptr*/)
 	{
-		if (base == Base::Absolute) { return QDir::root(); }
-		return QDir(baseLocation(base));
+		if (base == Base::Absolute)
+		{
+			if (ok) { *ok = true; }
+			return QDir::root();
+		}
+		return QDir(baseLocation(base, ok));
 	}
 
 	QString basePrefix(const Base base)
@@ -131,28 +136,37 @@ namespace PathUtil
 
 
 
-	QString toAbsolute(const QString & input)
+	QString toAbsolute(const QString & input, bool* ok /* = nullptr*/)
 	{
 		//First, do no harm to absolute paths
 		QFileInfo inputFileInfo = QFileInfo(input);
-		if (inputFileInfo.isAbsolute()) { return input; }
+		if (inputFileInfo.isAbsolute())
+		{
+			if (ok) { *ok = true; }
+			return input;
+		}
 		//Next, handle old relative paths with no prefix
 		QString upgraded = input.contains(":") ? input : oldRelativeUpgrade(input);
 
 		Base base = baseLookup(upgraded);
-		return baseLocation(base) + upgraded.remove(0, basePrefix(base).length());
+		return baseLocation(base, ok) + upgraded.remove(0, basePrefix(base).length());
 	}
 
 	QString relativeOrAbsolute(const QString & input, const Base base)
 	{
 		if (input.isEmpty()) { return input; }
 		QString absolutePath = toAbsolute(input);
 		if (base == Base::Absolute) { return absolutePath; }
-		QString relativePath = baseQDir(base).relativeFilePath(absolutePath);
-		return relativePath.startsWith("..") ? absolutePath : relativePath;
+		bool ok;
+		QString relativePath = baseQDir(base, &ok).relativeFilePath(absolutePath);
+		// Return the relative path if it didn't result in a path starting with ..
+		// and the baseQDir was resolved properly
+		return (relativePath.startsWith("..") || !ok)
+			? absolutePath
+			: relativePath;
 	}
 
-	QString toShortestRelative(const QString & input)
+	QString toShortestRelative(const QString & input, bool allowLocal /* = false*/)
 	{
 		QFileInfo inputFileInfo = QFileInfo(input);
 		QString absolutePath = inputFileInfo.isAbsolute() ? input : toAbsolute(input);
@@ -161,10 +175,9 @@ namespace PathUtil
 		QString shortestPath = relativeOrAbsolute(absolutePath, shortestBase);
 		for (auto base: relativeBases)
 		{
-			// Skip local paths when searching for the shortest relative, since those
-			// are only allowed for particular resources and will only be applied when
-			// saving bundles
-			if (base == Base::LocalDir) { continue; }
+			// Skip local paths when searching for the shortest relative if those
+			// are not allowed for that resource
+			if (base == Base::LocalDir && !allowLocal) { continue; }
 
 			QString otherPath = relativeOrAbsolute(absolutePath, base);
 			if (otherPath.length() < shortestPath.length())