NOTES.txt

Todos to check in qBittorent torrentexporter:
---------------------------------------------

 - set setForwardOnly(true) for all queries for better performance
 - solve explicit, default and delete for contructors, use this keywords correctly
 - use every where toNativePath()
 - rewrite all to range-based for loop


Todos to check in qMedia:
-------------------------

 - QHash::operator[] returns default when value not exists and silently inserts that item into the hash, check all code usage 😠


C preprocessor macros:
----------------------

 - LOG_CHANGED_TORRENTS - log debug messages about changed torrents, messages are logged every second
 - LOG_GEOMETRY - debug geometry changes, like resize and show/hide columns during qBittorent up/down
 - VISIBLE_CONSOLE - set up smaller, so I can see console output in the QtCreator, but only at initial


questions:
----------

 - laravel Grammar/Grammar::whereBasic()
    - $operator = str_replace('?', '??', $where['operator']);


Example code which heavily uses win32 api:
------------------------------------------

    BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM)
    {
        // For reference, very important:
        // https://docs.microsoft.com/en-us/archive/msdn-magazine/2015/july/c-using-stl-strings-at-win32-api-boundaries
        const int windowTextLength = ::GetWindowTextLength(hwnd) + 1;
        auto windowText = std::make_unique<wchar_t[]>(windowTextLength);
//        std::vector<wchar_t> windowText(windowTextLength);
//        std::wstring windowText;
//        windowText.resize(windowTextLength);

        ::GetWindowText(hwnd, windowText.get(), windowTextLength);
//        ::GetWindowText(hwnd, const_cast<wchar_t *>(windowText.c_str()), windowTextLength);
        std::wstring text(windowText.get());
//        windowText.resize(windowTextLength - 1);

        if (::wcsstr(windowText.get(), L"qBittorrent"))
            qDebug() << "xx";

        // Example: [D: 0 B/s, U: 1,3 MiB/s] qBittorrent v4.2.5
        const std::wregex re(L"^(\\[\\D: .*\\, U\\: .*\\] )?qBittorrent (v\\d+\\.\\d+\\.\\d+([a-zA-Z]+\\d{0,2})?)$");
        if (!std::regex_match(windowText.get(), re))
//        if (::!wcsstr(windowText.get(), L"qBittorrent"))
            return true;

//        wchar_t className[MAX_PATH];
//        ::GetClassName(hwnd, className, ARRAYSIZE(className));
//        if (!::wcscmp(className, L"Qt5QWindowIcon") != 0)
//            return true;

        DWORD pid;
        ::GetWindowThreadProcessId(hwnd, &pid);
        const HANDLE processHandle = ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
        if (processHandle == NULL) {
            qDebug() << "OpenProcess() in EnumWindows() failed : " << ::GetLastError();
            return true;
        }

        wchar_t moduleFilePath[MAX_PATH];
        ::GetModuleFileNameEx(processHandle, NULL, moduleFilePath, ARRAYSIZE(moduleFilePath));
        // More instances of qBittorrent can run, so find proper one
#ifdef QT_DEBUG
        // String has to start with moduleFileName
        if (::wcsstr(moduleFilePath, L"E:\\c\\qbittorrent_64-dev\\qBittorrent\\qBittorrent-builds")
            != &moduleFilePath[0])
            return true;
#else
        if (::wcsstr(moduleFileName, L"C:\\Program Files\\qBittorrent") != &moduleFileName[0])
            return true;
#endif
//        ::PathStripPath(moduleFileName);
        const QString moduleFileName = Utils::Fs::fileName(QString::fromWCharArray(moduleFilePath));
        ::CloseHandle(processHandle);
        if (moduleFileName == "qbittorrent.exe")
//        if (::wcscmp(moduleFilePath, L"qbittorrent.exe") != 0)
            return true;

        qDebug() << "HWND for qBittorrent window found : " << hwnd;
        l_mainWindow->setQBittorrentHwnd(hwnd);

        return false;
    }


QProgressBar in qTableView:
---------------------------

