18 files changed, 5074 insertions, 945 deletions

diff --git a/heimdall-frontend/Source/FirmwareInfo.cpp b/heimdall-frontend/Source/FirmwareInfo.cpp
new file mode 100755
index 0000000..7d11605
--- /dev/null
+++ b/heimdall-frontend/Source/FirmwareInfo.cpp
@@ -0,0 +1,571 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+// Heimdall Frontend
+#include "FirmwareInfo.h"
+
+using namespace HeimdallFrontend;
+
+DeviceInfo::DeviceInfo()
+{
+}
+
+DeviceInfo::DeviceInfo(const QString& manufacturer, const QString& product, const QString& name)
+{
+	this->manufacturer = manufacturer;
+	this->product = product;
+	this->name = name;
+}
+
+bool DeviceInfo::ParseXml(QXmlStreamReader& xml)
+{
+	bool foundManufacturer = false;
+	bool foundProduct = false;
+	bool foundName = false;
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "manufacturer")
+			{
+				if (foundManufacturer)
+				{
+					// TODO: "found multiple device manufacturers."
+					return (false);
+				}
+
+				foundManufacturer = true;
+
+				manufacturer = xml.readElementText();
+			}
+			else if (xml.name() == "product")
+			{
+				if (foundProduct)
+				{
+					// TODO: "found multiple device product identifiers."
+					return (false);
+				}
+
+				foundProduct = true;
+
+				product = xml.readElementText();
+			}
+			else if (xml.name() == "name")
+			{
+				if (foundName)
+				{
+					// TODO: "found multiple device names."));
+					return (false);
+				}
+
+				foundName = true;
+
+				name = xml.readElementText();
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "device")
+				return (foundManufacturer && foundProduct && foundName);
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <device>"
+				return (false);
+			}
+		}
+	}
+
+	return (false);
+}
+
+
+
+PlatformInfo::PlatformInfo()
+{
+}
+
+void PlatformInfo::Clear(void)
+{
+	name.clear();
+	version.clear();
+}
+
+bool PlatformInfo::IsCleared(void) const
+{
+	return (name.isEmpty() && version.isEmpty());
+}
+
+bool PlatformInfo::ParseXml(QXmlStreamReader& xml)
+{
+	Clear();
+
+	bool foundName = false;
+	bool foundVersion = false;
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "name")
+			{
+				if (foundName)
+				{
+					// TODO: "found multiple platform names."
+					return (false);
+				}
+
+				foundName = true;
+
+				name = xml.readElementText();
+			}
+			else if (xml.name() == "version")
+			{
+				if (foundVersion)
+				{
+					// TODO: "found multiple platform versions."
+					return (false);
+				}
+
+				foundVersion = true;
+
+				version = xml.readElementText();
+			}
+			else
+			{
+				// TODO: "found unknown <platform> sub-element <" + xml.name() + ">."
+				return (false);
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "platform")
+				return (foundName && foundVersion);
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <platform>"
+				return (false);
+			}
+		}
+	}
+
+	return (false);
+}
+
+
+
+FileInfo::FileInfo()
+{
+}
+
+FileInfo::FileInfo(unsigned int partitionId, const QString& filename)
+{
+	this->partitionId = partitionId;
+	this->filename = filename;
+}
+
+bool FileInfo::ParseXml(QXmlStreamReader& xml)
+{
+	bool foundId = false;
+	bool foundFilename = false;
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "id")
+			{
+				if (foundId)
+				{
+					// TODO: "found multiple file IDs."
+					return (false);
+				}
+
+				foundId = true;
+
+				partitionId = xml.readElementText().toInt();
+			}
+			else if (xml.name() == "filename")
+			{
+				if (foundFilename)
+				{
+					// TODO: "found multiple file filenames."
+					return (false);
+				}
+
+				foundFilename = true;
+
+				filename = xml.readElementText();
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "file")
+				return (foundId && foundFilename);
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <file>"
+				return (false);
+			}
+		}
+	}
+
+	return (false);
+}
+
+
+
+FirmwareInfo::FirmwareInfo()
+{
+	repartition = false;
+}
+
+void FirmwareInfo::Clear(void)
+{
+	name = "";
+	version = "";
+	platformInfo.Clear();
+
+	developers.clear();
+	url.clear();
+	donateUrl.clear();
+
+	deviceInfos.clear();
+
+	pitFilename.clear();
+	repartition = false;
+
+	fileInfos.clear();
+}
+
+bool FirmwareInfo::IsCleared(void) const
+{
+	return (name.isEmpty() && version.isEmpty() && platformInfo.IsCleared() && developers.isEmpty() && url.isEmpty() && url.isEmpty() && donateUrl.isEmpty()
+		&& deviceInfos.isEmpty() && pitFilename.isEmpty() && !repartition && fileInfos.isEmpty());
+}
+
+bool FirmwareInfo::ParseXml(QXmlStreamReader& xml)
+{
+	Clear();
+
+	bool foundName = false;
+	bool foundVersion = false;
+	bool foundPlatform = false;
+	bool foundDevelopers = false;
+	bool foundUrl = false;
+	bool foundDonateUrl = false;
+	bool foundDevices = false;
+	bool foundPit = false;
+	bool foundRepartition = false;
+	bool foundFiles = false;
+
+	if (!xml.readNextStartElement())
+	{
+		// TODO: "Failed to find <firmware> element."
+		return (false);
+	}
+
+	if (xml.name() != "firmware")
+	{
+		// TODO: "Expected <firmware> element but found <%s>"
+		return (false);
+	}
+
+	QString formatVersionString;
+	formatVersionString += xml.attributes().value("version");
+
+	if (formatVersionString.isEmpty())
+	{
+		// TODO: <firmware> is missing a version."
+		return (false);
+	}
+
+	bool parsedVersion = false;
+	int formatVersion = formatVersionString.toInt(&parsedVersion);
+
+	if (!parsedVersion)
+	{
+		// TODO: "<firmware> contains a malformed version."
+		return (false);
+	}
+
+	if (formatVersion > kVersion)
+	{
+		// TODO: "Package is for a newer version of Heimdall Frontend. Please download the latest version of Heimdall Frontend."
+		return (false);
+	}
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "name")
+			{
+				if (foundName)
+				{
+					// TODO: "found multiple firmware names."
+					return (false);
+				}
+
+				foundName = true;
+				name = xml.readElementText();
+			}
+			else if (xml.name() == "version")
+			{
+				if (foundVersion)
+				{
+					// TODO: "found multiple firmware versions."
+					return (false);
+				}
+
+				foundVersion = true;
+				version = xml.readElementText();
+			}
+			else if (xml.name() == "platform")
+			{
+				if (foundPlatform)
+				{
+					// TODO: "found multiple firmware platforms."
+					return (false);
+				}
+
+				foundPlatform = true;
+
+				if (!platformInfo.ParseXml(xml))
+					return (false);
+			}
+			else if (xml.name() == "developers")
+			{
+				if (foundDevelopers)
+				{
+					// TODO: "found multiple sets of firmware developers."
+					return (false);
+				}
+
+				foundDevelopers = true;
+
+				while (!xml.atEnd())
+				{
+					nextToken = xml.readNext();
+
+					if (nextToken == QXmlStreamReader::StartElement)
+					{
+						if (xml.name() == "name")
+							developers.append(xml.readElementText());
+					}
+					else if (nextToken == QXmlStreamReader::EndElement)
+					{
+						if (xml.name() == "developers")
+							break;
+					}
+					else
+					{
+						if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+						{
+							// TODO: "Unexpected token found in <developers>"
+							return (false);
+						}
+					}
+				}
+			}
+			else if (xml.name() == "url")
+			{
+				if (foundUrl)
+				{
+					// TODO: "found multiple firmware URLs."
+					return (false);
+				}
+
+				foundUrl = true;
+
+				url = xml.readElementText();
+			}
+			else if (xml.name() == "donateurl")
+			{
+				if (foundDonateUrl)
+				{
+					// TODO: "found multiple firmware donate URLs."
+					return (false);
+				}
+
+				foundDonateUrl = true;
+
+				donateUrl = xml.readElementText();
+			}
+			else if (xml.name() == "devices")
+			{
+				if (foundDevices)
+				{
+					// TODO: "found multiple sets of firmware devices."
+					return (false);
+				}
+
+				foundDevices = true;
+
+				while (!xml.atEnd())
+				{
+					nextToken = xml.readNext();
+
+					if (nextToken == QXmlStreamReader::StartElement)
+					{
+						if (xml.name() == "device")
+						{
+							DeviceInfo deviceInfo;
+
+							if (!deviceInfo.ParseXml(xml))
+								return (false);
+
+							deviceInfos.append(deviceInfo);
+						}
+					}
+					else if (nextToken == QXmlStreamReader::EndElement)
+					{
+						if (xml.name() == "devices")
+							break;
+					}
+					else
+					{
+						if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+						{
+							// TODO: "Unexpected token found in <devices>"
+							return (false);
+						}
+					}
+				}
+			}
+			else if (xml.name() == "pit")
+			{
+				if (foundPit)
+				{
+					// TODO: "found multiple firmware PIT files."
+					return (false);
+				}
+
+				foundPit = true;
+
+				pitFilename = xml.readElementText();
+			}
+			else if (xml.name() == "repartition")
+			{
+				if (foundRepartition)
+				{
+					// TODO: "found multiple firmware repartition values."
+					return (false);
+				}
+
+				foundRepartition = true;
+
+				repartition = (xml.readElementText().toInt() != 0);
+			}
+			else if (xml.name() == "files")
+			{
+				if (foundFiles)
+				{
+					// TODO: "found multiple sets of firmware files."
+					return (false);
+				}
+
+				foundFiles = true;
+
+				while (!xml.atEnd())
+				{
+					nextToken = xml.readNext();
+
+					if (nextToken == QXmlStreamReader::StartElement)
+					{
+						if (xml.name() == "file")
+						{
+							FileInfo fileInfo;
+
+							if (!fileInfo.ParseXml(xml))
+								return (false);
+
+							fileInfos.append(fileInfo);
+						}
+					}
+					else if (nextToken == QXmlStreamReader::EndElement)
+					{
+						if (xml.name() == "files")
+							break;
+					}
+					else
+					{
+						if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+						{
+							// TODO: "Unexpected token found in <devices>"
+							return (false);
+						}
+					}
+				}
+			}
+			else
+			{
+				// TODO: "unknown <firmware> sub-element <" + xml.name() + ">."
+				return (false);
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "firmware")
+			{
+				if (!(foundName && foundVersion && foundPlatform && foundDevelopers && foundDevices && foundPit && foundRepartition && foundFiles))
+					return (false);
+				else
+					break;
+			}
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <firmware>"
+				return (false);
+			}
+		}
+	}
+
+	// Read whitespaces at the end of the file (if there are any)
+	xml.readNext();
+
+	if (!xml.atEnd())
+	{
+		// TODO: "Found data after </firmware>"
+		return (false);
+	}
+	
+	return (true);
+}
diff --git a/heimdall-frontend/Source/FirmwareInfo.h b/heimdall-frontend/Source/FirmwareInfo.h
new file mode 100755
index 0000000..a72dab1
--- /dev/null
+++ b/heimdall-frontend/Source/FirmwareInfo.h
@@ -0,0 +1,286 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+#ifndef FIRMWAREINFO_H
+#define FIRMWAREINFO_H
+
+// Qt
+#include <QFile>
+#include <QString>
+#include <QXmlStreamReader>
+
+namespace HeimdallFrontend
+{
+	class DeviceInfo
+	{		
+		private:
+
+			QString manufacturer;
+			QString product;
+			QString name;
+
+		public:
+
+			DeviceInfo();
+			DeviceInfo(const QString& manufacturer, const QString& product, const QString& name);
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			const QString& GetManufacturer(void) const
+			{
+				return (manufacturer);
+			}
+
+			void SetManufacturer(const QString& manufacturer)
+			{
+				this->manufacturer = manufacturer;
+			}
+
+			const QString& GetProduct(void) const
+			{
+				return (product);
+			}
+
+			void SetProduct(const QString& product)
+			{
+				this->product = product;
+			}
+
+			const QString& GetName(void) const
+			{
+				return (name);
+			}
+
+			void SetName(const QString& name)
+			{
+				this->name = name;
+			}
+	};
+
+	class PlatformInfo
+	{
+		private:
+
+			QString name;
+			QString version;
+
+		public:
+
+			PlatformInfo();
+
+			void Clear(void);
+			bool IsCleared(void) const;
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			const QString& GetName(void) const
+			{
+				return (name);
+			}
+
+			void SetName(const QString& name)
+			{
+				this->name = name;
+			}
+
+			const QString& GetVersion(void) const
+			{
+				return (version);
+			}
+
+			void SetVersion(const QString& version)
+			{
+				this->version = version;
+			}
+	};
+
+	class FileInfo
+	{
+		private:
+
+			unsigned int partitionId;
+			QString filename;
+
+		public:
+
+			FileInfo();
+			FileInfo(unsigned int partitionId, const QString& filename);
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			unsigned int GetPartitionId(void) const
+			{
+				return (partitionId);
+			}
+
+			void SetPartitionId(unsigned int partitionId)
+			{
+				this->partitionId = partitionId;
+			}
+
+			const QString& GetFilename(void) const
+			{
+				return (filename);
+			}
+
+			void SetFilename(const QString& filename)
+			{
+				this->filename = filename;
+			}
+	};
+
+	class FirmwareInfo
+	{
+		public:
+
+			enum
+			{
+				kVersion = 1
+			};
+
+		private:
+
+			QString name;
+			QString version;
+			PlatformInfo platformInfo;
+
+			QList<QString> developers;
+			QString url;
+			QString donateUrl;
+
+			QList<DeviceInfo> deviceInfos;
+
+			QString pitFilename;
+			bool repartition;
+
+			QList<FileInfo> fileInfos;
+
+		public:
+
+			FirmwareInfo();
+
+			void Clear(void);
+			bool IsCleared(void) const;
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			const QString& GetName(void) const
+			{
+				return (name);
+			}
+
+			void SetName(const QString& name)
+			{
+				this->name = name;
+			}
+
+			const QString& GetVersion(void) const
+			{
+				return (version);
+			}
+
+			void SetVersion(const QString& version)
+			{
+				this->version = version;
+			}
+
+			const PlatformInfo& GetPlatformInfo(void) const
+			{
+				return (platformInfo);
+			}
+
+			PlatformInfo& GetPlatformInfo(void)
+			{
+				return (platformInfo);
+			}
+
+			const QList<QString>& GetDevelopers(void) const
+			{
+				return (developers);
+			}
+
+			QList<QString>& GetDevelopers(void)
+			{
+				return (developers);
+			}
+
+			const QString& GetUrl(void) const
+			{
+				return (url);
+			}
+
+			void SetUrl(const QString& url)
+			{
+				this->url = url;
+			}
+
+			const QString& GetDonateUrl(void) const
+			{
+				return (donateUrl);
+			}
+
+			void SetDonateUrl(const QString& donateUrl)
+			{
+				this->donateUrl = donateUrl;
+			}
+
+			const QList<DeviceInfo>& GetDeviceInfos(void) const
+			{
+				return (deviceInfos);
+			}
+
+			QList<DeviceInfo>& GetDeviceInfos(void)
+			{
+				return (deviceInfos);
+			}
+
+			const QString& GetPitFilename(void) const
+			{
+				return (pitFilename);
+			}
+
+			void SetPitFilename(const QString& pitFilename)
+			{
+				this->pitFilename = pitFilename;
+			}
+
+			bool GetRepartition(void) const
+			{
+				return (repartition);
+			}
+
+			void SetRepartition(bool repartition)
+			{
+				this->repartition = repartition;
+			}
+
+			const QList<FileInfo>& GetFileInfos(void) const
+			{
+				return (fileInfos);
+			}
+
+			QList<FileInfo>& GetFileInfos(void)
+			{
+				return (fileInfos);
+			}
+	};
+}
+
+#endif
diff --git a/heimdall-frontend/Source/PackageData.cpp b/heimdall-frontend/Source/PackageData.cpp
new file mode 100755
index 0000000..36138cf
--- /dev/null
+++ b/heimdall-frontend/Source/PackageData.cpp
@@ -0,0 +1,65 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+// Heimdall Frontend
+#include "PackageData.h"
+
+using namespace HeimdallFrontend;
+
+PackageData::PackageData()
+{
+}
+
+PackageData::~PackageData()
+{
+	for (int i = 0; i < files.length(); i++)
+		delete files[i];
+}
+
+void PackageData::Clear(void)
+{
+	firmwareInfo.Clear();
+
+	for (int i = 0; i < files.length(); i++)
+		delete files[i];
+
+	files.clear();
+}
+
+bool PackageData::ReadFirmwareInfo(QFile *file)
+{
+	if (!file->open(QFile::ReadOnly))
+	{
+		// TODO: Error
+		return (false);
+	}
+
+	QXmlStreamReader xml(file);
+	bool success = firmwareInfo.ParseXml(xml);
+
+	file->close();
+
+	return (success);
+}
+
+bool PackageData::IsCleared(void) const
+{
+	return (firmwareInfo.IsCleared() && files.isEmpty());
+}
diff --git a/heimdall-frontend/Source/PackageData.h b/heimdall-frontend/Source/PackageData.h
new file mode 100755
index 0000000..9952393
--- /dev/null
+++ b/heimdall-frontend/Source/PackageData.h
@@ -0,0 +1,77 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+#ifndef PACKAGEDATA_H
+#define PACKAGEDATA_H
+
+// Qt
+#include <QTemporaryFile>
+
+// Heimdall Frontend
+#include "FirmwareInfo.h"
+
+namespace HeimdallFrontend
+{
+	class PackageData
+	{
+		private:
+
+			FirmwareInfo firmwareInfo;
+			QList<QTemporaryFile *> files;
+
+		public:
+
+			PackageData();
+			~PackageData();
+
+			void Clear(void);
+			bool ReadFirmwareInfo(QFile *file);
+
+			bool IsCleared(void) const;
+
+			const FirmwareInfo& GetFirmwareInfo(void) const
+			{
+				return (firmwareInfo);
+			}
+
+			FirmwareInfo& GetFirmwareInfo(void)
+			{
+				return (firmwareInfo);
+			}
+
+			const QList<QTemporaryFile *>& GetFiles(void) const
+			{
+				return (files);
+			}
+
+			QList<QTemporaryFile *>& GetFiles(void)
+			{
+				return (files);
+			}
+
+			// Simply clears the files list, it does delete/close any files.
+			void RemoveAllFiles(void)
+			{
+				files.clear();
+			}
+	};
+}
+
+#endif
diff --git a/heimdall-frontend/Source/Packaging.cpp b/heimdall-frontend/Source/Packaging.cpp
new file mode 100755
index 0000000..cbd03a4
--- /dev/null
+++ b/heimdall-frontend/Source/Packaging.cpp
@@ -0,0 +1,345 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+// C/C++ Standard Library
+#include <stdio.h>
+
+// zlib
+#include "zlib.h"
+
+// Qt
+#include <QDateTime>
+#include <QDir>
+
+// Heimdall Frontend
+#include "Packaging.h"
+
+using namespace HeimdallFrontend;
+
+const char *Packaging::ustarMagic = "ustar";
+
+bool Packaging::ExtractTar(QTemporaryFile& tarFile, PackageData *outputPackageData)
+{
+	TarHeader tarHeader;
+
+	tarFile.reset();
+
+	bool previousEmpty = false;
+
+	while (!tarFile.atEnd())
+	{
+		qint64 dataRead = tarFile.read(tarHeader.buffer, TarHeader::kBlockLength);
+
+		if (dataRead != TarHeader::kBlockLength)
+			return (false);
+
+		bool ustarFormat = strcmp(tarHeader.fields.magic, ustarMagic) == 0;
+		bool empty = true;
+
+		for (int i = 0; i < TarHeader::kBlockLength; i++)
+		{
+			if (tarHeader.buffer[i] != 0)
+			{
+				empty = false;
+				break;
+			}
+		}
+
+		if (empty)
+		{
+			if (previousEmpty)
+			{
+				// Two empty blocks in a row means we've reached the end of the archive.
+				// TODO: Make sure we're at the end of the file.
+				break;
+			}
+		}
+		else
+		{
+			// TODO: Check checksum
+
+			bool parsed = false;
+		
+			// The size field is not always null terminated, so we must create a copy and null terminate it for parsing.
+			char fileSizeString[13];
+			memcpy(fileSizeString, tarHeader.fields.size, 12);
+			fileSizeString[12] = '\0';
+
+			qulonglong fileSize = QString(fileSizeString).toULongLong(&parsed, 8);
+
+			if (!parsed)
+			{
+				// TODO: Error message?
+				return (false);
+			}
+
+			if (fileSize > 0 && tarHeader.fields.typeFlag == '0')
+			{
+				// We're working with a file.
+				QString filename = QString::fromUtf8(tarHeader.fields.name);
+
+				// This is slightly pointless as we don't support directories...
+				if (ustarFormat)
+					filename.prepend(tarHeader.fields.prefix);
+
+				QTemporaryFile *outputFile = new QTemporaryFile("XXXXXX-" + filename);
+				outputFile->open();
+
+				outputPackageData->GetFiles().append(outputFile);
+
+				qulonglong dataRemaining = fileSize;
+				char readBuffer[TarHeader::kBlockReadCount * TarHeader::kBlockLength];
+
+				// Copy the file contents from tarFile to outputFile
+				while (dataRemaining > 0)
+				{
+					qint64 fileDataToRead = (dataRemaining < TarHeader::kBlockReadCount * TarHeader::kBlockLength)
+						? dataRemaining : TarHeader::kBlockReadCount * TarHeader::kBlockLength;
+
+					qint64 dataRead = tarFile.read(readBuffer, fileDataToRead + (TarHeader::kBlockLength - fileDataToRead % TarHeader::kBlockLength) % TarHeader::kBlockLength);
+
+					if (dataRead < fileDataToRead || dataRead % TarHeader::kBlockLength != 0)
+						return (false);
+
+					outputFile->write(readBuffer, fileDataToRead);
+
+					dataRemaining -= fileDataToRead;
+				}
+
+				outputFile->close();
+			}
+			else
+			{
+				// We don't support links/directories.
+				return (false);
+			}
+		}
+
+		previousEmpty = empty;
+	}
+
+	return (true);
+}
+
+bool Packaging::CreateTar(const PackageData& packageData, QTemporaryFile *outputTarFile)
+{
+	const QList<FileInfo>& fileInfos = packageData.GetFirmwareInfo().GetFileInfos();
+
+	if (!outputTarFile->open())
+	{
+		// TODO: "Failed to open \"%s\""
+		return (false);
+	}
+
+	bool failure = false;
+
+	TarHeader tarHeader;
+
+	for (int i = 0; i < fileInfos.length(); i++)
+	{
+		memset(tarHeader.buffer, 0, TarHeader::kBlockLength);
+
+		QFile file(fileInfos[i].GetFilename());
+
+		if (!file.open(QFile::ReadOnly))
+		{
+			// TODO: "Failed to open \"%s\""
+			failure = true;
+			break;
+		}
+
+		if (file.size() > TarHeader::kMaxFileSize)
+		{
+			// TODO: "File is too large to packaged"
+			failure = true;
+			break;
+		}
+
+		QFileInfo qtFileInfo(file);
+		strcpy(tarHeader.fields.name, qtFileInfo.fileName().toUtf8().constData());
+		
+		unsigned int mode = 0;
+
+		QFile::Permissions permissions = file.permissions();
+
+		// Other
+		if (permissions.testFlag(QFile::ExeOther))
+			mode |= TarHeader::kModeOtherExecute;
+		if (permissions.testFlag(QFile::WriteOther))
+			mode |= TarHeader::kModeOtherWrite;
+		if (permissions.testFlag(QFile::ReadOther))
+			mode |= TarHeader::kModeOtherRead;
+
+		// Group
+		if (permissions.testFlag(QFile::ExeGroup))
+			mode |= TarHeader::kModeGroupExecute;
+		if (permissions.testFlag(QFile::WriteGroup))
+			mode |= TarHeader::kModeGroupWrite;
+		if (permissions.testFlag(QFile::ReadGroup))
+			mode |= TarHeader::kModeGroupRead;
+
+		// Owner
+		if (permissions.testFlag(QFile::ExeOwner))
+			mode |= TarHeader::kModeOwnerExecute;
+		if (permissions.testFlag(QFile::WriteOwner))
+			mode |= TarHeader::kModeOwnerWrite;
+		if (permissions.testFlag(QFile::ReadOwner))
+			mode |= TarHeader::kModeOwnerRead;
+
+		sprintf(tarHeader.fields.mode, "%o", mode);
+
+		sprintf(tarHeader.fields.userId, "%o", qtFileInfo.ownerId());
+		sprintf(tarHeader.fields.groupId, "%o", qtFileInfo.groupId());
+
+		// Note: We don't support base-256 encoding. Support could be added in future.
+		sprintf(tarHeader.fields.size, "%o", file.size());
+
+		sprintf(tarHeader.fields.modifiedTime, "%o", qtFileInfo.lastModified().toMSecsSinceEpoch());
+		
+		// Regular File
+		tarHeader.fields.typeFlag = '0';
+
+		// Calculate checksum
+		int checksum = 0;
+
+		for (int i = 0; i < TarHeader::kTarHeaderLength; i++)
+			checksum += tarHeader.buffer[i];
+
+		sprintf(tarHeader.fields.checksum, "%o", checksum);
+
+		// Write the header to the TAR file.
+		outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+
+		char buffer[TarHeader::kBlockWriteCount * TarHeader::kBlockLength];
+
+		for (qint64 i = 0; i < file.size(); i++)
+		{
+			qint64 dataRead = file.read(buffer, TarHeader::kBlockWriteCount * TarHeader::kBlockLength);
+
+			if (outputTarFile->write(buffer, dataRead) != dataRead)
+			{
+				// TODO: "Failed to write data to the temporary TAR file."
+				failure = true;
+				break;
+			}
+
+			if (dataRead % TarHeader::kBlockLength != 0)
+			{
+				int remainingBlockLength = TarHeader::kBlockLength - dataRead % TarHeader::kBlockLength;
+				memset(buffer, 0, remainingBlockLength);
+
+				if (outputTarFile->write(buffer, remainingBlockLength) != remainingBlockLength)
+				{
+					// TODO: "Failed to write data to the temporary TAR file."
+					failure = true;
+					break;
+				}
+			}
+
+			i += dataRead;
+		}
+
+		if (failure)
+			break;
+	}
+
+	if (failure)
+	{
+		outputTarFile->resize(0);
+		outputTarFile->close();
+		return (false);
+	}
+
+	// Write two empty blocks to signify the end of the archive.
+	memset(tarHeader.buffer, 0, TarHeader::kBlockLength);
+	outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+	outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+
+	outputTarFile->close();
+
+	return (true);
+}
+
+bool Packaging::ExtractPackage(const QString& packagePath, PackageData *outputPackageData)
+{
+	FILE *compressedPackageFile = fopen(packagePath.toStdString().c_str(), "rb");
+	gzFile packageFile = gzdopen(fileno(compressedPackageFile), "rb");
+
+	QTemporaryFile outputTar("XXXXXX.tar");
+
+	if (!outputTar.open())
+	{
+		gzclose(packageFile);
+
+		return (false);
+	}
+
+	char buffer[32768];
+
+	int bytesRead;
+
+	do
+	{
+		bytesRead = gzread(packageFile, buffer, 32768);
+
+		if (bytesRead == -1)
+		{
+			gzclose(packageFile);
+
+			return (false);
+		}
+
+		outputTar.write(buffer, bytesRead);
+	} while (bytesRead > 0);
+
+	gzclose(packageFile); // Closes packageFile and compressedPackageFile
+
+	if (!ExtractTar(outputTar, outputPackageData))
+		return (false);
+
+	// Find and read firmware.xml
+	for (int i = 0; i < outputPackageData->GetFiles().length(); i++)
+	{
+		QTemporaryFile *file = outputPackageData->GetFiles()[i];
+
+		if (file->fileTemplate() == "XXXXXX-firmware.xml")
+		{
+			if (!outputPackageData->ReadFirmwareInfo(file))
+			{
+				outputPackageData->Clear();
+				return (false);
+			}
+
+			return (true);
+		}
+	}
+
+	return (false);
+}
+
+bool Packaging::BuildPackage(const QString& packagePath, const PackageData& packageData)
+{
+	QTemporaryFile temporaryFile("XXXXXX.tar");
+
+	if (!CreateTar(packageData, &temporaryFile))
+		return (false);
+
+	return (true);
+}
diff --git a/heimdall-frontend/Source/Packaging.h b/heimdall-frontend/Source/Packaging.h
new file mode 100755
index 0000000..c341f0f
--- /dev/null
+++ b/heimdall-frontend/Source/Packaging.h
@@ -0,0 +1,110 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+#ifndef PACKAGING_H
+#define PACKAGING_H
+
+// Qt
+#include <QList>
+#include <QString>
+#include <QTemporaryFile>
+
+// Heimdall Frontend
+#include "PackageData.h"
+
+namespace HeimdallFrontend
+{
+	union TarHeader
+	{		
+		enum
+		{
+			kBlockLength = 512,
+			kBlockReadCount = 8,
+			kBlockWriteCount = 8,
+
+			kTarHeaderLength = 257,
+			kUstarHeaderLength = 500,
+		};
+
+		enum : quint64
+		{
+			kMaxFileSize = 8589934592
+		};
+
+		enum
+		{
+			kModeOtherExecute = 1,
+			kModeOtherWrite = 1 << 1,
+			kModeOtherRead = 1 << 2,
+
+			kModeGroupExecute = 1 << 3,
+			kModeGroupWrite = 1 << 4,
+			kModeGroupRead = 1 << 5,
+
+			kModeOwnerExecute = 1 << 6,
+			kModeOwnerWrite = 1 << 7,
+			kModeOwnerRead = 1 << 8,
+
+			kModeReserved = 2 << 9,
+			kModeSetGid = 2 << 10,
+			kModeSetUid = 2 << 11		
+		};
+
+		struct
+		{
+			char name[100];
+			char mode[8];
+			char userId[8];
+			char groupId[8];
+			char size[12];
+			char modifiedTime[12];
+			char checksum[8];
+			char typeFlag;
+			char linkName[100];
+			char magic[6];
+			char version[2];
+			char userName[32];
+			char groupName[32];
+			char devMajor[8];
+			char devMinor[8];
+			char prefix[155];
+		} fields;
+
+		char buffer[kBlockLength];
+	};
+
+	class Packaging
+	{
+		private:
+			
+			// TODO: Add support for sparse files to both methods.
+			static bool ExtractTar(QTemporaryFile& tarFile, PackageData *outputPackageData);
+			static bool CreateTar(const PackageData& packageData, QTemporaryFile *outputTarFile); // Uses original TAR format.
+
+		public:
+
+			static const char *ustarMagic;
+
+			static bool ExtractPackage(const QString& packagePath, PackageData *outputPackageData);
+			static bool BuildPackage(const QString& packagePath, const PackageData& packageData);
+	};
+}
+
+#endif
diff --git a/heimdall-frontend/Source/aboutform.cpp b/heimdall-frontend/Source/aboutform.cpp
index f043c20..08b8a3e 100644
--- a/heimdall-frontend/Source/aboutform.cpp
+++ b/heimdall-frontend/Source/aboutform.cpp
@@ -18,7 +18,7 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall

