Merge pull request #15682 from Chocobo1/qt6

Store Qt6 table header states under a different key

src/app/qtlocalpeer/qtlocalpeer.cpp

@@ -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;

src/app/qtlocalpeer/qtlocalpeer.h

@@ -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;
 };

src/app/qtlocalpeer/qtlockedfile.cpp

@@ -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;
 }
 
 /*!

src/app/qtlocalpeer/qtlockedfile.h

@@ -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;
     };
 }

src/app/qtlocalpeer/qtlockedfile_unix.cpp

@@ -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;
 }
 

src/app/qtlocalpeer/qtlockedfile_win.cpp

@@ -70,64 +70,73 @@
 
 #include <QFileInfo>
 
-#define MUTEX_PREFIX "QtLockedFile mutex "
-// Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
-#define MAX_READERS MAXIMUM_WAIT_OBJECTS
+#include "base/global.h"
 
-#define QT_WA(unicode, ansi) unicode
+// Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
+const int MAX_READERS = MAXIMUM_WAIT_OBJECTS;
 
-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 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);
 }

src/base/bittorrent/torrentimpl.cpp

@@ -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>

src/base/preferences.cpp

@@ -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

src/base/utils/misc.cpp

@@ -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.

src/gui/addnewtorrentdialog.cpp

@@ -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);

src/gui/addnewtorrentdialog.h

@@ -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;
 };

src/gui/cookiesdialog.cpp

@@ -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;
 }
 

src/gui/cookiesdialog.h

@@ -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;
 };

src/gui/previewselectdialog.cpp

@@ -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);