Adds support for local paths and project bundles

include/DataFile.h

@@ -27,6 +27,7 @@
 #ifndef DATA_FILE_H
 #define DATA_FILE_H
 
+#include <map>
 #include <QDomDocument>
 
 #include "lmms_export.h"
@@ -72,6 +73,7 @@ class LMMS_EXPORT DataFile : public QDomDocument
 
 	void write( QTextStream& strm );
 	bool writeFile( const QString& fn );
+	bool writeBundle(const QString& fn);
 
 	QDomElement& content()
 	{
@@ -121,6 +123,9 @@ class LMMS_EXPORT DataFile : public QDomDocument
 	// List of ProjectVersions for the legacyFileVersion method
 	static const std::vector<ProjectVersion> UPGRADE_VERSIONS;
 
+	// Map with DOM elements that access resources (for making bundles)
+	static const std::map<QString, std::vector<QString>> ELEMENTS_WITH_RESOURCES;
+
 	void upgrade();
 
 	void loadData( const QByteArray & _data, const QString & _sourceFile );

include/PathUtil.h

@@ -8,7 +8,8 @@
 namespace PathUtil
 {
 	enum class Base { Absolute, ProjectDir, FactorySample, UserSample, UserVST, Preset,
-		UserLADSPA, DefaultLADSPA, UserSoundfont, DefaultSoundfont, UserGIG, DefaultGIG };
+		UserLADSPA, DefaultLADSPA, UserSoundfont, DefaultSoundfont, UserGIG, DefaultGIG,
+		LocalDir };
 
 	//! Return the directory associated with a given base as a QString
 	QString LMMS_EXPORT baseLocation(const Base base);

src/core/DataFile.cpp

@@ -27,10 +27,12 @@
 #include "DataFile.h"
 
 #include <math.h>
+#include <map>
 
 #include <QDebug>
 #include <QFile>
 #include <QFileInfo>
+#include <QDir>
 #include <QMessageBox>
 
 #include "base64.h"
@@ -43,12 +45,20 @@
 #include "ProjectVersion.h"
 #include "SongEditor.h"
 #include "TextFloat.h"
+#include "PathUtil.h"
 
 #include "lmmsversion.h"
 
 static void findIds(const QDomElement& elem, QList<jo_id_t>& idList);
 
 
+// QMap with the DOM elements that access file resources
+const std::map<QString, std::vector<QString>> DataFile::ELEMENTS_WITH_RESOURCES = {
+{ "sampletco", {"src"} },
+{ "audiofileprocessor", {"src"} },
+{ "vestige", {"plugin"} }
+};
+
 // Vector with all the upgrade methods
 const std::vector<DataFile::UpgradeMethod> DataFile::UPGRADE_METHODS = {
 	&DataFile::upgrade_0_2_1_20070501   ,   &DataFile::upgrade_0_2_1_20070508,
@@ -326,6 +336,139 @@ bool DataFile::writeFile( const QString& filename )
 
 
 
+// TODO: Remove qWarnings
+bool DataFile::writeBundle(const QString& filename)
+{
+	qWarning() << "Write Bundle DEBUG:";
+
+	const QString fullName = nameWithExtension(filename);
+	const QString fullNameTemp = fullName + ".new";
+	const QString resourcesDirName = QFileInfo(fullName).path() + "/resources";
+
+	qWarning() << "Destination File: " << fullName;
+	qWarning() << "Resources Folder: " << resourcesDirName;
+
+	QFile outfile(fullNameTemp);
+
+	if (!outfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
+	{
+		if (gui)
+		{
+			QMessageBox::critical(NULL,
+				SongEditor::tr("Could not write file"),
+				SongEditor::tr("Could not open %1 for writing. You probably are not permitted to "
+								"write to this file. Please make sure you have write-access to "
+								"the file and try again.").arg(fullName));
+		}
+		qWarning() << "ERROR: Failed to create bundle file!";
+		return false;
+	}
+
+	// Creates resources folder
+	if (QDir(resourcesDirName).exists())
+	{
+		qWarning() << "Warning: Resources dir already exists. Proceeding anyways.";
+	}
+	else
+	{
+		if(!QDir().mkdir(resourcesDirName))
+		{
+			qWarning() << "ERROR: Failed to create resources dir!";
+			return false;
+		}
+	}
+
+	// Files will be named by the counter number + file extension
+	// to avoid name conflicts
+	unsigned int resCounter = 1;
+
+	std::map<QString,std::vector<QString>>::const_iterator it = ELEMENTS_WITH_RESOURCES.begin();
+
+	// Copy resources and manipulate the DataFile to have local paths to them
+	while(it != ELEMENTS_WITH_RESOURCES.end())
+	{
+		qWarning() << "Looking for resources on: " << it->first;
+		QDomNodeList list = elementsByTagName(it->first);
+
+		// Go through all elements with the tagname from our map
+		for (int i = 0; !list.item(i).isNull(); ++i)
+		{
+			QDomElement el = list.item(i).toElement();
+
+			std::vector<QString>::const_iterator res = it->second.begin();
+
+			// Search for attributes that point to resources
+			while(res != it->second.end())
+			{
+				qWarning() << "Attribute: " << *res;
+				// If the element has that attribute
+				if(el.hasAttribute(*res))
+				{
+					// Get absolute path to resource
+					QString resPath = PathUtil::toAbsolute(el.attribute(*res));
+					// The new file name is the counter number + the file extension
+					QString finalFileName = QString::number(resCounter) + "." + resPath.section('.',-1);
+					// Final path is our resources dir + the new file name
+					QString finalPath = resourcesDirName + "/" + finalFileName;
+
+					qWarning() << "Original Resource: " << resPath;
+					qWarning() << "Resource Destination: " << finalPath;
+
+					// Copy resource file to the resources folder
+					if(!QFile::copy(resPath, finalPath))
+					{
+						qWarning("ERROR: Failed to copy resource");
+						return false;
+					}
+
+					// Update attribute path to point to the bundle file
+					QString newAtt = "local:resources/" + finalFileName;
+					el.setAttribute(*res, newAtt);
+
+					qWarning() << "New Path: " << newAtt;
+					// Increases file counter
+					++resCounter;
+				}
+				++res;
+			}
+		}
+		++it;
+	}
+
+	// Writes the final DataFile
+	if (fullName.section('.', -1) == "mmpz")
+	{
+		QString xml;
+		QTextStream ts(&xml);
+		write(ts);
+		outfile.write(qCompress(xml.toUtf8()));
+	}
+	else
+	{
+		QTextStream ts(&outfile);
+		write(ts);
+	}
+
+	outfile.close();
+
+	// Make sure the file has been written correctly
+	if (QFileInfo(outfile.fileName()).size() > 0)
+	{
+		// Remove current file if there's one
+		QFile::remove(fullName);
+		// Move temporary file to current file
+		QFile::rename(fullNameTemp, fullName);
+
+		return true;
+	}
+
+	return false;
+}
+
+
+
+
+
 DataFile::Type DataFile::type( const QString& typeName )
 {
 	for( int i = 0; i < TypeCount; ++i )

src/core/PathUtil.cpp

@@ -5,11 +5,14 @@
 #include <QFileInfo>
 
 #include "ConfigManager.h"
+#include "Engine.h"
+#include "Song.h"
 
 namespace PathUtil
 {
 	Base relativeBases[] = { Base::ProjectDir, Base::FactorySample, Base::UserSample, Base::UserVST, Base::Preset,
-		Base::UserLADSPA, Base::DefaultLADSPA, Base::UserSoundfont, Base::DefaultSoundfont, Base::UserGIG, Base::DefaultGIG };
+		Base::UserLADSPA, Base::DefaultLADSPA, Base::UserSoundfont, Base::DefaultSoundfont, Base::UserGIG, Base::DefaultGIG,
+		Base::LocalDir };
 
 	QString baseLocation(const Base base)
 	{
@@ -31,6 +34,21 @@ namespace PathUtil
 			case Base::DefaultSoundfont : loc = ConfigManager::inst()->userSf2Dir(); break;
 			case Base::UserGIG          : loc = ConfigManager::inst()->gigDir(); break;
 			case Base::DefaultGIG       : loc = ConfigManager::inst()->userGigDir(); break;
+			case Base::LocalDir    :
+			{
+				Song* s = Engine::getSong();
+				if (s)
+				{
+					QString projectPath = s->projectFileName();
+					loc = QFileInfo(projectPath).path();
+				}
+				else
+				{
+					qWarning("PathUtil: No song loaded!");
+					return QString("");
+				}
+				break;
+			}
 			default                   : return QString("");
 		}
 		return QDir::cleanPath(loc) + "/";
@@ -57,7 +75,8 @@ namespace PathUtil
 			case Base::DefaultSoundfont : return QStringLiteral("defaultsoundfont:");
 			case Base::UserGIG          : return QStringLiteral("usergig:");
 			case Base::DefaultGIG       : return QStringLiteral("defaultgig:");
-			default                   : return QStringLiteral("");
+			case Base::LocalDir         : return QStringLiteral("local:");
+			default                     : return QStringLiteral("");
 		}
 	}
 

src/core/main.cpp

@@ -404,6 +404,28 @@ int main( int argc, char * * argv )
 
 			return EXIT_SUCCESS;
 		}
+		else if (arg == "makeBundle" || arg == "--makeBundle")
+		{
+			++i;
+
+			if (i == argc)
+			{
+				return noInputFileError();
+			}
+
+			DataFile dataFile(QString::fromLocal8Bit(argv[i]));
+
+			if (argc > i+1) // Output file given
+			{
+				printf("Making bundle\n");
+				dataFile.writeBundle(QString::fromLocal8Bit(argv[i+1]));
+				return EXIT_SUCCESS;
+			}
+			else
+			{
+				return usageError("No output file specified.");
+			}
+		}
 		else if( arg == "--allowroot" )
 		{
 			// Ignore, processed earlier