+// Heimdall Frontend

 #include "aboutform.h"

 

 using namespace HeimdallFrontend;

diff --git a/heimdall-frontend/Source/aboutform.h b/heimdall-frontend/Source/aboutform.h
index 2a44c95..7e29136 100644
--- a/heimdall-frontend/Source/aboutform.h
+++ b/heimdall-frontend/Source/aboutform.h
@@ -18,12 +18,12 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall

-#include "ui_aboutform.h"

-

 // Qt

 #include <QWidget>

 

+// Heimdall Frontend

+#include "ui_aboutform.h"

+

 namespace HeimdallFrontend

 {

 	class AboutForm : public QWidget, public Ui::AboutForm

diff --git a/heimdall-frontend/Source/main.cpp b/heimdall-frontend/Source/main.cpp
index 8df987c..9db00f5 100644
--- a/heimdall-frontend/Source/main.cpp
+++ b/heimdall-frontend/Source/main.cpp
@@ -18,20 +18,20 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall Frontend

-#include "mainwindow.h"

-

 // Qt

 #include <QtGui/QApplication>

 

+// Heimdall Frontend

+#include "mainwindow.h"

+

 using namespace HeimdallFrontend;

 

 int main(int argc, char *argv[])

 {

-	QApplication a(argc, argv);

+	QApplication application(argc, argv);

 	

-	MainWindow w;

-	w.show();

+	MainWindow window;

+	window.show();

 

-	return a.exec();

+	return (application.exec());

 }

diff --git a/heimdall-frontend/Source/mainwindow.cpp b/heimdall-frontend/Source/mainwindow.cpp
index b5287e2..8043599 100644
--- a/heimdall-frontend/Source/mainwindow.cpp
+++ b/heimdall-frontend/Source/mainwindow.cpp
@@ -18,9 +18,6 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall Frontend

-#include "mainwindow.h"

-

 // Qt

 #include <QCoreApplication>

 #include <QDesktopServices>

@@ -30,151 +27,214 @@
 #include <QRegExp>

 #include <QUrl>

 

+// Heimdall Frontend

+#include "mainwindow.h"

+#include "Packaging.h"

+

 using namespace HeimdallFrontend;

 

-bool MainWindow::IsArchive(QString path)

+void MainWindow::UpdateUnusedPartitionIds(void)

 {

-	// Not a real check but hopefully it gets the message across, don't flash archives!

-	return (path.endsWith(".tar", Qt::CaseInsensitive) || path.endsWith(".gz", Qt::CaseInsensitive) || path.endsWith(".zip", Qt::CaseInsensitive)

-		|| path.endsWith(".bz2", Qt::CaseInsensitive) || path.endsWith(".7z", Qt::CaseInsensitive) || path.endsWith(".rar", Qt::CaseInsensitive));

+	unusedPartitionIds.clear();

+

+	// Initially populate unusedPartitionIds with all possible partition IDs. 

+	for (unsigned int i = 0; i < currentPitData.GetEntryCount(); i++)

+	{

+		const PitEntry *pitEntry = currentPitData.GetEntry(i);

+

+		if (!pitEntry->GetUnused() && strcmp(pitEntry->GetPartitionName(), "PIT") != 0)

+			unusedPartitionIds.append(pitEntry->GetPartitionIdentifier());

+	}

+

+	// Remove any used partition IDs from unusedPartitionIds

+	QList<FileInfo>& fileList = workingPackageData.GetFirmwareInfo().GetFileInfos();

+

+	for (int i = 0; i < fileList.length(); i++)

+		unusedPartitionIds.removeOne(fileList[i].GetPartitionId());

 }

 

-QString MainWindow::PromptFileSelection(void)

+bool MainWindow::ReadPit(QFile *file)

 {

-	QString path = QFileDialog::getOpenFileName(this, "Select File", lastDirectory);

+	if(!file->open(QIODevice::ReadOnly))

+		return (false);

 

-	if (path != "")

-		lastDirectory = path.left(path.lastIndexOf('/') + 1);

+	unsigned char *buffer = new unsigned char[file->size()];

 

-	return (path);

+	file->read(reinterpret_cast<char *>(buffer), file->size());

+	file->close();

+

+	bool success = currentPitData.Unpack(buffer);

+	delete buffer;

+

+	if (!success)

+		currentPitData.Clear();

+

+	return (success);

 }

 

-void MainWindow::UpdateStartButton(void)

+void MainWindow::UpdatePackageUserInterface(void)

 {

-	if (heimdallRunning)

+	supportedDevicesListWidget->clear();

+	includedFilesListWidget->clear();

+

+	if (loadedPackageData.IsCleared())

 	{

-		startFlashButton->setEnabled(false);

-		return;

-	}

+		// Package Interface

+		firmwareNameLineEdit->clear();

+		versionLineEdit->clear();

 

-	if (repartitionCheckBox->isChecked())

+		developerNamesLineEdit->clear();

+

+		platformLineEdit->clear();

+

+		developerHomepageButton->setEnabled(false);

+		developerDonateButton->setEnabled(false);

+		

+		repartitionRadioButton->setChecked(false);

+

+		loadFirmwareButton->setEnabled(false);

+	}

+	else

 	{

-		if (!IsArchive(pitLineEdit->text()) && factoryfsCheckBox->isChecked() && !IsArchive(factoryfsLineEdit->text()) && kernelCheckBox->isChecked()

-			&& !IsArchive(kernelLineEdit->text()) && paramCheckBox->isChecked() && !IsArchive(paramLineEdit->text())

-			&& primaryBootCheckBox->isChecked() && !IsArchive(primaryBootLineEdit->text()) && secondaryBootCheckBox->isChecked()

-			&& !IsArchive(secondaryBootLineEdit->text()) && modemCheckBox->isChecked() && !IsArchive(modemLineEdit->text()))

+		firmwareNameLineEdit->setText(loadedPackageData.GetFirmwareInfo().GetName());

+		versionLineEdit->setText(loadedPackageData.GetFirmwareInfo().GetVersion());

+

+		QString developerNames;

+

+		if (!loadedPackageData.GetFirmwareInfo().GetDevelopers().isEmpty())

 		{

-			startFlashButton->setEnabled(true);

+			developerNames = loadedPackageData.GetFirmwareInfo().GetDevelopers()[0];

+			for (int i = 1; i < loadedPackageData.GetFirmwareInfo().GetDevelopers().length(); i++)

+				developerNames += ", " + loadedPackageData.GetFirmwareInfo().GetDevelopers()[i];

 		}

+

+		developerNamesLineEdit->setText(developerNames);

+

+		platformLineEdit->setText(loadedPackageData.GetFirmwareInfo().GetPlatformInfo().GetName() + " ("

+			+ loadedPackageData.GetFirmwareInfo().GetPlatformInfo().GetVersion() + ")");

+

+		if (!loadedPackageData.GetFirmwareInfo().GetUrl().isEmpty())

+			developerHomepageButton->setEnabled(true);

 		else

+			developerHomepageButton->setEnabled(false);

+

+		if (!loadedPackageData.GetFirmwareInfo().GetDonateUrl().isEmpty())

+			developerDonateButton->setEnabled(true);

+		else

+			developerDonateButton->setEnabled(false);

+

+		for (int i = 0; i < loadedPackageData.GetFirmwareInfo().GetDeviceInfos().length(); i++)

 		{

-			startFlashButton->setEnabled(false);

+			const DeviceInfo& deviceInfo = loadedPackageData.GetFirmwareInfo().GetDeviceInfos()[i];

+			supportedDevicesListWidget->addItem(deviceInfo.GetManufacturer() + " " + deviceInfo.GetName() + " (" + deviceInfo.GetProduct() + ")");

 		}

-	}

-	else

-	{

-		bool atLeastOneFile = false;

 

-		if (factoryfsCheckBox->isChecked())

+		for (int i = 0; i < loadedPackageData.GetFirmwareInfo().GetFileInfos().length(); i++)

 		{

-			atLeastOneFile = true;

-

-			if (IsArchive(factoryfsLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

+			const FileInfo& fileInfo = loadedPackageData.GetFirmwareInfo().GetFileInfos()[i];

+			includedFilesListWidget->addItem(fileInfo.GetFilename());

 		}

 

-		if (kernelCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+		repartitionRadioButton->setChecked(loadedPackageData.GetFirmwareInfo().GetRepartition());

 

-			if (IsArchive(kernelLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+		loadFirmwareButton->setEnabled(true);

+	}

+}

 

-		if (paramCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+bool MainWindow::IsArchive(QString path)

+{

+	// Not a real check but hopefully it gets the message across, don't flash archives!

+	return (path.endsWith(".tar", Qt::CaseInsensitive) || path.endsWith(".gz", Qt::CaseInsensitive) || path.endsWith(".zip", Qt::CaseInsensitive)

+		|| path.endsWith(".bz2", Qt::CaseInsensitive) || path.endsWith(".7z", Qt::CaseInsensitive) || path.endsWith(".rar", Qt::CaseInsensitive));

+}

 

-			if (IsArchive(paramLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+QString MainWindow::PromptFileSelection(void)

+{

+	QString path = QFileDialog::getOpenFileName(this, "Select File", lastDirectory);

 

-		if (primaryBootCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	if (path != "")

+		lastDirectory = path.left(path.lastIndexOf('/') + 1);

 

-			if (IsArchive(primaryBootLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+	return (path);

+}

 

-		if (secondaryBootCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+QString MainWindow::PromptFileCreation(void)

+{

+	QString path = QFileDialog::getSaveFileName(this, "Save File", lastDirectory);

 

-			if (IsArchive(secondaryBootLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+	if (path != "")

+		lastDirectory = path.left(path.lastIndexOf('/') + 1);

 

-		if (cacheCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	return (path);

+}

 

-			if (IsArchive(cacheLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+void MainWindow::UpdatePartitionNamesInterface(void)

+{

+	populatingPartitionNames = true;

 

-		if (databaseCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	partitionNameComboBox->clear();

 

-			if (IsArchive(databaseLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+	int partitionsListWidgetRow = partitionsListWidget->currentRow();

 

-		if (modemCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	if (partitionsListWidgetRow >= 0)

+	{

+		const FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[partitionsListWidget->currentRow()];

 

-			if (IsArchive(modemLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+		for (int i = 0; i < unusedPartitionIds.length(); i++)

+			partitionNameComboBox->addItem(currentPitData.FindEntry(unusedPartitionIds[i])->GetPartitionName());

 

-		if (recoveryCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+		partitionNameComboBox->addItem(currentPitData.FindEntry(partitionInfo.GetPartitionId())->GetPartitionName());

+		partitionNameComboBox->setCurrentIndex(unusedPartitionIds.length());

 

-			if (IsArchive(recoveryLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

+		partitionNameComboBox->setEnabled(true);

+	}

+	else

+	{

+		partitionNameComboBox->setEnabled(false);

+	}

+

+	populatingPartitionNames = false;

+}

+

+void MainWindow::UpdateStartButton(void)

+{

+	if (heimdallRunning)

+	{

+		startFlashButton->setEnabled(false);

+		return;

+	}

+

+	bool allPartitionsValid = true;

+

+	QList<FileInfo>& fileList = workingPackageData.GetFirmwareInfo().GetFileInfos();

+

+	for (int i = 0; i < fileList.length(); i++)

+	{

+		if (fileList[i].GetFilename().isEmpty())

+		{

+			allPartitionsValid = false;

+			break;

 		}

+	}

+

+	bool validSettings = allPartitionsValid && fileList.length() > 0;

 

-		startFlashButton->setEnabled(atLeastOneFile);

+	startFlashButton->setEnabled(validSettings);

+	functionTabWidget->setTabEnabled(functionTabWidget->indexOf(createPackageTab), validSettings);

+}

+

+void MainWindow::UpdateBuildPackageButton(void)

+{

+	const FirmwareInfo& firmwareInfo = workingPackageData.GetFirmwareInfo();

+

+	if (firmwareInfo.GetName().isEmpty() || firmwareInfo.GetVersion().isEmpty() || firmwareInfo.GetPlatformInfo().GetName().isEmpty()

+		|| firmwareInfo.GetPlatformInfo().GetVersion().isEmpty() || firmwareInfo.GetDevelopers().isEmpty() || firmwareInfo.GetDeviceInfos().isEmpty())

+	{

+		buildPackageButton->setEnabled(false);

+	}

+	else

+	{

+		buildPackageButton->setEnabled(true);

 	}

 }

 

@@ -186,33 +246,52 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
 

 	lastDirectory = QDir::toNativeSeparators(QApplication::applicationDirPath());

 

+	populatingPartitionNames = false;

+

+	functionTabWidget->setTabEnabled(functionTabWidget->indexOf(createPackageTab), false);

+

 	QObject::connect(actionDonate, SIGNAL(triggered()), this, SLOT(OpenDonationWebpage()));

 	QObject::connect(actionAboutHeimdall, SIGNAL(triggered()), this, SLOT(ShowAbout()));

 

+	QObject::connect(browseFirmwarePackageButton, SIGNAL(clicked()), this, SLOT(SelectFirmwarePackage()));

+	QObject::connect(developerHomepageButton, SIGNAL(clicked()), this, SLOT(OpenDeveloperHomepage()));

+	QObject::connect(developerDonateButton, SIGNAL(clicked()), this, SLOT(OpenDeveloperDonationWebpage()));

+	QObject::connect(loadFirmwareButton, SIGNAL(clicked()), this, SLOT(LoadFirmwarePackage()));

+

+	QObject::connect(partitionsListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SelectPartition(int)));

+	QObject::connect(addPartitionButton, SIGNAL(clicked()), this, SLOT(AddPartition()));

+	QObject::connect(removePartitionButton, SIGNAL(clicked()), this, SLOT(RemovePartition()));

+

+	QObject::connect(partitionNameComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(SelectPartitionName(int)));

+	QObject::connect(partitionFileBrowseButton, SIGNAL(clicked()), this, SLOT(SelectPartitionFile()));

+

 	QObject::connect(pitBrowseButton, SIGNAL(clicked()), this, SLOT(SelectPit()));

-	QObject::connect(factoryfsBrowseButton, SIGNAL(clicked()), this, SLOT(SelectFactoryfs()));

-	QObject::connect(kernelBrowseButton, SIGNAL(clicked()), this, SLOT(SelectKernel()));

-	QObject::connect(paramBrowseButton, SIGNAL(clicked()), this, SLOT(SelectParam()));

-	QObject::connect(primaryBootBrowseButton, SIGNAL(clicked()), this, SLOT(SelectPrimaryBootloader()));

-	QObject::connect(secondaryBootBrowseButton, SIGNAL(clicked()), this, SLOT(SelectSecondaryBootloader()));

-	QObject::connect(cacheBrowseButton, SIGNAL(clicked()), this, SLOT(SelectCache()));

-	QObject::connect(databaseBrowseButton, SIGNAL(clicked()), this, SLOT(SelectDatabase()));

-	QObject::connect(modemBrowseButton, SIGNAL(clicked()), this, SLOT(SelectModem()));

-	QObject::connect(recoveryBrowseButton, SIGNAL(clicked()), this, SLOT(SelectRecovery()));

-

-	QObject::connect(repartitionCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetRepartionEnabled(int)));

-	QObject::connect(factoryfsCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetFactoryfsEnabled(int)));

-	QObject::connect(kernelCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetKernelEnabled(int)));

-	QObject::connect(paramCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetParamEnabled(int)));

-	QObject::connect(primaryBootCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetPrimaryBootloaderEnabled(int)));

-	QObject::connect(secondaryBootCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetSecondaryBootloaderEnabled(int)));

-	QObject::connect(cacheCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetCacheEnabled(int)));

-	QObject::connect(databaseCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetDatabaseEnabled(int)));

-	QObject::connect(modemCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetModemEnabled(int)));

-	QObject::connect(recoveryCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetRecoveryEnabled(int)));

+	QObject::connect(repartitionCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetRepartition(int)));

 	

 	QObject::connect(startFlashButton, SIGNAL(clicked()), this, SLOT(StartFlash()));

 

+	QObject::connect(createFirmwareNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(FirmwareNameChanged(const QString&)));

+	QObject::connect(createFirmwareVersionLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(FirmwareVersionChanged(const QString&)));

+	QObject::connect(createPlatformNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(PlatformNameChanged(const QString&)));

+	QObject::connect(createPlatformVersionLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(PlatformVersionChanged(const QString&)));

+

+	QObject::connect(createHomepageLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(HomepageUrlChanged(const QString&)));

+	QObject::connect(createDonateLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DonateUrlChanged(const QString&)));

+

+	QObject::connect(createDevelopersListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SelectDeveloper(int)));

+	QObject::connect(createDeveloperNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeveloperNameChanged(const QString&)));

+	QObject::connect(addDeveloperButton, SIGNAL(clicked()), this, SLOT(AddDeveloper()));

+	QObject::connect(removeDeveloperButton, SIGNAL(clicked()), this, SLOT(RemoveDeveloper()));

+

+	QObject::connect(createDevicesListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SelectDevice(int)));

+	QObject::connect(deviceManufacturerLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeviceInfoChanged(const QString&)));

+	QObject::connect(deviceNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeviceInfoChanged(const QString&)));

+	QObject::connect(deviceProductCodeLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeviceInfoChanged(const QString&)));

+	QObject::connect(addDeviceButton, SIGNAL(clicked()), this, SLOT(AddDevice()));

+	QObject::connect(removeDeviceButton, SIGNAL(clicked()), this, SLOT(RemoveDevice()));

+			

+	QObject::connect(buildPackageButton, SIGNAL(clicked()), this, SLOT(BuildPackage()));

+

 	QObject::connect(&process, SIGNAL(readyRead()), this, SLOT(HandleHeimdallStdout()));

 	QObject::connect(&process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(HandleHeimdallReturned(int, QProcess::ExitStatus)));

 	QObject::connect(&process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(HandleHeimdallError(QProcess::ProcessError)));

@@ -232,284 +311,314 @@ void MainWindow::ShowAbout(void)
 	aboutForm.show();

 }

 

-void MainWindow::SelectPit(void)

+void MainWindow::SelectFirmwarePackage(void)

 {

+	loadedPackageData.Clear();

+	UpdatePackageUserInterface();

+

 	QString path = PromptFileSelection();

-	pitLineEdit->setText(path);

+	firmwarePackageLineEdit->setText(path);

 

-	SetRepartionEnabled(path != "");

+	if (firmwarePackageLineEdit->text() != "")

+	{

+		if (Packaging::ExtractPackage(firmwarePackageLineEdit->text(), &loadedPackageData))

+		{

+			UpdatePackageUserInterface();

+		}

+		else

+		{

+			// TODO: Error?

+			loadedPackageData.Clear();

+		}

+	}

 }

 

-void MainWindow::SelectFactoryfs(void)

+void MainWindow::OpenDeveloperHomepage(void)

 {

-	QString path = PromptFileSelection();

-	factoryfsLineEdit->setText(path);

-

-	SetFactoryfsEnabled(path != "");

+	QDesktopServices::openUrl(QUrl(loadedPackageData.GetFirmwareInfo().GetUrl(), QUrl::TolerantMode));

 }

 

-void MainWindow::SelectKernel(void)

+void MainWindow::OpenDeveloperDonationWebpage(void)

 {

-	QString path = PromptFileSelection();

-	kernelLineEdit->setText(path);

-

-	SetKernelEnabled(path != "");

+	QDesktopServices::openUrl(QUrl(loadedPackageData.GetFirmwareInfo().GetDonateUrl(), QUrl::TolerantMode));

 }

 

-void MainWindow::SelectParam(void)

+void MainWindow::LoadFirmwarePackage(void)

 {

-	QString path = PromptFileSelection();

-	paramLineEdit->setText(path);

+	workingPackageData.Clear();

+	currentPitData.Clear();

+	

+	// Make flashSettings responsible for the temporary files

+	workingPackageData.GetFiles().append(loadedPackageData.GetFiles());

+	loadedPackageData.RemoveAllFiles();

 

-	SetParamEnabled(path != "");

-}

+	const QList<FileInfo> packageFileInfos = loadedPackageData.GetFirmwareInfo().GetFileInfos();

 

-void MainWindow::SelectPrimaryBootloader(void)

-{

-	QString path = PromptFileSelection();

-	primaryBootLineEdit->setText(path);

+	for (int i = 0; i < packageFileInfos.length(); i++)

+	{

+		for (int j = 0; j < workingPackageData.GetFiles().length(); j++)

+		{

+			if (workingPackageData.GetFiles()[j]->fileTemplate() == ("XXXXXX-" + packageFileInfos[i].GetFilename()))

+			{

+				FileInfo partitionInfo(packageFileInfos[i].GetPartitionId(), QDir::current().absoluteFilePath(workingPackageData.GetFiles()[j]->fileName()));

+				workingPackageData.GetFirmwareInfo().GetFileInfos().append(partitionInfo);

 

-	SetPrimaryBootloaderEnabled(path != "");

-}

+				break;

+			}

+		}

+	}

 

-void MainWindow::SelectSecondaryBootloader(void)

-{

-	QString path = PromptFileSelection();

-	secondaryBootLineEdit->setText(path);

+	// Find the PIT file and read it

+	for (int i = 0; i < workingPackageData.GetFiles().length(); i++)

+	{

+		QTemporaryFile *file = workingPackageData.GetFiles()[i];

 

-	SetSecondaryBootloaderEnabled(path != "");

-}

+		if (file->fileTemplate() == ("XXXXXX-" + loadedPackageData.GetFirmwareInfo().GetPitFilename()))

+		{

+			workingPackageData.GetFirmwareInfo().SetPitFilename(QDir::current().absoluteFilePath(file->fileName()));

 

-void MainWindow::SelectCache(void)

-{

-	QString path = PromptFileSelection();

-	cacheLineEdit->setText(path);

+			if (!ReadPit(file))

+			{

+				// TODO: Error

+				loadedPackageData.Clear();

+				UpdatePackageUserInterface();

 

-	SetCacheEnabled(path != "");

-}

+				workingPackageData.Clear();

+				UpdateUnusedPartitionIds();

+				return;

+			}

 

-void MainWindow::SelectDatabase(void)

-{

-	QString path = PromptFileSelection();

-	databaseLineEdit->setText(path);

+			break;

+		}

+	}

 

-	SetDatabaseEnabled(path != "");

-}

+	UpdateUnusedPartitionIds();

+	workingPackageData.GetFirmwareInfo().SetRepartition(loadedPackageData.GetFirmwareInfo().GetRepartition());

 

-void MainWindow::SelectModem(void)

-{

-	QString path = PromptFileSelection();

-	modemLineEdit->setText(path);

+	loadedPackageData.Clear();

+	UpdatePackageUserInterface();

+	firmwarePackageLineEdit->clear();

 

-	SetModemEnabled(path != "");

-}

+	partitionsListWidget->clear();

 

-void MainWindow::SelectRecovery(void)

-{

-	QString path = PromptFileSelection();

-	recoveryLineEdit->setText(path);

+	// Populate partitionsListWidget with partition names (from the PIT file)

+	for (int i = 0; i < workingPackageData.GetFirmwareInfo().GetFileInfos().length(); i++)

+	{

+		const FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[i];

 

-	SetRecoveryEnabled(path != "");

-}

+		const PitEntry *pitEntry = currentPitData.FindEntry(partitionInfo.GetPartitionId());

 

-void MainWindow::SetRepartionEnabled(int enabled)

-{

-	if (repartitionCheckBox->isChecked() != (enabled != 0))

-		repartitionCheckBox->setChecked(enabled);

+		if (pitEntry)

+		{

+			partitionsListWidget->addItem(pitEntry->GetPartitionName());

+		}

+		else

+		{

+			// TODO: "Firmware package includes invalid partition IDs."

+			loadedPackageData.GetFirmwareInfo().Clear();

+			currentPitData.Clear();

+			UpdateUnusedPartitionIds();

 

-	if (enabled)

-	{

-		repartitionCheckBox->setEnabled(true);

-		pitLineEdit->setEnabled(true);

-		repartitionCheckBox->setChecked(true);

-	}

-	else

-	{

-		repartitionCheckBox->setEnabled(pitLineEdit->text() != "");

-		pitLineEdit->setEnabled(false);

+			partitionsListWidget->clear();

+			return;

+		}

 	}

-	

-	UpdateStartButton();

-}

 

-void MainWindow::SetFactoryfsEnabled(int enabled)

-{

-	if (factoryfsCheckBox->isChecked() != (enabled != 0))

-		factoryfsCheckBox->setChecked(enabled);

+	partitionNameComboBox->clear();

+	partitionIdLineEdit->clear();

+	partitionFileLineEdit->clear();

+	partitionFileBrowseButton->setEnabled(false);

 

-	if (enabled)

-	{

-		factoryfsCheckBox->setEnabled(true);

-		factoryfsLineEdit->setEnabled(true);

-		factoryfsCheckBox->setChecked(true);

-	}

-	else

-	{

-		factoryfsCheckBox->setEnabled(factoryfsLineEdit->text() != "");

-		factoryfsLineEdit->setEnabled(false);

-	}

-	

-	UpdateStartButton();

-}

+	repartitionCheckBox->setEnabled(true);

+	repartitionCheckBox->setChecked(workingPackageData.GetFirmwareInfo().GetRepartition());

+	partitionsListWidget->setEnabled(true);

+	addPartitionButton->setEnabled(true);

+	removePartitionButton->setEnabled(true && partitionsListWidget->currentRow() >= 0);

 

-void MainWindow::SetKernelEnabled(int enabled)

-{

-	if (kernelCheckBox->isChecked() != (enabled != 0))

-		kernelCheckBox->setChecked(enabled);

+	pitLineEdit->setText(workingPackageData.GetFirmwareInfo().GetPitFilename());

+

+	functionTabWidget->setCurrentWidget(flashTab);

 

-	if (enabled)

-	{

-		kernelCheckBox->setEnabled(true);

-		kernelLineEdit->setEnabled(true);

-		kernelCheckBox->setChecked(true);

-	}

-	else

-	{

-		kernelCheckBox->setEnabled(kernelLineEdit->text() != "");

-		kernelLineEdit->setEnabled(false);

-	}

-	

 	UpdateStartButton();

 }

 

-void MainWindow::SetParamEnabled(int enabled)

+void MainWindow::SelectPartitionName(int index)

 {

-	if (paramCheckBox->isChecked() != (enabled != 0))

-		paramCheckBox->setChecked(enabled);

-

-	if (enabled)

-	{

-		paramCheckBox->setEnabled(true);

-		paramLineEdit->setEnabled(true);

-		paramCheckBox->setChecked(true);

-	}

-	else

+	if (!populatingPartitionNames && index != -1 && index != unusedPartitionIds.length())

 	{

-		paramCheckBox->setEnabled(paramLineEdit->text() != "");

-		paramLineEdit->setEnabled(false);

+		unsigned int newPartitionIndex = unusedPartitionIds[index];

+		unusedPartitionIds.removeAt(index);

+

+		FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[partitionsListWidget->currentRow()];

+		unusedPartitionIds.append(partitionInfo.GetPartitionId());

+		partitionInfo.SetPartitionId(newPartitionIndex);

+

+		partitionNameComboBox->clear();

+

+		// Update interface

+		UpdatePartitionNamesInterface();

+		partitionIdLineEdit->setText(QString::number(newPartitionIndex));

+		partitionsListWidget->currentItem()->setText(currentPitData.FindEntry(newPartitionIndex)->GetPartitionName());

 	}

-	

-	UpdateStartButton();

 }

 

-void MainWindow::SetPrimaryBootloaderEnabled(int enabled)

+void MainWindow::SelectPartitionFile(void)

 {

-	if (primaryBootCheckBox->isChecked() != (enabled != 0))

-		primaryBootCheckBox->setChecked(enabled);

+	QString path = PromptFileSelection();

 

-	if (enabled)

-	{

-		primaryBootCheckBox->setEnabled(true);

-		primaryBootLineEdit->setEnabled(true);

-		primaryBootCheckBox->setChecked(true);

-	}

-	else

+	if (path != "")

 	{

-		primaryBootCheckBox->setEnabled(primaryBootLineEdit->text() != "");

-		primaryBootLineEdit->setEnabled(false);

+		workingPackageData.GetFirmwareInfo().GetFileInfos()[partitionsListWidget->currentRow()].SetFilename(path);

+		partitionFileLineEdit->setText(path);

+

+		pitBrowseButton->setEnabled(true);

+		partitionsListWidget->setEnabled(true);

+		UpdateStartButton();

+

+		if (unusedPartitionIds.length() > 0)

+			addPartitionButton->setEnabled(true);

 	}

-	

-	UpdateStartButton();

 }

 

-void MainWindow::SetSecondaryBootloaderEnabled(int enabled)

+void MainWindow::SelectPartition(int row)

 {

-	if (secondaryBootCheckBox->isChecked() != (enabled != 0))

-		secondaryBootCheckBox->setChecked(enabled);

-

-	if (enabled)

+	if (row >= 0)

 	{

-		secondaryBootCheckBox->setEnabled(true);

-		secondaryBootLineEdit->setEnabled(true);

-		secondaryBootCheckBox->setChecked(true);

+		const FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[row];

+

+		UpdatePartitionNamesInterface();

+

+		partitionIdLineEdit->setText(QString::number(partitionInfo.GetPartitionId()));

+		partitionFileLineEdit->setText(partitionInfo.GetFilename());

+		partitionFileBrowseButton->setEnabled(true);

+

+		removePartitionButton->setEnabled(true);

 	}

 	else

 	{

-		secondaryBootCheckBox->setEnabled(secondaryBootLineEdit->text() != "");

-		secondaryBootLineEdit->setEnabled(false);

+		UpdatePartitionNamesInterface();

+

+		partitionIdLineEdit->clear();

+		partitionFileLineEdit->clear();

+		partitionFileBrowseButton->setEnabled(false);

+

+		removePartitionButton->setEnabled(false);

 	}

-	

-	UpdateStartButton();

 }

 

-void MainWindow::SetCacheEnabled(int enabled)

+void MainWindow::AddPartition(void)

 {

-	if (cacheCheckBox->isChecked() != (enabled != 0))

-		cacheCheckBox->setChecked(enabled);

+	FileInfo partitionInfo(unusedPartitionIds.first(), "");

+	workingPackageData.GetFirmwareInfo().GetFileInfos().append(partitionInfo);

+	UpdateUnusedPartitionIds();

 

-	if (enabled)

-	{

-		cacheCheckBox->setEnabled(true);

-		cacheLineEdit->setEnabled(true);

-		cacheCheckBox->setChecked(true);

-	}

-	else

-	{

-		cacheCheckBox->setEnabled(cacheLineEdit->text() != "");

-		cacheLineEdit->setEnabled(false);

-	}

-	

+	pitBrowseButton->setEnabled(false);

+	addPartitionButton->setEnabled(false);

+

+	partitionsListWidget->addItem(currentPitData.FindEntry(partitionInfo.GetPartitionId())->GetPartitionName());

+	partitionsListWidget->setCurrentRow(partitionsListWidget->count() - 1);

+	partitionsListWidget->setEnabled(false);

 	UpdateStartButton();

 }

 

-void MainWindow::SetDatabaseEnabled(int enabled)

+void MainWindow::RemovePartition(void)

 {

-	if (databaseCheckBox->isChecked() != (enabled != 0))

-		databaseCheckBox->setChecked(enabled);

+	workingPackageData.GetFirmwareInfo().GetFileInfos().removeAt(partitionsListWidget->currentRow());

+	UpdateUnusedPartitionIds();

 

-	if (enabled)

-	{

-		databaseCheckBox->setEnabled(true);

-		databaseLineEdit->setEnabled(true);

-		databaseCheckBox->setChecked(true);

-	}

-	else

-	{

-		databaseCheckBox->setEnabled(databaseLineEdit->text() != "");

-		databaseLineEdit->setEnabled(false);

-	}

-	

+	QListWidgetItem *item = partitionsListWidget->currentItem();

+	partitionsListWidget->setCurrentRow(-1);

+	delete item;

+

+	pitBrowseButton->setEnabled(true);

+	addPartitionButton->setEnabled(true);

+	partitionsListWidget->setEnabled(true);

 	UpdateStartButton();

 }

 

-void MainWindow::SetModemEnabled(int enabled)

+void MainWindow::SelectPit(void)

 {

-	if (modemCheckBox->isChecked() != (enabled != 0))

-		modemCheckBox->setChecked(enabled);

+	QString path = PromptFileSelection();

+	bool validPit = path != "";

+

+	// In order to map files in the old PIT to file in the new one, we first must use partition names instead of IDs.

+	QList<FileInfo> fileInfos = workingPackageData.GetFirmwareInfo().GetFileInfos();

+

+	int partitionNamesCount = fileInfos.length();

+	QString *partitionNames = new QString[fileInfos.length()];

+	for (int i = 0; i < fileInfos.length(); i++)

+		partitionNames[i] = currentPitData.FindEntry(fileInfos[i].GetPartitionId())->GetPartitionName();

 

-	if (enabled)

+	currentPitData.Clear();

+

+	if (validPit)

 	{

-		modemCheckBox->setEnabled(true);

-		modemLineEdit->setEnabled(true);

-		modemCheckBox->setChecked(true);

+		QFile pitFile(path);

+

+		if (ReadPit(&pitFile))

+		{

+			workingPackageData.GetFirmwareInfo().SetPitFilename(path);

+

+			partitionsListWidget->clear();

+			int partitionInfoIndex = 0;

+

+			for (int i = 0; i < partitionNamesCount; i++)

+			{

+				const PitEntry *pitEntry = currentPitData.FindEntry(partitionNames[i].toAscii().constData());

+				

+				if (pitEntry)

+				{

+					fileInfos[partitionInfoIndex++].SetPartitionId(pitEntry->GetPartitionIdentifier());

+					partitionsListWidget->addItem(pitEntry->GetPartitionName());

+				}

+				else

+				{

+					fileInfos.removeAt(partitionInfoIndex);

+				}

+			}

+		}

+		else

+		{

+			validPit = false;

+		}

 	}

-	else

+	

+	// If the selected PIT was invalid, attempt to reload the old one.

+	if (!validPit)

 	{

-		modemCheckBox->setEnabled(databaseLineEdit->text() != "");

-		modemLineEdit->setEnabled(false);

+		// TODO: "The file selected was not a valid PIT file."

+		QFile originalPitFile(workingPackageData.GetFirmwareInfo().GetPitFilename());

+

+		if (ReadPit(&originalPitFile))

+		{

+			validPit = true;

+		}

+		else

+		{

+			// TODO: "Failed to reload working PIT data."

+			workingPackageData.Clear();

+			partitionsListWidget->clear();

+		}

 	}

-	

+

+	UpdateUnusedPartitionIds();

+

+	delete [] partitionNames;

+

+	pitLineEdit->setText(workingPackageData.GetFirmwareInfo().GetPitFilename());

+

+	repartitionCheckBox->setEnabled(validPit);

+	partitionsListWidget->setEnabled(validPit);

+

+	addPartitionButton->setEnabled(validPit);

+	removePartitionButton->setEnabled(validPit && partitionsListWidget->currentRow() >= 0);

+

 	UpdateStartButton();

 }

 

-void MainWindow::SetRecoveryEnabled(int enabled)

+void MainWindow::SetRepartition(int enabled)

 {

-	if (recoveryCheckBox->isChecked() != (enabled != 0))

-		recoveryCheckBox->setChecked(enabled);

-

-	if (enabled)

-	{

-		recoveryCheckBox->setEnabled(true);

-		recoveryLineEdit->setEnabled(true);

-		recoveryCheckBox->setChecked(true);

-	}

-	else

-	{

-		recoveryCheckBox->setEnabled(databaseLineEdit->text() != "");

-		recoveryLineEdit->setEnabled(false);

-	}

-	

-	UpdateStartButton();

+	workingPackageData.GetFirmwareInfo().SetRepartition(enabled);

 }

 

 void MainWindow::StartFlash(void)

@@ -522,68 +631,13 @@ void MainWindow::StartFlash(void)
 

 	if (repartitionCheckBox->isChecked())

 	{

+		arguments.append("--repartition");

+

 		arguments.append("--pit");

 		arguments.append(pitLineEdit->text());

 	}

 

-	if (factoryfsCheckBox->isChecked())

-	{

-		arguments.append("--factoryfs");

-		arguments.append(factoryfsLineEdit->text());

-	}

-

-	if (kernelCheckBox->isChecked())

-	{

-		arguments.append("--kernel");

-		arguments.append(kernelLineEdit->text());

-	}

-

-	if (paramCheckBox->isChecked())

-	{

-		arguments.append("--param");

-		arguments.append(paramLineEdit->text());

-	}

-

-	if (primaryBootCheckBox->isChecked())

-	{

-		arguments.append("--primary-boot");

-		arguments.append(primaryBootLineEdit->text());

-	}

-

-	if (secondaryBootCheckBox->isChecked())

-	{

-		arguments.append("--secondary-boot");

-		arguments.append(secondaryBootLineEdit->text());

-	}

-

-	if (cacheCheckBox->isChecked())

-	{

-		arguments.append("--cache");

-		arguments.append(cacheLineEdit->text());

-	}

-

-	if (databaseCheckBox->isChecked())

-	{

-		arguments.append("--dbdata");

-		arguments.append(databaseLineEdit->text());

-	}

-

-	if (modemCheckBox->isChecked())

-	{

-		arguments.append("--modem");

-		arguments.append(modemLineEdit->text());

-	}

-

-	if (recoveryCheckBox->isChecked())

-	{

-		arguments.append("--recovery");

-		arguments.append(recoveryLineEdit->text());

-	}

-

-	if (repartitionCheckBox->isChecked())

-	{

-		arguments.append("--repartition");

-	}

+	// TODO: Loop through partitions and append them.

 

 	flashProgressBar->setEnabled(true);

 	UpdateStartButton();

@@ -600,13 +654,13 @@ void MainWindow::StartFlash(void)
 		QStringList environment = QProcess::systemEnvironment();

 		

 		QStringList paths;

-		// Ensure /usr/local/bin is in PATH

+		// Ensure /usr/bin is in PATH

 		for (int i = 0; i < environment.length(); i++)

 		{

 			if (environment[i].left(5) == "PATH=")

 			{

 				paths = environment[i].mid(5).split(':');

-				paths.prepend("/usr/local/bin");

+				paths.prepend("/usr/bin");

 				break;

 			}

 		}

@@ -640,6 +694,140 @@ void MainWindow::StartFlash(void)
 	}

 }

 

+void MainWindow::FirmwareNameChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetName(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::FirmwareVersionChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetVersion(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::PlatformNameChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().GetPlatformInfo().SetName(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::PlatformVersionChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().GetPlatformInfo().SetVersion(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::HomepageUrlChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetUrl(text);

+}

+

+void MainWindow::DonateUrlChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetDonateUrl(text);

+}

+

+void MainWindow::DeveloperNameChanged(const QString& text)

+{

+	if (text.isEmpty())

+		addDeveloperButton->setEnabled(false);

+	else

+		addDeveloperButton->setEnabled(true);

+}

+

+void MainWindow::SelectDeveloper(int row)

+{

+	if (row >= 0)

+		removeDeveloperButton->setEnabled(true);

+	else

+		removeDeveloperButton->setEnabled(false);

+}

+

+void MainWindow::AddDeveloper(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDevelopers().append(createDeveloperNameLineEdit->text());

+

+	createDevelopersListWidget->addItem(createDeveloperNameLineEdit->text());

+	createDeveloperNameLineEdit->clear();

+

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::RemoveDeveloper(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDevelopers().removeAt(createDevelopersListWidget->currentRow());

+

+	QListWidgetItem *item = createDevelopersListWidget->currentItem();

+	createDevelopersListWidget->setCurrentRow(-1);

+	delete item;

+

+	removeDeveloperButton->setEnabled(false);

+

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::DeviceInfoChanged(const QString& text)

+{

+	if (deviceManufacturerLineEdit->text().isEmpty() || deviceNameLineEdit->text().isEmpty() || deviceProductCodeLineEdit->text().isEmpty())

+		addDeviceButton->setEnabled(false);

+	else

+		addDeviceButton->setEnabled(true);

+}

+

+void MainWindow::SelectDevice(int row)

+{

+	if (row >= 0)

+		removeDeviceButton->setEnabled(true);

+	else

+		removeDeviceButton->setEnabled(false);

+}

+

+void MainWindow::AddDevice(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDeviceInfos().append(DeviceInfo(deviceManufacturerLineEdit->text(), deviceNameLineEdit->text(),

+		deviceProductCodeLineEdit->text()));

+

+	createDevicesListWidget->addItem(deviceManufacturerLineEdit->text() + " " + deviceNameLineEdit->text() + " (" + deviceProductCodeLineEdit->text() + ")");

+	deviceManufacturerLineEdit->clear();

+	deviceNameLineEdit->clear();

+	deviceProductCodeLineEdit->clear();

+

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::RemoveDevice(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDeviceInfos().removeAt(createDevicesListWidget->currentRow());

+

+	QListWidgetItem *item = createDevicesListWidget->currentItem();

+	createDevicesListWidget->setCurrentRow(-1);

+	delete item;

+

+	removeDeviceButton->setEnabled(false);

+

+	UpdateBuildPackageButton();

+}

+			

+void MainWindow::BuildPackage(void)

+{

+	QString packagePath = PromptFileCreation();

+

+	if (!packagePath.endsWith(".tar.gz", Qt::CaseInsensitive))

+	{

+		if (packagePath.endsWith(".tar", Qt::CaseInsensitive))

+			packagePath.append(".gz");

+		else if (packagePath.endsWith(".gz", Qt::CaseInsensitive))

+			packagePath.replace(packagePath.length() - 3, ".tar.gz");

+		else if (packagePath.endsWith(".tgz", Qt::CaseInsensitive))

+			packagePath.replace(packagePath.length() - 4, ".tar.gz");

+		else

+			packagePath.append(".tar.gz");

+	}

+

+	Packaging::BuildPackage(packagePath, workingPackageData);

+}

+

 void MainWindow::HandleHeimdallStdout(void)

 {

 	QString output = process.read(1024);

diff --git a/heimdall-frontend/Source/mainwindow.h b/heimdall-frontend/Source/mainwindow.h
index added4e..7525d67 100644
--- a/heimdall-frontend/Source/mainwindow.h
+++ b/heimdall-frontend/Source/mainwindow.h
@@ -21,13 +21,21 @@
 #ifndef MAINWINDOW_H

 #define MAINWINDOW_H

 

+// Qt

+#include <QList>

+#include <QMainWindow>

+#include <QProcess>

+#include <QTemporaryFile>

+

+// libpit

+#include "libpit.h"

+

 // Heimdall Frontend

 #include "aboutform.h"

 #include "ui_mainwindow.h"

+#include "PackageData.h"

 

-// Qt

-#include <QMainWindow>

-#include <QProcess>

+using namespace libpit;

 

 namespace HeimdallFrontend

 {

@@ -45,11 +53,29 @@ namespace HeimdallFrontend
 			bool heimdallRunning;

 			QProcess process;

 

+			PackageData loadedPackageData;

+			

+			PitData currentPitData;

+			PackageData workingPackageData;

+

+			bool populatingPartitionNames;

+			QList<unsigned int> unusedPartitionIds;

+

+			void UpdateUnusedPartitionIds(void);

+			bool ReadPit(QFile *file);

+

+			void UpdatePackageUserInterface(void);

+

 			bool IsArchive(QString path);

 

 			QString PromptFileSelection(void);

+			QString PromptFileCreation(void);

+

+			void UpdatePartitionNamesInterface(void);

 			void UpdateStartButton(void);

 

+			void UpdateBuildPackageButton(void);

+

 		public:

 

 			explicit MainWindow(QWidget *parent = 0);

@@ -60,30 +86,43 @@ namespace HeimdallFrontend
 			void OpenDonationWebpage(void);

 			void ShowAbout(void);

 

+			void SelectFirmwarePackage(void);

+			void OpenDeveloperHomepage(void);

+			void OpenDeveloperDonationWebpage(void);

+			void LoadFirmwarePackage(void);

+

+			void SelectPartitionName(int index);

+			void SelectPartitionFile(void);

+

+			void SelectPartition(int row);

+			void AddPartition(void);

+			void RemovePartition(void);

+

 			void SelectPit(void);

-			void SelectFactoryfs(void);

-			void SelectKernel(void);

-			void SelectParam(void);

-			void SelectPrimaryBootloader(void);

-			void SelectSecondaryBootloader(void);

-			void SelectCache(void);

-			void SelectDatabase(void);

-			void SelectModem(void);

-			void SelectRecovery(void);

-

-			void SetRepartionEnabled(int enabled);

-			void SetFactoryfsEnabled(int enabled);

-			void SetKernelEnabled(int enabled);

-			void SetParamEnabled(int enabled);

-			void SetPrimaryBootloaderEnabled(int enabled);

-			void SetSecondaryBootloaderEnabled(int enabled);

-			void SetCacheEnabled(int enabled);

-			void SetDatabaseEnabled(int enabled);

-			void SetModemEnabled(int enabled);

-			void SetRecoveryEnabled(int enabled);

+			void SetRepartition(int enabled);

 

 			void StartFlash(void);

 

+			void FirmwareNameChanged(const QString& text);

+			void FirmwareVersionChanged(const QString& text);

+			void PlatformNameChanged(const QString& text);

+			void PlatformVersionChanged(const QString& text);

+

+			void HomepageUrlChanged(const QString& text);

+			void DonateUrlChanged(const QString& text);

+

+			void DeveloperNameChanged(const QString& text);

+			void SelectDeveloper(int row);

+			void AddDeveloper(void);

+			void RemoveDeveloper(void);

+

+			void DeviceInfoChanged(const QString& text);

+			void SelectDevice(int row);

+			void AddDevice(void);

+			void RemoveDevice(void);

+			

+			void BuildPackage(void);

+

 			void HandleHeimdallStdout(void);

 			void HandleHeimdallReturned(int exitCode, QProcess::ExitStatus exitStatus);

 			void HandleHeimdallError(QProcess::ProcessError error);

diff --git a/heimdall-frontend/aboutform.ui b/heimdall-frontend/aboutform.ui
index 80b7181..39e87cc 100644
--- a/heimdall-frontend/aboutform.ui
+++ b/heimdall-frontend/aboutform.ui
@@ -32,7 +32,7 @@
    </size>

   </property>

   <property name="windowTitle">

-   <string>About Heimdall Frontend 1.1</string>

+   <string>About Heimdall Frontend</string>

   </property>

   <widget class="QGroupBox" name="groupBox">

    <property name="geometry">

@@ -50,14 +50,15 @@
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>190</y>

+      <y>160</y>

       <width>581</width>

-      <height>241</height>

+      <height>271</height>

      </rect>

     </property>

     <property name="font">

      <font>

       <pointsize>9</pointsize>

+      <kerning>true</kerning>

      </font>

     </property>

     <property name="autoFillBackground">

@@ -156,21 +157,17 @@ THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRES
       <x>10</x>

       <y>10</y>

       <width>581</width>

-      <height>101</height>

+      <height>51</height>

      </rect>

     </property>

     <property name="font">

      <font>

-      <pointsize>9</pointsize>

+      <pointsize>10</pointsize>

      </font>

     </property>

     <property name="text">

      <string>Heimdall Frontend

-Version 1.1.0

-Copyright © 2010 Benjamin Dobell, Glass Echidna

-

-Heimdall

-Version 1.1.0

+Version 1.3.0

 Copyright © 2010 Benjamin Dobell, Glass Echidna</string>

     </property>

     <property name="textFormat">

@@ -190,7 +187,7 @@ Copyright © 2010 Benjamin Dobell, Glass Echidna</string>
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>118</y>

+      <y>70</y>

       <width>581</width>

       <height>16</height>

      </rect>

@@ -217,7 +214,7 @@ Copyright © 2010 Benjamin Dobell, Glass Echidna</string>
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>130</y>

+      <y>90</y>

       <width>581</width>

       <height>21</height>

      </rect>

@@ -246,7 +243,7 @@ p, li { white-space: pre-wrap; }
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>150</y>

+      <y>110</y>

       <width>581</width>

       <height>16</height>

      </rect>

@@ -273,7 +270,7 @@ p, li { white-space: pre-wrap; }
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>162</y>

+      <y>130</y>

       <width>581</width>

       <height>21</height>

      </rect>

diff --git a/heimdall-frontend/heimdall-frontend.vcxproj b/heimdall-frontend/heimdall-frontend.vcxproj
index 6182ce6..6844d0a 100644
--- a/heimdall-frontend/heimdall-frontend.vcxproj
+++ b/heimdall-frontend/heimdall-frontend.vcxproj
@@ -62,19 +62,20 @@
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)\</IntDir>

     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(Configuration)\</IntDir>

     <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)\</IntDir>

-    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(IncludePath)</IncludePath>

+    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectDir)include;$(SolutionDir)libpit\Source;$(IncludePath)</IncludePath>

     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>

     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">false</LinkIncremental>

     <IncludePath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(IncludePath)</IncludePath>

     <IncludePath Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(IncludePath)</IncludePath>

     <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(LibraryPath)</LibraryPath>

     <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(LibraryPath)</LibraryPath>

-    <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(LibraryPath)</LibraryPath>

+    <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectDir)lib\win32;$(LibraryPath)</LibraryPath>

+    <SourcePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SourcePath)</SourcePath>

   </PropertyGroup>

   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

     <ClCompile>

       <PreprocessorDefinitions>UNICODE;WIN32;QT_LARGEFILE_SUPPORT;QT_CORE_LIB;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtXml;..\libpit\Source;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <Optimization>Disabled</Optimization>

       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>

       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>

@@ -85,15 +86,15 @@
     <Link>

       <SubSystem>Windows</SubSystem>

       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>

-      <AdditionalLibraryDirectories>$(QTDIR)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

+      <AdditionalLibraryDirectories>$(QTDIR)\lib;$(SolutionDir)$(Platform)\$(Configuration)\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

       <GenerateDebugInformation>true</GenerateDebugInformation>

-      <AdditionalDependencies>qtmaind.lib;QtCored4.lib;QtGuid4.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>qtmaind.lib;QtCored4.lib;QtGuid4.lib;QtXml4.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

     </Link>

   </ItemDefinitionGroup>

   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

     <ClCompile>

       <PreprocessorDefinitions>UNICODE;WIN32;QT_LARGEFILE_SUPPORT;QT_NO_DEBUG;NDEBUG;QT_CORE_LIB;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtXml;..\libpit\Source;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <DebugInformationFormat>

       </DebugInformationFormat>

       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>

@@ -106,15 +107,15 @@
     <Link>

       <SubSystem>Windows</SubSystem>

       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>

-      <AdditionalLibraryDirectories>$(QTDIR)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

+      <AdditionalLibraryDirectories>$(QTDIR)\lib;$(SolutionDir)$(Platform)\$(Configuration)\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

       <GenerateDebugInformation>false</GenerateDebugInformation>

-      <AdditionalDependencies>qtmain.lib;QtCore4.lib;QtGui4.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>qtmain.lib;QtCore4.lib;QtGui4.lib;QtXml4.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

     </Link>

   </ItemDefinitionGroup>

   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">

     <ClCompile>

       <PreprocessorDefinitions>UNICODE;WIN32;QT_LARGEFILE_SUPPORT;QT_NO_DEBUG;NDEBUG;QT_CORE_LIB;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtXml;..\libpit\Source;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <DebugInformationFormat>

       </DebugInformationFormat>

       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

@@ -127,9 +128,9 @@
     <Link>

       <SubSystem>Windows</SubSystem>

       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>

-      <AdditionalLibraryDirectories>$(QTDIR)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

+      <AdditionalLibraryDirectories>$(QTDIR)\lib;$(SolutionDir)$(Platform)\$(Configuration)\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

       <GenerateDebugInformation>false</GenerateDebugInformation>

-      <AdditionalDependencies>qtmains.lib;QtCore4s.lib;QtGui4s.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>qtmains.lib;QtCore4s.lib;QtGui4s.lib;QtXml4s.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

     </Link>

   </ItemDefinitionGroup>

   <ItemGroup>

@@ -147,10 +148,14 @@
     </ClCompile>

     <ClCompile Include="GeneratedFiles\Release\moc_mainwindow.cpp">

       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>

+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">true</ExcludedFromBuild>

     </ClCompile>

     <ClCompile Include="Source\aboutform.cpp" />

+    <ClCompile Include="Source\FirmwareInfo.cpp" />

     <ClCompile Include="Source\main.cpp" />

     <ClCompile Include="Source\mainwindow.cpp" />

+    <ClCompile Include="Source\PackageData.cpp" />

+    <ClCompile Include="Source\Packaging.cpp" />

   </ItemGroup>

   <ItemGroup>

     <CustomBuild Include="mainwindow.ui">

@@ -173,19 +178,22 @@
     <ClInclude Include="GeneratedFiles\ui_aboutform.h" />

     <ClInclude Include="GeneratedFiles\ui_mainwindow.h" />

     <ClInclude Include="Source\aboutform.h" />

+    <ClInclude Include="Source\FirmwareInfo.h" />

+    <ClInclude Include="Source\PackageData.h" />

+    <ClInclude Include="Source\Packaging.h" />

     <CustomBuild Include="Source\mainwindow.h">

       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

       <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Moc%27ing %(Identity)...</Message>

       <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>

-      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_CORE_LIB -DQT_GUI_LIB -D_UNICODE  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I." "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_CORE_LIB -DQT_GUI_LIB -D_UNICODE  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtXml" "-I.\..\libpit\Source" "-I." "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

       <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Moc%27ing %(Identity)...</Message>

       <Message Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">Moc%27ing %(Identity)...</Message>

       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>

       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>

-      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

-      <Command Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtXml" "-I.\..\libpit\Source" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

+      <Command Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtXml" "-I.\..\libpit\Source" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

     </CustomBuild>

   </ItemGroup>

   <ItemGroup>

diff --git a/heimdall-frontend/heimdall-frontend.vcxproj.filters b/heimdall-frontend/heimdall-frontend.vcxproj.filters
index aff2885..d1c227e 100644
--- a/heimdall-frontend/heimdall-frontend.vcxproj.filters
+++ b/heimdall-frontend/heimdall-frontend.vcxproj.filters
@@ -49,6 +49,15 @@
     <ClCompile Include="Source\aboutform.cpp">

       <Filter>Source</Filter>

     </ClCompile>

+    <ClCompile Include="Source\Packaging.cpp">

+      <Filter>Source</Filter>

+    </ClCompile>

+    <ClCompile Include="Source\PackageData.cpp">

+      <Filter>Source</Filter>

+    </ClCompile>

+    <ClCompile Include="Source\FirmwareInfo.cpp">

+      <Filter>Source</Filter>

+    </ClCompile>

   </ItemGroup>

   <ItemGroup>

     <CustomBuild Include="mainwindow.ui">

@@ -74,5 +83,14 @@
     <ClInclude Include="Source\aboutform.h">

       <Filter>Source</Filter>

     </ClInclude>

+    <ClInclude Include="Source\Packaging.h">

+      <Filter>Source</Filter>

+    </ClInclude>

+    <ClInclude Include="Source\PackageData.h">

+      <Filter>Source</Filter>

+    </ClInclude>

+    <ClInclude Include="Source\FirmwareInfo.h">

+      <Filter>Source</Filter>

+    </ClInclude>

   </ItemGroup>

 </Project>
\ No newline at end of file
diff --git a/heimdall-frontend/include/zconf.h b/heimdall-frontend/include/zconf.h
new file mode 100755
index 0000000..02ce56c
--- /dev/null
+++ b/heimdall-frontend/include/zconf.h
@@ -0,0 +1,428 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2010 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+
+/* all linked symbols */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  define gz_error              z_gz_error
+#  define gz_intmax             z_gz_intmax
+#  define gz_strwinerror        z_gz_strwinerror
+#  define gzbuffer              z_gzbuffer
+#  define gzclearerr            z_gzclearerr
+#  define gzclose               z_gzclose
+#  define gzclose_r             z_gzclose_r
+#  define gzclose_w             z_gzclose_w
+#  define gzdirect              z_gzdirect
+#  define gzdopen               z_gzdopen
+#  define gzeof                 z_gzeof
+#  define gzerror               z_gzerror
+#  define gzflush               z_gzflush
+#  define gzgetc                z_gzgetc
+#  define gzgets                z_gzgets
+#  define gzoffset              z_gzoffset
+#  define gzoffset64            z_gzoffset64
+#  define gzopen                z_gzopen
+#  define gzopen64              z_gzopen64
+#  define gzprintf              z_gzprintf
+#  define gzputc                z_gzputc
+#  define gzputs                z_gzputs
+#  define gzread                z_gzread
+#  define gzrewind              z_gzrewind
+#  define gzseek                z_gzseek
+#  define gzseek64              z_gzseek64
+#  define gzsetparams           z_gzsetparams
+#  define gztell                z_gztell
+#  define gztell64              z_gztell64
+#  define gzungetc              z_gzungetc
+#  define gzwrite               z_gzwrite
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  define uncompress            z_uncompress
+#  define zError                z_zError
+#  define zcalloc               z_zcalloc
+#  define zcfree                z_zcfree
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  define gzFile                z_gzFile
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef STDC
+#  include <sys/types.h>    /* for off_t */
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#  include <unistd.h>       /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>     /* for off_t */
+#  endif
+#  ifndef z_off_t
+#    define z_off_t off_t
+#  endif
+#endif
+
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#  define z_off64_t off64_t
+#else
+#  define z_off64_t z_off_t
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/heimdall-frontend/include/zlib.h b/heimdall-frontend/include/zlib.h
new file mode 100755
index 0000000..bfbba83
--- /dev/null
+++ b/heimdall-frontend/include/zlib.h
@@ -0,0 +1,1613 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.5, April 19th, 2010
+
+  Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.5"
+#define ZLIB_VERNUM 0x1250
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 5
+#define ZLIB_VER_SUBREVISION 0
+
+/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip streams in memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use in the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+#define Z_TREES         6
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).  Some
+    output may be provided even if flush is not set.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed code
+  block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error.  After
+  deflate has returned Z_STREAM_END, the only possible operations on the stream
+  are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step.  In this case, avail_out must be at least the
+  value returned by deflateBound (see below).  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  In doubt, the data is considered
+  binary.  This field is only for information purposes and does not affect the
+  compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not
+  fatal, and deflate() can be called again with more input and more output
+  space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  If next_in is not Z_NULL and avail_in is large enough (the
+   exact value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit() does not process any header information -- that is deferred
+   until inflate() is called.
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing will
+    resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all the uncompressed data.  (The size
+  of the uncompressed data may have been saved by the compressor for this
+  purpose.) The next operation on this stream must be inflateEnd to deallocate
+  the decompression state.  The use of Z_FINISH is never required, but can be
+  used to inform inflate that a faster approach may be used for the single
+  inflate() call.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the only effect of the flush parameter in this implementation
+  is on the return value of inflate(), as noted below, or when it returns early
+  because Z_BLOCK or Z_TREES is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the adler32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained, so applications that need that information should
+  instead use raw inflate, see inflateInit2() below, or inflateBack() and
+  perform their own processing of the gzip header and trailer.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent.  In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options.  The
+   fields next_in, zalloc, zfree and opaque must be initialized before by the
+   caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute an adler32 check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to 255 (unknown).  If a
+   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any call
+   of deflate.  The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   adler32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort).  deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.  The
+   stream will keep the same compression level and any other attributes that
+   may have been set by deflateInit2.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression level is changed, the input available so far is
+   compressed with the old level (and may be flushed); the new level will take
+   effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to be
+   compressed and flushed.  In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
+   strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called
+   immediately after inflateInit2() or inflateReset() and before any call of
+   inflate() to set the dictionary.  The application must insure that the
+   dictionary that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect adler32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+     Skips invalid compressed data until a full flush point (see above the
+   description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+   if no more input was provided, Z_DATA_ERROR if no flush point has been
+   found, or Z_STREAM_ERROR if the stream structure was inconsistent.  In the
+   success case, the application may save the current current value of total_in
+   which indicates where valid compressed data was found.  In the error case,
+   the application may repeatedly call inflateSync, providing more input each
+   time, until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
+                                      int windowBits));
+/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+   that this function is used to start inflating at a bit position in the
+   middle of a byte.  The provided bits will be used before any bytes are used
+   from next_in.  This function should only be used with raw inflate, and
+   should be used before the first inflate() call after inflateInit2() or
+   inflateReset().  bits must be less than or equal to 16, and that many of the
+   least significant bits of value will be inserted in the input.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above or -1 << 16 if the provided
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When any
+   of extra, name, or comment are not Z_NULL and the respective field is not
+   present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the paramaters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is more efficient than inflate() for
+   file i/o applications in that it avoids copying between the output and the
+   sliding window by simply making the window itself the output buffer.  This
+   function trusts the application to not change the output buffer passed by
+   the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the normal
+   behavior of inflate(), which expects either a zlib or gzip header and
+   trailer around the deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero--buf is ignored in that
+   case--and inflateBack() will return a buffer error.  inflateBack() will call
+   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
+   should return zero on success, or non-zero on failure.  If out() returns
+   non-zero, inflateBack() will return with an error.  Neither in() nor out()
+   are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.) Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer.  The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer.  Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data.  (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit, destLen
+   is the actual size of the uncompressed buffer.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+                        /* gzip file access functions */
+
+/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+typedef voidp gzFile;       /* opaque gzip file descriptor */
+
+/*
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
+   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
+   for fixed code compression as in "wb9F".  (See the description of
+   deflateInit2 for more information about the strategy parameter.) Also "a"
+   can be used instead of "w" to request that the gzip stream that will be
+   written be appended to the file.  "+" will result in an error, since reading
+   and writing to the same gzip file is not supported.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened.
+*/
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
+   are obtained from calls like open, dup, creat, pipe or fileno (if the file
+   has been previously opened with fopen).  The mode parameter is as in gzopen.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+/*
+     Set the internal buffer size used by this library's functions.  The
+   default buffer size is 8192 bytes.  This function must be called after
+   gzopen() or gzdopen(), and before any other calls that read or write the
+   file.  The buffer memory allocation is always deferred to the first read or
+   write.  Two buffers are allocated, either both of the specified size when
+   writing, or one of the specified size and the other twice that size when
+   reading.  A larger buffer size of, for example, 64K or 128K bytes will
+   noticeably increase the speed of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy.  See the description
+   of deflateInit2 for the meaning of these parameters.
+
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.  If
+   the input file was not in gzip format, gzread copies the given number of
+   bytes into the buffer.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream, or failing that, reading the rest
+   of the input file directly without decompression.  The entire input file
+   will be read if gzread is called until it returns less than the requested
+   len.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.
+*/
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+                                voidpc buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes written or 0 in case of
+   error.
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the arguments to the compressed file under
+   control of the format string, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or 0 in case of error.  The number of
+   uncompressed bytes written is limited to 8191, or one less than the buffer
+   size given to gzbuffer().  The caller should assure that this limit is not
+   exceeded.  If it is exceeded, then gzprintf() will return an error (0) with
+   nothing written.  In this case, there may also be a buffer overflow with
+   unpredictable consequences, which is possible only if zlib was compiled with
+   the insecure functions sprintf() or vsprintf() because the secure snprintf()
+   or vsnprintf() functions were not available.  This can be determined using
+   zlibCompileFlags().
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+     Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+     Reads bytes from the compressed file until len-1 characters are read, or a
+   newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  If any characters are read or if len == 1, the
+   string is terminated with a null character.  If no characters are read due
+   to an end-of-file or len < 1, then the buffer is left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error.  If there was an error, the contents at
+   buf are indeterminate.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+     Writes c, converted to an unsigned char, into the compressed file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+     Push one character back onto the stream to be read as the first character
+   on the next read.  At least one character of push-back is allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file.  The parameter flush
+   is as in the deflate() function.  The return value is the zlib error number
+   (see function gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatented gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                   z_off_t offset, int whence));
+
+     Sets the starting position for the next gzread or gzwrite on the given
+   compressed file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+     Returns the starting position for the next gzread or gzwrite on the given
+   compressed file.  This position represents a number of bytes in the
+   uncompressed data stream, and is zero when starting, even if appending or
+   reading a gzip stream from the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+     Returns the current offset in the file being read or written.  This offset
+   includes the count of bytes that precede the gzip stream, for example when
+   appending or when using gzdopen() for reading.  When reading, the offset
+   does not include as yet unused buffered input.  This information can be used
+   for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns true (1) if the end-of-file indicator has been set while reading,
+   false (0) otherwise.  Note that the end-of-file indicator is set only if the
+   read tried to go past the end of the input, but came up short.  Therefore,
+   just like feof(), gzeof() may return false even if there is no more data to
+   read, in the event that the last read request was for the exact number of
+   bytes remaining in the input file.  This will happen if the input file size
+   is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Returns true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.  This state can change from
+   false to true while reading the input file if the end of a gzip stream is
+   reached, but is followed by data that is not another gzip stream.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file and
+   deallocates the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, or Z_OK on success.
+*/
+
+ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the given
+   compressed file.  errnum is set to zlib error number.  If an error occurred
+   in the file system and not in the compression library, errnum is set to
+   Z_ERRNO and the application may consult errno to get the exact error code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clears the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum.  If buf is Z_NULL, this function returns the
+   required initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32.  If buf is Z_NULL, this function returns the required
+   initial value for the for the crc.  Pre- and post-conditioning (one's
+   complement) is performed within this function so it shouldn't be done by the
+   application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+        inflateBackInit_((strm), (windowBits), (window), \
+                                            ZLIB_VERSION, sizeof(z_stream))
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+#endif
+
+#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0
+#  define gzopen gzopen64
+#  define gzseek gzseek64
+#  define gztell gztell64
+#  define gzoffset gzoffset64
+#  define adler32_combine adler32_combine64
+#  define crc32_combine crc32_combine64
+#  ifdef _LARGEFILE64_SOURCE
+     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#  endif
+#else
+   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif
+
+/* hack for buggy compilers */
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;};
+#endif
+
+/* undocumented functions */
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/heimdall-frontend/lib/win32/zlib.lib b/heimdall-frontend/lib/win32/zlib.lib
new file mode 100755
index 0000000..9da4aeb
--- /dev/null
+++ b/heimdall-frontend/lib/win32/zlib.lib
diff --git a/heimdall-frontend/mainwindow.ui b/heimdall-frontend/mainwindow.ui
index 300be65..6165b8d 100644
--- a/heimdall-frontend/mainwindow.ui
+++ b/heimdall-frontend/mainwindow.ui
@@ -6,8 +6,8 @@
    <rect>

     <x>0</x>

     <y>0</y>

-    <width>902</width>

-    <height>523</height>

+    <width>788</width>

+    <height>505</height>

    </rect>

   </property>

   <property name="sizePolicy">

@@ -18,18 +18,18 @@
   </property>

   <property name="minimumSize">

    <size>

-    <width>902</width>

-    <height>523</height>

+    <width>788</width>

+    <height>505</height>

    </size>

   </property>

   <property name="maximumSize">

    <size>

-    <width>902</width>

-    <height>523</height>

+    <width>788</width>

+    <height>505</height>

    </size>

   </property>

   <property name="windowTitle">

-   <string notr="true">Heimdall Frontend 1.1</string>

+   <string notr="true">Heimdall Frontend</string>

   </property>

   <property name="toolTip">

    <string notr="true"/>

@@ -65,12 +65,15 @@
     </font>

    </property>

    <widget class="QTabWidget" name="functionTabWidget">

+    <property name="enabled">

+     <bool>true</bool>

+    </property>

     <property name="geometry">

      <rect>

-      <x>10</x>

+      <x>5</x>

       <y>0</y>

-      <width>881</width>

-      <height>491</height>

+      <width>780</width>

+      <height>481</height>

      </rect>

     </property>

     <property name="sizePolicy">

@@ -79,161 +82,416 @@
       <verstretch>0</verstretch>

      </sizepolicy>

     </property>

+    <property name="minimumSize">

+     <size>

+      <width>780</width>

+      <height>0</height>

+     </size>

+    </property>

+    <property name="maximumSize">

+     <size>

+      <width>780</width>

+      <height>780</height>

+     </size>

+    </property>

     <property name="currentIndex">

      <number>0</number>

     </property>

+    <property name="usesScrollButtons">

+     <bool>false</bool>

+    </property>

+    <widget class="QWidget" name="loadPackageTab">

+     <attribute name="title">

+      <string>Load Package</string>

+     </attribute>

+     <widget class="QGroupBox" name="includedFilesGroup">

+      <property name="geometry">

+       <rect>

+        <x>510</x>

+        <y>20</y>

+        <width>251</width>

+        <height>341</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Included Files</string>

+      </property>

+      <widget class="QListWidget" name="includedFilesListWidget">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>231</width>

+         <height>311</height>

+        </rect>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="platformGroup">

+      <property name="geometry">

+       <rect>

+        <x>350</x>

+        <y>80</y>

+        <width>151</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Platform</string>

+      </property>

+      <widget class="QLineEdit" name="platformLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>131</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="supportedDevicesGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>220</y>

+        <width>491</width>

+        <height>231</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Supported Devices</string>

+      </property>

+      <widget class="QListWidget" name="supportedDevicesListWidget">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>471</width>

+         <height>201</height>

+        </rect>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QRadioButton" name="repartitionRadioButton">

+      <property name="enabled">

+       <bool>false</bool>

+      </property>

+      <property name="geometry">

+       <rect>

+        <x>520</x>

+        <y>370</y>

+        <width>241</width>

+        <height>21</height>

+       </rect>

+      </property>

+      <property name="text">

+       <string>Repartition Recommended</string>

+      </property>

+     </widget>

+     <widget class="QPushButton" name="loadFirmwareButton">

+      <property name="enabled">

+       <bool>false</bool>

+      </property>

+      <property name="geometry">

+       <rect>

+        <x>580</x>

+        <y>410</y>

+        <width>121</width>

+        <height>31</height>

+       </rect>

+      </property>

+      <property name="text">

+       <string>Load / Customise</string>

+      </property>

+     </widget>

+     <widget class="QGroupBox" name="firmwareNameGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>80</y>

+        <width>221</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Firmware Name</string>

+      </property>

+      <widget class="QLineEdit" name="firmwareNameLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>201</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="firmwarePackageGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>10</y>

+        <width>491</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Heimdall Firmware Package</string>

+      </property>

+      <widget class="QLineEdit" name="firmwarePackageLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>391</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+      <widget class="QPushButton" name="browseFirmwarePackageButton">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>410</x>

+         <y>20</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Browse</string>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="versionGroup">

+      <property name="geometry">

+       <rect>

+        <x>240</x>

+        <y>80</y>

+        <width>101</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Version</string>

+      </property>

+      <widget class="QLineEdit" name="versionLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>81</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="developerGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>150</y>

+        <width>491</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Developer(s)</string>

+      </property>

+      <widget class="QLineEdit" name="developerNamesLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>311</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+      <widget class="QPushButton" name="developerDonateButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>410</x>

+         <y>20</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Donate</string>

+       </property>

+      </widget>

+      <widget class="QPushButton" name="developerHomepageButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>330</x>

+         <y>20</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Homepage</string>

+       </property>

+      </widget>

+     </widget>

+    </widget>

     <widget class="QWidget" name="flashTab">

      <attribute name="title">

       <string>Flash</string>

      </attribute>

-     <widget class="QGroupBox" name="pdaGroupBox">

+     <widget class="QGroupBox" name="statusGroup">

       <property name="geometry">

        <rect>

         <x>10</x>

-        <y>120</y>

-        <width>421</width>

-        <height>331</height>

+        <y>290</y>

+        <width>751</width>

+        <height>161</height>

        </rect>

       </property>

       <property name="title">

-       <string>PDA/Code</string>

+       <string>Status</string>

       </property>

-      <widget class="QGroupBox" name="factoryfsGroupBox">

+      <widget class="QProgressBar" name="flashProgressBar">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>320</x>

+         <y>120</y>

+         <width>311</width>

+         <height>31</height>

+        </rect>

+       </property>

+       <property name="value">

+        <number>0</number>

+       </property>

+      </widget>

+      <widget class="QPlainTextEdit" name="outputPlainTextEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>61</height>

+         <width>731</width>

+         <height>91</height>

         </rect>

        </property>

-       <property name="title">

-        <string>FactoryFS</string>

-       </property>

-       <widget class="QLineEdit" name="factoryfsLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="factoryfsBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="factoryfsCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

-      <widget class="QGroupBox" name="kernelGroupBox">

+      <widget class="QLabel" name="flashLabel">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>80</y>

-         <width>401</width>

-         <height>61</height>

+         <y>120</y>

+         <width>301</width>

+         <height>21</height>

         </rect>

        </property>

-       <property name="title">

-        <string>Kernel (zImage)</string>

+       <property name="layoutDirection">

+        <enum>Qt::RightToLeft</enum>

+       </property>

+       <property name="text">

+        <string notr="true">Ready</string>

+       </property>

+       <property name="textFormat">

+        <enum>Qt::PlainText</enum>

+       </property>

+       <property name="alignment">

+        <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>

        </property>

-       <widget class="QLineEdit" name="kernelLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="kernelBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="kernelCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

-      <widget class="QGroupBox" name="primaryBootGroupBox">

+      <widget class="QPushButton" name="startFlashButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>640</x>

+         <y>120</y>

+         <width>91</width>

+         <height>31</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Start</string>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="optionsGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>10</y>

+        <width>751</width>

+        <height>271</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Options</string>

+      </property>

+      <widget class="QGroupBox" name="pitGroup">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>200</y>

-         <width>401</width>

-         <height>61</height>

+         <y>20</y>

+         <width>381</width>

+         <height>91</height>

         </rect>

        </property>

        <property name="title">

-        <string>Primary Bootloader</string>

+        <string>PIT</string>

        </property>

-       <widget class="QLineEdit" name="primaryBootLineEdit">

+       <widget class="QLineEdit" name="pitLineEdit">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>30</x>

-          <y>30</y>

+          <x>10</x>

+          <y>50</y>

           <width>281</width>

           <height>21</height>

          </rect>

@@ -242,11 +500,14 @@
          <bool>true</bool>

         </property>

        </widget>

-       <widget class="QPushButton" name="primaryBootBrowseButton">

+       <widget class="QPushButton" name="pitBrowseButton">

+        <property name="enabled">

+         <bool>true</bool>

+        </property>

         <property name="geometry">

          <rect>

-          <x>320</x>

-          <y>30</y>

+          <x>300</x>

+          <y>50</y>

           <width>71</width>

           <height>23</height>

          </rect>

@@ -255,573 +516,647 @@
          <string>Browse</string>

         </property>

        </widget>

-       <widget class="QCheckBox" name="primaryBootCheckBox">

+       <widget class="QCheckBox" name="repartitionCheckBox">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

           <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

+          <y>20</y>

+          <width>91</width>

+          <height>17</height>

          </rect>

         </property>

         <property name="text">

-         <string/>

+         <string>Repartition</string>

         </property>

        </widget>

       </widget>

-      <widget class="QGroupBox" name="secondaryBootGroupBox">

+      <widget class="QPushButton" name="removePartitionButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>670</x>

+         <y>230</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Remove</string>

+       </property>

+      </widget>

+      <widget class="QGroupBox" name="partitionGroup">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>260</y>

-         <width>401</width>

-         <height>61</height>

+         <y>120</y>

+         <width>381</width>

+         <height>141</height>

         </rect>

        </property>

        <property name="title">

-        <string>Secondary Bootloader</string>

+        <string>File / Partition</string>

        </property>

-       <widget class="QLineEdit" name="secondaryBootLineEdit">

+       <widget class="QComboBox" name="partitionNameComboBox">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

+          <x>110</x>

+          <y>20</y>

+          <width>261</width>

+          <height>22</height>

          </rect>

         </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

        </widget>

-       <widget class="QPushButton" name="secondaryBootBrowseButton">

+       <widget class="QLabel" name="partitionNameLabel">

         <property name="geometry">

          <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

+          <x>10</x>

+          <y>20</y>

+          <width>91</width>

+          <height>16</height>

          </rect>

         </property>

         <property name="text">

-         <string>Browse</string>

+         <string>Partition Name</string>

         </property>

        </widget>

-       <widget class="QCheckBox" name="secondaryBootCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

+       <widget class="QLabel" name="partitionIdLabel">

         <property name="geometry">

          <rect>

           <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

+          <y>50</y>

+          <width>91</width>

+          <height>16</height>

          </rect>

         </property>

         <property name="text">

-         <string/>

+         <string>Partition ID</string>

         </property>

        </widget>

-      </widget>

-      <widget class="QGroupBox" name="paramGroupBox">

-       <property name="geometry">

-        <rect>

-         <x>10</x>

-         <y>140</y>

-         <width>401</width>

-         <height>61</height>

-        </rect>

-       </property>

-       <property name="title">

-        <string>Param.lfs</string>

-       </property>

-       <widget class="QLineEdit" name="paramLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="paramBrowseButton">

+       <widget class="QGroupBox" name="partitionFileGroup">

         <property name="geometry">

          <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

+          <x>10</x>

+          <y>80</y>

+          <width>361</width>

+          <height>51</height>

          </rect>

         </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

+        <property name="title">

+         <string>File</string>

+        </property>

+        <widget class="QLineEdit" name="partitionFileLineEdit">

+         <property name="enabled">

+          <bool>false</bool>

+         </property>

+         <property name="geometry">

+          <rect>

+           <x>10</x>

+           <y>20</y>

+           <width>261</width>

+           <height>21</height>

+          </rect>

+         </property>

+         <property name="readOnly">

+          <bool>true</bool>

+         </property>

+        </widget>

+        <widget class="QPushButton" name="partitionFileBrowseButton">

+         <property name="enabled">

+          <bool>false</bool>

+         </property>

+         <property name="geometry">

+          <rect>

+           <x>280</x>

+           <y>20</y>

+           <width>71</width>

+           <height>23</height>

+          </rect>

+         </property>

+         <property name="text">

+          <string>Browse</string>

+         </property>

+        </widget>

        </widget>

-       <widget class="QCheckBox" name="paramCheckBox">

+       <widget class="QLineEdit" name="partitionIdLineEdit">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

+          <x>110</x>

+          <y>50</y>

+          <width>261</width>

           <height>21</height>

          </rect>

         </property>

-        <property name="text">

-         <string/>

+        <property name="readOnly">

+         <bool>true</bool>

         </property>

        </widget>

       </widget>

+      <widget class="QPushButton" name="addPartitionButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>400</x>

+         <y>230</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Add</string>

+       </property>

+      </widget>

+      <widget class="QListWidget" name="partitionsListWidget">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>400</x>

+         <y>20</y>

+         <width>341</width>

+         <height>201</height>

+        </rect>

+       </property>

+      </widget>

      </widget>

-     <widget class="QGroupBox" name="cscGroupBox">

+    </widget>

+    <widget class="QWidget" name="createPackageTab">

+     <property name="enabled">

+      <bool>true</bool>

+     </property>

+     <attribute name="title">

+      <string>Create Package</string>

+     </attribute>

+     <widget class="QGroupBox" name="createSupportedDevicesGroup">

       <property name="geometry">

        <rect>

-        <x>440</x>

-        <y>10</y>

-        <width>421</width>

-        <height>151</height>

+        <x>0</x>

+        <y>230</y>

+        <width>491</width>

+        <height>221</height>

        </rect>

       </property>

       <property name="title">

-       <string>CSC</string>

+       <string>Supported Devices</string>

       </property>

-      <widget class="QGroupBox" name="cacheGroupBox">

+      <widget class="QListWidget" name="createDevicesListWidget">

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>61</height>

+         <width>471</width>

+         <height>151</height>

         </rect>

        </property>

-       <property name="title">

-        <string>Cache</string>

-       </property>

-       <widget class="QLineEdit" name="cacheLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="cacheBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="cacheCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

-      <widget class="QGroupBox" name="databaseGroupBox">

+      <widget class="QPushButton" name="removeDeviceButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

        <property name="geometry">

         <rect>

-         <x>10</x>

-         <y>80</y>

-         <width>401</width>

-         <height>61</height>

+         <x>380</x>

+         <y>180</y>

+         <width>101</width>

+         <height>23</height>

         </rect>

        </property>

-       <property name="title">

-        <string>Database Data</string>

+       <property name="text">

+        <string>Remove Device</string>

        </property>

-       <widget class="QLineEdit" name="databaseLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="databaseBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="databaseCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

      </widget>

-     <widget class="QGroupBox" name="repartitionGroupBox">

+     <widget class="QGroupBox" name="createFirmwareVersionGroup">

       <property name="geometry">

        <rect>

-        <x>10</x>

+        <x>240</x>

         <y>10</y>

-        <width>421</width>

-        <height>111</height>

+        <width>111</width>

+        <height>61</height>

        </rect>

       </property>

       <property name="title">

-       <string>Repartition</string>

+       <string>Firmware Version</string>

       </property>

-      <widget class="QGroupBox" name="pitGroupBox">

+      <widget class="QLineEdit" name="createFirmwareVersionLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>81</height>

+         <width>91</width>

+         <height>21</height>

         </rect>

        </property>

-       <property name="title">

-        <string>PIT</string>

+       <property name="readOnly">

+        <bool>false</bool>

        </property>

-       <widget class="QLineEdit" name="pitLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>50</y>

-          <width>301</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="pitBrowseButton">

-        <property name="enabled">

-         <bool>true</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>50</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="repartitionCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>20</y>

-          <width>381</width>

-          <height>17</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Repartition Device</string>

-        </property>

-       </widget>

       </widget>

      </widget>

-     <widget class="QPushButton" name="startFlashButton">

-      <property name="enabled">

-       <bool>false</bool>

-      </property>

+     <widget class="QGroupBox" name="createPlatformNameGroup">

       <property name="geometry">

        <rect>

-        <x>780</x>

-        <y>410</y>

-        <width>91</width>

-        <height>31</height>

+        <x>490</x>

+        <y>10</y>

+        <width>151</width>

+        <height>61</height>

        </rect>

       </property>

-      <property name="text">

-       <string>Start</string>

+      <property name="title">

+       <string>Platform Name</string>

       </property>

+      <widget class="QLineEdit" name="createPlatformNameLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>131</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

+      </widget>

      </widget>

-     <widget class="QProgressBar" name="flashProgressBar">

-      <property name="enabled">

-       <bool>false</bool>

-      </property>

+     <widget class="QGroupBox" name="createFirmwareNameGroup">

       <property name="geometry">

        <rect>

-        <x>460</x>

-        <y>410</y>

-        <width>311</width>

-        <height>31</height>

+        <x>10</x>

+        <y>10</y>

+        <width>221</width>

+        <height>61</height>

        </rect>

       </property>

-      <property name="value">

-       <number>0</number>

+      <property name="title">

+       <string>Firmware Name</string>

       </property>

+      <widget class="QLineEdit" name="createFirmwareNameLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>201</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

+      </widget>

      </widget>

-     <widget class="QGroupBox" name="otherGroupBox">

+     <widget class="QGroupBox" name="createDevelopersGroup">

       <property name="geometry">

        <rect>

-        <x>440</x>

-        <y>160</y>

-        <width>421</width>

-        <height>151</height>

+        <x>10</x>

+        <y>80</y>

+        <width>751</width>

+        <height>141</height>

        </rect>

       </property>

-      <property name="font">

-       <font>

-        <family>MS Shell Dlg 2</family>

-       </font>

-      </property>

       <property name="title">

-       <string>Other</string>

+       <string>Developers</string>

       </property>

-      <widget class="QGroupBox" name="recoveryGroupBox">

+      <widget class="QListWidget" name="createDevelopersListWidget">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

        <property name="geometry">

         <rect>

-         <x>10</x>

-         <y>80</y>

-         <width>401</width>

-         <height>61</height>

+         <x>550</x>

+         <y>20</y>

+         <width>191</width>

+         <height>81</height>

+        </rect>

+       </property>

+      </widget>

+      <widget class="QGroupBox" name="createDeveloperInfoGroup">

+       <property name="geometry">

+        <rect>

+         <x>300</x>

+         <y>20</y>

+         <width>241</width>

+         <height>101</height>

         </rect>

        </property>

        <property name="title">

-        <string>Recovery</string>

+        <string>Developer Info</string>

        </property>

-       <widget class="QLineEdit" name="recoveryLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

+       <widget class="QLabel" name="createDeveloperNameLabel">

         <property name="geometry">

          <rect>

-          <x>30</x>

+          <x>10</x>

           <y>30</y>

-          <width>281</width>

-          <height>21</height>

+          <width>41</width>

+          <height>16</height>

          </rect>

         </property>

-        <property name="readOnly">

-         <bool>true</bool>

+        <property name="text">

+         <string>Name</string>

         </property>

        </widget>

-       <widget class="QPushButton" name="recoveryBrowseButton">

+       <widget class="QLineEdit" name="createDeveloperNameLineEdit">

+        <property name="enabled">

+         <bool>true</bool>

+        </property>

         <property name="geometry">

          <rect>

-          <x>320</x>

+          <x>60</x>

           <y>30</y>

-          <width>71</width>

-          <height>23</height>

+          <width>171</width>

+          <height>21</height>

          </rect>

         </property>

-        <property name="text">

-         <string>Browse</string>

+        <property name="readOnly">

+         <bool>false</bool>

         </property>

        </widget>

-       <widget class="QCheckBox" name="recoveryCheckBox">

+       <widget class="QPushButton" name="addDeveloperButton">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

+          <x>140</x>

+          <y>60</y>

+          <width>91</width>

+          <height>23</height>

          </rect>

         </property>

         <property name="text">

-         <string/>

+         <string>Add Developer</string>

         </property>

        </widget>

       </widget>

-      <widget class="QGroupBox" name="modemGroupBox">

+      <widget class="QPushButton" name="removeDeveloperButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>630</x>

+         <y>110</y>

+         <width>111</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Remove Developer</string>

+       </property>

+      </widget>

+      <widget class="QGroupBox" name="createUrlsGroup">

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>61</height>

+         <width>281</width>

+         <height>101</height>

         </rect>

        </property>

        <property name="title">

-        <string>Modem</string>

+        <string>URLs (Optional)</string>

        </property>

-       <widget class="QLineEdit" name="modemLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

+       <widget class="QLabel" name="createDonateLabel">

         <property name="geometry">

          <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

+          <x>10</x>

+          <y>60</y>

+          <width>71</width>

+          <height>16</height>

          </rect>

         </property>

-        <property name="readOnly">

-         <bool>true</bool>

+        <property name="text">

+         <string>Donate</string>

         </property>

        </widget>

-       <widget class="QPushButton" name="modemBrowseButton">

+       <widget class="QLabel" name="createHomepageLabel">

         <property name="geometry">

          <rect>

-          <x>320</x>

+          <x>10</x>

           <y>30</y>

           <width>71</width>

-          <height>23</height>

+          <height>16</height>

          </rect>

         </property>

         <property name="text">

-         <string>Browse</string>

+         <string>Homepage</string>

         </property>

        </widget>

-       <widget class="QCheckBox" name="modemCheckBox">

+       <widget class="QLineEdit" name="createHomepageLineEdit">

         <property name="enabled">

-         <bool>false</bool>

+         <bool>true</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>10</x>

+          <x>90</x>

           <y>30</y>

-          <width>21</width>

+          <width>181</width>

           <height>21</height>

          </rect>

         </property>

-        <property name="text">

-         <string/>

+        <property name="readOnly">

+         <bool>false</bool>

+        </property>

+       </widget>

+       <widget class="QLineEdit" name="createDonateLineEdit">

+        <property name="enabled">

+         <bool>true</bool>

+        </property>

+        <property name="geometry">

+         <rect>

+          <x>90</x>

+          <y>60</y>

+          <width>181</width>

+          <height>21</height>

+         </rect>

+        </property>

+        <property name="readOnly">

+         <bool>false</bool>

         </property>

        </widget>

       </widget>

      </widget>

-     <widget class="QLabel" name="flashLabel">

+     <widget class="QGroupBox" name="createPlatformVersionGroup">

       <property name="geometry">

        <rect>

-        <x>460</x>

-        <y>380</y>

-        <width>411</width>

-        <height>21</height>

+        <x>650</x>

+        <y>10</y>

+        <width>111</width>

+        <height>61</height>

        </rect>

       </property>

-      <property name="text">

-       <string notr="true">Ready</string>

-      </property>

-      <property name="textFormat">

-       <enum>Qt::PlainText</enum>

-      </property>

-      <property name="alignment">

-       <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>

+      <property name="title">

+       <string>Platform Version</string>

       </property>

+      <widget class="QLineEdit" name="createPlatformVersionLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>91</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

+      </widget>

      </widget>

-    </widget>

-    <widget class="QWidget" name="firmwareTab">

-     <attribute name="title">

-      <string>Download Firmware</string>

-     </attribute>

-     <widget class="QGroupBox" name="groupBox_2">

+     <widget class="QGroupBox" name="createDeviceInfoGroup">

       <property name="geometry">

        <rect>

-        <x>10</x>

-        <y>10</y>

-        <width>851</width>

-        <height>441</height>

+        <x>500</x>

+        <y>250</y>

+        <width>271</width>

+        <height>151</height>

        </rect>

       </property>

       <property name="title">

-       <string/>

+       <string>Device Info</string>

       </property>

-      <widget class="QLabel" name="label">

+      <widget class="QLabel" name="deviceNameLabel">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>10</y>

-         <width>831</width>

-         <height>391</height>

+         <y>50</y>

+         <width>91</width>

+         <height>16</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Name</string>

+       </property>

+      </widget>

+      <widget class="QLineEdit" name="deviceNameLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>110</x>

+         <y>50</y>

+         <width>151</width>

+         <height>21</height>

         </rect>

        </property>

-       <property name="frameShape">

-        <enum>QFrame::NoFrame</enum>

+       <property name="readOnly">

+        <bool>false</bool>

        </property>

-       <property name="frameShadow">

-        <enum>QFrame::Plain</enum>

+      </widget>

+      <widget class="QLabel" name="deviceManufacturerLabel">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>91</width>

+         <height>16</height>

+        </rect>

        </property>

        <property name="text">

-        <string>This functionality is still under development and will be included in a future release.</string>

+        <string>Manufacturer</string>

        </property>

-       <property name="textFormat">

-        <enum>Qt::PlainText</enum>

+      </widget>

+      <widget class="QLineEdit" name="deviceManufacturerLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

        </property>

-       <property name="alignment">

-        <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>

+       <property name="geometry">

+        <rect>

+         <x>110</x>

+         <y>20</y>

+         <width>151</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

        </property>

-       <property name="wordWrap">

+      </widget>

+      <widget class="QLabel" name="productCodeLabel">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>80</y>

+         <width>91</width>

+         <height>16</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Product Code</string>

+       </property>

+      </widget>

+      <widget class="QLineEdit" name="deviceProductCodeLineEdit">

+       <property name="enabled">

         <bool>true</bool>

        </property>

+       <property name="geometry">

+        <rect>

+         <x>110</x>

+         <y>80</y>

+         <width>151</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

       </widget>

+      <widget class="QPushButton" name="addDeviceButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>160</x>

+         <y>110</y>

+         <width>101</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Add Device</string>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QPushButton" name="buildPackageButton">

+      <property name="enabled">

+       <bool>false</bool>

+      </property>

+      <property name="geometry">

+       <rect>

+        <x>580</x>

+        <y>410</y>

+        <width>121</width>

+        <height>31</height>

+       </rect>

+      </property>

+      <property name="text">

+       <string>Build</string>

+      </property>

      </widget>

     </widget>

    </widget>

@@ -831,7 +1166,7 @@
     <rect>

      <x>0</x>

      <y>0</y>

-     <width>902</width>

+     <width>788</width>

      <height>21</height>

     </rect>

    </property>

@@ -865,8 +1200,57 @@
     <string>Donate to Glass Echidna</string>

    </property>

   </action>

+  <action name="actionPackage_Creation">

+   <property name="text">

+    <string>Package Creation</string>

+   </property>

+  </action>

  </widget>

  <layoutdefault spacing="6" margin="11"/>

+ <tabstops>

+  <tabstop>functionTabWidget</tabstop>

+  <tabstop>firmwarePackageLineEdit</tabstop>

+  <tabstop>browseFirmwarePackageButton</tabstop>

+  <tabstop>firmwareNameLineEdit</tabstop>

+  <tabstop>versionLineEdit</tabstop>

+  <tabstop>platformLineEdit</tabstop>

+  <tabstop>developerNamesLineEdit</tabstop>

+  <tabstop>developerHomepageButton</tabstop>

+  <tabstop>developerDonateButton</tabstop>

+  <tabstop>supportedDevicesListWidget</tabstop>

+  <tabstop>includedFilesListWidget</tabstop>

+  <tabstop>repartitionRadioButton</tabstop>

+  <tabstop>loadFirmwareButton</tabstop>

+  <tabstop>repartitionCheckBox</tabstop>

+  <tabstop>pitLineEdit</tabstop>

+  <tabstop>pitBrowseButton</tabstop>

+  <tabstop>partitionNameComboBox</tabstop>

+  <tabstop>partitionIdLineEdit</tabstop>

+  <tabstop>partitionFileLineEdit</tabstop>

+  <tabstop>partitionFileBrowseButton</tabstop>

+  <tabstop>partitionsListWidget</tabstop>

+  <tabstop>addPartitionButton</tabstop>

+  <tabstop>removePartitionButton</tabstop>

+  <tabstop>outputPlainTextEdit</tabstop>

+  <tabstop>startFlashButton</tabstop>

+  <tabstop>createFirmwareNameLineEdit</tabstop>

+  <tabstop>createFirmwareVersionLineEdit</tabstop>

+  <tabstop>createPlatformNameLineEdit</tabstop>

+  <tabstop>createPlatformVersionLineEdit</tabstop>

+  <tabstop>createHomepageLineEdit</tabstop>

+  <tabstop>createDonateLineEdit</tabstop>

+  <tabstop>createDeveloperNameLineEdit</tabstop>

+  <tabstop>addDeveloperButton</tabstop>

+  <tabstop>createDevelopersListWidget</tabstop>

+  <tabstop>removeDeveloperButton</tabstop>

+  <tabstop>createDevicesListWidget</tabstop>

+  <tabstop>removeDeviceButton</tabstop>

+  <tabstop>deviceManufacturerLineEdit</tabstop>

+  <tabstop>deviceNameLineEdit</tabstop>

+  <tabstop>deviceProductCodeLineEdit</tabstop>

+  <tabstop>addDeviceButton</tabstop>

+  <tabstop>buildPackageButton</tabstop>

+ </tabstops>

  <resources/>

  <connections/>

 </ui>