mirrors/qBittorrent
1
0
Fork 0
mirror of https://github.com/qbittorrent/qBittorrent.git synced 2024-11-28 05:27:15 +03:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #15682 from Chocobo1/qt6

Browse source 
Store Qt6 table header states under a different key
This commit is contained in:
Chocobo1 2021-11-09 11:23:04 +08:00 committed by GitHub
commit ae1b963e0f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 248 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/app/qtlocalpeer/qtlocalpeer.cpp
View file

@ -90,49 +90,49 @@ namespace QtLP_Private
#endif
}
const char* QtLocalPeer::ack = "ack";
const char ACK[] = "ack";
QtLocalPeer::QtLocalPeer(const QString &path, QObject *parent)
: QObject(parent)
, socketName(path + QLatin1String("/ipc-socket"))
, server(new QLocalServer(this))
, m_socketName(path + QLatin1String("/ipc-socket"))
, m_server(new QLocalServer(this))
{
server->setSocketOptions(QLocalServer::UserAccessOption);
m_server->setSocketOptions(QLocalServer::UserAccessOption);
lockFile.setFileName(path + QLatin1String("/lockfile"));
lockFile.open(QIODevice::ReadWrite);
m_lockFile.setFileName(path + QLatin1String("/lockfile"));
m_lockFile.open(QIODevice::ReadWrite);
}
QtLocalPeer::~QtLocalPeer()
{
if (!isClient())
{
lockFile.unlock();
lockFile.remove();
m_lockFile.unlock();
m_lockFile.remove();
}
}
bool QtLocalPeer::isClient()
{
if (lockFile.isLocked())
if (m_lockFile.isLocked())
return false;
if (!lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
if (!m_lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
return true;
bool res = server->listen(socketName);
bool res = m_server->listen(m_socketName);
#if defined(Q_OS_UNIX)
// ### Workaround
if (!res && server->serverError() == QAbstractSocket::AddressInUseError)
if (!res && m_server->serverError() == QAbstractSocket::AddressInUseError)
{
QFile::remove(socketName);
res = server->listen(socketName);
QFile::remove(m_socketName);
res = m_server->listen(m_socketName);
}
#endif
if (!res)
qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qPrintable(server->errorString()));
qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qUtf8Printable(m_server->errorString()));
connect(server, &QLocalServer::newConnection, this, &QtLocalPeer::receiveConnection);
connect(m_server, &QLocalServer::newConnection, this, &QtLocalPeer::receiveConnection);
return false;
}
@ -146,7 +146,7 @@ bool QtLocalPeer::sendMessage(const QString &message, const int timeout)
for(int i = 0; i < 2; i++)
{
// Try twice, in case the other instance is just starting up
socket.connectToServer(socketName);
socket.connectToServer(m_socketName);
connOk = socket.waitForConnected(timeout/2);
if (connOk || i)
break;
@ -169,14 +169,14 @@ bool QtLocalPeer::sendMessage(const QString &message, const int timeout)
{
res &= socket.waitForReadyRead(timeout); // wait for ack
if (res)
res &= (socket.read(qstrlen(ack)) == ack);
res &= (socket.read(qstrlen(ACK)) == ACK);
}
return res;
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
QLocalSocket *socket = m_server->nextPendingConnection();
if (!socket)
return;
@ -220,7 +220,7 @@ void QtLocalPeer::receiveConnection()
return;
}
QString message(QString::fromUtf8(uMsg));
socket->write(ack, qstrlen(ack));
socket->write(ACK, qstrlen(ACK));
socket->waitForBytesWritten(1000);
socket->waitForDisconnected(1000); // make sure client reads ack
delete socket;

12
src/app/qtlocalpeer/qtlocalpeer.h
View file

@ -89,15 +89,11 @@ public:
signals:
void messageReceived(const QString &message);
protected slots:
private slots:
void receiveConnection();
protected:
QString id;
QString socketName;
QLocalServer *server = nullptr;
QtLP_Private::QtLockedFile lockFile;
private:
static const char* ack;
QString m_socketName;
QLocalServer *m_server = nullptr;
QtLP_Private::QtLockedFile m_lockFile;
};