//    QProxyStyle fusionStyle {"windowsvista"};

painter->save();
//    QPalette p = newopt.palette;
//    p.setColor(QPalette::Window, QColor(0, 0, 0, 0));
//    newopt.palette = p;
// Draw progressbar without border / groove
style->drawControl(QStyle::CE_ProgressBarContents, &newopt, painter);
style->drawControl(QStyle::CE_ProgressBarLabel, &newopt, painter);
//    style->drawControl(QStyle::CE_ProgressBarGroove, &newopt, painter);
//    style->drawControl(QStyle::CE_ProgressBar, &newopt, painter);
painter->restore();


WM_COPYDATA torrent ids as std::vector<quint64>:
------------------------------------------------

const COPYDATASTRUCT copyData = *reinterpret_cast<PCOPYDATASTRUCT>(msg->lParam);
switch (static_cast<int>(msg->wParam)) {
case MSG_QBT_TORRENTS_CHANGED:
    // Put together std::vector of torrentId
    const int dataSize = static_cast<int>(copyData.cbData);
    const quint64 *const begin = static_cast<const quint64 *>(copyData.lpData);
    const quint64 *const end = begin + (dataSize / sizeof(quint64));
    const std::vector<quint64> torrentIds(begin, end);

    qDebug() << "IPC qBittorrent : Changed torrents copyData size :" << dataSize;
    qDebug() << "IPC qBittorrent : Changed torrents ids :" << torrentIds;

    emit m_mainWindow->torrentsChanged(torrentIds);
    return true;
}


Directly update model:
----------------------

QModelIndexList selectedIndexes = ui->tableView->selectionModel()->selectedRows(1);
if (selectedIndexes.isEmpty())
    return;
QModelIndex selectedIndex = selectedIndexes.first();
if (!selectedIndex.isValid())
    return;
m_model->setData(m_proxyModel->mapToSource(selectedIndex), "ahoj");


Performance measure timer:
--------------------------

#include <QElapsedTimer>
QElapsedTimer timer;
timer.start();
qDebug().noquote() << QStringLiteral("Elapsed in XX : %1ms").arg(timer.elapsed());


Dark theme by Windows settings:
-------------------------------

#include <QSettings>
QSettings settings("HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\"
                   "Themes\\Personalize",
                   QSettings::NativeFormat);
if (settings.value("AppsUseLightTheme") == 0) {
}


imdb movie detail:
------------------

class AbstractMovieDetailService:
signals:
    void searchPageFetched();
    void movieDetailPageFetched();

protected:
    virtual QString getMovieDetailUrl(QString searchPage) = 0;

    QString prepareSearchQueryString(const QSqlRecord &torrent) const;

    MovieDetail m_movieDetail;
    QHash<quint64, MovieDetail> m_movieDetailsCache;

private:
    enum CurrentlyProcessing
    {
        PROCESSING_NOTHING,
        PROCESSING_SEARCH_PAGE,
        PROESSING_MOVIE_DETAIL_PAGE,
    };

    MovieDetail selectMovieDetailByTorrentId(quint64 id);
    void fetchPageByUrl(QString searchQuery);
    void fetchPageFinished(QNetworkReply *reply);
    void insertMovieDetailToDb(const MovieDetail &movieDetail);

    QString m_searchPage;
    QString m_movieDetailPage;
    int m_currentlyProcessing = PROCESSING_NOTHING;
    QNetworkAccessManager m_networkManager;


was in AbstractMovieDetailService::getMovieDetail():
    // Fetch movie detail from internet
//    {
//        QString searchQuery = prepareSearchQueryString(torrent);
//        m_currentlyProcessing = PROCESSING_SEARCH_PAGE;
//        fetchPageByUrl(searchQuery);
//        QEventLoop eventLoop;
//        eventLoop.connect(this, &AbstractMovieDetailService::searchPageFetched, &eventLoop, &QEventLoop::quit);
//        eventLoop.exec();
//    }
//    {
//        QString movieDetailUrl = getMovieDetailUrl(m_searchPage);
//        m_currentlyProcessing = PROESSING_MOVIE_DETAIL_PAGE;
//        fetchPageByUrl(movieDetailUrl);
//        QEventLoop eventLoop1;
//        eventLoop1.connect(this, &AbstractMovieDetailService::movieDetailPageFetched, &eventLoop1, &QEventLoop::quit);
//        eventLoop1.exec();
//    }

