ImageCache.moc.h

#pragma once
 
#include <Foundation/Communication/Event.h>
#include <Foundation/Configuration/Singleton.h>
#include <Foundation/Containers/Deque.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Containers/Set.h>
#include <Foundation/Strings/HashedString.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Time/Time.h>
#include <GuiFoundation/GuiFoundationDLL.h>
#include <QAbstractItemModel>
#include <QIcon>
#include <QPixmap>
#include <QString>
 
class PL_GUIFOUNDATION_DLL plQtImageCache : public QObject
{
  Q_OBJECT
 
  PL_DECLARE_SINGLETON(plQtImageCache);
 
public:
  plQtImageCache();
 
  void SetFallbackImages(const char* szLoading, const char* szUnavailable);
 
  const QPixmap* QueryPixmap(const char* szAbsolutePath, QModelIndex index = QModelIndex(), QVariant userData1 = QVariant(),
    QVariant userData2 = QVariant(), plUInt32* out_pImageID = nullptr);
 
  const QPixmap* QueryPixmapForType(const char* szType, const char* szAbsolutePath, QModelIndex index = QModelIndex(),
    QVariant userData1 = QVariant(), QVariant userData2 = QVariant(), plUInt32* out_pImageID = nullptr);
 
  void InvalidateCache(const char* szAbsolutePath);
 
  void SetMemoryUsageThreshold(plUInt64 uiMemoryThreshold) { m_iMemoryUsageThreshold = (plInt64)uiMemoryThreshold; }
 
  void StopRequestProcessing(bool bPurgeExistingCache);
 
  void EnableRequestProcessing();
 
  void RegisterTypeImage(const char* szType, QPixmap pixmap);
 
  const QPixmap* QueryTypeImage(const char* szType) const;
 
Q_SIGNALS:
  void ImageLoaded(QString sPath, QModelIndex index, QVariant userData1, QVariant userData2);
  void ImageInvalidated(QString sPath, unsigned int uiImageID);
 
private:
  void EmitLoadedSignal(QString sPath, QModelIndex index, QVariant UserData1, QVariant UserData2);
 
  void RunLoadingTask();
  static void LoadingTask(QString sPath, QModelIndex index, QVariant UserData1, QVariant UserData2);
  void CleanupCache();
 
  struct Request
  {
    plHashedString m_sPath;
    QModelIndex m_Index;
    QVariant m_UserData1;
    QVariant m_UserData2;
 
    bool operator<(const Request& rhs) const
    {
      if (m_sPath < rhs.m_sPath)
        return true;
      if (rhs.m_sPath < m_sPath)
        return false;
      if (m_Index < rhs.m_Index)
        return true;
      if (rhs.m_Index < m_Index)
        return false;
 
      // not supported in Qt 5.15 anymore, but doesn't look like it's vital
      //if (m_UserData1 < rhs.m_UserData1)
      //  return true;
      //if (rhs.m_UserData1 < m_UserData1)
      //  return false;
      //if (m_UserData2 < rhs.m_UserData2)
      //  return true;
      //if (rhs.m_UserData2 < m_UserData2)
      //  return false;
 
      return false;
    }
  };
 
  mutable plMutex m_Mutex;
  plSet<Request> m_Requests;
  bool m_bCacheEnabled;
  bool m_bTaskRunning;
  plTime m_LastCleanupTime;
  plInt64 m_iMemoryUsageThreshold;
  plInt64 m_iCurrentMemoryUsage;
  QPixmap* m_pImageLoading;
  QPixmap* m_pImageUnavailable;
  plUInt32 m_uiCurImageID;
 
  struct CacheEntry
  {
    QPixmap m_Pixmap;
    plTime m_LastAccess;
    plUInt32 m_uiImageID;
 
    CacheEntry() { m_uiImageID = 0xFFFFFFFF; }
  };
 
  plMap<QString, CacheEntry> m_ImageCache;
  plMap<QString, QPixmap> m_TypeImages;
};
 
constexpr static plUInt32 plThumbnailSize = 256;
 
PL_ALWAYS_INLINE QPixmap plSvgThumbnailToPixmap(const char* szFilePath)
{
  return QIcon(szFilePath).pixmap(QSize(plThumbnailSize, plThumbnailSize));
}