CactiChameleon9/PrismLauncher
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GH-1227: World import using drag and drop - zip files and folders

Browse Source
This commit is contained in:
Petr Mrázek
2015-09-09 23:53:33 +02:00
parent 51070a13f7
commit a1fd50e920
15 changed files with 345 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
logic/minecraft/ModList.cpp
View File

@ -539,6 +539,7 @@ QMimeData *ModList::mimeData(const QModelIndexList &indexes) const
data->setText(params.join('|'));
return data;
}
bool ModList::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
const QModelIndex &parent)
{

204
logic/minecraft/World.cpp
View File

@ -20,10 +20,13 @@
#include <pathutils.h>
#include "GZip.h"
#include <MMCZip.h>
#include <sstream>
#include <io/stream_reader.h>
#include <tag_string.h>
#include <tag_primitive.h>
#include <quazip.h>
#include <quazipfile.h>
World::World(const QFileInfo &file)
{
@ -32,8 +35,20 @@ World::World(const QFileInfo &file)
void World::repath(const QFileInfo &file)
{
m_file = file;
m_containerFile = file;
m_folderName = file.fileName();
if(file.isFile() && file.suffix() == "zip")
{
readFromZip(file);
}
else if(file.isDir())
{
readFromFS(file);
}
}
void World::readFromFS(const QFileInfo &file)
{
QDir worldDir(file.filePath());
is_valid = file.isDir() && worldDir.exists("level.dat");
if(!is_valid)
@ -48,66 +63,123 @@ void World::repath(const QFileInfo &file)
{
return;
}
QFileInfo finfo(fullFilePath);
levelDatTime = finfo.lastModified();
parseLevelDat(f.readAll());
}
void World::readFromZip(const QFileInfo &file)
{
QuaZip zip(file.absoluteFilePath());
is_valid = zip.open(QuaZip::mdUnzip);
if (!is_valid)
{
return;
}
QuaZipFile zippedFile(&zip);
// read the install profile
is_valid = zip.setCurrentFile("level.dat");
if (!is_valid)
{
return;
}
is_valid = zippedFile.open(QIODevice::ReadOnly);
QuaZipFileInfo64 levelDatInfo;
zippedFile.getFileInfo(&levelDatInfo);
auto modTime = levelDatInfo.getNTFSmTime();
if(!modTime.isValid())
{
modTime = levelDatInfo.dateTime;
}
levelDatTime = modTime;
if (!is_valid)
{
return;
}
parseLevelDat(zippedFile.readAll());
zippedFile.close();
}
bool World::install(QString to)
{
auto finalPath = PathCombine(to, DirNameFromString(m_actualName, to));
if(!ensureFolderPathExists(finalPath))
{
return false;
}
if(m_containerFile.isFile())
{
// FIXME: check if this is OK.
return !MMCZip::extractDir(m_containerFile.absoluteFilePath(), finalPath).isEmpty();
}
else if(m_containerFile.isDir())
{
QString from = m_containerFile.filePath();
return copyPath(from, finalPath);
}
return false;
}
static QString read_string (nbt::value& parent, const char * name, const QString & fallback = QString())
{
try
{
auto &namedValue = parent.at(name);
if(namedValue.get_type() != nbt::tag_type::String)
{
return fallback;
}
auto & tag_str = namedValue.as<nbt::tag_string>();
return QString::fromStdString(tag_str.get());
}
catch(std::out_of_range e)
{
// fallback for old world formats
qWarning() << "String NBT tag" << name << "could not be found. Defaulting to" << fallback;
return fallback;
}
catch(std::bad_cast e)
{
// type mismatch
qWarning() << "NBT tag" << name << "could not be converted to string. Defaulting to" << fallback;
return fallback;
}
};
static int64_t read_long (nbt::value& parent, const char * name, const int64_t & fallback = 0)
{
try
{
auto &namedValue = parent.at(name);
if(namedValue.get_type() != nbt::tag_type::Long)
{
return fallback;
}
auto & tag_str = namedValue.as<nbt::tag_long>();
return tag_str.get();
}
catch(std::out_of_range e)
{
// fallback for old world formats
qWarning() << "Long NBT tag" << name << "could not be found. Defaulting to" << fallback;
return fallback;
}
catch(std::bad_cast e)
{
// type mismatch
qWarning() << "NBT tag" << name << "could not be converted to long. Defaulting to" << fallback;
return fallback;
}
};
void World::parseLevelDat(QByteArray data)
{
QByteArray output;
is_valid = GZip::inflate(f.readAll(), output);
is_valid = GZip::inflate(data, output);
if(!is_valid)
{
return;
}
f.close();
auto read_string = [](nbt::value& parent, const char * name, const QString & fallback = QString()) -> QString
{
try
{
auto &namedValue = parent.at(name);
if(namedValue.get_type() != nbt::tag_type::String)
{
return fallback;
}
auto & tag_str = namedValue.as<nbt::tag_string>();
return QString::fromStdString(tag_str.get());
}
catch(std::out_of_range e)
{
// fallback for old world formats
qWarning() << "String NBT tag" << name << "could not be found. Defaulting to" << fallback;
return fallback;
}
catch(std::bad_cast e)
{
// type mismatch
qWarning() << "NBT tag" << name << "could not be converted to string. Defaulting to" << fallback;
return fallback;
}
};
auto read_long = [](nbt::value& parent, const char * name, const int64_t & fallback = 0) -> int64_t
{
try
{
auto &namedValue = parent.at(name);
if(namedValue.get_type() != nbt::tag_type::Long)
{
return fallback;
}
auto & tag_str = namedValue.as<nbt::tag_long>();
return tag_str.get();
}
catch(std::out_of_range e)
{
// fallback for old world formats
qWarning() << "Long NBT tag" << name << "could not be found. Defaulting to" << fallback;
return fallback;
}
catch(std::bad_cast e)
{
// type mismatch
qWarning() << "NBT tag" << name << "could not be converted to long. Defaulting to" << fallback;
return fallback;
}
};
try
{
@ -138,8 +210,7 @@ void World::repath(const QFileInfo &file)
int64_t temp = read_long(val, "LastPlayed", 0);
if(temp == 0)
{
QFileInfo finfo(fullFilePath);
m_lastPlayed = finfo.lastModified();
m_lastPlayed = levelDatTime;
}
else
{
@ -164,11 +235,11 @@ bool World::replace(World &with)
{
if (!destroy())
return false;
bool success = copyPath(with.m_file.filePath(), m_file.path());
bool success = copyPath(with.m_containerFile.filePath(), m_containerFile.path());
if (success)
{
m_folderName = with.m_folderName;
m_file.refresh();
m_containerFile.refresh();
}
return success;
}
@ -176,18 +247,15 @@ bool World::replace(World &with)
bool World::destroy()
{
if(!is_valid) return false;
if (m_file.isDir())
if (m_containerFile.isDir())
{
QDir d(m_file.filePath());
if (d.removeRecursively())
{
return true;
}
return false;
QDir d(m_containerFile.filePath());
return d.removeRecursively();
}
else
else if(m_containerFile.isFile())
{
return false;
QFile file(m_containerFile.absoluteFilePath());
return file.remove();
}
return true;
}

10
logic/minecraft/World.h
View File

@ -48,15 +48,23 @@ public:
// change the world's filesystem path (used by world lists for *MAGIC* purposes)
void repath(const QFileInfo &file);
bool install(QString to);
// WEAK compare operator - used for replacing worlds
bool operator==(const World &other) const;
bool strongCompare(const World &other) const;
private:
void readFromZip(const QFileInfo &file);
void readFromFS(const QFileInfo &file);
void parseLevelDat(QByteArray data);
protected:
QFileInfo m_file;
QFileInfo m_containerFile;
QString m_folderName;
QString m_actualName;
QDateTime levelDatTime;
QDateTime m_lastPlayed;
int64_t m_randomSeed = 0;
bool is_valid = false;

116
logic/minecraft/WorldList.cpp
View File

@ -62,40 +62,28 @@ void WorldList::stopWatching()
}
}
void WorldList::internalSort(QList<World> &what)
{
auto predicate = [](const World &left, const World &right)
{
return left.folderName().localeAwareCompare(right.folderName()) < 0;
};
std::sort(what.begin(), what.end(), predicate);
}
bool WorldList::update()
{
if (!isValid())
return false;
QList<World> orderedWorlds;
QList<World> newWorlds;
m_dir.refresh();
auto folderContents = m_dir.entryInfoList();
// if there are any untracked files...
if (folderContents.size())
for (QFileInfo entry : folderContents)
{
// the order surely changed!
for (auto entry : folderContents)
if(!entry.isDir())
continue;
World w(entry);
if(w.isValid())
{
World w(entry);
if(w.isValid()) {
newWorlds.append(w);
}
newWorlds.append(w);
}
internalSort(newWorlds);
orderedWorlds.append(newWorlds);
}
beginResetModel();
worlds.swap(orderedWorlds);
worlds.swap(newWorlds);
endResetModel();
return true;
}
@ -232,6 +220,7 @@ QStringList WorldList::mimeTypes() const
{
QStringList types;
types << "text/plain";
types << "text/uri-list";
return types;
}
@ -250,3 +239,90 @@ QMimeData *WorldList::mimeData(const QModelIndexList &indexes) const
data->setText(QString::number(row));
return data;
}
Qt::ItemFlags WorldList::flags(const QModelIndex &index) const
{
Qt::ItemFlags defaultFlags = QAbstractListModel::flags(index);
if (index.isValid())
return Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled |
defaultFlags;
else
return Qt::ItemIsDropEnabled | defaultFlags;
}
Qt::DropActions WorldList::supportedDragActions() const
{
// move to other mod lists or VOID
return Qt::MoveAction;
}
Qt::DropActions WorldList::supportedDropActions() const
{
// copy from outside, move from within and other mod lists
return Qt::CopyAction | Qt::MoveAction;
}
void WorldList::installWorld(QFileInfo filename)
{
qDebug() << "installing: " << filename.absoluteFilePath();
World w(filename);
if(!w.isValid())
{
return;
}
w.install(m_dir.absolutePath());
}
bool WorldList::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
const QModelIndex &parent)
{
if (action == Qt::IgnoreAction)
return true;
// check if the action is supported
if (!data || !(action & supportedDropActions()))
return false;
// files dropped from outside?
if (data->hasUrls())
{
bool was_watching = is_watching;
if (was_watching)
stopWatching();
auto urls = data->urls();
for (auto url : urls)
{
// only local files may be dropped...
if (!url.isLocalFile())
continue;
QString filename = url.toLocalFile();
QFileInfo worldInfo(filename);
installWorld(worldInfo);
}
if (was_watching)
startWatching();
return true;
}
/*
else if (data->hasText())
{
QString sourcestr = data->text();
auto list = sourcestr.split('|');
if (list.size() != 2)
return false;
QString remoteId = list[0];
int remoteIndex = list[1].toInt();
qDebug() << "move: " << sourcestr;
// no moving of things between two lists
if (remoteId != m_list_id)
return false;
// no point moving to the same place...
if (row == remoteIndex)
return false;
// otherwise, move the mod :D
moveModTo(remoteIndex, row);
return true;
}
*/
return false;
}

15
logic/minecraft/WorldList.h
View File

@ -19,6 +19,7 @@
#include <QString>
#include <QDir>
#include <QAbstractListModel>
#include <QMimeData>
#include "minecraft/World.h"
#include "multimc_logic_export.h"
@ -71,16 +72,28 @@ public:
/// Reloads the mod list and returns true if the list changed.
virtual bool update();
/// Install a world from location
void installWorld(QFileInfo filename);
/// Deletes the mod at the given index.
virtual bool deleteWorld(int index);
/// Deletes all the selected mods
virtual bool deleteWorlds(int first, int last);
/// flags, mostly to support drag&drop
virtual Qt::ItemFlags flags(const QModelIndex &index) const;
/// get data for drag action
virtual QMimeData *mimeData(const QModelIndexList &indexes) const;
/// get the supported mime types
virtual QStringList mimeTypes() const;
/// process data from drop action
virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
/// what drag actions do we support?
virtual Qt::DropActions supportedDragActions() const;
/// what drop actions do we support?
virtual Qt::DropActions supportedDropActions() const;
void startWatching();
void stopWatching();
@ -97,8 +110,6 @@ public:
return worlds;
}
private:
void internalSort(QList<World> &what);
private slots:
void directoryChanged(QString path);