AbstractMovieDetailService::AbstractMovieDetailService(QObject *parent)
    : QObject(parent)
{
    //
    connect(&m_networkManager, &QNetworkAccessManager::finished, this, &AbstractMovieDetailService::fetchPageFinished);
}

void AbstractMovieDetailService::fetchPageByUrl(QString searchQuery)
{
    // TODO error handling silverqx
    QString searchUrlString = "https://www.csfd.cz/hledat/?q=" + searchQuery;
    m_networkManager.get(QNetworkRequest(QUrl(searchUrlString)));
}

void AbstractMovieDetailService::fetchPageFinished(QNetworkReply *reply)
{
    QString pageContent = QString::fromStdString(reply->readAll().toStdString());

    switch (m_currentlyProcessing) {
    case PROCESSING_SEARCH_PAGE:
        m_searchPage = pageContent;
        emit searchPageFetched();
        break;
    case PROESSING_MOVIE_DETAIL_PAGE:
        m_movieDetailPage = pageContent;
        emit movieDetailPageFetched();
        break;
    }
}

was in CsfdMovieDetail:
    QString getMovieDetailUrl(QString searchPage) override;


csfd-api movie scrapper:
------------------------

missing:
 - SE special edition length ( eg. aliens movie )
 - kamera ( aliens )
 - pracovní název for titles ( How to Train Your Dragon 3 )

app colors:
-----------

    // Blue
//    darkPalette.setColor(QPalette::Link, QColor(42, 130, 218));

    // Blue
//    darkPalette.setColor(QPalette::Highlight, QColor(42, 130, 218));
//    darkPalette.setColor(QPalette::HighlightedText, Qt::black);
    // Dark pastel green
//    darkPalette.setColor(QPalette::Highlight, QColor(29, 84, 92));
//    darkPalette.setColor(QPalette::HighlightedText, textColor);
    // Dark orange
//    darkPalette.setColor(QPalette::Highlight, QColor(255, 139, 0));
//    darkPalette.setColor(QPalette::HighlightedText, textColor);


detect resize event ended:
--------------------------

https://stackoverflow.com/questions/7753795/qt-user-resize-event-ends-stops


decoration position for QStyledItemDelegate:
--------------------------------------------

code is from QStyledItemDelegate::initStyleOption()

QSize actualSize = option->icon.actualSize(option->decorationSize, mode, state);
// For highdpi icons actualSize might be larger than decorationSize, which we don't want. Clamp it to decorationSize.
option->decorationSize = QSize(qMin(option->decorationSize.width(), actualSize.width()),
                               qMin(option->decorationSize.height(), actualSize.height()));


Merge torrents' changed properties:
-----------------------------------

torrentexporter.h:
--
    class TorrentExporter final : public QObject
    private:
        struct ChangedPropertiesStore
        {
            TorrentsChangedHash torrents;
            TorrentsFilesChangedHash torrentsFiles;

            inline bool isEmpty() const
            {
                if (torrents.isEmpty() && torrentsFiles.isEmpty())
                    return true;
                return false;
            }

            inline void clear()
            {
                torrents.clear();
                torrentsFiles.clear();
            }
        } m_changedPropertiesStore;

        void mergeTorrentChangedProperties(const TorrentId torrentId,
                const QSharedPointer<TorrentChangedProperties> &torrentsChangedProperties);
        void mergeTorrentFilesChangedProperties(
                const TorrentId torrentId,
                const QSharedPointer<TorrentFilesChangedHash> &filesChangedProperties);
        void mergeChangedProperties(
                const QSharedPointer<QVariantHash> &propertiesStore,
                const QSharedPointer<const QVariantHash> &changedProperties);