14
src/app/qtlocalpeer/qtlockedfile.cpp
View file

@ -108,11 +108,7 @@
\sa QFile::QFile()
*/
QtLockedFile::QtLockedFile()
: QFile()
{
m_lock_mode = NoLock;
}
QtLockedFile::QtLockedFile() = default;
/*!
Constructs an unlocked QtLockedFile object with file \a name. This
@ -124,7 +120,6 @@ QtLockedFile::QtLockedFile()
QtLockedFile::QtLockedFile(const QString &name)
: QFile(name)
{
m_lock_mode = NoLock;
}
/*!
@ -142,7 +137,8 @@ QtLockedFile::QtLockedFile(const QString &name)
*/
bool QtLockedFile::open(const OpenMode mode)
{
if (mode & QIODevice::Truncate) {
if (mode & QIODevice::Truncate)
{
qWarning("QtLockedFile::open(): Truncate mode not allowed.");
return false;
}
@ -157,7 +153,7 @@ bool QtLockedFile::open(const OpenMode mode)
*/
bool QtLockedFile::isLocked() const
{
return m_lock_mode != NoLock;
return m_lockMode != NoLock;
}
/*!
@ -168,7 +164,7 @@ bool QtLockedFile::isLocked() const
*/
QtLockedFile::LockMode QtLockedFile::lockMode() const
{
return m_lock_mode;
return m_lockMode;
}
/*!

12
src/app/qtlocalpeer/qtlockedfile.h
View file

@ -101,14 +101,14 @@ namespace QtLP_Private
private:
#ifdef Q_OS_WIN
Qt::HANDLE getMutexHandle(int idx, bool doCreate);
bool waitMutex(Qt::HANDLE mutex, bool doBlock);
bool waitMutex(Qt::HANDLE mutex, bool doBlock) const;
Qt::HANDLE wmutex = nullptr;
Qt::HANDLE rmutex = nullptr;
QVector<Qt::HANDLE> rmutexes;
QString mutexname;
Qt::HANDLE m_writeMutex = nullptr;
Qt::HANDLE m_readMutex = nullptr;
QVector<Qt::HANDLE> m_readMutexes;
QString m_mutexName;
#endif
LockMode m_lock_mode;
LockMode m_lockMode = NoLock;
};
}

22
src/app/qtlocalpeer/qtlockedfile_unix.cpp
View file

@ -73,9 +73,10 @@
#include <string.h>
#include <unistd.h>
bool QtLockedFile::lock(LockMode mode, bool block)
bool QtLockedFile::lock(const LockMode mode, const bool block)
{
if (!isOpen()) {
if (!isOpen())
{
qWarning("QtLockedFile::lock(): file is not opened");
return false;
}
@ -83,10 +84,10 @@ bool QtLockedFile::lock(LockMode mode, bool block)
if (mode == NoLock)
return unlock();
if (mode == m_lock_mode)
if (mode == m_lockMode)
return true;
if (m_lock_mode != NoLock)
if (m_lockMode != NoLock)
unlock();
struct flock fl;
@ -97,19 +98,21 @@ bool QtLockedFile::lock(LockMode mode, bool block)
int cmd = block ? F_SETLKW : F_SETLK;
int ret = fcntl(handle(), cmd, &fl);
if (ret == -1) {
if (ret == -1)
{
if (errno != EINTR && errno != EAGAIN)
qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
return false;
}
m_lock_mode = mode;
m_lockMode = mode;
return true;
}
bool QtLockedFile::unlock()
{
if (!isOpen()) {
if (!isOpen())
{
qWarning("QtLockedFile::unlock(): file is not opened");
return false;
}
@ -124,12 +127,13 @@ bool QtLockedFile::unlock()
fl.l_type = F_UNLCK;
int ret = fcntl(handle(), F_SETLKW, &fl);
if (ret == -1) {
if (ret == -1)
{
qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
return false;
}
m_lock_mode = NoLock;
m_lockMode = NoLock;
return true;
}

167
src/app/qtlocalpeer/qtlockedfile_win.cpp
View file

@ -70,64 +70,73 @@
#include <QFileInfo>
#define MUTEX_PREFIX "QtLockedFile mutex "
#include "base/global.h"
// Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
#define MAX_READERS MAXIMUM_WAIT_OBJECTS
const int MAX_READERS = MAXIMUM_WAIT_OBJECTS;
#define QT_WA(unicode, ansi) unicode
Qt::HANDLE QtLockedFile::getMutexHandle(int idx, bool doCreate)
Qt::HANDLE QtLockedFile::getMutexHandle(const int idx, const bool doCreate)
{
if (mutexname.isEmpty()) {
if (m_mutexName.isEmpty())
{
QFileInfo fi(*this);
mutexname = QString::fromLatin1(MUTEX_PREFIX)
+ fi.absoluteFilePath().toLower();
m_mutexName = QString::fromLatin1("QtLockedFile mutex ") + fi.absoluteFilePath().toLower();
}
QString mname(mutexname);
QString mname = m_mutexName;
if (idx >= 0)
mname += QString::number(idx);
Qt::HANDLE mutex;
if (doCreate) {
QT_WA( { mutex = CreateMutexW(NULL, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16())); },
{ mutex = CreateMutexA(NULL, FALSE, mname.toLocal8Bit().constData()); } );
if (!mutex) {
if (doCreate)
{
const Qt::HANDLE mutex = ::CreateMutexW(NULL, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16()));
if (!mutex)
{
qErrnoWarning("QtLockedFile::lock(): CreateMutex failed");
return 0;
return nullptr;
}
return mutex;
}
else {
QT_WA( { mutex = OpenMutexW(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16())); },
{ mutex = OpenMutexA(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, mname.toLocal8Bit().constData()); } );
if (!mutex) {
else
{
const Qt::HANDLE mutex = ::OpenMutexW((SYNCHRONIZE | MUTEX_MODIFY_STATE), FALSE, reinterpret_cast<const TCHAR *>(mname.utf16()));
if (!mutex)
{
if (GetLastError() != ERROR_FILE_NOT_FOUND)
qErrnoWarning("QtLockedFile::lock(): OpenMutex failed");
return 0;
return nullptr;
}
return mutex;
}
return mutex;
return nullptr;
}
bool QtLockedFile::waitMutex(Qt::HANDLE mutex, bool doBlock)
bool QtLockedFile::waitMutex(const Qt::HANDLE mutex, const bool doBlock) const
{
Q_ASSERT(mutex);
DWORD res = WaitForSingleObject(mutex, doBlock ? INFINITE : 0);
switch (res) {
const DWORD res = ::WaitForSingleObject(mutex, (doBlock ? INFINITE : 0));
switch (res)
{
case WAIT_OBJECT_0:
case WAIT_ABANDONED:
return true;
break;
case WAIT_TIMEOUT:
break;
return false;
default:
qErrnoWarning("QtLockedFile::lock(): WaitForSingleObject failed");
break;
}
return false;
}
bool QtLockedFile::lock(LockMode mode, bool block)
bool QtLockedFile::lock(const LockMode mode, const bool block)
{
if (!isOpen()) {
if (!isOpen())
{
qWarning("QtLockedFile::lock(): file is not opened");
return false;
}
@ -135,72 +144,85 @@ bool QtLockedFile::lock(LockMode mode, bool block)
if (mode == NoLock)
return unlock();
if (mode == m_lock_mode)
if (mode == m_lockMode)
return true;
if (m_lock_mode != NoLock)
if (m_lockMode != NoLock)
unlock();
if (!wmutex && !(wmutex = getMutexHandle(-1, true)))
if (!m_writeMutex && !(m_writeMutex = getMutexHandle(-1, true)))
return false;
if (!waitMutex(wmutex, block))
if (!waitMutex(m_writeMutex, block))
return false;
if (mode == ReadLock) {
if (mode == ReadLock)
{
int idx = 0;
for (; idx < MAX_READERS; idx++) {
rmutex = getMutexHandle(idx, false);
if (!rmutex || waitMutex(rmutex, false))
for (; idx < MAX_READERS; ++idx)
{
m_readMutex = getMutexHandle(idx, false);
if (!m_readMutex || waitMutex(m_readMutex, false))
break;
CloseHandle(rmutex);
::CloseHandle(m_readMutex);
}
bool ok = true;
if (idx >= MAX_READERS) {
if (idx >= MAX_READERS)
{
qWarning("QtLockedFile::lock(): too many readers");
rmutex = 0;
m_readMutex = nullptr;
ok = false;
}
else if (!rmutex) {
rmutex = getMutexHandle(idx, true);
if (!rmutex || !waitMutex(rmutex, false))
else if (!m_readMutex)
{
m_readMutex = getMutexHandle(idx, true);
if (!m_readMutex || !waitMutex(m_readMutex, false))
ok = false;
}
if (!ok && rmutex) {
CloseHandle(rmutex);
rmutex = 0;
if (!ok && m_readMutex)
{
::CloseHandle(m_readMutex);
m_readMutex = nullptr;
}
ReleaseMutex(wmutex);
::ReleaseMutex(m_writeMutex);
if (!ok)
return false;
}
else {
Q_ASSERT(rmutexes.isEmpty());
for (int i = 0; i < MAX_READERS; i++) {
Qt::HANDLE mutex = getMutexHandle(i, false);
else
{
Q_ASSERT(m_readMutexes.isEmpty());
for (int i = 0; i < MAX_READERS; ++i)
{
const Qt::HANDLE mutex = getMutexHandle(i, false);
if (mutex)
rmutexes.append(mutex);
m_readMutexes.append(mutex);
}
if (rmutexes.size()) {
DWORD res = WaitForMultipleObjects(rmutexes.size(), rmutexes.constData(),
TRUE, block ? INFINITE : 0);
if (res != WAIT_OBJECT_0 && res != WAIT_ABANDONED) {
if (m_readMutexes.size())
{
const DWORD res = ::WaitForMultipleObjects(m_readMutexes.size(), m_readMutexes.constData(),
TRUE, (block ? INFINITE : 0));
if ((res != WAIT_OBJECT_0) && (res != WAIT_ABANDONED))
{
if (res != WAIT_TIMEOUT)
qErrnoWarning("QtLockedFile::lock(): WaitForMultipleObjects failed");
m_lock_mode = WriteLock; // trick unlock() to clean up - semiyucky
m_lockMode = WriteLock; // trick unlock() to clean up - semiyucky
unlock();
return false;
}
}
}
m_lock_mode = mode;
m_lockMode = mode;
return true;
}
bool QtLockedFile::unlock()
{
if (!isOpen()) {
if (!isOpen())
{
qWarning("QtLockedFile::unlock(): file is not opened");
return false;
}
@ -208,21 +230,24 @@ bool QtLockedFile::unlock()
if (!isLocked())
return true;
if (m_lock_mode == ReadLock) {
ReleaseMutex(rmutex);
CloseHandle(rmutex);
rmutex = 0;
if (m_lockMode == ReadLock)
{
::ReleaseMutex(m_readMutex);
::CloseHandle(m_readMutex);
m_readMutex = nullptr;
}
else {
foreach(Qt::HANDLE mutex, rmutexes) {
ReleaseMutex(mutex);
CloseHandle(mutex);
else
{
for (const Qt::HANDLE &mutex : asConst(m_readMutexes))
{
::ReleaseMutex(mutex);
::CloseHandle(mutex);
}
rmutexes.clear();
ReleaseMutex(wmutex);
m_readMutexes.clear();
::ReleaseMutex(m_writeMutex);
}
m_lock_mode = QtLockedFile::NoLock;
m_lockMode = QtLockedFile::NoLock;
return true;
}
@ -230,6 +255,6 @@ QtLockedFile::~QtLockedFile()
{
if (isOpen())
unlock();
if (wmutex)
CloseHandle(wmutex);
if (m_writeMutex)
::CloseHandle(m_writeMutex);
}

4
src/base/bittorrent/torrentimpl.cpp
View file

@ -33,10 +33,6 @@
#include <memory>
#include <type_traits>
#ifdef Q_OS_WIN
#include <Windows.h>
#endif
#include <libtorrent/address.hpp>
#include <libtorrent/alert_types.hpp>
#include <libtorrent/magnet_uri.hpp>

72
src/base/preferences.cpp
View file

@ -1265,12 +1265,20 @@ void Preferences::setMainGeometry(const QByteArray &geometry)
QByteArray Preferences::getMainVSplitterState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/MainWindow/VSplitterState").toByteArray();
#else
return value("MainWindow/qt5/vsplitterState").toByteArray();
#endif
}
void Preferences::setMainVSplitterState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/MainWindow/VSplitterState", state);
#else
setValue("MainWindow/qt5/vsplitterState", state);
#endif
}
QString Preferences::getMainLastDir() const
@ -1285,12 +1293,20 @@ void Preferences::setMainLastDir(const QString &path)
QByteArray Preferences::getPeerListState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/TorrentProperties/PeerListState").toByteArray();
#else
return value("TorrentProperties/Peers/qt5/PeerListState").toByteArray();
#endif
}
void Preferences::setPeerListState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/TorrentProperties/PeerListState", state);
#else
setValue("TorrentProperties/Peers/qt5/PeerListState", state);
#endif
}
QString Preferences::getPropSplitterSizes() const
@ -1305,12 +1321,20 @@ void Preferences::setPropSplitterSizes(const QString &sizes)
QByteArray Preferences::getPropFileListState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/TorrentProperties/FilesListState").toByteArray();
#else
return value("TorrentProperties/qt5/FilesListState").toByteArray();
#endif
}
void Preferences::setPropFileListState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/TorrentProperties/FilesListState", state);
#else
setValue("TorrentProperties/qt5/FilesListState", state);
#endif
}
int Preferences::getPropCurTab() const
@ -1335,12 +1359,20 @@ void Preferences::setPropVisible(const bool visible)
QByteArray Preferences::getPropTrackerListState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/TorrentProperties/TrackerListState").toByteArray();
#else
return value("TorrentProperties/Trackers/qt5/TrackerListState").toByteArray();
#endif
}
void Preferences::setPropTrackerListState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/TorrentProperties/TrackerListState", state);
#else
setValue("TorrentProperties/Trackers/qt5/TrackerListState", state);
#endif
}
QSize Preferences::getRssGeometrySize() const
@ -1355,12 +1387,20 @@ void Preferences::setRssGeometrySize(const QSize &geometry)
QByteArray Preferences::getRssHSplitterSizes() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/RSSFeedDownloader/HSplitterSizes").toByteArray();
#else
return value("RssFeedDownloader/qt5/hsplitterSizes").toByteArray();
#endif
}
void Preferences::setRssHSplitterSizes(const QByteArray &sizes)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/RSSFeedDownloader/HSplitterSizes", sizes);
#else
setValue("RssFeedDownloader/qt5/hsplitterSizes", sizes);
#endif
}
QStringList Preferences::getRssOpenFolders() const
@ -1375,32 +1415,56 @@ void Preferences::setRssOpenFolders(const QStringList &folders)
QByteArray Preferences::getRssSideSplitterState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/RSSWidget/SideSplitterState").toByteArray();
#else
return value("GUI/RSSWidget/qt5/splitter_h").toByteArray();
#endif
}
void Preferences::setRssSideSplitterState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/RSSWidget/SideSplitterState", state);
#else
setValue("GUI/RSSWidget/qt5/splitter_h", state);
#endif
}
QByteArray Preferences::getRssMainSplitterState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/RSSWidget/MainSplitterState").toByteArray();
#else
return value("GUI/RSSWidget/qt5/splitterMain").toByteArray();
#endif
}
void Preferences::setRssMainSplitterState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/RSSWidget/MainSplitterState", state);
#else
setValue("GUI/RSSWidget/qt5/splitterMain", state);
#endif
}
QByteArray Preferences::getSearchTabHeaderState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/SearchTab/HeaderState").toByteArray();
#else
return value("SearchTab/qt5/HeaderState").toByteArray();
#endif
}
void Preferences::setSearchTabHeaderState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/SearchTab/HeaderState", state);
#else
setValue("SearchTab/qt5/HeaderState", state);
#endif
}
bool Preferences::getRegexAsFilteringPatternForSearchJob() const
@ -1495,12 +1559,20 @@ void Preferences::setTransSelFilter(const int index)
QByteArray Preferences::getTransHeaderState() const
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
return value("GUI/Qt6/TransferList/HeaderState").toByteArray();
#else
return value("TransferList/qt5/HeaderState").toByteArray();
#endif
}
void Preferences::setTransHeaderState(const QByteArray &state)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
setValue("GUI/Qt6/TransferList/HeaderState", state);
#else
setValue("TransferList/qt5/HeaderState", state);
#endif
}
bool Preferences::getRegexAsFilteringPatternForTransferList() const

6
src/base/utils/misc.cpp
View file

@ -133,18 +133,18 @@ void Utils::Misc::shutdownComputer(const ShutdownDialogAction &action)
if (action == ShutdownDialogAction::Suspend)
{
::SetSuspendState(false, false, false);
::SetSuspendState(FALSE, FALSE, FALSE);
}
else if (action == ShutdownDialogAction::Hibernate)
{
::SetSuspendState(true, false, false);
::SetSuspendState(TRUE, FALSE, FALSE);
}
else
{
const QString msg = QCoreApplication::translate("misc", "qBittorrent will shutdown the computer now because all downloads are complete.");
auto msgWchar = std::make_unique<wchar_t[]>(msg.length() + 1);
msg.toWCharArray(msgWchar.get());
::InitiateSystemShutdownW(nullptr, msgWchar.get(), 10, true, false);
::InitiateSystemShutdownW(nullptr, msgWchar.get(), 10, TRUE, FALSE);
}
// Disable shutdown privilege.

10
src/gui/addnewtorrentdialog.cpp
View file

@ -82,10 +82,14 @@ AddNewTorrentDialog::AddNewTorrentDialog(const BitTorrent::AddTorrentParams &inP
, m_ui(new Ui::AddNewTorrentDialog)
, m_torrentParams(inParams)
, m_storeDialogSize(SETTINGS_KEY("DialogSize"))
, m_storeSplitterState(SETTINGS_KEY("SplitterState"))
, m_storeDefaultCategory(SETTINGS_KEY("DefaultCategory"))
, m_storeRememberLastSavePath(SETTINGS_KEY("RememberLastSavePath"))
, m_storeTreeHeaderState(SETTINGS_KEY("TreeHeaderState"))
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
, m_storeSplitterState("GUI/Qt6/" SETTINGS_KEY("SplitterState"))
#else
, m_storeSplitterState(SETTINGS_KEY("SplitterState"))
#endif
{
// TODO: set dialog file properties using m_torrentParams.filePriorities
m_ui->setupUi(this);
@ -715,8 +719,8 @@ void AddNewTorrentDialog::setupTreeview()
// List files in torrent
m_contentModel->model()->setupModelData(m_torrentInfo);
if (!m_storeTreeHeaderState.get().isEmpty())
m_ui->contentTreeView->header()->restoreState(m_storeTreeHeaderState);
if (const QByteArray state = m_storeTreeHeaderState; !state.isEmpty())
m_ui->contentTreeView->header()->restoreState(state);
// Hide useless columns after loading the header state
m_ui->contentTreeView->hideColumn(PROGRESS);

4
src/gui/addnewtorrentdialog.h
View file

@ -118,8 +118,8 @@ private:
BitTorrent::AddTorrentParams m_torrentParams;
SettingValue<QSize> m_storeDialogSize;
SettingValue<QByteArray> m_storeSplitterState;
SettingValue<QString> m_storeDefaultCategory;
SettingValue<bool> m_storeRememberLastSavePath;
CachedSettingValue<QByteArray> m_storeTreeHeaderState;
SettingValue<QByteArray> m_storeTreeHeaderState;
SettingValue<QByteArray> m_storeSplitterState;
};

21
src/gui/cookiesdialog.cpp
View file

@ -32,20 +32,23 @@
#include "base/global.h"
#include "base/net/downloadmanager.h"
#include "base/settingsstorage.h"
#include "cookiesmodel.h"
#include "ui_cookiesdialog.h"
#include "uithememanager.h"
#include "utils.h"
#define SETTINGS_KEY(name) QStringLiteral("CookiesDialog/" name)
const QString KEY_SIZE = SETTINGS_KEY("Size");
const QString KEY_COOKIESVIEWSTATE = SETTINGS_KEY("CookiesViewState");
#define SETTINGS_KEY(name) "CookiesDialog/" name
CookiesDialog::CookiesDialog(QWidget *parent)
: QDialog(parent)
, m_ui(new Ui::CookiesDialog)
, m_cookiesModel(new CookiesModel(Net::DownloadManager::instance()->allCookies(), this))
, m_storeDialogSize(SETTINGS_KEY("Size"))
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
, m_storeViewState("GUI/Qt6/" SETTINGS_KEY("ViewState"))
#else
, m_storeViewState(SETTINGS_KEY("CookiesViewState"))
#endif
{
m_ui->setupUi(this);
@ -61,16 +64,14 @@ CookiesDialog::CookiesDialog(QWidget *parent)
m_cookiesModel->index(0, 0),
QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
Utils::Gui::resize(this, SettingsStorage::instance()->loadValue<QSize>(KEY_SIZE));
m_ui->treeView->header()->restoreState(
SettingsStorage::instance()->loadValue<QByteArray>(KEY_COOKIESVIEWSTATE));
Utils::Gui::resize(this, m_storeDialogSize);
m_ui->treeView->header()->restoreState(m_storeViewState);
}
CookiesDialog::~CookiesDialog()
{
SettingsStorage::instance()->storeValue(KEY_SIZE, size());
SettingsStorage::instance()->storeValue(
KEY_COOKIESVIEWSTATE, m_ui->treeView->header()->saveState());
m_storeDialogSize = size();
m_storeViewState = m_ui->treeView->header()->saveState();
delete m_ui;
}

5
src/gui/cookiesdialog.h
View file

@ -30,6 +30,8 @@
#include <QDialog>
#include "base/settingvalue.h"
class CookiesModel;
namespace Ui
@ -55,4 +57,7 @@ private slots:
private:
Ui::CookiesDialog *m_ui;
CookiesModel *m_cookiesModel;
SettingValue<QSize> m_storeDialogSize;
SettingValue<QByteArray> m_storeViewState;
};

4
src/gui/previewselectdialog.cpp
View file

@ -52,7 +52,11 @@ PreviewSelectDialog::PreviewSelectDialog(QWidget *parent, const BitTorrent::Torr
, m_ui(new Ui::PreviewSelectDialog)
, m_torrent(torrent)
, m_storeDialogSize(SETTINGS_KEY("Size"))
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
, m_storeTreeHeaderState("GUI/Qt6/" SETTINGS_KEY("HeaderState"))
#else
, m_storeTreeHeaderState(SETTINGS_KEY("HeaderState"))
#endif
{
m_ui->setupUi(this);