Add author-abandoned basket application

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/basket@1072339 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 637 insertions, 0 deletions

diff --git a/src/archive.cpp b/src/archive.cpp
new file mode 100644
index 0000000..7365501
--- /dev/null
+++ b/src/archive.cpp
@@ -0,0 +1,637 @@
+/***************************************************************************
+ *   Copyright (C) 2006 by Sébastien Laoût                                 *
+ *   slaout@linux62.org                                                    *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
+ ***************************************************************************/
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qmap.h>
+#include <qdir.h>
+#include <ktar.h>
+#include <qdom.h>
+#include <kmessagebox.h>
+#include <qpixmap.h>
+#include <qpainter.h>
+#include <kstandarddirs.h>
+#include <kapplication.h>
+#include <kiconloader.h>
+#include <kprogress.h>
+#include <kmainwindow.h>
+
+#include "archive.h"
+#include "global.h"
+#include "bnpview.h"
+#include "basket.h"
+#include "basketlistview.h"
+#include "basketfactory.h"
+#include "tag.h"
+#include "xmlwork.h"
+#include "tools.h"
+#include "backgroundmanager.h"
+#include "formatimporter.h"
+
+#include <iostream>
+
+void Archive::save(Basket *basket, bool withSubBaskets, const QString &destination)
+{
+	QDir dir;
+
+	KProgressDialog dialog(0, 0, i18n("Save as Basket Archive"), i18n("Saving as basket archive. Please wait..."), /*Not modal, for password dialogs!*/false);
+	dialog.showCancelButton(false);
+	dialog.setAutoClose(true);
+	dialog.show();
+	KProgress *progress = dialog.progressBar();
+	progress->setTotalSteps(/*Preparation:*/1 + /*Finishing:*/1 + /*Basket:*/1 + /*SubBaskets:*/(withSubBaskets ? Global::bnpView->basketCount(Global::bnpView->listViewItemForBasket(basket)) : 0));
+	progress->setValue(0);
+
+	// Create the temporar folder:
+	QString tempFolder = Global::savesFolder() + "temp-archive/";
+	dir.mkdir(tempFolder);
+
+	// Create the temporar archive file:
+	QString tempDestination = tempFolder + "temp-archive.tar.gz";
+	KTar tar(tempDestination, "application/x-gzip");
+	tar.open(IO_WriteOnly);
+	tar.writeDir("baskets", "", "");
+
+	progress->advance(1); // Preparation finished
+	std::cout << "Preparation finished out of " << progress->totalSteps() << std::endl;
+
+	// Copy the baskets data into the archive:
+	QStringList backgrounds;
+	saveBasketToArchive(basket, withSubBaskets, &tar, backgrounds, tempFolder, progress);
+
+	// Create a Small baskets.xml Document:
+	QDomDocument document("basketTree");
+	QDomElement root = document.createElement("basketTree");
+	document.appendChild(root);
+	Global::bnpView->saveSubHierarchy(Global::bnpView->listViewItemForBasket(basket), document, root, withSubBaskets);
+	Basket::safelySaveToFile(tempFolder + "baskets.xml", "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + document.toString());
+	tar.addLocalFile(tempFolder + "baskets.xml", "baskets/baskets.xml");
+	dir.remove(tempFolder + "baskets.xml");
+
+	// Save a Small tags.xml Document:
+	QValueList<Tag*> tags;
+	listUsedTags(basket, withSubBaskets, tags);
+	Tag::saveTagsTo(tags, tempFolder + "tags.xml");
+	tar.addLocalFile(tempFolder + "tags.xml", "tags.xml");
+	dir.remove(tempFolder + "tags.xml");
+
+	// Save Tag Emblems (in case they are loaded on a computer that do not have those icons):
+	QString tempIconFile = tempFolder + "icon.png";
+	for (Tag::List::iterator it = tags.begin(); it != tags.end(); ++it) {
+		State::List states = (*it)->states();
+		for (State::List::iterator it2 = states.begin(); it2 != states.end(); ++it2) {
+			State *state = (*it2);
+			QPixmap icon = kapp->iconLoader()->loadIcon(state->emblem(), KIcon::Small, 16, KIcon::DefaultState, /*path_store=*/0L, /*canReturnNull=*/true);
+			if (!icon.isNull()) {
+				icon.save(tempIconFile, "PNG");
+				QString iconFileName = state->emblem().replace('/', '_');
+				tar.addLocalFile(tempIconFile, "tag-emblems/" + iconFileName);
+			}
+		}
+	}
+	dir.remove(tempIconFile);
+
+	// Finish Tar.Gz Exportation:
+	tar.close();
+
+	// Computing the File Preview:
+	Basket *previewBasket = basket; // FIXME: Use the first non-empty basket!
+	QPixmap previewPixmap(previewBasket->visibleWidth(), previewBasket->visibleHeight());
+	QPainter painter(&previewPixmap);
+	// Save old state, and make the look clean ("smile, you are filmed!"):
+	NoteSelection *selection = previewBasket->selectedNotes();
+	previewBasket->unselectAll();
+	Note *focusedNote = previewBasket->focusedNote();
+	previewBasket->setFocusedNote(0);
+	previewBasket->doHoverEffects(0, Note::None);
+	// Take the screenshot:
+	previewBasket->drawContents(&painter, 0, 0, previewPixmap.width(), previewPixmap.height());
+	// Go back to the old look:
+	previewBasket->selectSelection(selection);
+	previewBasket->setFocusedNote(focusedNote);
+	previewBasket->doHoverEffects();
+	// End and save our splandid painting:
+	painter.end();
+	QImage previewImage = previewPixmap.convertToImage();
+	const int PREVIEW_SIZE = 256;
+	previewImage = previewImage.scale(PREVIEW_SIZE, PREVIEW_SIZE, QImage::ScaleMin);
+	previewImage.save(tempFolder + "preview.png", "PNG");
+
+	// Finaly Save to the Real Destination file:
+	QFile file(destination);
+	if (file.open(IO_WriteOnly)) {
+		ulong previewSize = QFile(tempFolder + "preview.png").size();
+		ulong archiveSize = QFile(tempDestination).size();
+		QTextStream stream(&file);
+		stream.setEncoding(QTextStream::Latin1);
+		stream << "BasKetNP:archive\n"
+		       << "version:0.6.1\n"
+//		       << "read-compatible:0.6.1\n"
+//		       << "write-compatible:0.6.1\n"
+		       << "preview*:" << previewSize << "\n";
+		// Copy the Preview File:
+		const Q_ULONG BUFFER_SIZE = 1024;
+		char *buffer = new char[BUFFER_SIZE];
+		Q_LONG sizeRead;
+		QFile previewFile(tempFolder + "preview.png");
+		if (previewFile.open(IO_ReadOnly)) {
+			while ((sizeRead = previewFile.readBlock(buffer, BUFFER_SIZE)) > 0)
+				file.writeBlock(buffer, sizeRead);
+		}
+		stream << "archive*:" << archiveSize << "\n";
+		// Copy the Archive File:
+		QFile archiveFile(tempDestination);
+		if (archiveFile.open(IO_ReadOnly)) {
+			while ((sizeRead = archiveFile.readBlock(buffer, BUFFER_SIZE)) > 0)
+				file.writeBlock(buffer, sizeRead);
+		}
+		// Clean Up:
+		delete buffer;
+		buffer = 0;
+		file.close();
+	}
+
+	progress->advance(1); // Finishing finished
+	std::cout << "Finishing finished" << std::endl;
+
+	// Clean Up Everything:
+	dir.remove(tempFolder + "preview.png");
+	dir.remove(tempDestination);
+	dir.rmdir(tempFolder);
+}
+
+void Archive::saveBasketToArchive(Basket *basket, bool recursive, KTar *tar, QStringList &backgrounds, const QString &tempFolder, KProgress *progress)
+{
+	// Basket need to be loaded for tags exportation.
+	// We load it NOW so that the progress bar really reflect the state of the exportation:
+	if (!basket->isLoaded()) {
+		basket->load();
+	}
+
+	QDir dir;
+	// Save basket data:
+	tar->addLocalDirectory(basket->fullPath(), "baskets/" + basket->folderName());
+	tar->addLocalFile(basket->fullPath() + ".basket", "baskets/" + basket->folderName() + ".basket"); // The hidden files were not added
+	// Save basket icon:
+	QString tempIconFile = tempFolder + "icon.png";
+	if (!basket->icon().isEmpty() && basket->icon() != "basket") {
+		QPixmap icon = kapp->iconLoader()->loadIcon(basket->icon(), KIcon::Small, 16, KIcon::DefaultState, /*path_store=*/0L, /*canReturnNull=*/true);
+		if (!icon.isNull()) {
+			icon.save(tempIconFile, "PNG");
+			QString iconFileName = basket->icon().replace('/', '_');
+			tar->addLocalFile(tempIconFile, "basket-icons/" + iconFileName);
+		}
+	}
+	// Save basket backgorund image:
+	QString imageName = basket->backgroundImageName();
+	if (!basket->backgroundImageName().isEmpty() && !backgrounds.contains(imageName)) {
+		QString backgroundPath = Global::backgroundManager->pathForImageName(imageName);
+		if (!backgroundPath.isEmpty()) {
+			// Save the background image:
+			tar->addLocalFile(backgroundPath, "backgrounds/" + imageName);
+			// Save the preview image:
+			QString previewPath = Global::backgroundManager->previewPathForImageName(imageName);
+			if (!previewPath.isEmpty())
+				tar->addLocalFile(previewPath, "backgrounds/previews/" + imageName);
+			// Save the configuration file:
+			QString configPath = backgroundPath + ".config";
+			if (dir.exists(configPath))
+				tar->addLocalFile(configPath, "backgrounds/" + imageName + ".config");
+		}
+		backgrounds.append(imageName);
+	}
+
+	progress->advance(1); // Basket exportation finished
+	std::cout << basket->basketName() << " finished" << std::endl;
+
+	// Recursively save child baskets:
+	BasketListViewItem *item = Global::bnpView->listViewItemForBasket(basket);
+	if (recursive && item->firstChild()) {
+		for (BasketListViewItem *child = (BasketListViewItem*) item->firstChild(); child; child = (BasketListViewItem*) child->nextSibling()) {
+			saveBasketToArchive(child->basket(), recursive, tar, backgrounds, tempFolder, progress);
+		}
+	}
+}
+
+void Archive::listUsedTags(Basket *basket, bool recursive, QValueList<Tag*> &list)
+{
+	basket->listUsedTags(list);
+	BasketListViewItem *item = Global::bnpView->listViewItemForBasket(basket);
+	if (recursive && item->firstChild()) {
+		for (BasketListViewItem *child = (BasketListViewItem*) item->firstChild(); child; child = (BasketListViewItem*) child->nextSibling()) {
+			listUsedTags(child->basket(), recursive, list);
+		}
+	}
+}
+
+void Archive::open(const QString &path)
+{
+	// Create the temporar folder:
+	QString tempFolder = Global::savesFolder() + "temp-archive/";
+	QDir dir;
+	dir.mkdir(tempFolder);
+	const Q_ULONG BUFFER_SIZE = 1024;
+
+	QFile file(path);
+	if (file.open(IO_ReadOnly)) {
+		QTextStream stream(&file);
+		stream.setEncoding(QTextStream::Latin1);
+		QString line = stream.readLine();
+		if (line != "BasKetNP:archive") {
+			KMessageBox::error(0, i18n("This file is not a basket archive."), i18n("Basket Archive Error"));
+			file.close();
+			Tools::deleteRecursively(tempFolder);
+			return;
+		}
+		QString version;
+		QStringList readCompatibleVersions;
+		QStringList writeCompatibleVersions;
+		while (!stream.atEnd()) {
+			// Get Key/Value Pair From the Line to Read:
+			line = stream.readLine();
+			int index = line.find(':');
+			QString key;
+			QString value;
+			if (index >= 0) {
+				key = line.left(index);
+				value = line.right(line.length() - index - 1);
+			} else {
+				key = line;
+				value = "";
+			}
+			if (key == "version") {
+				version = value;
+			} else if (key == "read-compatible") {
+				readCompatibleVersions = QStringList::split(value, ";");
+			} else if (key == "write-compatible") {
+				writeCompatibleVersions = QStringList::split(value, ";");
+			} else if (key == "preview*") {
+				bool ok;
+				ulong size = value.toULong(&ok);
+				if (!ok) {
+					KMessageBox::error(0, i18n("This file is corrupted. It can not be opened."), i18n("Basket Archive Error"));
+					file.close();
+					Tools::deleteRecursively(tempFolder);
+					return;
+				}
+				// Get the preview file:
+//FIXME: We do not need the preview for now
+//				QFile previewFile(tempFolder + "preview.png");
+//				if (previewFile.open(IO_WriteOnly)) {
+					char *buffer = new char[BUFFER_SIZE];
+					Q_LONG sizeRead;
+					while ((sizeRead = file.readBlock(buffer, QMIN(BUFFER_SIZE, size))) > 0) {
+//						previewFile.writeBlock(buffer, sizeRead);
+						size -= sizeRead;
+					}
+//					previewFile.close();
+					delete buffer;
+//				}
+			} else if (key == "archive*") {
+				if (version != "0.6.1" && readCompatibleVersions.contains("0.6.1") && !writeCompatibleVersions.contains("0.6.1")) {
+					KMessageBox::information(
+						0,
+						i18n("This file was created with a recent version of %1. "
+						     "It can be opened but not every information will be available to you. "
+						     "For instance, some notes may be missing because they are of a type only available in new versions. "
+						     "When saving the file back, consider to save it to another file, to preserve the original one.")
+							.arg(kapp->aboutData()->programName()),
+						i18n("Basket Archive Error")
+					);
+				}
+				if (version != "0.6.1" && !readCompatibleVersions.contains("0.6.1") && !writeCompatibleVersions.contains("0.6.1")) {
+					KMessageBox::error(
+						0,
+						i18n("This file was created with a recent version of %1. Please upgrade to a newer version to be able to open that file.")
+							.arg(kapp->aboutData()->programName()),
+						i18n("Basket Archive Error")
+					);
+					file.close();
+					Tools::deleteRecursively(tempFolder);
+					return;
+				}
+
+				bool ok;
+				ulong size = value.toULong(&ok);
+				if (!ok) {
+					KMessageBox::error(0, i18n("This file is corrupted. It can not be opened."), i18n("Basket Archive Error"));
+					file.close();
+					Tools::deleteRecursively(tempFolder);
+					return;
+				}
+
+				Global::mainWindow()->raise();
+
+				// Get the archive file:
+				QString tempArchive = tempFolder + "temp-archive.tar.gz";
+				QFile archiveFile(tempArchive);
+				if (archiveFile.open(IO_WriteOnly)) {
+					char *buffer = new char[BUFFER_SIZE];
+					Q_LONG sizeRead;
+					while ((sizeRead = file.readBlock(buffer, QMIN(BUFFER_SIZE, size))) > 0) {
+						archiveFile.writeBlock(buffer, sizeRead);
+						size -= sizeRead;
+					}
+					archiveFile.close();
+					delete buffer;
+
+					// Extract the Archive:
+					QString extractionFolder = tempFolder + "extraction/";
+					QDir dir;
+					dir.mkdir(extractionFolder);
+					KTar tar(tempArchive, "application/x-gzip");
+					tar.open(IO_ReadOnly);
+					tar.directory()->copyTo(extractionFolder);
+					tar.close();
+
+					// Import the Tags:
+					importTagEmblems(extractionFolder); // Import and rename tag emblems BEFORE loading them!
+					QMap<QString, QString> mergedStates = Tag::loadTags(extractionFolder + "tags.xml");
+					QMap<QString, QString>::Iterator it;
+					if (mergedStates.count() > 0) {
+						Tag::saveTags();
+					}
+
+					// Import the Background Images:
+					importArchivedBackgroundImages(extractionFolder);
+
+					// Import the Baskets:
+					renameBasketFolders(extractionFolder, mergedStates);
+
+				}
+			} else if (key.endsWith("*")) {
+				// We do not know what it is, but we should read the embedded-file in order to discard it:
+				bool ok;
+				ulong size = value.toULong(&ok);
+				if (!ok) {
+					KMessageBox::error(0, i18n("This file is corrupted. It can not be opened."), i18n("Basket Archive Error"));
+					file.close();
+					Tools::deleteRecursively(tempFolder);
+					return;
+				}
+				// Get the archive file:
+				char *buffer = new char[BUFFER_SIZE];
+				Q_LONG sizeRead;
+				while ((sizeRead = file.readBlock(buffer, QMIN(BUFFER_SIZE, size))) > 0) {
+					size -= sizeRead;
+				}
+				delete buffer;
+			} else {
+				// We do not know what it is, and we do not care.
+			}
+			// Analyse the Value, if Understood:
+		}
+		file.close();
+	}
+	Tools::deleteRecursively(tempFolder);
+}
+
+/**
+ * When opening a basket archive that come from another computer,
+ * it can contains tags that use icons (emblems) that are not present on that computer.
+ * Fortunately, basket archives contains a copy of every used icons.
+ * This method check for every emblems and import the missing ones.
+ * It also modify the tags.xml copy for the emblems to point to the absolute path of the impported icons.
+ */
+void Archive::importTagEmblems(const QString &extractionFolder)
+{
+	QDomDocument *document = XMLWork::openFile("basketTags", extractionFolder + "tags.xml");
+	if (document == 0)
+		return;
+	QDomElement docElem = document->documentElement();
+
+	QDir dir;
+	dir.mkdir(Global::savesFolder() + "tag-emblems/");
+	FormatImporter copier; // Only used to copy files synchronously
+
+	QDomNode node = docElem.firstChild();
+	while (!node.isNull()) {
+		QDomElement element = node.toElement();
+		if ( (!element.isNull()) && element.tagName() == "tag" ) {
+			QDomNode subNode = element.firstChild();
+			while (!subNode.isNull()) {
+				QDomElement subElement = subNode.toElement();
+				if ( (!subElement.isNull()) && subElement.tagName() == "state" ) {
+					QString emblemName = XMLWork::getElementText(subElement, "emblem");
+					if (!emblemName.isEmpty()) {
+						QPixmap emblem = kapp->iconLoader()->loadIcon(emblemName, KIcon::NoGroup, 16, KIcon::DefaultState, 0L, /*canReturnNull=*/true);
+						// The icon does not exists on that computer, import it:
+						if (emblem.isNull()) {
+							// Of the emblem path was eg. "/home/seb/emblem.png", it was exported as "tag-emblems/_home_seb_emblem.png".
+							// So we need to copy that image to "~/.kde/share/apps/basket/tag-emblems/emblem.png":
+							int slashIndex = emblemName.findRev("/");
+							QString emblemFileName = (slashIndex < 0 ? emblemName : emblemName.right(slashIndex - 2));
+							QString source      = extractionFolder + "tag-emblems/" + emblemName.replace('/', '_');
+							QString destination = Global::savesFolder() + "tag-emblems/" + emblemFileName;
+							if (!dir.exists(destination))
+								copier.copyFolder(source, destination);
+							// Replace the emblem path in the tags.xml copy:
+							QDomElement emblemElement = XMLWork::getElement(subElement, "emblem");
+							subElement.removeChild(emblemElement);
+							XMLWork::addElement(*document, subElement, "emblem", destination);
+						}
+					}
+				}
+				subNode = subNode.nextSibling();
+			}
+		}
+		node = node.nextSibling();
+	}
+	Basket::safelySaveToFile(extractionFolder + "tags.xml", document->toString());
+}
+
+void Archive::importArchivedBackgroundImages(const QString &extractionFolder)
+{
+	FormatImporter copier; // Only used to copy files synchronously
+	QString destFolder = KGlobal::dirs()->saveLocation("data", "basket/backgrounds/");
+
+	QDir dir(extractionFolder + "backgrounds/", /*nameFilder=*/"*.png", /*sortSpec=*/QDir::Name | QDir::IgnoreCase, /*filterSpec=*/QDir::Files | QDir::NoSymLinks);
+	QStringList files = dir.entryList();
+	for (QStringList::Iterator it = files.begin(); it != files.end(); ++it) {
+		QString image = *it;
+		if (!Global::backgroundManager->exists(image)) {
+			// Copy images:
+			QString imageSource = extractionFolder + "backgrounds/" + image;
+			QString imageDest   = destFolder + image;
+			copier.copyFolder(imageSource, imageDest);
+			// Copy configuration file:
+			QString configSource = extractionFolder + "backgrounds/" + image + ".config";
+			QString configDest   = destFolder + image;
+			if (dir.exists(configSource))
+				copier.copyFolder(configSource, configDest);
+			// Copy preview:
+			QString previewSource = extractionFolder + "backgrounds/previews/" + image;
+			QString previewDest   = destFolder + "previews/" + image;
+			if (dir.exists(previewSource)) {
+				dir.mkdir(destFolder + "previews/"); // Make sure the folder exists!
+				copier.copyFolder(previewSource, previewDest);
+			}
+			// Append image to database:
+			Global::backgroundManager->addImage(imageDest);
+		}
+	}
+}
+
+void Archive::renameBasketFolders(const QString &extractionFolder, QMap<QString, QString> &mergedStates)
+{
+	QDomDocument *doc = XMLWork::openFile("basketTree", extractionFolder + "baskets/baskets.xml");
+	if (doc != 0) {
+		QMap<QString, QString> folderMap;
+		QDomElement docElem = doc->documentElement();
+		QDomNode node = docElem.firstChild();
+		renameBasketFolder(extractionFolder, node, folderMap, mergedStates);
+		loadExtractedBaskets(extractionFolder, node, folderMap, 0);
+	}
+}
+
+void Archive::renameBasketFolder(const QString &extractionFolder, QDomNode &basketNode, QMap<QString, QString> &folderMap, QMap<QString, QString> &mergedStates)
+{
+	QDomNode n = basketNode;
+	while ( ! n.isNull() ) {
+		QDomElement element = n.toElement();
+		if ( (!element.isNull()) && element.tagName() == "basket" ) {
+			QString folderName = element.attribute("folderName");
+			if (!folderName.isEmpty()) {
+				// Find a folder name:
+				QString newFolderName = BasketFactory::newFolderName();
+				folderMap[folderName] = newFolderName;
+				// Reserve the folder name:
+				QDir dir;
+				dir.mkdir(Global::basketsFolder() + newFolderName);
+				// Rename the merged tag ids:
+//				if (mergedStates.count() > 0) {
+					renameMergedStatesAndBasketIcon(extractionFolder + "baskets/" + folderName + ".basket", mergedStates, extractionFolder);
+//				}
+				// Child baskets:
+				QDomNode node = element.firstChild();
+				renameBasketFolder(extractionFolder, node, folderMap, mergedStates);
+			}
+		}
+		n = n.nextSibling();
+	}
+}
+
+void Archive::renameMergedStatesAndBasketIcon(const QString &fullPath, QMap<QString, QString> &mergedStates, const QString &extractionFolder)
+{
+	QDomDocument *doc = XMLWork::openFile("basket", fullPath);
+	if (doc == 0)
+		return;
+	QDomElement docElem = doc->documentElement();
+	QDomElement properties = XMLWork::getElement(docElem, "properties");
+	importBasketIcon(properties, extractionFolder);
+	QDomElement notes = XMLWork::getElement(docElem, "notes");
+	if (mergedStates.count() > 0)
+		renameMergedStates(notes, mergedStates);
+	Basket::safelySaveToFile(fullPath, /*"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + */doc->toString());
+}
+
+void Archive::importBasketIcon(QDomElement properties, const QString &extractionFolder)
+{
+	QString iconName = XMLWork::getElementText(properties, "icon");
+	if (!iconName.isEmpty() && iconName != "basket") {
+		QPixmap icon = kapp->iconLoader()->loadIcon(iconName, KIcon::NoGroup, 16, KIcon::DefaultState, 0L, /*canReturnNull=*/true);
+		// The icon does not exists on that computer, import it:
+		if (icon.isNull()) {
+			QDir dir;
+			dir.mkdir(Global::savesFolder() + "basket-icons/");
+			FormatImporter copier; // Only used to copy files synchronously
+			// Of the icon path was eg. "/home/seb/icon.png", it was exported as "basket-icons/_home_seb_icon.png".
+			// So we need to copy that image to "~/.kde/share/apps/basket/basket-icons/icon.png":
+			int slashIndex = iconName.findRev("/");
+			QString iconFileName = (slashIndex < 0 ? iconName : iconName.right(slashIndex - 2));
+			QString source       = extractionFolder + "basket-icons/" + iconName.replace('/', '_');
+			QString destination = Global::savesFolder() + "basket-icons/" + iconFileName;
+			if (!dir.exists(destination))
+				copier.copyFolder(source, destination);
+			// Replace the emblem path in the tags.xml copy:
+			QDomElement iconElement = XMLWork::getElement(properties, "icon");
+			properties.removeChild(iconElement);
+			QDomDocument document = properties.ownerDocument();
+			XMLWork::addElement(document, properties, "icon", destination);
+		}
+	}
+}
+
+void Archive::renameMergedStates(QDomNode notes, QMap<QString, QString> &mergedStates)
+{
+	QDomNode n = notes.firstChild();
+	while ( ! n.isNull() ) {
+		QDomElement element = n.toElement();
+		if (!element.isNull()) {
+			if (element.tagName() == "group" ) {
+				renameMergedStates(n, mergedStates);
+			} else if (element.tagName() == "note") {
+				QString tags = XMLWork::getElementText(element, "tags");
+				if (!tags.isEmpty()) {
+					QStringList tagNames = QStringList::split(";", tags);
+					for (QStringList::Iterator it = tagNames.begin(); it != tagNames.end(); ++it) {
+						QString &tag = *it;
+						if (mergedStates.contains(tag)) {
+							tag = mergedStates[tag];
+						}
+					}
+					QString newTags = tagNames.join(";");
+					QDomElement tagsElement = XMLWork::getElement(element, "tags");
+					element.removeChild(tagsElement);
+					QDomDocument document = element.ownerDocument();
+					XMLWork::addElement(document, element, "tags", newTags);
+				}
+			}
+		}
+		n = n.nextSibling();
+	}
+}
+
+void Archive::loadExtractedBaskets(const QString &extractionFolder, QDomNode &basketNode, QMap<QString, QString> &folderMap, Basket *parent)
+{
+	bool basketSetAsCurrent = (parent != 0);
+	QDomNode n = basketNode;
+	while ( ! n.isNull() ) {
+		QDomElement element = n.toElement();
+		if ( (!element.isNull()) && element.tagName() == "basket" ) {
+			QString folderName = element.attribute("folderName");
+			if (!folderName.isEmpty()) {
+				// Move the basket folder to its destination, while renaming it uniquely:
+				QString newFolderName = folderMap[folderName];
+				FormatImporter copier;
+				// The folder has been "reserved" by creating it. Avoid asking the user to override:
+				QDir dir;
+				dir.rmdir(Global::basketsFolder() + newFolderName);
+				copier.moveFolder(extractionFolder + "baskets/" + folderName, Global::basketsFolder() + newFolderName);
+				// Append and load the basket in the tree:
+				Basket *basket = Global::bnpView->loadBasket(newFolderName);
+				BasketListViewItem *basketItem = Global::bnpView->appendBasket(basket, (basket && parent ? Global::bnpView->listViewItemForBasket(parent) : 0));
+				basketItem->setOpen(!XMLWork::trueOrFalse(element.attribute("folded", "false"), false));
+				QDomElement properties = XMLWork::getElement(element, "properties");
+				importBasketIcon(properties, extractionFolder); // Rename the icon fileName if necessary
+				basket->loadProperties(properties);
+				// Open the first basket of the archive:
+				if (!basketSetAsCurrent) {
+					Global::bnpView->setCurrentBasket(basket);
+					basketSetAsCurrent = true;
+				}
+				QDomNode node = element.firstChild();
+				loadExtractedBaskets(extractionFolder, node, folderMap, basket);
+			}
+		}
+		n = n.nextSibling();
+	}
+}