torrentexporter.cpp:
--
void TorrentExporter::mergeTorrentChangedProperties(
        const TorrentId torrentId,
        const QSharedPointer<TorrentChangedProperties> &changedProperties)
{
    auto &torrentsStore = m_changedPropertiesStore.torrents;

    // If this torrent's changed properties aren't in the store, simply insert them
    if (!torrentsStore.contains(torrentId)) {
        torrentsStore.insert(torrentId, changedProperties);
        return;
    }

    // Process/Merge changed properties
    mergeChangedProperties(torrentsStore[torrentId], changedProperties);
}

void TorrentExporter::mergeTorrentFilesChangedProperties(
        const TorrentId torrentId,
        const QSharedPointer<TorrentFilesChangedHash> &filesChangedProperties)
{
    auto &torrentsFilesStore = m_changedPropertiesStore.torrentsFiles;

    // If these torrent files changed properties are not in the store, simply insert them
    if (!torrentsFilesStore.contains(torrentId)) {
        torrentsFilesStore.insert(torrentId, filesChangedProperties);
        return;
    }

    // Iterate over a changed files
    auto itFiles = filesChangedProperties->constBegin();
    while (itFiles != filesChangedProperties->constEnd())
    {
        const auto fileId = itFiles.key();
        const auto changedFileProperties = itFiles.value();

        ++itFiles;

        auto &changedFilesStore = torrentsFilesStore[torrentId];

        // If this torrent file is not in the store, simply insert it
        if (!changedFilesStore->contains(fileId)) {
            changedFilesStore->insert(fileId, changedFileProperties);
            continue;
        }

        // Process/Merge changed file properties
        mergeChangedProperties((*changedFilesStore)[fileId], changedFileProperties);
    }
}

void TorrentExporter::mergeChangedProperties(
        const QSharedPointer<QVariantHash> &propertiesStore,
        const QSharedPointer<const QVariantHash> &changedProperties)
{
    // Process/Merge changed properties
    auto itTorrent = changedProperties->constBegin();
    while (itTorrent != changedProperties->constEnd())
    {
        const auto property = itTorrent.key();
        const auto value = itTorrent.value();

        ++itTorrent;

        // Torrent property value is the same, can be skipped
        if (propertiesStore->value(property) == value)
            continue;

        // Insert new or overwrite the old one
        propertiesStore->insert(property, value);
    }
}


qBittorrent deduce return type:
-------------------------------

template <typename T>
struct return_type;
template <typename R, typename... Args>
struct return_type<R(*)(Args...)> { using type = R; };
template <typename R, typename C, typename... Args>
struct return_type<R(C::*)(Args...)> { using type = R; };
template <typename R, typename C, typename... Args>
struct return_type<R(C::*)(Args...) const> { using type = R; };
template <typename R, typename C, typename... Args>
struct return_type<R(C::*)(Args...) volatile> { using type = R; };
template <typename R, typename C, typename... Args>
struct return_type<R(C::*)(Args...) const volatile> { using type = R; };
template <typename T>
using return_type_t = typename return_type<T>::type;

header:
--
class BaseRepository
    template<typename P>
    Export::return_type_t<decltype (&P::present)>
    presentResult(QSqlQuery &query);

source:
--
template<typename P>
Export::return_type_t<decltype (&P::present)>
BaseRepository::presentResult(QSqlQuery &query)
{
    return P().present(query);
}

presenters test code:
--
    const auto hash = static_cast<QString>(torrents.first()->hash());
    const auto torrentId =
            m_torrentsRepository.findWhere<Presenter::FirstId>({{"hash", hash}},
                                                               {{"id"}});
    if (torrentId)
        ;
    const auto torrentId1 =
            m_torrentsRepository.findWhere({{"hash", hash}},
                                           {{"id"}});

