sneedmc/launcher/minecraft/WorldList.cpp

438 lines
10 KiB
C++
Raw Normal View History

// SPDX-License-Identifier: GPL-3.0-only
/*
* PolyMC - Minecraft Launcher
* Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
*
* 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, version 3.
*
* 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, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2013-2021 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "WorldList.h"
2022-03-31 16:45:17 +00:00
#include "Application.h"
2015-10-04 23:47:27 +00:00
#include <FileSystem.h>
#include <Qt>
#include <QMimeData>
#include <QUrl>
#include <QUuid>
#include <QString>
#include <QFileSystemWatcher>
#include <QDebug>
WorldList::WorldList(const QString &dir)
2018-07-15 12:51:05 +00:00
: QAbstractListModel(), m_dir(dir)
{
2018-07-15 12:51:05 +00:00
FS::ensureFolderPathExists(m_dir.absolutePath());
m_dir.setFilter(QDir::Readable | QDir::NoDotAndDotDot | QDir::Files | QDir::Dirs);
2018-07-15 12:51:05 +00:00
m_dir.setSorting(QDir::Name | QDir::IgnoreCase | QDir::LocaleAware);
m_watcher = new QFileSystemWatcher(this);
is_watching = false;
connect(m_watcher, SIGNAL(directoryChanged(QString)), this,
SLOT(directoryChanged(QString)));
}
void WorldList::startWatching()
{
2018-07-15 12:51:05 +00:00
if(is_watching)
{
return;
}
update();
is_watching = m_watcher->addPath(m_dir.absolutePath());
if (is_watching)
{
qDebug() << "Started watching " << m_dir.absolutePath();
}
else
{
qDebug() << "Failed to start watching " << m_dir.absolutePath();
}
}
void WorldList::stopWatching()
{
2018-07-15 12:51:05 +00:00
if(!is_watching)
{
return;
}
is_watching = !m_watcher->removePath(m_dir.absolutePath());
if (!is_watching)
{
qDebug() << "Stopped watching " << m_dir.absolutePath();
}
else
{
qDebug() << "Failed to stop watching " << m_dir.absolutePath();
}
}
bool WorldList::update()
{
2018-07-15 12:51:05 +00:00
if (!isValid())
return false;
QList<World> newWorlds;
m_dir.refresh();
auto folderContents = m_dir.entryInfoList();
// if there are any untracked files...
for (QFileInfo entry : folderContents)
{
if(!entry.isDir())
continue;
World w(entry);
if(w.isValid())
{
newWorlds.append(w);
}
}
beginResetModel();
worlds.swap(newWorlds);
endResetModel();
return true;
}
void WorldList::directoryChanged(QString path)
{
2018-07-15 12:51:05 +00:00
update();
}
bool WorldList::isValid()
{
2018-07-15 12:51:05 +00:00
return m_dir.exists() && m_dir.isReadable();
}
bool WorldList::deleteWorld(int index)
{
2018-07-15 12:51:05 +00:00
if (index >= worlds.size() || index < 0)
return false;
World &m = worlds[index];
if (m.destroy())
{
beginRemoveRows(QModelIndex(), index, index);
worlds.removeAt(index);
endRemoveRows();
emit changed();
return true;
}
return false;
}
bool WorldList::deleteWorlds(int first, int last)
{
2018-07-15 12:51:05 +00:00
for (int i = first; i <= last; i++)
{
World &m = worlds[i];
m.destroy();
}
beginRemoveRows(QModelIndex(), first, last);
worlds.erase(worlds.begin() + first, worlds.begin() + last + 1);
endRemoveRows();
emit changed();
return true;
}
bool WorldList::resetIcon(int row)
{
if (row >= worlds.size() || row < 0)
return false;
World &m = worlds[row];
if(m.resetIcon()) {
emit dataChanged(index(row), index(row), {WorldList::IconFileRole});
return true;
}
return false;
}
int WorldList::columnCount(const QModelIndex &parent) const
{
2022-03-31 16:45:17 +00:00
return 4;
}
QVariant WorldList::data(const QModelIndex &index, int role) const
{
2018-07-15 12:51:05 +00:00
if (!index.isValid())
return QVariant();
int row = index.row();
int column = index.column();
if (row < 0 || row >= worlds.size())
return QVariant();
2022-03-31 16:45:17 +00:00
QLocale locale;
2018-07-15 12:51:05 +00:00
auto & world = worlds[row];
switch (role)
{
case Qt::DisplayRole:
switch (column)
{
case NameColumn:
return world.name();
case GameModeColumn:
return world.gameType().toTranslatedString();
2018-07-15 12:51:05 +00:00
case LastPlayedColumn:
return world.lastPlayed();
2022-03-31 16:45:17 +00:00
case SizeColumn:
return locale.formattedDataSize(world.bytes());
2018-07-15 12:51:05 +00:00
default:
return QVariant();
}
case Qt::UserRole:
switch (column)
{
case SizeColumn:
return QVariant::fromValue<qlonglong>(world.bytes());
default:
return data(index, Qt::DisplayRole);
}
2018-07-15 12:51:05 +00:00
case Qt::ToolTipRole:
{
return world.folderName();
}
case ObjectRole:
{
return QVariant::fromValue<void *>((void *)&world);
}
case FolderRole:
{
return QDir::toNativeSeparators(dir().absoluteFilePath(world.folderName()));
}
case SeedRole:
{
return QVariant::fromValue<qlonglong>(world.seed());
2018-07-15 12:51:05 +00:00
}
case NameRole:
{
return world.name();
}
case LastPlayedRole:
{
return world.lastPlayed();
}
2022-03-31 16:45:17 +00:00
case SizeRole:
{
return QVariant::fromValue<qlonglong>(world.bytes());
2022-03-31 16:45:17 +00:00
}
case IconFileRole:
{
return world.iconFile();
}
2018-07-15 12:51:05 +00:00
default:
return QVariant();
}
}
QVariant WorldList::headerData(int section, Qt::Orientation orientation, int role) const
{
2018-07-15 12:51:05 +00:00
switch (role)
{
case Qt::DisplayRole:
switch (section)
{
case NameColumn:
return tr("Name");
case GameModeColumn:
return tr("Game Mode");
2018-07-15 12:51:05 +00:00
case LastPlayedColumn:
return tr("Last Played");
2022-03-31 16:45:17 +00:00
case SizeColumn:
//: World size on disk
return tr("Size");
2018-07-15 12:51:05 +00:00
default:
return QVariant();
}
case Qt::ToolTipRole:
switch (section)
{
case NameColumn:
return tr("The name of the world.");
case GameModeColumn:
return tr("Game mode of the world.");
2018-07-15 12:51:05 +00:00
case LastPlayedColumn:
return tr("Date and time the world was last played.");
2022-03-31 16:45:17 +00:00
case SizeColumn:
return tr("Size of the world on disk.");
2018-07-15 12:51:05 +00:00
default:
return QVariant();
}
default:
return QVariant();
}
return QVariant();
}
QStringList WorldList::mimeTypes() const
{
2018-07-15 12:51:05 +00:00
QStringList types;
types << "text/uri-list";
return types;
}
class WorldMimeData : public QMimeData
{
Q_OBJECT
public:
2018-07-15 12:51:05 +00:00
WorldMimeData(QList<World> worlds)
{
m_worlds = worlds;
2018-07-15 12:51:05 +00:00
}
QStringList formats() const
{
return QMimeData::formats() << "text/uri-list";
}
protected:
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QVariant retrieveData(const QString &mimetype, QMetaType type) const
#else
2018-07-15 12:51:05 +00:00
QVariant retrieveData(const QString &mimetype, QVariant::Type type) const
#endif
2018-07-15 12:51:05 +00:00
{
QList<QUrl> urls;
for(auto &world: m_worlds)
{
if(!world.isValid() || !world.isOnFS())
continue;
QString worldPath = world.container().absoluteFilePath();
qDebug() << worldPath;
urls.append(QUrl::fromLocalFile(worldPath));
}
const_cast<WorldMimeData*>(this)->setUrls(urls);
return QMimeData::retrieveData(mimetype, type);
}
private:
2018-07-15 12:51:05 +00:00
QList<World> m_worlds;
};
QMimeData *WorldList::mimeData(const QModelIndexList &indexes) const
{
2018-07-15 12:51:05 +00:00
if (indexes.size() == 0)
return new QMimeData();
QList<World> worlds;
for(auto idx : indexes)
{
if(idx.column() != 0)
continue;
int row = idx.row();
if (row < 0 || row >= this->worlds.size())
continue;
worlds.append(this->worlds[row]);
}
if(!worlds.size())
{
return new QMimeData();
}
return new WorldMimeData(worlds);
}
Qt::ItemFlags WorldList::flags(const QModelIndex &index) const
{
2018-07-15 12:51:05 +00:00
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
{
2018-07-15 12:51:05 +00:00
// move to other mod lists or VOID
return Qt::MoveAction;
}
Qt::DropActions WorldList::supportedDropActions() const
{
2018-07-15 12:51:05 +00:00
// copy from outside, move from within and other mod lists
return Qt::CopyAction | Qt::MoveAction;
}
void WorldList::installWorld(QFileInfo filename)
{
2018-07-15 12:51:05 +00:00
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,
2018-07-15 12:51:05 +00:00
const QModelIndex &parent)
{
2018-07-15 12:51:05 +00:00
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);
if(!m_dir.entryInfoList().contains(worldInfo))
{
installWorld(worldInfo);
}
}
if (was_watching)
startWatching();
return true;
}
return false;
}
#include "WorldList.moc"