//    QStringList ll;
//    ll << "id" << "hash";
    auto vv = m_torrentsRepository.findWhereIn<Presenter::TorrentIdByInfoHash, TorrentId>(
                "id",
                {{269, 268, 267}});
    qDebug() << "vv :" << vv;
    auto [zzok, zzquery] = m_torrentsRepository.findWhereIn<void, TorrentId>(
                "id",
                {{269, 268, 267}});
    qDebug() << "zzok :" << zzok;

    qt_noop();

presenters with data test code ✨🚀, wtf 😂💪:
--
    QHash<BitTorrent::InfoHash, QString> data {
        {BitTorrent::InfoHash("6948503d484853cc6380374268daac161d4139cb"), QString("dvasestdevet")},
        {BitTorrent::InfoHash("bf9661defa3daecacfde5bde0214c4a439351d4d"), QString("jedna")},
        {BitTorrent::InfoHash("d3fc13dc12d8d7a58e7ae87295e93dbaddb5d36b"), QString("pjet")},
    };
    auto xx = m_torrentsRepository.findWhere<Presenter::TorrentHandleByInfoHashData>(
                  {{"id", 269, "=", "OR"}, {"id", 5, "=", "OR"}, {"id", 1, "="}},
                  data, {"id", "hash"});
    qDebug() << "xx :" << xx;
    auto yy = m_torrentsRepository.findWhereIn<Presenter::TorrentHandleByInfoHashData, quint64>(
                  "id", {269, 1, 5},
                  data, {"id", "hash"});
    qDebug() << "yy :" << yy;

prepareWhere() test code:
--
BaseRepository::BaseRepository(EntityManager &em)
    : m_em(em)
{
    auto xx = prepareWhereClause({
                                        {"name", "peto"},
                                        {"name", "andrej", "<>"},
                                        {"index", 10}
                                    });
    auto yy = prepareWhereCondClause({
                                     {"name", "peto"},
                                     {"name", "andrej", "<>", "OR"},
                                     {"index", 10, "=", ""}
                                 });
    qDebug() << "xx :" << xx;
    qDebug() << "yy :" << yy;
    qt_noop();
}


Prototype store:
----------------

 - I no longer remember how this was intended.

struct StoreItem
{
    std::function<void()> service;
    StoreItem(std::function<void()> service_)
        : service(service_)
    {}
};
struct StoreItemHandle : public StoreItem
{
    BitTorrent::TorrentHandle *const torrent;
    StoreItemHandle(std::function<void()> service_, BitTorrent::TorrentHandle *const torrent_)
        : StoreItem(service_)
        , torrent(torrent_)
    {}
};
struct StoreItemHash final : public StoreItem
{
    BitTorrent::InfoHash infoHash;
};
struct StoreItemPath final : public StoreItemHandle
{
    QString newPath;
};

QQueue<StoreItem> m_changedPropertiesStore;


constructor copy/move snippet:
------------------------------

Torrent(const Torrent &torrent)
    : BaseModel(torrent)
{
    qDebug() << "Torrent copy ctor";
}
Torrent &operator=(const Torrent &torrent)
{
    BaseModel::operator=(torrent);
    qDebug() << "Torrent copy assign";
    return *this;
}
Torrent(Torrent &&torrent)
    : BaseModel(std::move(torrent))
{
    qDebug() << "Torrent move ctor";
}
Torrent &operator=(Torrent &&torrent)
{
    BaseModel::operator=(std::move(torrent));
    qDebug() << "Torrent move assign";
    return *this;
}


conversions:
------------

Makes possible to assign QVector<AttributeItem> to the Model,
or implicitly converts a QVector<AttributeItem> to Model:

BaseModel(const QVector<AttributeItem> &attributes);
BaseModel(QVector<AttributeItem> &&attributes);

--
Allows initialize the Model with QVector<AttributeItem>:

BaseModel(std::initializer_list<AttributeItem> attributes)
    : BaseModel(QVector<AttributeItem> {attributes.begin(), attributes.end()})
{}

--
Makes possible to assign the Model to the QVector<AttributeItem>,
or converts the Model to the QVector<AttributeItem>:

operator QVector<AttributeItem>() const;